spring源码学习之默认标签的解析（一）

　　继续spring源码的学习之路，现在越来越觉得这个真的很枯燥的，而且我觉得要是自己来看源码，真的看不下去，不是没有耐心，而是真的没有头绪，我觉得结合着书来看，还是很有必要的，最起码大致的流程是能够捋清楚的，继续，希望自己能够坚持到最后！

一、标签解析的总体的理解

spring标签包括默认标签和自定义标签两种，今天只是来探索默认标签的！

org.springframework.beans.factory.xml包下的DefaultBeanDefinitionDocumentReader类中

 1 private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
 2     // 对import标签的处理
 3     if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
 4         importBeanDefinitionResource(ele);
 5     }
 6     // 对alias标签的处理
 7     else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
 8         processAliasRegistration(ele);
 9     }
10     // 对bean标签的处理
11     else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
12         processBeanDefinition(ele, delegate);
13     }
14     // 对beans标签的处理
15     else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
16         // recurse
17         doRegisterBeanDefinitions(ele);
18     }
19 }

二、bean标签的解析与注册

org.springframework.beans.factory.xml包下的DefaultBeanDefinitionDocumentReader类中

 1 /**
 2  * Process the given bean element, parsing the bean definition
 3  * and registering it with the registry.
 4  */
 5 protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
 6     // 进行元素解析，获取配置文件中的属性
 7     BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
 8     if (bdHolder != null) {
 9         // 对子节点下自定义标签进行解析
10         bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
11         try {
12             // Register the final decorated instance.
13             BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
14         }
15         catch (BeanDefinitionStoreException ex) {
16             getReaderContext().error("Failed to register bean definition with name '" +
17                     bdHolder.getBeanName() + "'", ele, ex);
18         }
19         // Send registration event.
20         getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
21     }
22 }

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

1、解析BeanDefinition（Definition的意思是定义实体bean的定义）

这个对应着就是元素解析及信息提取，也就是下面这行代码的解析，进入BeanDefinitionParserDelegate类的parseBeanDefinitionElement方法
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

BeanDefinitionParserDelegate类所在的包：org.springframework.beans.factory.xml下BeanDefinitionParserDelegate类

第一步调用此方法：

1 /**
2  * Parses the supplied {@code <bean>} element. May return {@code null}
3  * if there were errors during parse. Errors are reported to the
4  * {@link org.springframework.beans.factory.parsing.ProblemReporter}.
5  */
6 @Nullable
7 public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
8     return parseBeanDefinitionElement(ele, null);
9 }

下一步调用具体的代码实现：

 1 /**
 2  * Parses the supplied {@code <bean>} element. May return {@code null}
 3  * if there were errors during parse. Errors are reported to the
 4  * {@link org.springframework.beans.factory.parsing.ProblemReporter}.
 5  */
 6 @Nullable
 7 public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
 8     // 解析id属性
 9     String id = ele.getAttribute(ID_ATTRIBUTE);
10     // 解析name属性
11     String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
12 
13     // 分割name属性 注意这里为什么进行name属性的分割，因为bean配置文件的定义中，name是可以有多个值的，多个值之前用","":"隔开
14     List<String> aliases = new ArrayList<>();
15     if (StringUtils.hasLength(nameAttr)) {
16         // MULTI_VALUE_ATTRIBUTE_DELIMITERS变量的定义就是：MULTI_VALUE_ATTRIBUTE_DELIMITERS = ",; ";
17         String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
18         // aliases的意思是别名
19         aliases.addAll(Arrays.asList(nameArr));
20     }
21 
22     String beanName = id;
23     if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
24         beanName = aliases.remove(0);
25         if (logger.isDebugEnabled()) {
26             logger.debug("No XML 'id' specified - using '" + beanName +
27                     "' as bean name and " + aliases + " as aliases");
28         }
29     }
30 
31     if (containingBean == null) {
32         checkNameUniqueness(beanName, aliases, ele);
33     }
34 
35     AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
36     if (beanDefinition != null) {
37         if (!StringUtils.hasText(beanName)) {
38             try {
39                 // 如果不存在beanName那么根据spring中提供的命名规则为当前bean生成对应的beanName
40                 if (containingBean != null) {
41                     beanName = BeanDefinitionReaderUtils.generateBeanName(
42                             beanDefinition, this.readerContext.getRegistry(), true);
43                 }
44                 else {
45                     beanName = this.readerContext.generateBeanName(beanDefinition);
46                     // Register an alias for the plain bean class name, if still possible,
47                     // if the generator returned the class name plus a suffix.
48                     // This is expected for Spring 1.2/2.0 backwards compatibility.
49                     String beanClassName = beanDefinition.getBeanClassName();
50                     if (beanClassName != null &&
51                             beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
52                             !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
53                         aliases.add(beanClassName);
54                     }
55                 }
56                 if (logger.isDebugEnabled()) {
57                     logger.debug("Neither XML 'id' nor 'name' specified - " +
58                             "using generated bean name [" + beanName + "]");
59                 }
60             }
61             catch (Exception ex) {
62                 error(ex.getMessage(), ele);
63                 return null;
64             }
65         }
66         String[] aliasesArray = StringUtils.toStringArray(aliases);
67         return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
68     }
69 
70     return null;
71 }

以上就是对默认标签解析的全过程，尽管只能看到对id以及name属性的解析，但是大致的思路我们是知道了，
在开始对属性展开全面解析前，spring在外层又做了一个当前层的功能架构，在当前层完成的主要工作如下：
（1）提取元素中的id和name属性
（2）进一步解析其他所有属性并统一封装到GenericBeanDefinition中
（3）如果检测到bean没有指定beanName，那么使用默认规则为此Bean生成beanName
（4）将获取到的信息封装到BeanDefinitionHolder的实例中

我们进一步查看步骤2中对标签其他属性的解析过程：
这个方法还是在BeanDefinitionParserDelegate类中

 1 /**
 2  * Parse the bean definition itself, without regard to name or aliases. May return
 3  * {@code null} if problems occurred during the parsing of the bean definition.
 4  */
 5 @Nullable
 6 public AbstractBeanDefinition parseBeanDefinitionElement(
 7         Element ele, String beanName, @Nullable BeanDefinition containingBean) {
 8 
 9     this.parseState.push(new BeanEntry(beanName));
10 
11     String className = null;
12     // 对class属性的解析
13     if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
14         className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
15     }
16     String parent = null;
17     // 对parent属性解析
18     if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
19         parent = ele.getAttribute(PARENT_ATTRIBUTE);
20     }
21 
22     try {
23         // 创建用于承载属性的AbstractBeanDefinition类型的GenericBeanDefinition，需要到createBeanDefinition方法中看一下源码
24         AbstractBeanDefinition bd = createBeanDefinition(className, parent);
25         
26         // 硬编码解析默认bean的各种属性
27         parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
28         // 提取description
29         bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
30 
31         // 解析元数据
32         parseMetaElements(ele, bd);
33         // 解析lookup-method属性
34         parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
35         // 解析replaced-method属性
36         parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
37         /**
38          *  lookup-method通常称为获取器注入，spring in action中对它的描述是，一种特殊的方法注入，<br>
39          *     它是把一个方法声明为返回某种类型的bean，而实际要返回的bean是在配置文件里面配置的， <br>
40          *     可用在设计可插拔的功能上，接触程序依赖。同理replaced-method则是将之前执行的逻辑替换掉
41          */
42 
43         // 解析构造函数参数
44         parseConstructorArgElements(ele, bd);
45         // 解析property子元素
46         parsePropertyElements(ele, bd);
47         // 解析qualifier子元素
48         parseQualifierElements(ele, bd);
49 
50         bd.setResource(this.readerContext.getResource());
51         bd.setSource(extractSource(ele));
52 
53         return bd;
54     }
55     catch (ClassNotFoundException ex) {
56         error("Bean class [" + className + "] not found", ele, ex);
57     }
58     catch (NoClassDefFoundError err) {
59         error("Class that bean class [" + className + "] depends on not found", ele, err);
60     }
61     catch (Throwable ex) {
62         error("Unexpected failure during bean definition parsing", ele, ex);
63     }
64     finally {
65         this.parseState.pop();
66     }
67 
68     return null;
69 }

终于，bean标签的所有属性，不论常用的还是不常用的我们都看到了，尽管有些复杂的属性还需要进一步解析，继续一些复杂标签的属性的解析
（1）创建用于属性承载的BeanDefinition
BeanDefinition是一个接口，在spring中有三种实现，RootBeanDefinition、ChildBeanDefinition以及GenericBeanDefinition，
三种实现均继承了AbstractBeanDefinition，其中BeanDefinition是配置文件<bean>元素标签在容器内部的表现形式。
BeanDefinition属性和<bean>标签中属性是一一对应的，RootBeanDefinition是最常用的实现类，他对应一般元素的<bean>标签
spring通过BeanDefinition将配置文件中的<bean>配置信息转换为容器的内部表示，并将这些BeanDefinition注册到BeanDefinitionRegistry中。
spring容器的BeanDefinitionRegistry就像是spring配置信息的内存数据库，主要以map的形式保存，后续操作直接从BeanDefinitionRegistry中读取配置信息
要解析属性首先要创建用于承载属性的实例，也就是创建GenericBeanDefinition类型的实例，createBeanDefinition(className, parent)就是创建这个实例

 1 /**
 2  * Create a new GenericBeanDefinition for the given parent name and class name,
 3  * eagerly loading the bean class if a ClassLoader has been specified.
 4  * @param parentName the name of the parent bean, if any
 5  * @param className the name of the bean class, if any
 6  * @param classLoader the ClassLoader to use for loading bean classes
 7  * (can be {@code null} to just register bean classes by name)
 8  * @return the bean definition
 9  * @throws ClassNotFoundException if the bean class could not be loaded
10  */
11 public static AbstractBeanDefinition createBeanDefinition(
12         @Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {
13 
14     GenericBeanDefinition bd = new GenericBeanDefinition();
15     bd.setParentName(parentName);
16     if (className != null) {
17         if (classLoader != null) {
18             bd.setBeanClass(ClassUtils.forName(className, classLoader));
19         }
20         else {
21             bd.setBeanClassName(className);
22         }
23     }
24     return bd;
25 }

（2）解析各种属性
当创建了bean信息的承载实例后，便可以进行bean信息的各种属性解析了，首先我们进入parseBeanDefinitionAttributes方法，这个是对bean标签中所有属性的解析
此方法在org.springframework.beans.factory.xml包下的BeanDefinitionParserDelegate类中：

 1 /**
 2  * Apply the attributes of the given bean element to the given bean * definition.
 3  * @param ele bean declaration element
 4  * @param beanName bean name
 5  * @param containingBean containing bean definition
 6  * @return a bean definition initialized according to the bean element attributes
 7  */
 8 public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
 9         @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
10     // 解析singleton属性
11     if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
12         error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
13     }
14     // 解析scope属性
15     else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
16         bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
17     }
18     else if (containingBean != null) {
19         // Take default from containing bean in case of an inner bean definition.
20         bd.setScope(containingBean.getScope());
21     }
22 
23     // 解析abstract属性
24     if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
25         bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
26     }
27 
28     // 解析lazy-init属性
29     String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
30     if (isDefaultValue(lazyInit)) {
31         lazyInit = this.defaults.getLazyInit();
32     }
33     // 若没有设置或设置成其他字符都设置成false
34     bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
35 
36     // 解析autowire属性
37     String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
38     bd.setAutowireMode(getAutowireMode(autowire));
39 
40     // 解析depends-on属性
41     if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
42         String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
43         bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
44     }
45 
46     // 解析autowire-candidate属性
47     String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
48     if (isDefaultValue(autowireCandidate)) {
49         String candidatePattern = this.defaults.getAutowireCandidates();
50         if (candidatePattern != null) {
51             String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
52             bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
53         }
54     }
55     else {
56         bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
57     }
58     
59     // 解析primary属性
60     if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
61         bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
62     }
63 
64     // 解析init-method属性
65     if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
66         String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
67         bd.setInitMethodName(initMethodName);
68     }
69     else if (this.defaults.getInitMethod() != null) {
70         bd.setInitMethodName(this.defaults.getInitMethod());
71         bd.setEnforceInitMethod(false);
72     }
73 
74     // 解析destroy-method属性
75     if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
76         String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
77         bd.setDestroyMethodName(destroyMethodName);
78     }
79     else if (this.defaults.getDestroyMethod() != null) {
80         bd.setDestroyMethodName(this.defaults.getDestroyMethod());
81         bd.setEnforceDestroyMethod(false);
82     }
83 
84     // 解析factory-method属性
85     if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
86         bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
87     }
88     // 解析factory-bean属性
89     if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
90         bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
91     }
92 
93     return bd;
94 }

（3）解析子元素meta

这个属性之前都没有听说过，更没有用过：，不过这里也把该属性的源代码拿出来，方便以后来学习：
具体xml中使用：
<bean id="myTestBean" class="bean.myTestBean">
　　<meta key="testStr" value="aaa" />
</bean>
meta属性解析方法的源代码：
此方法在org.springframework.beans.factory.xml包下的BeanDefinitionParserDelegate类中

 1 public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {
 2     // 获取当前节点的所有子节点
 3     NodeList nl = ele.getChildNodes();
 4     for (int i = 0; i < nl.getLength(); i++) {
 5         Node node = nl.item(i);
 6         // 提取meta属性
 7         if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) {
 8             Element metaElement = (Element) node;
 9             String key = metaElement.getAttribute(KEY_ATTRIBUTE);
10             String value = metaElement.getAttribute(VALUE_ATTRIBUTE);
11             // 使用key、value构建BeanMetadataAttribute类
12             BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
13             attribute.setSource(extractSource(metaElement));
14             // 记录信息
15             attributeAccessor.addMetadataAttribute(attribute);
16         }
17     }
18 }

（4）解析子元素lookup-method

这个子元素也是不是很常用，所以就简单的记录一下，这个子元素通常称为获取器注入，spring in action 中有对这哥获取器注入的解释：
获取器注入是一种特殊的方法注入，他是把一个方法声明为返回某种类型的bean，但是实际要返回的bean是在配置文件中配置的，此方法
可用在设计有些可插拔的功能上，解除程序依赖

具体xml中使用：
<bean id="getBeanTest" class="test.lookup.bean.GetBeanTest">
<lookup-method name="getBean" bean="teacher"/>
</bean>

lookup-method属性解析的源码：
此方法在org.springframework.beans.factory.xml包下的BeanDefinitionParserDelegate类中

 1 /**
 2  * Parse lookup-override sub-elements of the given bean element.
 3  */
 4 public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
 5     NodeList nl = beanEle.getChildNodes();
 6     for (int i = 0; i < nl.getLength(); i++) {
 7         Node node = nl.item(i);
 8         // 仅当在spring默认bean的子元素下且为lookup-method时有效
 9         if (isCandidateElement(node) && nodeNameEquals(node, LOOKUP_METHOD_ELEMENT)) {
10             Element ele = (Element) node;
11             // 获取要修饰的方法
12             String methodName = ele.getAttribute(NAME_ATTRIBUTE);
13             // 获取配置返回的bean
14             String beanRef = ele.getAttribute(BEAN_ELEMENT);
15             LookupOverride override = new LookupOverride(methodName, beanRef);
16             override.setSource(extractSource(ele));
17             overrides.addOverride(override);
18         }
19     }
20 }

（5）解析子元素replace-method

bean子元素-方法替换，可以在运行时用新的方法替换原来的方法。与之前lookup-method不同的是，replace-method不但可以
动态地替换返回实体bean，而且还能动态的更改原有方法的逻辑
具体xml 中使用：
<bean id="testChangeMethod" class="test.replacemethod.TestChangeMethod">
　　<replace-method name="changeMe" replacer="replacer" />
</bean>
<bean id="replacer" class="test.replacemethod.TestMethodReplacer" />

replace-method属性解析的源码：
此方法在org.springframework.beans.factory.xml包下的BeanDefinitionParserDelegate类中

 1 /**
 2  * Parse replaced-method sub-elements of the given bean element.
 3  */
 4 public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {
 5     NodeList nl = beanEle.getChildNodes();
 6     for (int i = 0; i < nl.getLength(); i++) {
 7         Node node = nl.item(i);
 8         if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) {
 9             Element replacedMethodEle = (Element) node;
10             // 提取要替换的旧的方法
11             String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);
12             // 提取新的方法
13             String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);
14             ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
15             // Look for arg-type match elements. 查找新方法对应的bean
16             List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT);
17             for (Element argTypeEle : argTypeEles) {
18                 // 记录参数
19                 String match = argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE);
20                 match = (StringUtils.hasText(match) ? match : DomUtils.getTextValue(argTypeEle));
21                 if (StringUtils.hasText(match)) {
22                     replaceOverride.addTypeIdentifier(match);
23                 }
24             }
25             replaceOverride.setSource(extractSource(replacedMethodEle));
26             overrides.addOverride(replaceOverride);
27         }
28     }
29 }

无论是lookup-method还是replace-method都构建了一个MethodOverride，并最终记录在了AbstractBeanDefinition的MethodOverrides属性中了，
而这个属性如何完成它所提供的功能我们会在后面介绍

（6）解析子元素constructor-arg

这个就是比较熟悉的了，对构造函数的解析，这个是经常使用的，
<bean id="helloWorld" class="com.HelloWorld">
　　<constructor-arg index="0">
　　　　<value>java</value>
　　</constructor-arg>
　　<constructor-arg index="1">
　　　　<value>javascript</value>
　　</constructor-arg>
</bean>
这就是spring中构造函数最基础的配置，实现的功能是对HelloWorld bean的自动寻找对应的构造函数，并在初始化的过程中将参数传递进去
看一下constructor-arg的解析过程：spring通过parseConstructorArgElements方法解析的
此方法在org.springframework.beans.factory.xml包下的BeanDefinitionParserDelegate类中

 1 /**
 2  * Parse constructor-arg sub-elements of the given bean element.
 3  */
 4 public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {
 5     NodeList nl = beanEle.getChildNodes();
 6     for (int i = 0; i < nl.getLength(); i++) {
 7         Node node = nl.item(i);
 8         if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {
 9             // 解析constructor-arg子元素
10             parseConstructorArgElement((Element) node, bd);
11         }
12     }
13 }

具体的实现逻辑是在另一个方法中实现的：

 1 /**
 2  * Parse a constructor-arg element.
 3  */
 4 public void parseConstructorArgElement(Element ele, BeanDefinition bd) {
 5     // 提取index属性
 6     String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);
 7     // 提取type属性
 8     String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);
 9     // 提取name属性
10     String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
11     if (StringUtils.hasLength(indexAttr)) {
12         try {
13             int index = Integer.parseInt(indexAttr);
14             if (index < 0) {
15                 error("'index' cannot be lower than 0", ele);
16             }
17             else {
18                 try {
19                     this.parseState.push(new ConstructorArgumentEntry(index));
20                     // 解析ele对应的元素
21                     Object value = parsePropertyValue(ele, bd, null);
22                     ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
23                     if (StringUtils.hasLength(typeAttr)) {
24                         valueHolder.setType(typeAttr);
25                     }
26                     if (StringUtils.hasLength(nameAttr)) {
27                         valueHolder.setName(nameAttr);
28                     }
29                     valueHolder.setSource(extractSource(ele));
30                     // 不允许指定相同的参数
31                     if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {
32                         error("Ambiguous constructor-arg entries for index " + index, ele);
33                     }
34                     else {
35                         bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);
36                     }
37                 }
38                 finally {
39                     this.parseState.pop();
40                 }
41             }
42         }
43         catch (NumberFormatException ex) {
44             error("Attribute 'index' of tag 'constructor-arg' must be an integer", ele);
45         }
46     }
47     else {
48         // 没有index属性则忽略去属性，自动寻找
49         try {
50             this.parseState.push(new ConstructorArgumentEntry());
51             Object value = parsePropertyValue(ele, bd, null);
52             ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
53             if (StringUtils.hasLength(typeAttr)) {
54                 valueHolder.setType(typeAttr);
55             }
56             if (StringUtils.hasLength(nameAttr)) {
57                 valueHolder.setName(nameAttr);
58             }
59             valueHolder.setSource(extractSource(ele));
60             bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
61         }
62         finally {
63             this.parseState.pop();
64         }
65     }
66 }

这个主要是分为两种情况：一种是指定了index属性，一种是没指定
如果配置中指定了index属性，则是这样解析
（1）解析constructor-arg的子元素
（2）使用ConstructorArgumentValues.ValueHolder 来封装解析出来的元素
（3）将index，name，type属性一并封装在ConstructorArgumentValues.ValueHolder 中，并添加到
BeanDefinition的ConstructorArgumentValues的indexedArgumentValue属性中
如果没有指定index属性，则如下解析方式
（1）解析constructor-arg的子元素
（2）使用ConstructorArgumentValues.ValueHolder 来封装解析出来的元素
（3）将index，name，type属性一并封装在ConstructorArgumentValues.ValueHolder 中，并添加到
BeanDefinition的ConstructorArgumentValues的genericArgumentValue属性中
这两种解析方式，关键在于属性存放的位置是不同的

我们尝试着进步了解解析构造函数配置中子元素的过程，进入parsePropertyValue方法
此方法在org.springframework.beans.factory.xml包下的BeanDefinitionParserDelegate类中

 1 /**
 2  * Get the value of a property element. May be a list etc.
 3  * Also used for constructor arguments, "propertyName" being null in this case.
 4  */
 5 @Nullable
 6 public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
 7     String elementName = (propertyName != null ?
 8             "<property> element for property '" + propertyName + "'" :
 9             "<constructor-arg> element");
10 
11     // Should only have one child element: ref, value, list, etc.
12     // 一个属性只能对应一种类型，ref、value、list等
13     NodeList nl = ele.getChildNodes();
14     Element subElement = null;
15     for (int i = 0; i < nl.getLength(); i++) {
16         Node node = nl.item(i);
17         // 对应的description或者meta属性不处理
18         if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
19                 !nodeNameEquals(node, META_ELEMENT)) {
20             // Child element is what we're looking for.
21             if (subElement != null) {
22                 error(elementName + " must not contain more than one sub-element", ele);
23             }
24             else {
25                 subElement = (Element) node;
26             }
27         }
28     }
29 
30     // 解析constructor-arg标签上的ref属性
31     boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
32     // 解析constructor-arg标签上的value属性
33     boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
34     /**
35      * 在constructor-arg上不存在
36      * 1、同时既有ref属性又有value属性
37      * 2、存在ref属性或者value属性且又有子元素
38      */
39     if ((hasRefAttribute && hasValueAttribute) ||
40             ((hasRefAttribute || hasValueAttribute) && subElement != null)) {
41         error(elementName +
42                 " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
43     }
44 
45     if (hasRefAttribute) {
46         // ref属性的处理 使用RuntimeBeanReference封装对应的ref名称
47         String refName = ele.getAttribute(REF_ATTRIBUTE);
48         if (!StringUtils.hasText(refName)) {
49             error(elementName + " contains empty 'ref' attribute", ele);
50         }
51         RuntimeBeanReference ref = new RuntimeBeanReference(refName);
52         ref.setSource(extractSource(ele));
53         return ref;
54     }
55     else if (hasValueAttribute) {
56         // value属性的处理，使用TypedStringValue封装
57         TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
58         valueHolder.setSource(extractSource(ele));
59         return valueHolder;
60     }
61     else if (subElement != null) {
62         // 解析子元素
63         return parsePropertySubElement(subElement, bd);
64     }
65     else {
66         // Neither child element nor "ref" or "value" attribute found.
67         // 既没有ref 又没有value属性 也没有子元素 spring懵逼了
68         error(elementName + " must specify a ref or value", ele);
69         return null;
70     }
71 }

文字解释一下其中代码做了哪些事情：
（1）略过description或者meta
（2）提取constructor-arg上的ref和value属性，以便于根据规则验证正确性，其中以下情况不存在：
同时既有ref属性又有value属性
存在ref属性或者value属性且又有子元素
（3）ref属性的处理，使用RuntimeBeanReference封装对应的ref名称
<constructor-arg ref="a" />
（4）value属性的处理，使用TypedStringValue封装对应的value名称
<constructor-arg value="a" />
（5）子元素的处理
<constructor-arg>
　　<map>
　　　　<entry key="key" value="value"/>
　　</map>
<constructor-arg/>

看看如何解析各种子元素的，源码在parsePropertySubElement方法中
此方法在org.springframework.beans.factory.xml包下的BeanDefinitionParserDelegate类中

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

进入return中的parsePropertySubElement方法
此方法在org.springframework.beans.factory.xml包下的BeanDefinitionParserDelegate类中

 1 /**
 2  * Parse a value, ref or collection sub-element of a property or
 3  * constructor-arg element.
 4  * @param ele subelement of property element; we don't know which yet
 5  * @param defaultValueType the default type (class name) for any
 6  * {@code <value>} tag that might be created
 7  */
 8 @Nullable
 9 public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {
10     if (!isDefaultNamespace(ele)) {
11         return parseNestedCustomElement(ele, bd);
12     }
13     else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
14         BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
15         if (nestedBd != null) {
16             nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
17         }
18         return nestedBd;
19     }
20     else if (nodeNameEquals(ele, REF_ELEMENT)) {
21         // A generic reference to any name of any bean.
22         String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
23         boolean toParent = false;
24         if (!StringUtils.hasLength(refName)) {
25             // A reference to the id of another bean in a parent context.
26             // 解析parent属性
27             refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
28             toParent = true;
29             if (!StringUtils.hasLength(refName)) {
30                 error("'bean' or 'parent' is required for <ref> element", ele);
31                 return null;
32             }
33         }
34         if (!StringUtils.hasText(refName)) {
35             error("<ref> element contains empty target attribute", ele);
36             return null;
37         }
38         RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
39         ref.setSource(extractSource(ele));
40         return ref;
41     }
42     // 对idref元素的解析
43     else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
44         return parseIdRefElement(ele);
45     }
46     // 对value子元素的解析
47     else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
48         return parseValueElement(ele, defaultValueType);
49     }
50     // 对null子元素的解析
51     else if (nodeNameEquals(ele, NULL_ELEMENT)) {
52         // It's a distinguished null value. Let's wrap it in a TypedStringValue
53         // object in order to preserve the source location.
54         TypedStringValue nullHolder = new TypedStringValue(null);
55         nullHolder.setSource(extractSource(ele));
56         return nullHolder;
57     }
58     // 对array子元素的解析
59     else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
60         return parseArrayElement(ele, bd);
61     }
62     // 对list子元素的解析
63     else if (nodeNameEquals(ele, LIST_ELEMENT)) {
64         return parseListElement(ele, bd);
65     }
66     // 对set子元素的解析
67     else if (nodeNameEquals(ele, SET_ELEMENT)) {
68         return parseSetElement(ele, bd);
69     }
70     // 对map子元素的解析
71     else if (nodeNameEquals(ele, MAP_ELEMENT)) {
72         return parseMapElement(ele, bd);
73     }
74     // 对props子元素的解析
75     else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
76         return parsePropsElement(ele);
77     }
78     // 这些子元素除外的就不处理了，报错！！！
79     else {
80         error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
81         return null;
82     }
83 }

（7）解析子元素property

这个就是提取bean标签中的属性定义，源码在parsePropertyElements方法中
此方法在org.springframework.beans.factory.xml包下的BeanDefinitionParserDelegate类中

 1 /**
 2  * Parse property sub-elements of the given bean element.
 3  */
 4 public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
 5     NodeList nl = beanEle.getChildNodes();
 6     for (int i = 0; i < nl.getLength(); i++) {
 7         Node node = nl.item(i);
 8         if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
 9             parsePropertyElement((Element) node, bd);
10         }
11     }
12 }
13 
14 /**
15  * Parse a property element.
16  */
17 public void parsePropertyElement(Element ele, BeanDefinition bd) {
18     // 获取配置配置元素中的name值
19     String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
20     if (!StringUtils.hasLength(propertyName)) {
21         error("Tag 'property' must have a 'name' attribute", ele);
22         return;
23     }
24     this.parseState.push(new PropertyEntry(propertyName));
25     try {
26         // 不允许多次对同一属性配置
27         if (bd.getPropertyValues().contains(propertyName)) {
28             error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
29             return;
30         }
31         Object val = parsePropertyValue(ele, bd, propertyName);
32         PropertyValue pv = new PropertyValue(propertyName, val);
33         parseMetaElements(ele, pv);
34         pv.setSource(extractSource(ele));
35         bd.getPropertyValues().addPropertyValue(pv);
36     }
37     finally {
38         this.parseState.pop();
39     }
40 }

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

（8）解析子元素qualifier

这个完全没有使用过，对于qualifier元素的获取，我们接触的最多的是注解的方式，在使用spring框架自动注入时，
spring容器中匹配的候选bean的数目必须有且仅有一个，当找不到一个匹配的bean的时候，spring框架将抛出 BeanCreationException，
并指出必须至少拥有一个指定的bean。
spring允许我们通过Qualifier指定注入bean的名称，配置如下：
<bean id="myTestBean" class="bean.MyTestBean">
　　<qualifier type="org.springframework.beans.factory.annotation.Qualifier" value="qf"/>
</bean>
解析过程大致相同！

相关阅读:
《C++反汇编与逆向分析技术揭秘》--构造函数读书笔记
 《C++反汇编与逆向分析技术揭秘》--虚函数读书笔记
 VPP-main() 源码学习
 【转】几种TCP连接中出现RST的情况
 动态追踪学习
 RCU学习总结
 内核栈回溯原理学习应用
 《C++反汇编与逆向分析技术揭秘》--单类继承读书笔记
 C# 防火墙操作之创建规则
 C# 防火墙操作之特定程序
原文地址：https://www.cnblogs.com/ssh-html/p/11179860.html