默认标签的解析

最新推荐文章于 2022-04-30 09:23:44 发布

不许人间到白头~

最新推荐文章于 2022-04-30 09:23:44 发布

阅读量531

点赞数 1

分类专栏： Spring源码系列文章标签： java spring

本文链接：https://blog.csdn.net/my_air/article/details/121559807

版权

Spring源码系列专栏收录该内容

5 篇文章 0 订阅

订阅专栏

简介

Spring 中的标签分为 默认标签和自定义标签两种，而两种标签的用法以及解析方式存在着很大的不同。

默认标签的解析是在parseDefaultElement 函数中进行的，函数中的功能逻辑一目了然，分别对4中不同标签（import, alias, bean, beas）做了不同的处理。

DefaultBeanDefinitionDocumentReader.java

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);
		}
    	// 对beans标签的处理
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}

bean 标签的解析及注册

在这4中标签的解析中，对bean标签的解析最为复杂也最为重要，所以我们从此标签开始深入分析，如果能够理解此标签的解析过程，其他标签也自然就懂了。首先看bean标签的解析函数processBeanDefinition(ele, delegate)：

DefaultBeanDefinitionDocumentReader.java

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    // 进行元素解析，封装成BeanDefinitionHolder 实例
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
            // 当返回的bdHolder不为空的时候，若存在默认标签的子节点下再有自定义属性，还需要再次对自定义标签进行解析
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// Register the final decorated instance.
                // 解析完成后，需要对解析后的bdHolder 进行注册，
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			// Send registration event.
            // 发出响应时间，通知相关的监听器，这个bean已经加载完成了
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}

这个大致的逻辑总结如下：

首先委托 BeanDefinitionDelegate 类的parseBeanDefinitionElement 方法进行元素解析，返回BeanDefinitionHolder 类型的实例 bdHolder, 经过这个方法后，bdHolder 实例以及包含我们配置文件中配置的各种属性了，例如class,name, id，alias 之类的属性。
当返回的bdHolder 不为空的情况下若存在默认标签的子节点下再有自定义属性，还需要再次对自定义标签进行解析。
解析完成后，需要对解析后的bdHolder 进行注册，同样，注册操作委托给了BeanDefinitionReaderUtils 的 registerBeanDefinition 方法。
最后发出响应事件，通知相关的监听器，这个bean 已经加载完成了，

时序图：
在这里插入图片描述

解析BeanDefinition

下面我们就针对各个操作做具体的分析。首先我们从元素解析及信息提取开始，也就是BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); 进入 BeanDefinitionDelegate 类的 parseBeanDefinitionElement 方法。

BeanDefinitionDelegate.java

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
		return parseBeanDefinitionElement(ele, null);
}

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
    // 解析id属性， ID_ATTRIBUTE = 'id'
		String id = ele.getAttribute(ID_ATTRIBUTE);
    // 解析name属性， NAME_ATTRIBUTE = 'name'
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

    // 分割name 属性，放入到aliases 集合中
		List<String> aliases = new ArrayList<>();
		if (StringUtils.hasLength(nameAttr)) {
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			aliases.addAll(Arrays.asList(nameArr));
		}

		String beanName = id;
		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
			beanName = aliases.remove(0);
			if (logger.isTraceEnabled()) {
				logger.trace("No XML 'id' specified - using '" + beanName +
						"' as bean name and " + aliases + " as aliases");
			}
		}

		if (containingBean == null) {
			checkNameUniqueness(beanName, aliases, ele);
		}
		// 进一步解析其他所有属性并统一封装至GenericBeanDefinition类型的实例中。
		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		if (beanDefinition != null) {
			if (!StringUtils.hasText(beanName)) {
				try {
                    // 如果不存在beanBane,那么根据Spring中提供的命名规则为当前bean生成对应的beanName
					if (containingBean != null) {
						beanName = BeanDefinitionReaderUtils.generateBeanName(
								beanDefinition, this.readerContext.getRegistry(), true);
					}
					else {
						beanName = this.readerContext.generateBeanName(beanDefinition);
						String beanClassName = beanDefinition.getBeanClassName();
						if (beanClassName != null &&
								beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
								!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
							aliases.add(beanClassName);
						}
					}
					if (logger.isTraceEnabled()) {
						logger.trace("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);
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}

		return null;
	}

以上就是对默认标签解析的全过程了。当然，对Spring的解析犹如洋葱剥皮一样，一层一层的进行，尽管现在只能看到对属性id以及 name的解析，但是很庆幸，思路我们以及了解了。在开始对属性展开全面解析前，Spring在外层又做了一个当前层的功能结构，在当前层完成的主要工作包括如下内容。

提取元素中的id以及name属性。
进一步解析其他所有属性并统一封装至GenericBeanDefinition类型的实例中。
如果检查到bean 没有指定beanName, 那么使用默认规则为此Bean生成beanName。
将获取到的信息封装到BeanDefinitionHolder的实例中。

我们进一步查看步骤2中对标签其他属性的解析过程

BeanDefinitionParserDelegate.java

public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, @Nullable BeanDefinition containingBean) {

		this.parseState.push(new BeanEntry(beanName));

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

		try {
            // 创建用于承载属性的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标签的所有属性，不论常用的还是不常用的我们都看到了，金冠有些复杂的属性还需要进一步的解析，不过丝毫不会影响我们兴奋的心情。接下来，我们继续分析一些复杂标签属性的解析。

创建用于属性承载的BeanDefinition

BeanDefintion 是一个接口，在Spring 中存在三种实现： RootBeanDefinition,ChildBeanDefinition 以及 GenericBeanDefinition.三种实现均继承了AbstractBeanDefinition, 其中BeanDefinition 是配置文件<bean> 元素标签在容器中的内部表示形式。<bean> 元素标签用于class, scope, lazy-init 等配置属性， BeanDefinition 则提供了相应的beanClass, scope, lazyInit 属性，BeanDefinition 和<bean> 中的属性是一一对应的。其中RootBeanDefinition 是最常用的实现类，它对应一般性的元素标签， GenericBeanDefinition 是自2.5 版本以后新加入的bean 文件配置属性定义类，是一站式服务类。

在配置文件中可以定义父<bean> 和子<bean>，父<bean> 用RootBeanDefinition 表示，而子<bean> 用ChildBeanDefinition 对两者共同的类信息进行抽象。

Spring 通过 BeanDefinition 将配置文件中的<bean> 配置信息转换为容器的内部表示，并将这些BeanDefinition 注册到BeanDefinitionRegistry 中，Spring 容器的BeanDefinitionRegistry 就像是Spring 配置信息的内存数据库，主要是以map的形式保存，后续操作直接从BeanDefinitionRegistry 中读取配置信息。他们之间的关系如图所示。
在这里插入图片描述
由此可知，要解析属性首先要创建用于承载属性的实例，也就是创建GenericBeanDefinition 类型的实例。而代码createBeanDefiniiton(className, parent) 的作用就是实现此功能。

BeanDefinitionParserDelegate.java

protected AbstractBeanDefinition createBeanDefinition(@Nullable String className, @Nullable String parentName)
			throws ClassNotFoundException {

		return BeanDefinitionReaderUtils.createBeanDefinition(
				parentName, className, this.readerContext.getBeanClassLoader());
	}

BeanDefinitionReaderUtils.java

public static AbstractBeanDefinition createBeanDefinition(
			@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {

		GenericBeanDefinition bd = new GenericBeanDefinition();
    // parentName 可能为空
		bd.setParentName(parentName);
		if (className != null) {
			if (classLoader != null) {
                // 如果classLoader不为空，则使用传入的classLoader 同一虚拟机加载类对象，否则只是记录className
				bd.setBeanClass(ClassUtils.forName(className, classLoader));
			}
			else {
				bd.setBeanClassName(className);
			}
		}
		return bd;
	}

说明一下：查看一下GenericBeanDefinition 的源码

public class GenericBeanDefinition extends AbstractBeanDefinition {

	@Nullable
	private String parentName;


	/**
	 * Create a new GenericBeanDefinition, to be configured through its bean
	 * properties and configuration methods.
	 * @see #setBeanClass
	 * @see #setScope
	 * @see #setConstructorArgumentValues
	 * @see #setPropertyValues
	 */
	public GenericBeanDefinition() {
		super();
	}

	/**
	 * Create a new GenericBeanDefinition as deep copy of the given
	 * bean definition.
	 * @param original the original bean definition to copy from
	 */
	public GenericBeanDefinition(BeanDefinition original) {
		super(original);
	}


	@Override
	public void setParentName(@Nullable String parentName) {
		this.parentName = parentName;
	}

	@Override
	@Nullable
	public String getParentName() {
		return this.parentName;
	}


	@Override
	public AbstractBeanDefinition cloneBeanDefinition() {
		return new GenericBeanDefinition(this);
	}

	@Override
	public boolean equals(@Nullable Object other) {
		if (this == other) {
			return true;
		}
		if (!(other instanceof GenericBeanDefinition)) {
			return false;
		}
		GenericBeanDefinition that = (GenericBeanDefinition) other;
		return (ObjectUtils.nullSafeEquals(this.parentName, that.parentName) && super.equals(other));
	}

	@Override
	public String toString() {
		if (this.parentName != null) {
			return "Generic bean with parent '" + this.parentName + "': " + super.toString();
		}
		return "Generic bean: " + super.toString();
	}

}

发现他继承了AbstractBeanDefinition，只是在自己的代码中添加了一个parentName 属性，并重写了cloneBeanDefinition 原型方法，其他都是用父类的属性以及方法。

解析各种属性

当我们创建了bean信息的承载实例后，便可以进行bean信息的各种属性解析了，首先我们进入parseBeanDefinitionAttributes 方法。parseBeanDefinitionAttbutes 方法是对element所有元素属性进行解析：

BeanDefinitionParserDelegate.java

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
			@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
		// 解析singleton 属性，现在使用scope代替singleton，singleton不允许使用了
		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) {
			// Take default from containing bean in case of an inner bean definition.
			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);
		if (isDefaultValue(lazyInit)) {
			lazyInit = this.defaults.getLazyInit();
		}
    	// 若没有设置或设置成其他字符都会被设置为false, 这个方法很秀，可以防止无效字符
		bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
		// 解析autowire 属性
		String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
		bd.setAutowireMode(getAutowireMode(autowire));
		// 解析 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 (isDefaultValue(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);
			bd.setInitMethodName(initMethodName);
		}
		else if (this.defaults.getInitMethod() != null) {
			bd.setInitMethodName(this.defaults.getInitMethod());
			bd.setEnforceInitMethod(false);
		}
// 解析idestroy-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);
		}
// 解析 facotory-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;
	}

可以看到Spring 完成了对所欲bean属性的解析，这些属性中有很多是我们经常使用的。

解析子元素 meta

在开始解析元数据的分析前，我们先看一下元数据meta属性的使用。

<bean id='myTestBean' class="com.zh.sound.pojo.MyTestBean">
	<meta key="testStr" value="aaaaaa"/>
</bean>

这段代码并不会体现再MyTestBean 的属性当中，而是一个额外的声明，当需要使用里面的信息的时候，可以通过BeanDefinition 的 getAttribute(key)方法进行获取。对meta 属性的解析代码如下

BeanDefinitionParserDelegate.java

public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {
    // 获取当前节点的所有子元素
		NodeList nl = ele.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
            // 提取meta 属性
			if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) {
				Element metaElement = (Element) node;
				String key = metaElement.getAttribute(KEY_ATTRIBUTE);
				String value = metaElement.getAttribute(VALUE_ATTRIBUTE);
                // 使用 key, value 构造 BeanMetadateAttribute
				BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
				attribute.setSource(extractSource(metaElement));
                // 记录信息
				attributeAccessor.addMetadataAttribute(attribute);
			}
		}
	}

解析子元素 lookup-method

同样，子元素lookup-method 不是很常用，但是在某些时候他的确是非常有用的属性，通常我们称它为获取器注入。引用 Spring in Action 中的一句话：获取器注入是一种特殊的方法注入，它是把一个方法声明为返回某中类型的bean, 但实际要返回的bean 是在配置文件里面配置的，此方法可用在设计有些可插拔的功能上，解除程序的依赖。我们看看具体的应用:

首先创建一个父类：

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

创建子类并覆盖父类方法

public class Teacher extends User{

	@Override
	public void showMe(){
		System.out.println("i am teacher");
	}
}

创建调用方法

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

创建测试方法：

public class TestShowMe {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("spring-bean1.xml");
		GetBeanTest getBeanTest = (GetBeanTest) context.getBean("getBeanTest");
		getBeanTest.showMe();
	}
}

到此为止，除了配置文件外，整个测试方法就完成了，如果之前没有接触过获取器注入的可能会有疑问：抽象方法还没有实现，怎么可以直接注入Spring, 并且可以直接调用那？答案就在Spring 为我们提供的获取器中，我们看看配置文件是怎么配置的。

<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="teacher" class="com.zh.sound.pojo.Teacher"/>

	<bean id="getBeanTest" class="com.zh.sound.pojo.GetBeanTest" >
		<lookup-method name="getBean" bean="teacher"/>
	</bean>

</beans>

在配置文件中，我们看到了源码解析中提到的 lookup-method 子元素，这个配置完成的功能是动态的将teacher所代表的bean 作为getBean 的返回值，运行测试方法我们就会看到控制台上的输出：

i am teacher

当我们的业务变更或者在其他情况下，teacher 里面的业务逻辑已经不再符合我们的业务要求，需要进行替换怎么办那？这是我们需要增加新的逻辑类：

public class Student extends User{
	@Override
	public void showMe(){
		System.out.println("i am student");
	}
}

同时修改配置文件：

<?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="teacher" class="com.zh.sound.pojo.Teacher"/>
	<bean id="student" class="com.zh.sound.pojo.Student"/>

	<bean id="getBeanTest" class="com.zh.sound.pojo.GetBeanTest" >
		<lookup-method name="getBean" bean="student"/>
	</bean>

</beans>

再次运行测试类，会发现不一样的结果：

i am student

到此为止，我们已经初步了解了lookup-method 子元素所提供的大致功能，相信这时再次去看他的属性提取源码会觉得更有针对性。

BeanDefinitionParserDelegate.java

public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
    // 获取当前节点的子元素
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
            // 仅当在Spring 默认bean的子元素下且为 <lookup-method 时有效
			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 对象
				LookupOverride override = new LookupOverride(methodName, beanRef);
				override.setSource(extractSource(ele));
                // 记录信息
				overrides.addOverride(override);
			}
		}
	}

是不是看上面的代码很熟悉，似乎与parseMetaElements 的代码大同小异，最大的区别就是在if判断中的节点名称，在这里被修改为LOOKUP_METHOD_ELEMENT。还有就是在数据存储上面使用了LookupOverride 类型的实体类来进行数据承载并记录在AbstractBeanDefinition 中的methodOverrides 属性中。

解析子元素 replaced-method

这个方法主要是对bean 中 replaced-method 子元素的提取，在开始提取分析之前我们开始先介绍下这个元素的用法。

方法替换：可以在运行时用新的方法替换现有的方法。与之前的lookup-method 不同的是，replaced-method 不但可以动态的替换返回实体bean, 而且还能动态的更改原有方法的逻辑。我们来看看使用示例。

在changeMe 中完成某个业务逻辑

public class TestChangeMethod {
	public void changeMe(){
		System.out.println("changeMe");
	}
}

在运营一段时间后需要改变原有的业务逻辑。

public class TestMethodReplacer implements MethodReplacer {
	@Override
	public Object reimplement(Object obj, Method method, Object[] args) throws Throwable {
		System.out.println("我们替换了原有方法");
		return null;
	}
}

修改配置文件

<?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="replacer" class="com.zh.sound.replaced.TestMethodReplacer"/>


	<bean id="testChangeMethod" class="com.zh.sound.replaced.TestChangeMethod" >
		<replaced-method  name="changeMe" replacer="replacer"/>
	</bean>

</beans>

测试

public class TestMain {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("spring-replace.xml");
		TestChangeMethod testChangeMethod = (TestChangeMethod) context.getBean("testChangeMethod");
		testChangeMethod.changeMe();
	}
}
// 输出结果为：我们替换了原有方法

知道了这个元素的用法，接下来我们在查看元素的提取过程：

BeanDefinitionParserDelegate.java

public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {
    // 获取当前元素的子节点
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
            // 仅当Spring 默认bean的子元素下且为 <replaced-method 时有效
			if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) {
				Element replacedMethodEle = (Element) node;
                // 提取要替换的旧的方法名
				String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);
                // 提取对应的新的替换方法
				String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);
                // 将数据封装成 ReplaceOverride 对象
				ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
				// Look for arg-type match elements.
				List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT);
				for (Element argTypeEle : argTypeEles) {
					String match = argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE);
					match = (StringUtils.hasText(match) ? match : DomUtils.getTextValue(argTypeEle));
					if (StringUtils.hasText(match)) {
						replaceOverride.addTypeIdentifier(match);
					}
				}
				replaceOverride.setSource(extractSource(replacedMethodEle));
                // 记录参数
				overrides.addOverride(replaceOverride);
			}
		}
	}

可以看到无论是lookup-mehtod 还是 replaced-method 都是构造了一个MethodOverride, 并最终记录在了 AbstractBeanDefinition 中的 methodOverrides 属性中。而这个属性如何使用以完成它所提供的功能我们在后续详细的介绍.

解析子元素constructor-arg

这个元素想必大家都非常的熟悉，就是构造函数，举个小栗子：

public class HelloWorld {

	public String str;

	public HelloWorld(){}

	public HelloWorld(String str){
		this.str = str;
	}

	public HelloWorld(String str, String str1){
		this.str = str;
		System.out.println(str1);
	}
}

<bean id="helloWorld" class="com.zh.sound.constuctor.HelloWorld">
		<constructor-arg index="0">
			<value>张三</value>
		</constructor-arg>
		<constructor-arg index="1">
			<value>李四</value>
		</constructor-arg>
	</bean>

上面的配置是Spring 构造函数配置中最基础的配置，实现的功能就是对 HelloWorld 自动寻找对应的构造函数，并在初始化的时候将设置的参数传入进去。那么让我们来看看具体的解析过程。对于 constructor-arg 子元素的解析，Spring 是通过parseConstructorArgElements 函数来实现的，具体的代码如下：

BeanDefinitionParserDelegate.java

public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
             // 仅当Spring 默认bean的子元素下且为 <constructor-arg  时有效
			if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {
                // 具体的解析constructor-arg 过程
				parseConstructorArgElement((Element) node, bd);
			}
		}
	}

public void parseConstructorArgElement(Element ele, BeanDefinition bd) {
    // 提取index 属性
		String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);
    // 提取 type属性
		String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);
    // 提取name 属性
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
		if (StringUtils.hasLength(indexAttr)) {
			try {
				int index = Integer.parseInt(indexAttr);
				if (index < 0) {
					error("'index' cannot be lower than 0", ele);
				}
				else {
					try {
						this.parseState.push(new ConstructorArgumentEntry(index));
                        // 解析ele对应的属性元素
						Object value = parsePropertyValue(ele, bd, null);
						ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
						if (StringUtils.hasLength(typeAttr)) {
							valueHolder.setType(typeAttr);
						}
						if (StringUtils.hasLength(nameAttr)) {
							valueHolder.setName(nameAttr);
						}
						valueHolder.setSource(extractSource(ele));
                        // 不允许重复指定相同参数
						if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {
							error("Ambiguous constructor-arg entries for index " + index, ele);
						}
						else {
							bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);
						}
					}
					finally {
						this.parseState.pop();
					}
				}
			}
			catch (NumberFormatException ex) {
				error("Attribute 'index' of tag 'constructor-arg' must be an integer", ele);
			}
		}
		else {
            // 没有index 属性则忽略去属性，自动寻找
			try {
				this.parseState.push(new ConstructorArgumentEntry());
				Object value = parsePropertyValue(ele, bd, null);
				ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
				if (StringUtils.hasLength(typeAttr)) {
					valueHolder.setType(typeAttr);
				}
				if (StringUtils.hasLength(nameAttr)) {
					valueHolder.setName(nameAttr);
				}
				valueHolder.setSource(extractSource(ele));
				bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
			}
			finally {
				this.parseState.pop();
			}
		}
	}

上面一段看似复杂的代码让很多人失去了耐心，但是，涉及的逻辑其实并不复杂，首先是提取constructor-arg 上必要的属性（index, type, name）.

如果配置中指定了index属性，那么操作步骤如下。
- 解析constructor-arg 的子元素
- 使用ConstructorArgumentValues.ValueHolder 类型来封装解析出来的元素。
- 将type, name 和 index 属性一并封装在 ConstructorArgumentValues.ValueHolder 类型中，并添加至当前BeanDefinition 的constructorArgumentValues 的 indexedArgumentValues 属性中。
如果没有指定index属性，那么操作如下。
- 解析constructor-arg 的子元素。
- 使用ConstructorArgumentValues.ValueHolder 类型来封装解析出来的元素。
- 将type, name 和 index 属性一并封装在 ConstructorArgumentValues.ValueHolder 类型中，并添加至当前BeanDefinition 的constructorArgumentValues 的 genericArgumentValues 属性中。

可以看到了解了整个流程后，我们尝试着进一步了解解析构造函数配置中子元素的过程，进入parsePropertyValue

BeanDefinitionParserDelegate.java

public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
		String elementName = (propertyName != null ?
				"<property> element for property '" + propertyName + "'" :
				"<constructor-arg> element");

		// 获取当前元素的子节点
		NodeList nl = ele.getChildNodes();
		Element subElement = null;
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
            // 如果当前节点不是 DESCRIPTION_ELEMENT 或者 META_ELEMENT则执行
			if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
					!nodeNameEquals(node, META_ELEMENT)) {
				// Child element is what we're looking for.
				if (subElement != null) {
					error(elementName + " must not contain more than one sub-element", ele);
				}
				else {
					subElement = (Element) node;
				}
			}
		}
    // 解析constructor-arg 上的 ref 属性
   		boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
    // 解析constructor-arg 上的 value 属性
		boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
		if ((hasRefAttribute && hasValueAttribute) ||
				((hasRefAttribute || hasValueAttribute) && subElement != null)) {
            /*
            * 在 constructor-arg 上不存在：
            * 	1. 同时既有 ref 属性又有 value 属性
            * 	2. 存在 ref 属性或者 value 属性且又有子元素
            */
			error(elementName +
					" is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
		}
		// ref 属性的处理，使用RuntimeBeanReference 封装对应的ref名称
		if (hasRefAttribute) {
			String refName = ele.getAttribute(REF_ATTRIBUTE);
			if (!StringUtils.hasText(refName)) {
				error(elementName + " contains empty 'ref' attribute", ele);
			}
			RuntimeBeanReference ref = new RuntimeBeanReference(refName);
			ref.setSource(extractSource(ele));
			return ref;
		}
    	// value 属性的处理，使用TypedStringValue 封装
		else if (hasValueAttribute) {
			TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
			valueHolder.setSource(extractSource(ele));
			return valueHolder;
		}
    	// 解析子元素
		else if (subElement != null) {
			return parsePropertySubElement(subElement, bd);
		}
		else {
			// 既没有ref 也没有value,也没有子元素，Spring不知所措
			error(elementName + " must specify a ref or value", ele);
			return null;
		}
	}

从代码上来看，对构造函数中属性元素的解析，经历了一下一个过程。

略过 description 或者 meta.
提取constructor-arg 上的ref 和value 属性，以便于根据规则验证正确性，其规则在为constructor-arg 上不存在以下情况
1. 同时既有ref属性又有value属性。
2. 存在ref属性或者value属性且又有子元素。
ref属性的处理，使用RuntimeBeanReference 封装对应的ref名称，如：
```
<constructor-arg ref="a">
```
value 属性的处理。使用TypedStringValue 封装，如：
```
<constructor-arg value="a">
```

子元素的处理，如：

<constructor-arg>
    <map>
        <entry key="key" value="value"/>
    </map>
</constructor-arg>

而对于子元素的处理，例如这里提到的在构造函数中又嵌入了子元素map 是怎么实现的那？parsePropertySubElement 中实现了对各种子元素的分类处理。

 BeanDefinitionParserDelegate.java

public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd) {
		return parsePropertySubElement(ele, bd, null);
}

public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {
    // 如果不是默认标签，使用自定义标签解析
		if (!isDefaultNamespace(ele)) {
			return parseNestedCustomElement(ele, bd);
		}
    // 对bean 元素的解析
		else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
			BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
			if (nestedBd != null) {
				nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
			}
			return nestedBd;
		}
    // 对ref子元素的解析
		else if (nodeNameEquals(ele, REF_ELEMENT)) {
			// A generic reference to any name of any bean.
			String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
			boolean toParent = false;
			if (!StringUtils.hasLength(refName)) {
				// A reference to the id of another bean in a parent context.
				refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
				toParent = true;
				if (!StringUtils.hasLength(refName)) {
					error("'bean' or 'parent' is required for <ref> element", ele);
					return null;
				}
			}
			if (!StringUtils.hasText(refName)) {
				error("<ref> element contains empty target attribute", ele);
				return null;
			}
			RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
			ref.setSource(extractSource(ele));
			return ref;
		}
    // 对idref 元素的解析
		else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
			return parseIdRefElement(ele);
		}
    // 对value子元素的解析
		else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
			return parseValueElement(ele, defaultValueType);
		}
    // 对 null子元素的解析
		else if (nodeNameEquals(ele, NULL_ELEMENT)) {
			// It's a distinguished null value. Let's wrap it in a TypedStringValue
			// object in order to preserve the source location.
			TypedStringValue nullHolder = new TypedStringValue(null);
			nullHolder.setSource(extractSource(ele));
			return nullHolder;
		}
    // 对 array子元素的解析
		else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
			return parseArrayElement(ele, bd);
		}
    // 对 list子元素的解析
		else if (nodeNameEquals(ele, LIST_ELEMENT)) {
			return parseListElement(ele, bd);
		}
    // 对 set子元素的解析
		else if (nodeNameEquals(ele, SET_ELEMENT)) {
			return parseSetElement(ele, bd);
		}
    // 对map子元素的解析
		else if (nodeNameEquals(ele, MAP_ELEMENT)) {
			return parseMapElement(ele, bd);
		}
		else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
			return parsePropsElement(ele);
		}
		else {
			error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
			return null;
		}
	}

到这里，上面的函数中实现了所有可支持的子类的分类处理，大致理清构造函数的解析流程。

解析子元素property

parsePropertyElement 函数完成了对property 属性的提取，property 使用方式如下：

<bean id="getBeanTest" class="com.zh.sound.pojo.GetBeanTest" >
	<property name="testStr" value="aaa"/>
</bean>

或者

<bean id="getBeanTest" class="com.zh.sound.pojo.GetBeanTest" >
    <property name="p">
    	<list>
            <value>aa</value>
            <value>bb</value>
        </list>
    </property>
</bean>

而具体的解析过程如下：

BeanDefinitionParserDelegate.java

public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
				parsePropertyElement((Element) node, bd);
			}
		}
	}

parsePropertyElement处理，parsePropertyElement 代码如下：

public void parsePropertyElement(Element ele, BeanDefinition bd) {
    // 获取配置元素中的name值
		String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
		if (!StringUtils.hasLength(propertyName)) {
			error("Tag 'property' must have a 'name' attribute", ele);
			return;
		}
		this.parseState.push(new PropertyEntry(propertyName));
		try {
            // 不允许多次对统一属性配置
			if (bd.getPropertyValues().contains(propertyName)) {
				error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
				return;
			}
            // 解析property元素中的value
			Object val = parsePropertyValue(ele, bd, propertyName);
			PropertyValue pv = new PropertyValue(propertyName, val);
			parseMetaElements(ele, pv);
			pv.setSource(extractSource(ele));
			bd.getPropertyValues().addPropertyValue(pv);
		}
		finally {
			this.parseState.pop();
		}
	}

可以看到上面函数与构造函数注入方式不同的是将返回值使用PropertyValue进行封装，并记录在了BeanDefinition中的propertyValues属性中。

解析子元素 qualifier

对于quailifer 元素的获取，我们接触很多的是注解的形式，在使用Spring框架中进行自动注入时，Spring容器中匹配的候选Bean 数目必须有且仅有一个。当找不到一个匹配的Bean时，Spring 容器将抛出BeanCreationException 异常，并指出必须至少拥有一个匹配的Bean。

Spring 允许我们通过Qualifier 指定注入Bean的名称，这样歧义就消除了，而对于配置方式使用如：

<bean id="demo" class="com.zh.sound.pojo.MyTestBean">
		<qualifier type="org.springframework.beans.factory.annotation.Qualifier" value="qf"/>
</bean>

其解析过程大同小异，不在说了。

AbstractBeanDefinition 属性

到此我们已经完成了对XML 文档到GenericBeanDefinition的转换，也就是说到这里，XML 中所有的配置都可以在 GenericBeanDefinition 的实例类中找到对应的配置。

GenericBeanDefinition只是子类实现，而大部分的通用属性都保存在了 AbstractBeanDefinition 中，那么我们再次通过AbstractBeanDefinition 的属性来回顾一下我们都解析了那些对应的配置。

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
		implements BeanDefinition, Cloneable {

	// bean的作用范围，对应bean属性scope
	@Nullable
	private String scope = SCOPE_DEFAULT;

    // 是否是抽象，对应bean属性 abstract
	private boolean abstractFlag = false;

    // 是否延迟加载，对应bean属性lazy-init
	@Nullable
	private Boolean lazyInit;

    // 自动注入模式，对应bean属性 autowire
	private int autowireMode = AUTOWIRE_NO;

    // 依赖检查，Spring3.0 后启用这个属性
	private int dependencyCheck = DEPENDENCY_CHECK_NONE;

	// 用来表示一个bean的实例化依靠另一个bean先实例化，对应bean属性depend-on
	private String[] dependsOn;

    /*
    *autowire-candidate 属性设置为false,这样容器在查找自动装配对象时，
    *将不考虑该bean，即他不会被考虑作为其他bean 自动装配的候选者，但是该bean 本身还是可以使用	*自动装配来注入其他bean的。
    * 对应bean属性autowire-candidate
    */
	private boolean autowireCandidate = true;

    // 自动装配时当出现多个bean候选者时，将作为首选者，对应bean属性primary
	private boolean primary = false;

    // 用于记录qualifier, 对应子元素qualifier
	private final Map<String, AutowireCandidateQualifier> qualifiers = new LinkedHashMap<>();

	@Nullable
	private Supplier<?> instanceSupplier;

    // 允许访问非公开的构造器和方法，程序设置
	private boolean nonPublicAccessAllowed = true;

    // 抛出异常，因为Spring 无法准确定位那个构造函数
	private boolean lenientConstructorResolution = true;

	@Nullable
	private String factoryBeanName;

	@Nullable
	private String factoryMethodName;

	// 记录构造函数注入属性，对应bean属性 constructor-arg
	private ConstructorArgumentValues constructorArgumentValues;

	// 普通属性集合
	private MutablePropertyValues propertyValues;

    // 方法重写的持有者，记录lookup-method, replaced-method 元素
	private MethodOverrides methodOverrides = new MethodOverrides();

	// 初始化方法名称，对应 init-mehtod
	private String initMethodName;

	// 销毁方法，对应bean属性destory-method
	private String destroyMethodName;
	
    // 是否执行init-method 
	private boolean enforceInitMethod = true;

    // 是否执行destory-method
	private boolean enforceDestroyMethod = true;

    // 是否是用户定义的而不是应用程序本身定义的，创建AOP时候为true
	private boolean synthetic = false;

    // 定义这个bean的应用，APPLICATION:用户，INFRASTRUCTURE:完全内部使用，与用户无关，SUPPORT:某些复杂配置的一部分
	private int role = BeanDefinition.ROLE_APPLICATION;

	// bean的描述信息
	private String description;

	// 这个bean 定义的资源
	private Resource resource;
    
    // 此处省略get,set方法
}

解析默认标签中的自定义标签元素

到这里我们已经完成了分析默认标签的解析与提取过程，或许涉及的内容太多，我们已经王了我们从哪个函数开始的了，我们再次回顾下默认标签解析函数的起始函数：

DefaultBeanDefinitionDocumentReader.java

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// Register the final decorated instance.
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			// Send registration event.
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}

我们刚刚分析了 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele)这句代码，接下来，我们进行 bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder)代码的分析，首先大致了解下这句代码的作用，起始我们可以从语义上分析：如果需要的话就对 beanDefinition进行装饰，这句代码到底是什么功能？其实这句代码适用于这样的场景，如:

<bean id="test" class="test.MyTest">
	<mybean:user username="aaa"/>
</bean>

当Spring 中bean使用的是默认的标签配置，但是其中的子元素却使用了自定义的配置时，这句代码便会起作用了。可能有人会有疑问，之前讲过，对 bean的解析分为两种类型，一种是默认类型的解析，另一种是自定义类型的解析，这不正是自定义类型的解析吗？为什么会在默认类型解析中单独添加一个方法处理那？因为这个自定义类型并不是以 Bean 的形式出现的，原来说的两种类型的不同处理只是针对 Bean 的，这里这个自定义类型其实是属性，接下来分析这段代码的逻辑:

BeanDefinitionParserDelegate.java

public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder originalDef) {
		return decorateBeanDefinitionIfRequired(ele, originalDef, null);
	}

这里将函数中第三个参数设置为空，其实这第三个参数是父类 bean, 当对某个嵌套配置进行分析时，这里需要传递父类 beanDefinition。分析源码就知道这里传递的参数是为了使用父类scope属性，以备子类若没有设置scope 时默认使用父类的属性，这里分析的是顶层的配置，所以传递null. 将第三个参数设置为空后进一步跟踪函数：

BeanDefinitionParserDelegate.java

public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
			Element ele, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {

		BeanDefinitionHolder finalDefinition = originalDef;

		// 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 函数的调用，我们继续跟踪代码：

BeanDefinitionParserDelegate

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/schema/")) {
				error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
			}
			else {
				// A custom namespace, not to be handled by Spring - maybe "xml:...".
				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));
}

到这里，条理已经非常清楚了，首先获取属性或者元素的命名空间。以此来判断该元素或者属性是否适用于自定义标签的解析条件，找出自定义类型所对应的NamespaceHandler 并进行下一步解析。在自定义标签解析的文章中会仔细讲解自定义标签的解析。所以decorateBeanDefinitionIfRequired 方法是对程序的默认标签的处理其实是直接略过的，因为默认的标签到这里已经被处理完成了，这里只对自定义的标签或者说对 bean的自定义属性感兴趣。

注册解析的 BeanDefinition

对于配置文件，解析也解析完成了，装饰也装饰完了，对于得到的 beanDefinition 已经可以满足后续的使用要求了，唯一还剩下的工作就是注册了，也就是processBeanDefinition 函数中的 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()) 代码的解析了。

BeanDefinitionReaderUtil.java

public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// 使用beanName做唯一标识注册
		String beanName = definitionHolder.getBeanName();
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// 注册所有别名
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
	}

解析的beanDefinition 都会被注册到BeanDefinitionRegistry 类型的实例 registry 中，而对于beanDefinition 的注册分成了两部分，通过beanName的注册以及通过别名的注册

通过 beanName 注册 beanDefinition

对于beanDefinition 的注册，其实就是做了注册前的最后一次校验，然后将 beanDefinition 直接放入 map中，使用beanName 作为key.

DefaultListableBeanFactory.java

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		Assert.hasText(beanName, "Bean name must not be empty");
		Assert.notNull(beanDefinition, "BeanDefinition must not be null");

		if (beanDefinition instanceof AbstractBeanDefinition) {
			try {
                // 这是注册前的最后一次校验，这里的校验不同于之前的XML文件校验。
                // 主要是对于AbstractBeanDefinition 属性中的methodOverrides 校验
                // 校验methodOverrides是否与工厂方法并存或者methodOverrides对应的方法根本不存在
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}

		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    	// 处理已经注册过的beanName 情况
		if (existingDefinition != null) {
            // 如果对应的 beanName已经注册且在配置中配置了bean不允许被覆盖，则抛出异常
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
			}
			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
				if (logger.isInfoEnabled()) {
					logger.info("Overriding user-defined bean definition for bean '" + beanName +
							"' with a framework-generated bean definition: replacing [" +
							existingDefinition + "] with [" + beanDefinition + "]");
				}
			}
			else if (!beanDefinition.equals(existingDefinition)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			else {
				if (logger.isTraceEnabled()) {
					logger.trace("Overriding bean definition for bean '" + beanName +
							"' with an equivalent definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
            // 替换旧的 bean
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
            // beanName 还没有注册，检查该工厂的bean创建阶段是否已经开始
			if (hasBeanCreationStarted()) {
				// 因为beanDefinitionMap是全局变量，会存在并发访问的情况
				synchronized (this.beanDefinitionMap) {
                    // 注册beanDefinition
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					removeManualSingletonName(beanName);
				}
			}
			else {
				// Still in startup registration phase
				this.beanDefinitionMap.put(beanName, beanDefinition);
				this.beanDefinitionNames.add(beanName);
				removeManualSingletonName(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (existingDefinition != null || containsSingleton(beanName)) {
            // 重置所有beanName 对应的缓存
			resetBeanDefinition(beanName);
		}
	}

通过上面的代码可以看到，在对于beanDefinition的注册处理方式上，主要进行了几个步骤。

对AbstractBeanDefinition 的校验。
对 beanName 已经注册的情况的处理，如果设置了不允许bean的覆盖，则需要抛出异常，否则直接覆盖
加入map缓存
清除解析之前留下的对应beanName的缓存。

通过别名注册BeanDefinition

在理解了注册bean的原理后，理解注册别名的原理就容易多了

SimpleAliasRegistry.java

public void registerAlias(String name, String alias) {
        Assert.hasText(name, "'name' must not be empty");
        Assert.hasText(alias, "'alias' must not be empty");
    	// aliasMap同样是全局变量，存在并发问题
        synchronized(this.aliasMap) {
            // 如果beanName 与alias 相同的话不记录alias，并删除对应的alias
            if (alias.equals(name)) {
                this.aliasMap.remove(alias);
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
                }
            } else {
                String registeredName = (String)this.aliasMap.get(alias);
                // alias已经存在
                if (registeredName != null) {
                    // 并且数据与已经存在的数据相同，则直接return
                    if (registeredName.equals(name)) {
                        return;
                    }
					// 如果不允许覆盖，则抛出异常
                    if (!this.allowAliasOverriding()) {
                        throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" + name + "': It is already registered for name '" + registeredName + "'.");
                    }

                    if (this.logger.isDebugEnabled()) {
                        this.logger.debug("Overriding alias '" + alias + "' definition for registered name '" + registeredName + "' with new target name '" + name + "'");
                    }
                }
				// 当 A -> B 存在时，若再次出现A -> C ->B 时则会抛出异常
                this.checkForAliasCircle(name, alias);
                this.aliasMap.put(alias, name);
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
                }
            }

        }
    }

由上面的代码可以看出alias 的步骤如下：

alias 与beanName 相同情况处理。若 alias 与beanName 并名称相同则不需要处理并删除掉原有alias.
alias覆盖处理。并且数据与已经存在的数据相同，则直接return，如果不允许覆盖则抛出异常
alias 循环检查。当 A -> B 存在时，若再次出现A -> C ->B 时则会抛出异常
注册alias

通知监听器解析及注册完成

通过代码getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder))完成此工作，这里的实现只为扩展，当需要对注册BeanDefinition时间进行监听时可以通过注册监听器的方式并将处理逻辑写入监听器中，目前在Spring 中并没有对此时间做任何逻辑处理。

alias 标签的解析

通过上面我们分析完成了默认标签中对 bean 标签的处理，那么我们之前提到过，对配置文件的解析包括对import 标签，alias标签， bean标签，beans的处理，其他的解析步骤都是围绕 bean解析而进行的，现在看看对alias 标签的解析。

在对bean进行定义时，处理使用id属性来指定名称之外，为了提供多个名称，可以使用alias标签来指定。而所有的这些名称都指向同一个bean, 在某些情况下提供别名非常有用，比如为了让应用的每一个组件能更容易的对公共组件进行引用。

在定义bean时就指定所有的别名并不是总是恰当的。有时我们期望能在当前位置为那些在别处定义的bean引入别名。在XML 配置文件中，可用单独的 <alias />元素来完成bean别名的定义，如配置文件中定义了一个JavaBean:

<bean id="testBean" class="com.test"/>

要给这个JavaBean 增加别名，以方便不同对象来调用，我们就可以直接使用bean 标签中的name属性

<bean id="testBean" name="testBean1,testBean2" class="com.test"/>

同样，Spring 还有另一种声明别名的方式：

<bean id="testBean" class="com.test"/>
<alias name="testBean" alias="testBean1,testBean2"/>

再来看一下 alias标签的解析过程：

DefaultBeanDefinitionDocumentReader.java

protected void processAliasRegistration(Element ele) {
    	// 提取name 属性
		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 {
                // 调用SimpleAliasRegistry 的registerAlias注册 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的调用一致，不在多说了。

import 标签的解析

对于Spring 配置文件的编写，我想，经过了庞大项目的人，都有那种恐惧的心理，太多的配置文件了。不过，分模块大多数人能想到的方法，但是，怎么分模块，那就仁者见仁智者见智了。使用import 是个好办法，例如我们可以构造这样的Spring配置文件：

applicationContext.xml

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

	<import resource="customerContext.xml"/>
	<import resource="systemContext.xml"/>
</beans>

applicationContext.xml 文件中使用import 的方式导入有模块配置文件，以后若有新模块的加入，那就可以简单修改这个文件了。这样大大简化了配置后期维护的复杂度，并是配置模块化，易于管理。我们来看看Spring 是如何解析import 配置文件的

DefaultBeanDefinitionDocumentReader.java

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);

		// 判断 localtion 是绝对 URI资源 还是相对URI资源
		boolean absoluteLocation = false;
		try {
			absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
		}
		catch (URISyntaxException ex) {
		}

		// 如果是绝对URI, 则直接根据地址加载对应的配置文件
		if (absoluteLocation) {
			try {
				int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
				if (logger.isTraceEnabled()) {
					logger.trace("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 存在多个子实现类，如 VfsResouce, FileSystemResource等，
                // 而每个resource 的 createRelative 方法实现都不一样，所以这里先使用自乐你的方法尝试解析
				Resource relativeResource = getReaderContext().getResource().createRelative(location);
				if (relativeResource.exists()) {
					importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
					actualResources.add(relativeResource);
				}
				else {
                    // 如果解析不成功，则使用默认的解析器 ResoucePatternResolver进行解析
					String baseLocation = getReaderContext().getResource().getURL().toString();
					importCount = getReaderContext().getReader().loadBeanDefinitions(
							StringUtils.applyRelativePath(baseLocation, location), actualResources);
				}
				if (logger.isTraceEnabled()) {
					logger.trace("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));
	}

上面的代码不难，相信配置注释会很好理解，Spring 解析 impost标签的大致步骤如下：

获取resource属性所表示的路径
解析路径中的系统属性，格式如“${user.dir}”.
判断location 是绝对路径还是相对路径。
如果是就绝对路径则递归调用bean的解析过程，进行另一个的解析。
如果是相对路径则计算出绝对路径并进行解析。
通知监听器，解析完成。

嵌入式beans 标签的解析

对于嵌入式的beans 标签，相信大家使用过会接触过，非常类似于import标签所提供的功能，使用如下:

<?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="aa" class="test.aa"/>
    <beans>
    </beans>
</beans>

对于嵌入式beans标签来讲，并没有太多可将，与单独的配置文件没有太大的差别，无非是递归调用beans的解析过程。

注意：

本文是参考《Spring源码深度解析》- 郝佳，
另外因为如果第一次或者刚阅读Spring源码的小伙伴，才读完这篇文章后会发现还是很懵，建议多读几遍，我也是这样的。最后希望这边文章对你理解Spring源码有所帮助。

最后根据自己的理解画出默认标签的解析时序图：
在这里插入图片描述
步骤说明：

在DefaultBeanDefinitionDocumentReader 类的 parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) 中进入自定义标签的解析parseDefaultElement方法。
判断标签为Bean标签，调用自身方法processBeanDefinition(ele, delegate)来进行bean标签的解析。
调用parseBeanDefinitionElement方法来解析封装标签。进入到该方法里面
调用重载方法parseBeanDefinitionElement 来解析默认bean标签.
获取 bean 标签中的id属性
获取bean标签中的name属性
调用重载方法parseBeanDefinitionElement
创建一个GenericBeanDefinition的真实对象来存储解析出来的数据。
parseBeanDefinitionAttbutes 方法是对element所有元素属性进行解析
解析meta子元素
解析lookup-method子元素
解析replaced-method子元素
解析constructor-arg子元素
解析property子元素
解析qualifier 子元素
将解析好的数据封装到BeanDefinitionHolder中返回到 DefaultBeanDefinitionDocumentReader 中
decorateBeanDefinitionIfRequire 方法是对beanDefinition进行装饰
调用registerBeanDefinition 方法开始注册 beanDefinition 和 alias
调用registerBeanDefinition方法注册beanDefinition,beanDefinition 的注册其实就是存储在了 DefaultListableBeanFactory 类中 beanDefinitionMap 属性中, beanName 为key, beanDefinition 为value
调用registerAlias 方法注册别名, 别名的注册是存储在了SimpleAliasRegistry 类中 aliasMap 属性中, alias为key, beanName 为value
通知监听器解析及注册完成

不许人间到白头~

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
默认标签的解析

默认标签的解析简介bean 标签的解析及注册解析BeanDefinition创建用于属性承载的BeanDefinition解析各种属性解析子元素 meta解析子元素 lookup-method解析子元素 replaced-method解析子元素constructor-arg解析子元素property解析子元素 qualifierAbstractBeanDefinition 属性解析默认标签中的自定义标签元素注册解析的 BeanDefinition通过 beanName 注册 beanDefinition通过
复制链接

扫一扫