Spring 源碼閱讀(二)：bean 元素解析以及註冊

在上一篇文章中，我們瞭解了加載 bean 的整個過程，在最後會走入到 XMLBeanDefinitionReader 類下的 doLoadBeanDefinitions() 方法，在此之前會對 Resource 進行封裝，目的是考慮到 Resource 可能存在編碼要求的情況，其次，通過 SAX 讀取 XML 文件的方式來準備 InputResource 對象，最後將準備的數據通過參數傳入真正的核心處理部分，即 doLoadBeanDefinitions(inputResource, encodedReource.getResource())。我們在看看這個方法的代碼邏輯。

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
	// 各種異常捕獲被 delete 掉，只留下核心部分
	Document doc = doLoadDocument(inputSource, resource);
	return registerBeanDefinitions(doc, resource);
}

上述方法其實只做了三件事：

獲取對 XML 文件的驗證模式
加載 XML 文件，並得到對應的 Document
根據返回的 Document 註冊 Bean 信息

其中第三點尤其重要，而且非常複雜，因爲它是對配置文件的解析。不過在進入第三步之前，先簡單瞭解下前面兩步。

1 XML 的驗證模式

總所周知 XML 文件的驗證模式保證了 XML 文件的正確性，而目前比較常用的兩種驗證模式：DTD 和 XSD。
DTD（Document Type Definition）即文檔類型定義，是一種 XML 約束模式語言，是 XML 文件的驗證機制，屬於 XML 文件組成的一部分。從它的定義可以看出，它是爲了保證 XML 文件的正確性，相當於定義了 XML 文件可以有什麼元素，元素有什麼屬性，以及元素的結構和元素之間的關係。
要使用 DTD 驗證模式，需要在 XML 文件的頭部聲明，以下是在 Spring 中使用 DTD 聲明方式的代碼：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//Spring//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
</beans>

XML Schema 語言就是 XSD（XLM Schema Definition）。XML Schema 描述了 XML 文檔的結構，它本身也是一個 XML 文檔，它符合 XML 語法結構。不過使用方式稍微比 DTD 麻煩點，在使用它時，除了要聲明名稱空間外（xmlns=http://www.springframework.org/schema/beans），還必須指定該名稱空間所對應的 XML Schema 文檔的存儲位置。通過 schemaLocation 屬性來指定名稱空間所對應的 XML Schema 文檔存儲位置，它包含兩個部分，一部分是名稱空間的 URI，一部分是該名稱空間所標識的 XLM Schema 文件位置或 URL 地址。

<?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">
    
</beans>

1.1 驗證模式

在瞭解了基本的 XML 文件後，我們看看剛纔的方法的第一行代碼 doLoadDocument()。

protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
	return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
			getValidationModeForResource(resource), isNamespaceAware());
}

在真正加載 Document 之前，會先調用 getValidationModeForResource(resouce) 方法獲取驗證模式，邏輯很簡單，就是判斷 XML 文檔頭部有沒有 DOCTYPE，有則 DTD 模式，否則就是 XSD 模式。然後還會調用 getEntityResolver() 方法獲取 EntityResolver 對象，那這個對象是什麼呢？
官網解釋爲：如果 SAX 應用程序需要實現自定義處理外部實體，則必須實現此接口並使用 setEntityResolver() 方法向 SAX 驅動器註冊一個實例。也就是說，對於解析一個 XML，SAX 首先讀取該 XML 文檔上的聲明，根據聲明去尋找相應的 DTD 定義，以便對文檔進行一個驗證。默認尋找規則是通過網絡下載相應的 DTD 聲明，並進行驗證。但網絡是不可靠的，因此 EntityResolver 的作用就是項目本身可以提供一個如何尋找 DTD 聲明的方法，即由程序實現尋找 DTD 聲明的過程。

2 解析以及註冊 BeanDefinition

當獲取到 Document 對象後，就可以進行解析以及註冊 BeanDefinition 了，這是重點，也是難點啊。

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
	BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
	// 已註冊的 BeanDefinition 數量
	int countBefore = getRegistry().getBeanDefinitionCount();
	// 解析以及註冊 BeanDefinition
	documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
	return getRegistry().getBeanDefinitionCount() - countBefore;
}

創建 BeanDefinitionDocumentReader 對象，主要是對 Document 文檔進行讀取。

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
	this.readerContext = readerContext;
	logger.debug("Loading bean definitions");
	// 獲取 root 元素，就是 <beans />
	Element root = doc.getDocumentElement();
	doRegisterBeanDefinitions(root);
}

protected void doRegisterBeanDefinitions(Element root) {
	BeanDefinitionParserDelegate parent = this.delegate;
	this.delegate = createDelegate(getReaderContext(), root, parent);

	if (this.delegate.isDefaultNamespace(root)) {
		String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
		if (StringUtils.hasText(profileSpec)) {
			String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
					profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
				if (logger.isInfoEnabled()) {
					logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
							"] not matching: " + getReaderContext().getResource());
				}
				return;
			}
		}
	}
	// 鉤子方法，默認爲空實現，子類可以重寫
	preProcessXml(root);
	// 解析以及註冊
	parseBeanDefinitions(root, this.delegate);
	// 鉤子方法，默認爲空實現，子類可以重寫
	postProcessXml(root);

	this.delegate = parent;
}

此方法還並不是真正去解析以及註冊 BeanDefinition，真正解析以及註冊的邏輯是通過調用 parseBeanDefinitions() 方法完成。

/**
 * Parse the elements at the root level in the document:
 * "import", "alias", "bean".
 * @param root the DOM root element of the document
 */
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
	if (delegate.isDefaultNamespace(root)) {
		// 獲取 <beans /> 元素下所有子節點
		NodeList nl = root.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			if (node instanceof Element) {
				Element ele = (Element) node;
				// spring 定義的元素
				if (delegate.isDefaultNamespace(ele)) {
					// 解析
					parseDefaultElement(ele, delegate);
				}
				else {
					delegate.parseCustomElement(ele);
				}
			}
		}
	}
	else {
		delegate.parseCustomElement(root);
	}
}

因爲在 spring 的 XML 配置裏面有兩大類 bean 聲明，一個默認的，如：

<bean id="test" class="test.Test" />

另一類就是自定義的，如：

<tx:annotation-driven />

默認元素和自定義元素的解析有比較大的差距，默認的當然不用說，spring 肯定知道怎麼去解析它，但如果是自定義的元素，那麼就需要用戶實現一些接口以及配置了。對於根節點或者子節點，如果是自定義的話使用 delegate.parseCustomElement() 方法對自定義命名空間進行解析。而判斷是否是默認命名還是自定義命名空間的辦法其實就是使用 node.getNamepsaceURI() 獲取命名空間，並與 spring 中固定的命名空間 http://www.springframework.org/schema/beans 進行對比。如果不一致就是自定義。

2.1 解析默認標籤

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
	// 解析 <import /> 元素
	if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
		importBeanDefinitionResource(ele);
	}
	// 解析 <alias /> 元素
	else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
		processAliasRegistration(ele);
	}
	// 解析 <bean /> 元素
	else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
		processBeanDefinition(ele, delegate);
	}
	else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
		// 遞歸解析 <beans /> 元素
		doRegisterBeanDefinitions(ele);
	}
}

方法邏輯一目瞭然，就是對 4 種不同標籤進行解析，而對 <bean /> 元素的解析是最爲複雜也是最爲重要的，所以我們從此元素開始分析。

2.1.1 bean 標籤的解析及註冊

/**
 * 解析給定的 <bean> 元素, 解析 BeanDefinition 並往註冊中心註冊
 */
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
	// 解析
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		// 若存在默認標籤的子節點下再有自定義屬性，還需要再次對自定義標籤進行解析
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			// 註冊
			BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
		}
		catch (BeanDefinitionStoreException ex) {
			getReaderContext().error("Failed to register bean definition with name '" +
					bdHolder.getBeanName() + "'", ele, ex);
		}
		// 發送註冊事件，通知相關監聽器，這個 bean 加載完成
		getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
	}
}

終於找到了解析以及註冊 BeanDefinition 的入口，我們先分析下 BeanDefinitionParserDelegate 類的 parseBeanDefinitionElement(ele) 方法，此方法之後直接調用 parseBeanDefinitionElement(ele, null) 這個方法。

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
	// 獲取 id 屬性
	String id = ele.getAttribute(ID_ATTRIBUTE);
	// 獲取 name 屬性
	String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

	List<String> aliases = new ArrayList<String>();
	// name 屬性不爲空
	if (StringUtils.hasLength(nameAttr)) {
		// 通過 ,和; 對其進行分割
		String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
		aliases.addAll(Arrays.asList(nameArr));
	}

	// beanName 爲 id 屬性值
	String beanName = id;
	// id 屬性值爲空，但 name 屬性值不爲空
	if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
		// beanName 爲別名當中第一個值
		beanName = aliases.remove(0);
		if (logger.isDebugEnabled()) {
			logger.debug("No XML 'id' specified - using '" + beanName +
					"' as bean name and " + aliases + " as aliases");
		}
	}

	if (containingBean == null) {
		// 保證 beanName 唯一
		checkNameUniqueness(beanName, aliases, ele);
	}
	
	// 解析 BeanDefinition，忽略 beanName 和 alias，解析錯誤返回 null
	AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

	if (beanDefinition != null) { // 解析正常，處理 beanName
		if (!StringUtils.hasText(beanName)) { // 沒有定義 beanName
			try {
				// 如果 <bean> 元素作爲子元素，spring 自動生成 beanName
				if (containingBean != null) {
					beanName = BeanDefinitionReaderUtils.generateBeanName(
							beanDefinition, this.readerContext.getRegistry(), true);
				}
				else {
					// spring 自動生成 beanName
					beanName = this.readerContext.generateBeanName(beanDefinition);
					// Register an alias for the plain bean class name, if still possible,
					// if the generator returned the class name plus a suffix.
					// This is expected for Spring 1.2/2.0 backwards compatibility.	
					String beanClassName = beanDefinition.getBeanClassName();
					if (beanClassName != null &&
							beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
							!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
						aliases.add(beanClassName);
					}
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Neither XML 'id' nor 'name' specified - " +
							"using generated bean name [" + beanName + "]");
				}
			}
			catch (Exception ex) {
				error(ex.getMessage(), ele);
				return null;
			}
		}
		String[] aliasesArray = StringUtils.toStringArray(aliases);
		// 構造 BeanDefinitionHolder，一個 <bean> 元素一個 BeanDefinitionHolder
		return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
	}

	return null;
}

這就是對 <bean /> 元素解析的全過程了，主要過程概括如下：

提取元素中的 id 和 name 屬性
進一步解析其他所有屬性並同意封裝至 GenericBeanDefinition 類型的實例中
如果檢測到 bean 沒有指定 beanName，那麼使用默認規則爲此 bean 生成 beanName
將獲取到的信息封裝到 BeanDefinitionHolder 的實例中

我們深入第二步查看對其他屬性的解析過程：

public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, BeanDefinition containingBean) {
	this.parseState.push(new BeanEntry(beanName));

	// 解析 class 屬性
	String className = null;
	if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
		className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
	}

	try {
		String parent = null;
		if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
			parent = ele.getAttribute(PARENT_ATTRIBUTE);
		}
		// 創建承載屬性的 AbstractBeanDefinition 類型的 GenericBeanDefinition
		AbstractBeanDefinition bd = createBeanDefinition(className, parent);

		// 解析 <bean> 元素的其他屬性
		parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
		// 讀取 description
		bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

		// 解析元數據
		parseMetaElements(ele, bd);
		// 解析 lookup-method 子元素
		parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
		// 解析 replaced-method 子元素
		parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

		// 解析構造函數參數
		parseConstructorArgElements(ele, bd);
		// 解析 property 子元素
		parsePropertyElements(ele, bd);
		// 解析 qualifier 子元素
		parseQualifierElements(ele, bd);

		bd.setResource(this.readerContext.getResource());
		bd.setSource(extractSource(ele));

		return bd;
	}
	catch (ClassNotFoundException ex) {
		error("Bean class [" + className + "] not found", ele, ex);
	}
	catch (NoClassDefFoundError err) {
		error("Class that bean class [" + className + "] depends on not found", ele, err);
	}
	catch (Throwable ex) {
		error("Unexpected failure during bean definition parsing", ele, ex);
	}
	finally {
		this.parseState.pop();
	}

	return null;
}

終於可以看到對 <bean /> 元素其他屬性進行解析了，不過不會像表面看起來這麼簡單，方法調用一下就 ok 了，有些複雜的屬性是需要注意的。

在進入細節之前，我們先了解一下 spring 中的 BeanDefinition 接口。它的類圖如圖所示：

從圖中可以看到 BeanDefinition 有四種實現，其中三種實現都繼承了 AbstractBeanDefinition，其中BeanDefinition是配置文件 <bean /> 元素在容器中的內部表現形式，它跟 <bean /> 中的屬性是一一對應的。其中 RootBeanDefinition 是最常用的實現類，它賭贏一般性的 <bean /> 元素，GenericBeanDefinition 是一站式服務。
在配置文件中可以自定義 <bean /> 和子 <bean />，父用 RootBeanDefinition 表示，而子用ChildBeanDefinition 表示，而沒有父級關係的就使用 RootBeanDefinition 表示，AbstractBeanDefinition 是對兩者共同的類信息進行抽象。

在進入對 <bean /> 元素的屬性解析之前，我們先瞧瞧對其子元素的解析。

解析子元素 lookup-method

子元素 lookup-method 在實際的開發者並不是很常用，但是在某些時候還是非常有用的，通常它被稱爲獲取器注入。***獲取器注入是一種特殊的方法注入，它是把一個方法聲明爲返回某種類型的 bean，但實際要返回的 bean 是在配置文件裏面配置的，此方法可以用在設計有些可插拔的功能上，解除程序依賴。**比如如下例子：

public class User {
	public void show() {
		System.out.println("i am user");
	}
}

public class Teacher extends User {
	public void show() {
		System.out.println("i am teacher");
	}
}

public abstract class GetBeanTest {
	public void show() {
		this.getBean().show();
	}
	
	public abstract User getBean();
}

public class Main {
	public static void main(String[] args) {
		ApplicationContext ioc = new ClassPathXmlApplicationContext("test.xml");
		GetBeanTest test = (GetBeanTest) ioc.getBean("getBeanTest");
		test.show();
	}
}

我們已經把類都寫好了，除了配置文件。大家看到 GetBeanTest 是一個抽象類，沒有子類繼承實現抽象方法，怎麼還可以使用呢？那麼 lookup-method 元素就有用武之地了。

<?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="getBeanTest" class="GetBeanTest">
    	<lookup-method name="getBean" bean="teacher" />
    </bean>
    
    <bean id="teacher" class="Teacher" />
</beans>

這個配置完成的功能就是動態地將 teacher 所代表的 bean 做爲 getBean() 方法的返回值。可以想象底層應該是由動態代理完成的。
此時再看看 spring 對 <lookup-method /> 子元素的解析邏輯，應該就比較清晰了。

public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
	NodeList nl = beanEle.getChildNodes();
	for (int i = 0; i < nl.getLength(); i++) {
		Node node = nl.item(i);
		if (isCandidateElement(node) && nodeNameEquals(node, LOOKUP_METHOD_ELEMENT)) {
			Element ele = (Element) node;
			// 獲取要修飾的方法名
			String methodName = ele.getAttribute(NAME_ATTRIBUTE);
			// 獲取配置返回的 bean
			String beanRef = ele.getAttribute(BEAN_ELEMENT);
			// 封裝
			LookupOverride override = new LookupOverride(methodName, beanRef);
			override.setSource(extractSource(ele));
			overrides.addOverride(override);
		}
	}
}

解析子元素 replace-method

可以在運行時用新的方法替換現有的方法。跟 lookup-method 不同的是，它不但可以動態地替換返回實體 bean，而且還能動態地更改原有方法的邏輯。

<?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="xxx" class="Xxx">
    	<replaced-method name="methodName" replacer="replacer" />
    </bean>
</beans>

解析 constructor-arg 子元素

代碼比較多，就不貼了，總結下過程。
- 如果指定了 index 屬性
  1. 解析 constructor-arg 的子元素
  2. 使用 ConstructorArgumentValues.ValueHolder 類型來封裝解析出來的元素。
  3. 將 type、name 和 index 屬性一併封裝在 ValueHolder 類型中，並添加至當前 BeanDefinition 的 constructorArgumentValues 的 indexedArgumentValues 屬性中。
- 如果沒有指定 index 屬性
  1. 解析 constructor-arg 的子元素
  2. 使用 ConstructorArgumentValues.ValueHolder 類型來封裝解析出來的元素。
  3. 將 type、name 和 index 屬性一併封裝在 ValueHolder 類型中，並添加至當前 BeanDefinition 的 constructorArgumentValues 的 genericArgumentValues 屬性中。

當我們創建了 bean 信息的承載實例後，就可以進行屬性解析了，首先我們看看 parseBeanDefinitionnAttributes() 方法，它對所有元素進行解析。

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
			BeanDefinition containingBean, AbstractBeanDefinition bd) {
	if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
		error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
	}
	// 解析 scope 屬性
	else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
		bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
	}
	else if (containingBean != null) {
		// 內嵌 bean 的 scope 屬性可以來自父 bean
		bd.setScope(containingBean.getScope());
	}
	// 解析 abstract 屬性
	if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
		bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
	}

	// 解析 lazy-init 屬性
	String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
	// 如果爲默認值，lazyInit 爲當前所解析文檔的默認 lazy-init 標誌
	if (DEFAULT_VALUE.equals(lazyInit)) {
		lazyInit = this.defaults.getLazyInit();
	}
	bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

	// 解析 autowire 屬性
	String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
	// 設置 autowire 模式（0（no）、1（byName）、2（byType）、3（構造器）、4（自動發現））
	bd.setAutowireMode(getAutowireMode(autowire));
	// 依賴檢查
	String dependencyCheck = ele.getAttribute(DEPENDENCY_CHECK_ATTRIBUTE);
	bd.setDependencyCheck(getDependencyCheck(dependencyCheck));
	// 解析 depends-on 屬性
	if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
		String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
		bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
	}
	
	// 解析 autowire-candidate 屬性
	String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
	if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {
		String candidatePattern = this.defaults.getAutowireCandidates();
		if (candidatePattern != null) {
			String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
			bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
		}
	}
	else {
		bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
	}
	// 解析 primary 屬性
	if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
		bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
	}

	// 解析 init-method 屬性
	if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
		String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
		if (!"".equals(initMethodName)) {
			bd.setInitMethodName(initMethodName);
		}
	}
	else {
		if (this.defaults.getInitMethod() != null) {
			bd.setInitMethodName(this.defaults.getInitMethod());
			bd.setEnforceInitMethod(false);
		}
	}

	// 解析 destroy-method 屬性
	if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
		String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
		bd.setDestroyMethodName(destroyMethodName);
	}
	else {
		if (this.defaults.getDestroyMethod() != null) {
			bd.setDestroyMethodName(this.defaults.getDestroyMethod());
			bd.setEnforceDestroyMethod(false);
		}
	}

	// 解析 factory-method 屬性
	if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
		bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
	}
	// 解析 factory-bean 屬性
	if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
		bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
	}

	return bd;
}

那麼到現在我們對默認標籤的解析與提取已經大致瞭解了，已經從 xml 文件中的配置形式轉換成了可以在內存中表示的 GenericBeanDefinition。那麼接下來就需要看看對默認標籤中的自定義標籤的解析。

2.1.2 默認標籤中的自定義標籤解析。

由於前面內容過多，可能現在回頭都不清楚從哪開始的了，我們在看下解析默認標籤方法的起始地方。(DefaultBeanDefinitionDocumentReader)

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		// 對 BeanDefinition 進行裝飾
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			// 註冊
			BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
		}
		catch (BeanDefinitionStoreException ex) {
			getReaderContext().error("Failed to register bean definition with name '" +
					bdHolder.getBeanName() + "'", ele, ex);
		}
		// 發送事件
		getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
	}
}

起初看這段代碼可能會有疑問，decorateBeanDefinition() 方法到底是幹啥的？如果我們有遇到這種使用方式，那麼應該就明白了。

<bean id="test" class="Test">
	<test:user username="test" />
</bean>

當在默認標籤下面的子元素爲自定義的標籤時，這段代碼就起作用了，但是之前有提到 spring 是對標籤分兩類：默認標籤和自定義標籤。在這裏，**這個自定義標籤並不是以 Bean 的像是出現的，我們之前提到的兩種不同類型的處理只是針對 bean 的。**具體解析就不在這裏贅述了，不是很重要。

Spring 源碼閱讀(二)：bean 元素解析以及註冊

1 XML 的驗證模式

1.1 驗證模式

2 解析以及註冊 BeanDefinition

2.1 解析默認標籤

2.1.1 bean 標籤的解析及註冊

2.1.2 默認標籤中的自定義標籤解析。

985 碩士程序員，空窗 4 個月沒有 Offer！

一文搞懂 Spring 循環依賴

賽博鬥地主——使用大語言模型扮演Agent智能體玩牌類遊戲。

VScode右鍵打開(添加到右鍵)

記一次 .NET某工控視覺自動化系統卡死分析

Java併發——深入 ThreadPoolExecutor 任務執行原理

Java併發——深入 ReadWriteLock 原理

Java併發——別再問 ReentrantLock 的原理了

Mybatis 源碼分析：Mapper 解析過程

Mybatis 源碼分析：SqlSessionFactory 的創建過程

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結