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

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

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

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

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

 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标签的解析与注册

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

 /**
  * Process the given bean element, parsing the bean definition
  * and registering it with the registry.
  */
 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));
     }
 }

（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类

第一步调用此方法：

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

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

 /**
  * Parses the supplied {@code <bean>} element. May return {@code null}
  * if there were errors during parse. Errors are reported to the
  * {@link org.springframework.beans.factory.parsing.ProblemReporter}.
  */
 @Nullable
 public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
     // 解析id属性
     String id = ele.getAttribute(ID_ATTRIBUTE);
     // 解析name属性
     String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

     // 分割name属性 注意这里为什么进行name属性的分割，因为bean配置文件的定义中，name是可以有多个值的，多个值之前用","":"隔开
     List<String> aliases = new ArrayList<>();
     if (StringUtils.hasLength(nameAttr)) {
         // MULTI_VALUE_ATTRIBUTE_DELIMITERS变量的定义就是：MULTI_VALUE_ATTRIBUTE_DELIMITERS = ",; ";
         String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
         // aliases的意思是别名
         aliases.addAll(Arrays.asList(nameArr));
     }

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

     if (containingBean == null) {
         checkNameUniqueness(beanName, aliases, ele);
     }

     AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
     if (beanDefinition != null) {
         if (!StringUtils.hasText(beanName)) {
             try {
                 // 如果不存在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.isDebugEnabled()) {
                     logger.debug("Neither XML 'id' nor 'name' specified - " +
                             "using generated bean name [" + beanName + "]");
                 }
             }
             catch (Exception ex) {
                 error(ex.getMessage(), ele);
                 return null;
             }
         }
         String[] aliasesArray = StringUtils.toStringArray(aliases);
         return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
     }

     return null;
 }

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

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

 /**
  * Parse the bean definition itself, without regard to name or aliases. May return
  * {@code null} if problems occurred during the parsing of the bean definition.
  */
 @Nullable
 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，需要到createBeanDefinition方法中看一下源码
         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());
         /**
          *  lookup-method通常称为获取器注入，spring in action中对它的描述是，一种特殊的方法注入，<br>
          *     它是把一个方法声明为返回某种类型的bean，而实际要返回的bean是在配置文件里面配置的， <br>
          *     可用在设计可插拔的功能上，接触程序依赖。同理replaced-method则是将之前执行的逻辑替换掉
          */

         // 解析构造函数参数
         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标签的所有属性，不论常用的还是不常用的我们都看到了，尽管有些复杂的属性还需要进一步解析，继续一些复杂标签的属性的解析
（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)就是创建这个实例

 /**
  * Create a new GenericBeanDefinition for the given parent name and class name,
  * eagerly loading the bean class if a ClassLoader has been specified.
  * @param parentName the name of the parent bean, if any
  * @param className the name of the bean class, if any
  * @param classLoader the ClassLoader to use for loading bean classes
  * (can be {@code null} to just register bean classes by name)
  * @return the bean definition
  * @throws ClassNotFoundException if the bean class could not be loaded
  */
 public static AbstractBeanDefinition createBeanDefinition(
         @Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {

     GenericBeanDefinition bd = new GenericBeanDefinition();
     bd.setParentName(parentName);
     if (className != null) {
         if (classLoader != null) {
             bd.setBeanClass(ClassUtils.forName(className, classLoader));
         }
         else {
             bd.setBeanClassName(className);
         }
     }
     return bd;
 }

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

 /**
  * Apply the attributes of the given bean element to the given bean * definition.
  * @param ele bean declaration element
  * @param beanName bean name
  * @param containingBean containing bean definition
  * @return a bean definition initialized according to the bean element attributes
  */
 public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
         @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
     // 解析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);
     }

     // 解析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;
 }

（3）解析子元素meta

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

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

（4）解析子元素lookup-method

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

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

<bean id="teacher" class="test.lookup.bean.Teacher">
</bean>

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

 /**
  * Parse lookup-override sub-elements of the given bean element.
  */
 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 override = new LookupOverride(methodName, beanRef);
             override.setSource(extractSource(ele));
             overrides.addOverride(override);
         }
     }
 }

（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类中

 /**
  * Parse replaced-method sub-elements of the given bean element.
  */
 public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {
     NodeList nl = beanEle.getChildNodes();
     for (int i = 0; i < nl.getLength(); i++) {
         Node node = nl.item(i);
         if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) {
             Element replacedMethodEle = (Element) node;
             // 提取要替换的旧的方法
             String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);
             // 提取新的方法
             String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);
             ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
             // Look for arg-type match elements. 查找新方法对应的bean
             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-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类中

 /**
  * Parse constructor-arg sub-elements of the given bean element.
  */
 public void parseConstructorArgElements(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, CONSTRUCTOR_ARG_ELEMENT)) {
             // 解析constructor-arg子元素
            parseConstructorArgElement((Element) node, bd);
         }
     }
 }

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

 /**
  * 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);
     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();
         }
     }
 }

这个主要是分为两种情况：一种是指定了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类中

 /**
  * 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) {
     String elementName = (propertyName != null ?
             "<property> element for property '" + propertyName + "'" :
             "<constructor-arg> element");

     // Should only have one child element: ref, value, list, etc.
     // 一个属性只能对应一种类型，ref、value、list等
     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属性且又有子元素
      */
     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属性的处理 使用RuntimeBeanReference封装对应的ref名称
         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;
     }
     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.
         // 既没有ref 又没有value属性 也没有子元素 spring懵逼了
         error(elementName + " must specify a ref or value", ele);
         return null;
     }
 }

文字解释一下其中代码做了哪些事情：
（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类中

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

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

 /**
  * Parse a value, ref or collection sub-element of a property or
  * constructor-arg element.
  * @param ele subelement of property element; we don't know which yet
  * @param defaultValueType the default type (class name) for any
  * {@code <value>} tag that might be created
  */
 @Nullable
 public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {
     if (!isDefaultNamespace(ele)) {
         return parseNestedCustomElement(ele, bd);
     }
     else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
         BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
         if (nestedBd != null) {
             nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
         }
         return nestedBd;
     }
     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.
             // 解析parent属性
             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;
     }
 }

（7）解析子元素property

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

 /**
  * 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);
         }
     }
 }

 /**
  * 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;
         }
         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属性中

（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>
解析过程大致相同！