首页 > 编程语言> > 【Spring 源码深度解析】02 默认标签的解析

【Spring 源码深度解析】02 默认标签的解析

2022-01-23 16:03:02 作者：互联网

文章目录

1 parseDefaultlement
2 bean 标签的解析
3 alias 标签的解析
4 import 标签的解析
5. 嵌入式 beans 标签的解析

1 parseDefaultlement

Spring 中的标签包括默认标签和自定义标签。

默认标签的解析在 DefaultBeanDefinitionDucumentReader 中 parseDefaultElement(ele, delegate) 方法中解析。包括 import，alias，bean，beans等标签。

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)) {
		doRegisterBeanDefinitions(ele);
	}
}

2 bean 标签的解析

对于四种默认标签的解析，其中 bean 标签的解析最为复杂，因此先对 bean 标签的解析进行分析理解。

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
	//1. 委托 BeanDefinitionParserDelegate 类的 parseBeanDefinitionElement 方法进行元素解析，
	//返回 BeanDefinitionHolder 的实例 bdHolder，经过该方法，bdHolder实例已经包含配置文件
	//中配置的各种属性了，例如class，name，id，alias之类的属性
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		//2. 当返回的 bdHolder 不为空的情况下若存在默认标签的子节点下再有自定义属性，还需要
		//再次对自定义标签进行解析，装饰者模式,
		//在 Spring 中bean 使用的是默认的标签配置，而 子元素又使用了自定义的配置时，会执行该方法
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			// Register the final decorated instance.
			//3. 解析完成后，需要对解析后的 bdHolder 进行注册，同样，注册操作委托给 BeanDefinitionReaderUtils
			//的 registerBeanDefinition 方法
			BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
		}
		catch (BeanDefinitionStoreException ex) {
			getReaderContext().error("Failed to register bean definition with name '" +
					bdHolder.getBeanName() + "'", ele, ex);
		}
		// Send registration event.aWW
		//发送响应事件，通知相关监听器，这个bean已经加载完成了
		//扩展实现，需要对注册 BeanDefinition 时间进行监听时可以通过
		//注册监听器的方式将处理逻辑写入监听器. 继承 EmptyReaderEventListener
		getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
	}
}

上述主要逻辑：
1）委托 BeanDefinitionDelegate 类的 parseBeanDefinitionElement 方法进行元素解析，返回 BeanDefinitionHolder 类型的实例 bdHolder，该实例中已经包含了配置文件的各个属性，如id，class，name，alias 等属性。
2）当返回的 bdHolder 不为空，且该默认标签下的子节点有自定义属性，会调用 delegate 的 decorateBeanDefinitionIfRequired(ele, bdHolder) 方法对 bdHolder 实例进行装饰，将自定义属性包装进该实例中。
3）解析完成后，需要对 bdHolder 进行注册，将该逻辑委托给 BeanDefinitionReaderUtils 工具类的 registerBeanDefinition(bdHolder, registry) 方法。
4）最后发出响应事件，通知相关的监听器，这个 bean 已经加载完成。
在这里插入图片描述

2.1 解析 BeanDefinition

首先从元素解析及信息提取开始，就是 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele)。对 parseBeanDefinitionElement 方法进行分析。

// BeanDefinitionParserDelegate.java

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

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
	//1. 解析元素中的id以及name属性
	//解析id属性
	String id = ele.getAttribute(ID_ATTRIBUTE);
	//解析name属性
	String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

	//分割name属性，用来为 id 创建一个或多个别名"name1,name2"
	List<String> aliases = new ArrayList<>();
	if (StringUtils.hasLength(nameAttr)) {
		String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
		aliases.addAll(Arrays.asList(nameArr));
	}
	//用 id 作为默认的 beanName
	String beanName = id;
	if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
		//如果id为空，且name不为空，则取name的第一个为id
		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) {
		//检查beanName的唯一
		checkNameUniqueness(beanName, aliases, ele);
	}
	//2. 最终解析其他属性并统一封装到 GenericBeanDefinition 类型的实例中
	AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

	if (beanDefinition != null) {
		if (!StringUtils.hasText(beanName)) {
			try {
				//3. 如果不存在beanName 那么根据 Spring 中提供的命名规则为当前bean 生成对应的 beanName
				if (containingBean != null) {
					beanName = BeanDefinitionReaderUtils.generateBeanName(
							beanDefinition, this.readerContext.getRegistry(), true);
				}
				else {
					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.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);
		//4. 将获取的信息封装到 BeanDefinitionHolder 的实例中
		return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
	}

	return null;
}

上述代码主要逻辑：
1）提取元素的 id，和 name，name分割作为别，放入名为 alias 的 list 中，将 id 作为默认的 beanName，如果 id 为空且list不为空，取第一个别名作为beanName，并从list中移除。父类 containingBean 为空，检查beanName 的唯一性。
2）调用 parseBeanDefinitionElement(ele, beanName, containingBean) 方法将其它属性一同封装到 GenericBeanDefinition 的 beanDefinition 实例中。
3）返回的 beanDefinition 不为空，检测 beanName 是否有效，如果为空，则调用 Spring 的默认规则为该 bean 生成 beanName。
4）最后将获取到的信息封装到 BeanDefinitionHolder 中并并返回实例。

2.1.1 对其它属性的解析

进一步分析步骤二中对其它属性的解析过程。

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 实例
		//用于承载属性的BeanDefinition
		AbstractBeanDefinition bd = createBeanDefinition(className, parent);

		//硬编码解析默认bean的各种属性
		parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);

		//提取description 子元素
		bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

		//解析 meta 元数据 子元素，额外的数据
		parseMetaElements(ele, bd);

		//解析 lookup-method 子元素，获取器注入
		parseLookupOverrideSubElements(ele, bd.getMethodOverrides());

		//解析 replaced-method 子元素
		parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

		//解析 constructor-arg 构造函数子元素
		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;
}

主要解析过程：
1）解析 class(className) 和 parent 属性。
2）使用 className 和 parent 创建用于承载属性的 GenericBeanDefinition 实例。
（1）BeanDefinition 是一个接口，是配置文件中标签的内部表示，BeanDefinition 和的属性是一一对应的。
（2）BeanDefinition 的实现由3种: RootBeanDefinition, ChildrenBeanDefinition, GenericBeanDefinition。3中实现都继承自 AbstractBeanDefinition。
（3）Spring 通过 BeanDefinition 将配置文件中的标签属性转换为容器的内部表示，并将这些 BeanDefinition 注册到 BeanDefinitionRegistry 中。BeanDefinitionRegistry 类似一个配置信息的内存数据库，以 map 形式保存 BeanDefinition 的信息，后序操作直接从 BeanDefinitionRegistry 中读取配置信息。
（4）通过 createBeanDefinition(className, parent) 方法创建 GenericBeanDefinition 属性。

/**
 * BeanDefinition：接口，和<bean></bean> 标签一一对应，属性也是对应的
 * AbstractBeanDefinition：抽象实现
 * RootBeanDefinition：最常用的实现类，
 * ChildBeanDefinition：子bean
 * GenericBeanDefinition：一站式服务类
 * Spring 通过BeanDefinition 将配置文件中的<bean></bean>配置信息转换为容器的内部表示
 * 并将这些BeanDefinition注册到BeanDefinitionRegistry中。
 * BeanDefinitionRegistry：类似Spring配置信息的内存数据库，主要以map形式保存，后序Spring直接从中取出配置信息
 */
protected AbstractBeanDefinition createBeanDefinition(@Nullable String className, @Nullable String parentName)
		throws ClassNotFoundException {

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

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

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

3）解析各种属性并创建完成 GenericBeanDefinition 后，就可以进行 bean 信息的各种属性解析了。由 parseBeanDefinitionAttributes 方法实现。

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
	@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
	// singleton 属性新版本不再有起任何作用, 1.x 的老版本中有使用到, 新版本使用scope 属性
	if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
		error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
	}
	//设置scope，singleton 或 property
	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.
		// 在嵌入beanDefinition 情况下且没有单独指定 scope 属性则使用父类默认的属性
		bd.setScope(containingBean.getScope());
	}
	//解析abstract属性，和 parent 属性联合起来使用，当作一个模板来给子类继承公共属性
	if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
		//默认为false
		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 属性，自动注入的方式，该类中如果引用了其它类，会将其它类自动注入
	//byName，byType，constructor，default(继承 beans 的 default-autowire属性)，no(默认，不注入)
	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属性，设为 false 的不会被其它类作为自动注入的候选者，
	String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
	//默认值true
	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)) {
		//默认false
		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);
	}
	//解析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;
}

4）解析子标签 meta。

/**
 * 解析 子元素 meta
 * <bean id='testBean' class='TestBean'>
 *     <meta key='testStr' value='aaa'>
 * </bean>
 * 一个额外的声明，当需要使用里面的信息时可以通过BeanDefinition 的 getAttribute(key) 获取
 * Parse the meta elements underneath the given element, if any.
 */
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构造 BeanMetadataAttribute
			BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
			attribute.setSource(extractSource(metaElement));
			//记录信息
			attributeAccessor.addMetadataAttribute(attribute);
		}
	}
}

meta 属性的用法，下述代码的 testStr 不会体现在 TestBean 的属性中，而是一个额外的声明，当需要使用这里面的信息时，可以通过 BeanDefinition 的 getAttribute(key) 方法获取。

<bean id="testBean"  class="org.springframework.demo.bean.TestBean">
	<meta key="testStr" value="aaaa" />
</bean>

5）解析子标签 look-method，称为获取器注入，把一个方法声明为返回某种类型的 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 class Student extends User {

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

public abstract class GetBeanTest {

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

public class Main {

	public static void main(String[] args) {
		ApplicationContext bf =
				new ClassPathXmlApplicationContext("test/lookup/lookupTest.xml");
		GetBeanTest getBeanTest = (GetBeanTest) bf.getBean("getBeanTest");
		getBeanTest.showMe();
	}
}

抽象方法在配置文件中配置，可以替换 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="getBeanTest" class="org.springframework.lookup.bean.GetBeanTest">
		<lookup-method name="getBean" bean="student"></lookup-method>
	</bean>

	<bean id="teacher" class="org.springframework.lookup.bean.Teacher"></bean>
	<bean id="student" class="org.springframework.lookup.bean.Student"></bean>
</beans>

下面是解析该子标签的逻辑代码：

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);
			//将其封装成 MethodOverride
			LookupOverride override = new LookupOverride(methodName, beanRef);
			override.setSource(extractSource(ele));
			//保存到 beanDefinition 的 overrides 中去，给后面创建bean是调用
			overrides.addOverride(override);
		}
	}
}

6）解析子标签 replaced-method 方法级别的替换，可以在运行时用新的方法替换现有的方法。

应用实例

public class TestChangeMethod {

	public void changeMe(String text) {
		System.out.println(text);
	}
}

public class TestMethodReplacer implements MethodReplacer {

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

public class Main {

	public static void main(String[] args) {
		ApplicationContext context =
				new ClassPathXmlApplicationContext("test/replacedmethod/replacedMethodTest.xml");
		TestChangeMethod testChangeMethod = (TestChangeMethod) context.getBean("testChangeMethod");
		testChangeMethod.changeMe("你好");
	}
}

具体配置文件

<?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="testChangeMethod" class="org.springframework.test.replacemethod.TestChangeMethod">
		<!--
			changeMe：要被替换的方法名
			replacer：替换类
			arg-type：存在重载方法时，指定方法参数
		-->
		<replaced-method name="changeMe" replacer="testMethodReplacer">
			<arg-type match="java.lang.String"></arg-type>
		</replaced-method>
		<qualifier type="org.springframework.beans.factory.annotation.Qualifier" value="qf">
			<!--<attribute key="" value=""></attribute>-->
		</qualifier>
	</bean>
	<bean id="testMethodReplacer" class="org.springframework.test.replacemethod.TestMethodReplacer"></bean>
</beans>

解析该子标签的源代码

/**
 * 在运行时用新的方法替换现有的方法。与之前的 look-up 不同，
 * 不仅可以多态的返回实体bean，还能动态的更改原有方法的逻辑。
 * Parse replaced-method sub-elements of the given bean element.
 * @see org.springframework.test.replacedmethod.Main spring-demo
 */
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;
			//获取方法名 name (久方法)
			String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);
			//获取替换类的引用 replacer (新方法)
			String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);
			//extends MethodOverride
			ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
			// Look for arg-type match elements. 解析子元素 arg-type
			//作用是存在 重载方法时，找到具体的方法
			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);
		}
	}
}

和 look-method 一样都是构造成一个 MethodOverride 的实例，并记录到 methodOverrides 中去。

7）解析子标签 constructor-arg，这是对构造函数的解析。

应用实例

public class HelloBean {

	private String arg1;
	private Integer arg2;
	private float arg3;
	private Map<String, Object> map;

	public HelloBean(String arg1, Integer arg2, float arg3, Map<String, Object> map) {
		this.arg1 = arg1;
		this.arg2 = arg2;
		this.arg3 = arg3;
		this.map = map;
	}

配置中可以指定参数的索引位置

<?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="helloBean" class="org.springframework.test.constructorarg.HelloBean">
		<constructor-arg index="0" name="arg1" type="java.lang.String">
			<value>hello</value>
		</constructor-arg>
		<constructor-arg index="1" name="arg2">
			<value>12</value>
		</constructor-arg>
		<constructor-arg name="arg3"  value="12.3f"></constructor-arg>
		<constructor-arg>
			<map>
				<entry key="key" value="value"/>
			</map>
		</constructor-arg>
	</bean>
</beans>

下面是解析该子标签的逻辑代码：

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 默认标签下 constructor-arg 的子元素
		if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {
			//调用该方法解析每一个构造器子元素
			parseConstructorArgElement((Element) node, bd);
		}
	}
}

具体的解析由parseConstructorArgElement((Element) node, bd)方法实现。

/**
 * 提取 index, type, name属性
 * 如果指定了index属性
 * 	1. 解析 Constructor-arg 的子元素
 * 	2. 使用 ConstructorArgumentValues.ValueHolder 封装解析出的元素
 * 	3. 将 index, type, name属性 一并封装到 ConstructorArgumentValues.ValueHolder 类型中
 * 		并添加至 BeanDefinition 的 constructorArgumentValues 的 indexArgumentValues 中
 * 如果没有index属性
 * 	1. 解析 Constructor-arg 的子元素
 * 	2. 使用 ConstructorArgumentValues.ValueHolder 封装解析出的元素
 * 	3. 将 index, type, name属性 一并封装到 ConstructorArgumentValues.ValueHolder 类型中
 * 		并添加至 BeanDefinition 的 constructorArgumentValues 的 genericArgumentValues 中
 * Parse a constructor-arg element.
 */
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);
	//index 不为空
	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 {
		try {
			this.parseState.push(new ConstructorArgumentEntry());
			// 解析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));
			bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
		}
		finally {
			this.parseState.pop();
		}
	}
}

主要解析步骤，提取 index, type, name 属性。
如果指定了index属性：

解析 Constructor-arg 的子元素
使用 ConstructorArgumentValues.ValueHolder 封装解析出的元素
将 index, type, name属性一并封装到 ConstructorArgumentValues.ValueHolder 类型中，并添加至 BeanDefinition 的 constructorArgumentValues 的 indexArgumentValues 中
如果没有index属性：
解析 Constructor-arg 的子元素
使用 ConstructorArgumentValues.ValueHolder 封装解析出的元素
将 index, type, name属性一并封装到 ConstructorArgumentValues.ValueHolder 类型中，并添加至 BeanDefinition 的 constructorArgumentValues 的 genericArgumentValues 中

对于属性及子标签的解析由 parsePropertyValue方法实现：

/**
 * 属性的解析，主要的处理流程
 * 1. 略过 description 或 meta
 * 2. 获取 constructor-arg 上的 ref 和 value 属性，其不存在以下情况
 * 	2.1  既有 ref 属性又有 value 属性
 * 	2.2 存在 ref(value) 属性又有 ref(value) 子元素
 * 3. ref 属性的处理，使用 RuntimeDeanDefinition 封装，如 <constructor-arg ref='a'></constructor-arg>
 * 4. value 属性的处理，使用 TypedStringValue 封装，如 <constructor-arg value='a'></constructor-arg>
 * 5. 对子元素的处理，调用 parsePropertySubElement 方法对各种子元素进行处理
 *
 * Get the value of a property element. May be a list etc.
 * Also used for constructor arguments, "propertyName" being null in this case.
 */
@Nullable
public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
	//元素的类型 property 或 constructor-arg
	String elementName = (propertyName != null ?
			"<property> element for property '" + propertyName + "'" :
			"<constructor-arg> element");

	// Should only have one child element: ref, value, list, etc.
	// 只能有一个子元素
	NodeList nl = ele.getChildNodes();
	Element subElement = null;
	for (int i = 0; i < nl.getLength(); i++) {
		Node node = nl.item(i);
		//对description 或 meta 不处理
		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);

	/*
	 * 在 constructor-arg 上不能
	 * 	1. 既有 ref 属性又有 value 属性
	 * 	2. 存在 ref(value) 属性又有 ref(value) 子元素
	 */
	if ((hasRefAttribute && hasValueAttribute) ||
			((hasRefAttribute || hasValueAttribute) && subElement != null)) {
		error(elementName +
				" is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
	}

	if (hasRefAttribute) {
		//ref 属性的处理
		String refName = ele.getAttribute(REF_ATTRIBUTE);
		if (!StringUtils.hasText(refName)) {
			error(elementName + " contains empty 'ref' attribute", ele);
		}
		//封装到 RuntimeDeanDefinition 中
		RuntimeBeanReference ref = new RuntimeBeanReference(refName);
		ref.setSource(extractSource(ele));
		return ref;
	}
	else if (hasValueAttribute) {
		//value 属性的处理 使用TypedStringValue 处理
		TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
		valueHolder.setSource(extractSource(ele));
		return valueHolder;
	}
	else if (subElement != null) {
		//如果是子元素
		return parsePropertySubElement(subElement, bd);
	}
	else {
		// Neither child element nor "ref" or "value" attribute found.
		error(elementName + " must specify a ref or value", ele);
		return null;
	}
}

从上述代码可以看出对标签元素的解析主要有下面几个步骤：

略过 description 或 meta
获取 constructor-arg 上的 ref 和 value 属性，其不存在以下情况
1. 既有 ref 属性又有 value 属性
2. 存在 ref(value) 属性又有 ref(value) 子元素
ref 属性的处理，使用 RuntimeDeanDefinition 封装，如
value 属性的处理，使用 TypedStringValue 封装，如
对子元素的处理，调用 parsePropertySubElement 方法对各种子元素进行处理

而对于子标签的处理，例如在构造函数中嵌入了标签，则由parsePropertySubElement(subElement, bd)方法处理。

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);
	}
	//props
	else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
		return parsePropsElement(ele);
	}
	else {
		error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
		return null;
	}
}

可以看到上面所有支持的子标签包括：

bean
ref
idref
value
null
array
list
set
map
props

8）解析子标签 property
parsePropertyElements 方法完成了对 property 子标签的解析，使用方法如下。

<bean id="testBean"  class="org.springframework.demo.bean.TestBean">
	<property name="testStr" value="123"/>
</bean>

具体解析过程：

/**
 * 解析 property 子元素
 * <bean id='test' class='Test'>
 * 		<property name='testStr' value='aaa'></property>
 *
 * 		<property name='list'>
 * 		 	<list>
 * 		 	  <value>a</value>
 * 		 	  <value>b</value>
 * 		 	</list>
 * 		</property>
 * </bean>
 * Parse property sub-elements of the given bean element.
 */
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((Element) node, bd)方法解析。

/**
 * 和 constructor-arg 标签的解析相似
 *
 * Parse a property element.
 */
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;
		}
		//解析ele对应的属性元素 和 constructor-arg 调用的同一个方法
		Object val = parsePropertyValue(ele, bd, propertyName);
		//使用 PropertyValue 封装
		PropertyValue pv = new PropertyValue(propertyName, val);
		parseMetaElements(ele, pv);
		pv.setSource(extractSource(ele));
		// 存到 propertyValues
		bd.getPropertyValues().addPropertyValue(pv);
	}
	finally {
		this.parseState.pop();
	}
}

可以看到和解析 constructor-arg 一样都是调用 parsePropertyValue 来解析值。不同的是使用 PropertyValue 进行封装，并存放到 propertyValues 属性中。

9）解析子标签 qualifier
Spring 许我 Qualifier 指定注入 Bean 名称，而对于配置方式使用如下。

<bean id="testBean"  class="org.springframework.demo.bean.TestBean">
	<qualifier type="org.springframework.beans.factory.annotation.Qualifier" value="qf" />
</bean>

主要逻辑：

/**
 * 可以指定导入的类型
 *
 * <qualifier type="org.springframework.beans.factory.annotation.Qualifier" value="qf"></qualifier>
 * Parse qualifier sub-elements of the given bean element.
 */
public void parseQualifierElements(Element beanEle, AbstractBeanDefinition bd) {
	NodeList nl = beanEle.getChildNodes();
	for (int i = 0; i < nl.getLength(); i++) {
		Node node = nl.item(i);
		if (isCandidateElement(node) && nodeNameEquals(node, QUALIFIER_ELEMENT)) {
			parseQualifierElement((Element) node, bd);
		}
	}
}

public void parseQualifierElement(Element ele, AbstractBeanDefinition bd) {
	//类型名称
	String typeName = ele.getAttribute(TYPE_ATTRIBUTE);
	if (!StringUtils.hasLength(typeName)) {
		error("Tag 'qualifier' must have a 'type' attribute", ele);
		return;
	}
	this.parseState.push(new QualifierEntry(typeName));
	try {
		AutowireCandidateQualifier qualifier = new AutowireCandidateQualifier(typeName);
		qualifier.setSource(extractSource(ele));
		//bean 名称
		String value = ele.getAttribute(VALUE_ATTRIBUTE);
		if (StringUtils.hasLength(value)) {
			qualifier.setAttribute(AutowireCandidateQualifier.VALUE_KEY, value);
		}
		NodeList nl = ele.getChildNodes();
		//存在子元素
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			//解析 attribute 子元素，额外数据，类似 bean 的 子元素 meta
			if (isCandidateElement(node) && nodeNameEquals(node, QUALIFIER_ATTRIBUTE_ELEMENT)) {
				Element attributeEle = (Element) node;
				String attributeName = attributeEle.getAttribute(KEY_ATTRIBUTE);
				String attributeValue = attributeEle.getAttribute(VALUE_ATTRIBUTE);
				if (StringUtils.hasLength(attributeName) && StringUtils.hasLength(attributeValue)) {
					BeanMetadataAttribute attribute = new BeanMetadataAttribute(attributeName, attributeValue);
					attribute.setSource(extractSource(attributeEle));
					qualifier.addMetadataAttribute(attribute);
				}
				else {
					error("Qualifier 'attribute' tag must have a 'name' and 'value'", attributeEle);
					return;
				}
			}
		}
		//加到 qualifiers 中
		bd.addQualifier(qualifier);
	}
	finally {
		this.parseState.pop();
	}
}

2.1.2 AbstractBeanDefinition 的属性

到此完成了从 XML 配置文件到 GenericBeanDefinition 的转换，XML 中的所有属性都可以在 GenericBeanDefinition 中找到。而 GenericBeanDefinition 是子类实现，其主要属性都在 AbstractBeanDefinition 中。

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
		implements BeanDefinition, Cloneable {
	/**
	 * 在解析其它属性 到 GenericBeanDefinition 时
	 * 如果指定了 classLoader 时会设置
	 * @see org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionAttributes(Element, String, BeanDefinition, AbstractBeanDefinition)
	 * @see org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#createBeanDefinition(String, String)
	 * @see BeanDefinitionReaderUtils#createBeanDefinition(String, String, ClassLoader)
	 */
	@Nullable
	private volatile Object beanClass;

	/**
	 * bean 的作用范围，对应 bean 标签的 scope 属性
	 * 默认为空
	 */
	@Nullable
	private String scope = SCOPE_DEFAULT;

	/**
	 * 对应 abstract
	 */
	private boolean abstractFlag = false;

	/**
	 * 懒加载，对应 lazy-init
	 */
	private boolean lazyInit = false;

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

	/**
	 * 依赖检查，Spring 3.0 后弃用
	 */
	private int dependencyCheck = DEPENDENCY_CHECK_NONE;

	/**
	 * 依赖其它类的实例化，对应 depend-on
	 */
	@Nullable
	private String[] dependsOn;

	/**
	 * autowireCandidate 为 false 时，容器在查找自动
	 * 装配对象时，不会考虑该bean，即不会被当作其它bean自动装配的候选者，但是
	 * bean本身还是可以使用自身来注入其它bean的。
	 * 对应 autowire-candidates 属性
	 */
	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;

	/**
	 * 是否以宽松的模式解析构造函数，默认true
	 * 为false 时：
	 * interface ITest{}
	 * class ITestImpl implements ITest{}
	 * Main {
	 *     Main(ITest i){}
	 *     Main(ITestImpl i){}
	 * }
	 * 抛出异常，无法准确定位到那个构造函数程序设置
	 */
	private boolean lenientConstructorResolution = true;

	/**
	 * 对应 factory-bean, 用法
	 * <bean id="instanceFactoryBean" class="org.springframework.factorybean.InstanceFactoryBean"></bean>
	 * <bean id="currentTime" factory-bean="instanceFactoryBean" factory-method="creteTime"></bean>
	 *
	 * @see org.springframework.factorybean.Main spring-demo
	 */
	@Nullable
	private String factoryBeanName;

	/**
	 * 对应 factory-method
	 */
	@Nullable
	private String factoryMethodName;

	/**
	 * 记录构造函数的注入属性，对应 constructor-arg 子元素
	 */
	@Nullable
	private ConstructorArgumentValues constructorArgumentValues;

	/**
	 * 普通属性集合，对应 property 子元素
	 */
	@Nullable
	private MutablePropertyValues propertyValues;

	/**
	 * 维护一个 CopyOnWriteArraySet -> MethodOverride
	 * 保存 子元素 lookup-method 和 replaced-method
	 */
	private MethodOverrides methodOverrides = new MethodOverrides();

	/**
	 * 初始化方法
	 * 对应 init-method
	 */
	@Nullable
	private String initMethodName;

	/**
	 * 销毁方法
	 * 对应 destroy-method
	 */
	@Nullable
	private String destroyMethodName;

	/**
	 * 是否执行 init-method，程序设置
	 */
	private boolean enforceInitMethod = true;

	/**
	 * 是否执行 destroy-method，程序设置
	 */
	private boolean enforceDestroyMethod = true;

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

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

	/**
	 * bean的描述信息
	 */
	@Nullable
	private String description;

	/**
	 * 定义这个 bean 的资源
	 */
	@Nullable
	private Resource resource;
  	...
}

2.2 解析默认标签中的自定义标签

完成了默认标签的解析和提取后（BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);），解析来就是bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);的分析。这句代码是在默认标签下有自定义子标签的情况下处理的，如：

<bean id=”test” class= ”test MyClass” >
	<mybean:user username= ”aaa” />
</bean>

具体逻辑：

// BeanDefinitionParserDelegate.java
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder originalDef) {
    // 参数3 传的是父类 bean，当对某个嵌套配置进行分析 ，这里需要传递父类
	// beanDefinition 这里传递的参数是为了使用父类的 scope 属性，以备子类若
	// 没有设置 scope 默认使用父类的属性，这里是顶层配置所以是 null。
	return decorateBeanDefinitionIfRequired(ele, originalDef, null);
}

进一步跟踪：

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 方法。

/**
 * 1. 获取命名空间
 * 2. 判断该元素或属性是否符合自定义的标签的解析条件
 * 3. 找到对应 NamespaceHandler 进行解析
 */
public BeanDefinitionHolder decorateIfRequired(
		Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {
	//获取自定义标签的命名空间
	String namespaceUri = getNamespaceURI(node);
	//对非默认标签进行解析
	if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {
		//根据命名空间找到对应的处理器
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler != null) {
			//进行修饰
			BeanDefinitionHolder decorated =
					handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
			if (decorated != null) {
				return decorated;
			}
		}
		else if (namespaceUri.startsWith("http://www.springframework.org/")) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
		}
		else {
			// 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;
}

上述代码的主要逻辑：

获取命名空间
判断该元素或属性是否符合自定义的标签的解析条件
找到对应 NamespaceHandler 进行解析

2.3 注册解析完成的 BeanDefinition

完成配置文件的解析及装饰后，就可以进行注册了。即调用 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()) 方法进行注册。

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

	// Register bean definition under primary name.
	String beanName = definitionHolder.getBeanName();
	// 使用注册器 进行注册 DefaultListableBeanFactory
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

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

解析后的 BeanDefinition 会被注册到 BeanDefinitionRegistry 类型的实例 registry 中，主要包括 beanName 的注册和 aliases 的注册。

2.3.1 通过 beanName 注册 BeanDefinition

调用 DefaultListableBeanDeanFactory#registerBeanDefinition 方法。

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 {
			/*
			 * 注册前的最后一次校验，
			 * 主要是对于AbstractBeanDefinition 属性中的 methodOverrides(lookup-method 和 replaced-method) 校验
			 * 校验 methodOverrides 是否与工厂方法并存或  methodOverrides 对于的方法根本不存在
			 */
			((AbstractBeanDefinition) beanDefinition).validate();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
					"Validation of bean definition failed", ex);
		}
	}
	// 使用 ConcurrentHashMap 来进行并发的控制
	BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
	//存在已注册的名字
	if (existingDefinition != null) {
		//如果对于的 beanName 已被注册，且在配置中配置了bean 不允许覆盖，则抛出异常
		if (!isAllowBeanDefinitionOverriding()) {
			throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
		}
		// 判断 Bean 的角色大小:
		//      0：用户定义的 Bean、1：来源于配置文件的 Bean、2：Spring 内部的 Bean；
		// 当原 BeanDefinition 角色小于新的 BeanDefinition 角色时，输出一个 warn 日志，提示 BeanDefinition 被覆盖
		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 + "]");
			}
		}
		//放入缓存中，替换原有的
		this.beanDefinitionMap.put(beanName, beanDefinition);
	}
	else {
		//是否 bean 的创建已经开始
		if (hasBeanCreationStarted()) {
			// Cannot modify startup-time collection elements anymore (for stable iteration)
			//不能修改原有的 beanDefinitionNames 集合
			synchronized (this.beanDefinitionMap) {
				this.beanDefinitionMap.put(beanName, beanDefinition);
				// 创建新的 beanNames 集合，并将已缓存的 beanName 和新的 beanName 加入该集合
				List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
				updatedDefinitions.addAll(this.beanDefinitionNames);
				updatedDefinitions.add(beanName);
				this.beanDefinitionNames = updatedDefinitions;

				// 在手动注册 Bean 的集合中，如果存在同名的 beanName，则将集合中同名的 beanName 删除
				removeManualSingletonName(beanName);
			}
		}
		//还在注册阶段
		else {
			// Still in startup registration phase
			//注册
			this.beanDefinitionMap.put(beanName, beanDefinition);
			//记录beanName
			this.beanDefinitionNames.add(beanName);
			// 删除手动注册 Bean 集合中同名的 beanName
			removeManualSingletonName(beanName);
		}
		// 将存储冻结 BeanDefinition 的 Map 置为 null
		this.frozenBeanDefinitionNames = null;
	}
	// 当前注册的 BeanDefinition 已在 beanDefinitionMap 中存在，或者其实例已在存储单例 Bean 的 Map 中存在
	if (existingDefinition != null || containsSingleton(beanName)) {
		//重置所有缓存
		resetBeanDefinition(beanName);
	}
}

主要步骤如下：

对 AbstractBeanDefinition 的校验。针对 methodOverrides 属性的校验。
对 beanNam 已经存在的情况进行处理，如果设置了不允许 bean 的覆盖，则抛出异常。
加入 map 缓存。
清除解析之前留下的对应 beanName 缓存。

2.3.2 alias 的注册

调用 SimpleAliasRegistry#registerAlias 方法进行注册。

public void registerAlias(String name, String alias) {
	Assert.hasText(name, "'name' must not be empty");
	Assert.hasText(alias, "'alias' must not be empty");
	synchronized (this.aliasMap) {
		// 如果 beanName 和 alias 相同则不记录 alias，并且删除 alias
		if (alias.equals(name)) {
			this.aliasMap.remove(alias);
			if (logger.isDebugEnabled()) {
				logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
			}
		}
		else {
			String registeredName = this.aliasMap.get(alias);
			//已存在指向
			if (registeredName != null) {
				//如果相同则不执行
				if (registeredName.equals(name)) {
					// An existing alias - no need to re-register
					return;
				}
				//如不允许被覆盖，则抛出异常
				if (!allowAliasOverriding()) {
					throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
							name + "': It is already registered for name '" + registeredName + "'.");
				}
				//打印日志
				if (logger.isDebugEnabled()) {
					logger.debug("Overriding alias '" + alias + "' definition for registered name '" +
							registeredName + "' with new target name '" + name + "'");
				}
			}
			//循环检查
			//如 A -> B,且 A -> C -> B ，则抛出异常
			checkForAliasCircle(name, alias);
			//注册alias
			this.aliasMap.put(alias, name);
			if (logger.isTraceEnabled()) {
				//打印
				logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
			}
		}
	}
}

主要解析步骤：

alias 与 beanName 相同的处理。如果 beanName 和 alias 相同则不记录 alias，并且删除 alias
alias 覆盖处理。根据用户的设置进行处理。
alias 的循环检测。
注册alias。

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

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

3 alias 标签的解析

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

在 XML 配置文件中使用标签完成 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"
	   xmlns:tx="http://www.springframework.org/schema/tx"
	   xsi:schemaLocation="
	   http://www.springframework.org/schema/beans
	   http://www.springframework.org/schema/beans/spring-beans.xsd
	   http://www.springframework.org/schema/tx
	   http://www.springframework.org/schema/tool/spring-tx.xsd">

	<bean id="test" name="test1,test2" class="org.springframework.test.base.TestBean" />

	<alias name="test" alias="test3" />
</beans>

具体解析过程如下：

protected void processAliasRegistration(Element ele) {
	// 获取 beanName
	String name = ele.getAttribute(NAME_ATTRIBUTE);
	// 获取 alias
	String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
	boolean valid = true;
	if (!StringUtils.hasText(name)) {
		getReaderContext().error("Name must not be empty", ele);
		valid = false;
	}
	if (!StringUtils.hasText(alias)) {
		getReaderContext().error("Alias must not be empty", ele);
		valid = false;
	}
	if (valid) {
		try {
			// 注册 alias，和 bean 中 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));
	}
}

4 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"
	   xmlns:tx="http://www.springframework.org/schema/tx"
	   xsi:schemaLocation="
	   http://www.springframework.org/schema/beans
	   http://www.springframework.org/schema/beans/spring-beans.xsd
	   http://www.springframework.org/schema/tx
	   http://www.springframework.org/schema/tool/spring-tx.xsd">

	<import resource="alias.xml" />
	<import resource="bean.xml" />
	...
</beans>

具体解析逻辑：

protected void importBeanDefinitionResource(Element ele) {
	//获取resource属性
	String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
	// 不存在 resource 属性，不做处理
	if (!StringUtils.hasText(location)) {
		getReaderContext().error("Resource location must not be empty", ele);
		return;
	}

	// 解析系统属性，格式如 "${user.dir}"
	// Resolve system properties: e.g. "${user.dir}"
	location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

	Set<Resource> actualResources = new LinkedHashSet<>(4);

	// Discover whether the location is an absolute or relative URI
	//判断 location 是相对 URI 还是绝对 URI
	boolean absoluteLocation = false;
	try {
		absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
	}
	catch (URISyntaxException ex) {
		// cannot convert to an URI, considering the location relative
		// unless it is the well-known Spring prefix "classpath*:"
	}

	// Absolute or relative?
	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 {
		// No URL -> considering resource location as relative to the current file.
		//计算出绝对路径
		try {
			int importCount;
			//Resource 存在多个实现子类，每个实现类的 createRelative 不同
			//先使用子类的方法进行解析
			Resource relativeResource = getReaderContext().getResource().createRelative(location);
			if (relativeResource.exists()) {
				importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
				actualResources.add(relativeResource);
			}
			else {
				//解析不成功，则使用 ResourcePatternResolver 进行解析
				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));
}

主要逻辑如下：

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

5. 嵌入式 beans 标签的解析

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

对标签的解析就是递归调用 DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions 方法进行解析。

标签：02,bd,String,ele,bean,源码,解析,属性
来源： https://blog.csdn.net/green1997/article/details/122371300