Spring 源码阅读(二)：bean 元素解析以及注册

最新推荐文章于 2022-08-29 15:31:13 发布

迷茫的老人

最新推荐文章于 2022-08-29 15:31:13 发布

阅读量164

点赞数

分类专栏： spring 文章标签： spring bean 解析

本文链接：https://blog.csdn.net/henlf/article/details/83834055

版权

spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

在上一篇文章中，我们了解了加载 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 类图

从图中可以看到 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 的。**具体解析就不在这里赘述了，不是很重要。

迷茫的老人

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录