spring原始碼深度解析— IOC 之 預設標籤解析(下)
在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 載入。
&n