在spring原始碼深度解析— IOC 之 預設標籤解析（上）中我們已經完成了從xml配置檔案到BeanDefinition的轉換，轉換後的例項是GenericBeanDefinition的例項。本文主要來看看標籤解析剩餘部分及BeanDefinition的註冊。
預設標籤中的自定義標籤解析
在上篇博文中我們已經分析了對於預設標籤的解析，我們繼續看戲之前的程式碼，如下圖片中有一個方法：delegate.decorateBeanDefinitionIfRequired(ele, bdHolder)
這個方法的作用是什麼呢？首先我們看下這種場景，如下配置檔案：
<bean id="demo" class="com.chenhao.spring.MyTestBean">
<property name="beanName" value="bean demo1"/>
<meta key="demo" value="demo"/>
<mybean:username="mybean"/>
</bean>
這個配置檔案中有個自定義的標籤，decorateBeanDefinitionIfRequired方法就是用來處理這種情況的，其中的null是用來傳遞父級BeanDefinition的，我們進入到其方法體：
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder) { return decorateBeanDefinitionIfRequired(ele, definitionHolder, null); } public BeanDefinitionHolder decorateBeanDefinitionIfRequired( Element ele, BeanDefinitionHolder definitionHolder, @Nullable BeanDefinition containingBd) { BeanDefinitionHolder finalDefinition = definitionHolder; // Decorate based on custom attributes first. NamedNodeMap attributes = ele.getAttributes(); for (int i = 0; i < attributes.getLength(); i++) { Node node = attributes.item(i); finalDefinition = decorateIfRequired(node, finalDefinition, containingBd); } // Decorate based on custom nested elements. NodeList children = ele.getChildNodes(); for (int i = 0; i < children.getLength(); i++) { Node node = children.item(i); if (node.getNodeType() == Node.ELEMENT_NODE) { finalDefinition = decorateIfRequired(node, finalDefinition, containingBd); } } return finalDefinition; }
我們看到上面的程式碼有兩個遍歷操作，一個是用於對所有的屬性進行遍歷處理，另一個是對所有的子節點進行處理，兩個遍歷操作都用到了decorateIfRequired(node, finalDefinition, containingBd);方法，我們繼續跟蹤程式碼，進入方法體：
public BeanDefinitionHolder decorateIfRequired( Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) { // 獲取自定義標籤的名稱空間 String namespaceUri = getNamespaceURI(node); // 過濾掉預設命名標籤 if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) { // 獲取相應的處理器 NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri); if (handler != null) { // 進行裝飾處理 BeanDefinitionHolder decorated = handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd)); if (decorated != null) { return decorated; } } else if (namespaceUri.startsWith("http://www.springframework.org/")) { error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node); } else { if (logger.isDebugEnabled()) { logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]"); } } } return originalDef; } public String getNamespaceURI(Node node) { return node.getNamespaceURI(); } public boolean isDefaultNamespace(@Nullable String namespaceUri) { //BEANS_NAMESPACE_URI = "http://www.springframework.org/schema/beans"; return (!StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri)); }
首先獲取自定義標籤的名稱空間，如果不是預設的名稱空間則根據該名稱空間獲取相應的處理器，最後呼叫處理器的 decorate() 進行裝飾處理。具體的裝飾過程這裡不進行講述，在後面分析自定義標籤時會做詳細說明。
註冊解析的BeanDefinition
對於配置檔案，解析和裝飾完成之後，對於得到的beanDefinition已經可以滿足後續的使用要求了，還剩下注冊，也就是processBeanDefinition函式中的BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,getReaderContext().getRegistry())程式碼的解析了。進入方法體：
public static void registerBeanDefinition( BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException { // Register bean definition under primary name. //使用beanName做唯一標識註冊 String beanName = definitionHolder.getBeanName(); registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); // Register aliases for bean name, if any. //註冊所有的別名 String[] aliases = definitionHolder.getAliases(); if (aliases != null) { for (String alias : aliases) { registry.registerAlias(beanName, alias); } } }
從上面的程式碼我們看到是用了beanName作為唯一標示進行註冊的，然後註冊了所有的別名aliase。而beanDefinition最終都是註冊到BeanDefinitionRegistry中，接下來我們具體看下注冊流程。
通過beanName註冊BeanDefinition
在spring中除了使用beanName作為key將BeanDefinition放入Map中還做了其他一些事情，我們看下方法registerBeanDefinition程式碼，BeanDefinitionRegistry是一個介面，他有三個實現類，DefaultListableBeanFactory、SimpleBeanDefinitionRegistry、GenericApplicationContext，其中SimpleBeanDefinitionRegistry非常簡單，而GenericApplicationContext最終也是使用的DefaultListableBeanFactory中的實現方法，我們看下程式碼：
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException { // 校驗 beanName 與 beanDefinition Assert.hasText(beanName, "Bean name must not be empty"); Assert.notNull(beanDefinition, "BeanDefinition must not be null"); if (beanDefinition instanceof AbstractBeanDefinition) { try { // 校驗 BeanDefinition // 這是註冊前的最後一次校驗了，主要是對屬性 methodOverrides 進行校驗 ((AbstractBeanDefinition) beanDefinition).validate(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", ex); } } BeanDefinition oldBeanDefinition; // 從快取中獲取指定 beanName 的 BeanDefinition oldBeanDefinition = this.beanDefinitionMap.get(beanName); /** * 如果存在 */ if (oldBeanDefinition != null) { // 如果存在但是不允許覆蓋，丟擲異常 if (!isAllowBeanDefinitionOverriding()) { throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName + "': There is already [" + oldBeanDefinition + "] bound."); } // else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) { // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE if (this.logger.isWarnEnabled()) { this.logger.warn("Overriding user-defined bean definition for bean '" + beanName + "' with a framework-generated bean definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]"); } } // 覆蓋 beanDefinition 與 被覆蓋的 beanDefinition 不是同類 else if (!beanDefinition.equals(oldBeanDefinition)) { if (this.logger.isInfoEnabled()) { this.logger.info("Overriding bean definition for bean '" + beanName + "' with a different definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]"); } } else { if (this.logger.isDebugEnabled()) { this.logger.debug("Overriding bean definition for bean '" + beanName + "' with an equivalent definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]"); } } // 允許覆蓋，直接覆蓋原有的 BeanDefinition this.beanDefinitionMap.put(beanName, beanDefinition); } /** * 不存在 */ else { // 檢測建立 Bean 階段是否已經開啟，如果開啟了則需要對 beanDefinitionMap 進行併發控制 if (hasBeanCreationStarted()) { // beanDefinitionMap 為全域性變數，避免併發情況 synchronized (this.beanDefinitionMap) { // this.beanDefinitionMap.put(beanName, beanDefinition); List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1); updatedDefinitions.addAll(this.beanDefinitionNames); updatedDefinitions.add(beanName); this.beanDefinitionNames = updatedDefinitions; if (this.manualSingletonNames.contains(beanName)) { Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames); updatedSingletons.remove(beanName); this.manualSingletonNames = updatedSingletons; } } } else { // 不會存在併發情況，直接設定 this.beanDefinitionMap.put(beanName, beanDefinition); this.beanDefinitionNames.add(beanName); this.manualSingletonNames.remove(beanName); } this.frozenBeanDefinitionNames = null; } if (oldBeanDefinition != null || containsSingleton(beanName)) { // 重新設定 beanName 對應的快取 resetBeanDefinition(beanName); } }
處理過程如下：
- 首先 BeanDefinition 進行校驗，該校驗也是註冊過程中的最後一次校驗了，主要是對 AbstractBeanDefinition 的 methodOverrides 屬性進行校驗
- 根據 beanName 從快取中獲取 BeanDefinition，如果快取中存在，則根據 allowBeanDefinitionOverriding 標誌來判斷是否允許覆蓋，如果允許則直接覆蓋，否則丟擲 BeanDefinitionStoreException 異常
- 若快取中沒有指定 beanName 的 BeanDefinition，則判斷當前階段是否已經開始了 Bean 的建立階段（），如果是，則需要對 beanDefinitionMap 進行加鎖控制併發問題，否則直接設定即可。對於
hasBeanCreationStarted()方法後續做詳細介紹，這裡不過多闡述。 - 若快取中存在該 beanName 或者 單利 bean 集合中存在該 beanName，則呼叫
resetBeanDefinition()重置 BeanDefinition 快取。
其實整段程式碼的核心就在於 this.beanDefinitionMap.put(beanName, beanDefinition); 。BeanDefinition 的快取也不是神奇的東西，就是定義 一個 ConcurrentHashMap，key 為 beanName，value 為 BeanDefinition。
通過別名註冊BeanDefinition
通過別名註冊BeanDefinition最終是在SimpleBeanDefinitionRegistry中實現的，我們看下程式碼：
public void registerAlias(String name, String alias) { Assert.hasText(name, "'name' must not be empty"); Assert.hasText(alias, "'alias' must not be empty"); synchronized (this.aliasMap) { if (alias.equals(name)) { this.aliasMap.remove(alias); } else { String registeredName = this.aliasMap.get(alias); if (registeredName != null) { if (registeredName.equals(name)) { // An existing alias - no need to re-register return; } if (!allowAliasOverriding()) { throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" + name + "': It is already registered for name '" + registeredName + "'."); } } //當A->B存在時，若再次出現A->C->B時候則會丟擲異常。 checkForAliasCircle(name, alias); this.aliasMap.put(alias, name); } } }
上述程式碼的流程總結如下：
（1）alias與beanName相同情況處理，若alias與beanName併名稱相同則不需要處理並刪除原有的alias
（2）alias覆蓋處理。若aliasName已經使用並已經指向了另一beanName則需要使用者的設定進行處理
（3）alias迴圈檢查，當A->B存在時，若再次出現A->C->B時候則會丟擲異常。
alias標籤的解析
對應bean標籤的解析是最核心的功能，對於alias、import、beans標籤的解析都是基於bean標籤解析的，接下來我就分析下alias標籤的解析。我們回到 parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)方法，繼續看下方法體，如下圖所示：
對bean進行定義時，除了用id來 指定名稱外，為了提供多個名稱，可以使用alias標籤來指定。而所有這些名稱都指向同一個bean。在XML配置檔案中，可用單獨的元素來完成bean別名的定義。我們可以直接使用bean標籤中的name屬性，如下：
<bean id="demo" class="com.chenhao.spring.MyTestBean" name="demo1,demo2">
<property name="beanName" value="bean demo1"/>
</bean>
在Spring還有另外一種宣告別名的方式：
<bean id="myTestBean" class="com.chenhao.spring.MyTestBean"/>
<alias name="myTestBean" alias="testBean1,testBean2"/>
我們具體看下alias標籤的解析過程，解析使用的方法processAliasRegistration(ele)，方法體如下：
protected void processAliasRegistration(Element ele) { //獲取beanName String name = ele.getAttribute(NAME_ATTRIBUTE); //獲取alias String alias = ele.getAttribute(ALIAS_ATTRIBUTE); boolean valid = true; if (!StringUtils.hasText(name)) { getReaderContext().error("Name must not be empty", ele); valid = false; } if (!StringUtils.hasText(alias)) { getReaderContext().error("Alias must not be empty", ele); valid = false; } if (valid) { try { //註冊alias getReaderContext().getRegistry().registerAlias(name, alias); } catch (Exception ex) { getReaderContext().error("Failed to register alias '" + alias + "' for bean with name '" + name + "'", ele, ex); } getReaderContext().fireAliasRegistered(name, alias, extractSource(ele)); } }
通過程式碼可以發現解析流程與bean中的alias解析大同小異，都是講beanName與別名alias組成一對註冊到registry中。跟蹤程式碼最終使用了SimpleAliasRegistry中的registerAlias(String name, String alias)方法
推薦部落格
import標籤的解析
對於Spring配置檔案的編寫，經歷過大型專案的人都知道，裡面有太多的配置檔案了。基本採用的方式都是分模組，分模組的方式很多，使用import就是其中一種，例如我們可以構造這樣的Spring配置檔案：
<?xml version="1.0" encoding="UTF-8" ?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="demo" class="com.chenhao.spring.MyTestBean" name="demo1,demo2"> <property name="beanName" value="bean demo1"/> </bean> <import resource="lookup-method.xml"/> <import resource="replaced-method.xml"/> </beans>
applicationContext.xml檔案中使用import方式匯入有模組配置檔案，以後若有新模組的加入，那就可以簡單修改這個檔案了。這樣大大簡化了配置後期維護的複雜度，並使配置模組化，易於管理。我們來看看Spring是如何解析import配置檔案的呢。解析import標籤使用的是importBeanDefinitionResource(ele)，進入方法體：
protected void importBeanDefinitionResource(Element ele) { // 獲取 resource 的屬性值 String location = ele.getAttribute(RESOURCE_ATTRIBUTE); // 為空，直接退出 if (!StringUtils.hasText(location)) { getReaderContext().error("Resource location must not be empty", ele); return; } // 解析系統屬性，格式如 ："${user.dir}" location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location); Set<Resource> actualResources = new LinkedHashSet<>(4); // 判斷 location 是相對路徑還是絕對路徑 boolean absoluteLocation = false; try { absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute(); } catch (URISyntaxException ex) { // cannot convert to an URI, considering the location relative // unless it is the well-known Spring prefix "classpath*:" } // 絕對路徑 if (absoluteLocation) { try { // 直接根據地址載入相應的配置檔案 int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources); if (logger.isDebugEnabled()) { logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]"); } } catch (BeanDefinitionStoreException ex) { getReaderContext().error( "Failed to import bean definitions from URL location [" + location + "]", ele, ex); } } else { // 相對路徑則根據相應的地址計算出絕對路徑地址 try { int importCount; Resource relativeResource = getReaderContext().getResource().createRelative(location); if (relativeResource.exists()) { importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource); actualResources.add(relativeResource); } else { String baseLocation = getReaderContext().getResource().getURL().toString(); importCount = getReaderContext().getReader().loadBeanDefinitions( StringUtils.applyRelativePath(baseLocation, location), actualResources); } if (logger.isDebugEnabled()) { logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]"); } } catch (IOException ex) { getReaderContext().error("Failed to resolve current resource location", ele, ex); } catch (BeanDefinitionStoreException ex) { getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]", ele, ex); } } // 解析成功後，進行監聽器啟用處理 Resource[] actResArray = actualResources.toArray(new Resource[0]); getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele)); }
解析 import 過程較為清晰，整個過程如下：
- 獲取 source 屬性的值，該值表示資源的路徑
- 解析路徑中的系統屬性，如”${user.dir}”
- 判斷資源路徑 location 是絕對路徑還是相對路徑
- 如果是絕對路徑，則調遞迴呼叫 Bean 的解析過程，進行另一次的解析
- 如果是相對路徑，則先計算出絕對路徑得到 Resource，然後進行解析
- 通知監聽器，完成解析
判斷路徑
方法通過以下方法來判斷 location 是為相對路徑還是絕對路徑：
absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
判斷絕對路徑的規則如下：
- 以 classpath*: 或者 classpath: 開頭為絕對路徑
- 能夠通過該 location 構建出
java.net.URL為絕對路徑 - 根據 location 構造
java.net.URI判斷呼叫isAbsolute()判斷是否為絕對路徑
如果 location 為絕對路徑則呼叫 loadBeanDefinitions()，該方法在 AbstractBeanDefinitionReader 中定義。
public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException { ResourceLoader resourceLoader = getResourceLoader(); if (resourceLoader == null) { throw new BeanDefinitionStoreException( "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available"); } if (resourceLoader instanceof ResourcePatternResolver) { // Resource pattern matching available. try { Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location); int loadCount = loadBeanDefinitions(resources); if (actualResources != null) { for (Resource resource : resources) { actualResources.add(resource); } } if (logger.isDebugEnabled()) { logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]"); } return loadCount; } catch (IOException ex) { throw new BeanDefinitionStoreException( "Could not resolve bean definition resource pattern [" + location + "]", ex); } } else { // Can only load single resources by absolute URL. Resource resource = resourceLoader.getResource(location); int loadCount = loadBeanDefinitions(resource); if (actualResources != null) { actualResources.add(resource); } if (logger.isDebugEnabled()) { logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]"); } return loadCount; } }
整個邏輯比較簡單，首先獲取 ResourceLoader，然後根據不同的 ResourceLoader 執行不同的邏輯，主要是可能存在多個 Resource，但是最終都會迴歸到 XmlBeanDefinitionReader.loadBeanDefinitions() ，所以這是一個遞迴的過程。
至此，import 標籤解析完畢，整個過程比較清晰明瞭：獲取 source 屬性值，得到正確的資源路徑，然後呼叫 loadBeanDefinitions() 方法進行遞迴的 BeanDefinition 載入。