三、Spring源码分析：IOC-默认标签的解析

最新推荐文章于 2022-06-07 12:42:19 发布

kinron_

最新推荐文章于 2022-06-07 12:42:19 发布

阅读量172

点赞数 2

分类专栏： Spring-framework源码分析文章标签： spring java ioc 源码软件框架

本文链接：https://blog.csdn.net/joker678/article/details/112603887

版权

Spring-framework源码分析专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文深入剖析Spring框架中XML配置文件的默认标签解析过程，包括bean、constructor-arg、property、meta、lookup-method、replaced-method等元素的解析，以及如何将这些信息转化为BeanDefinition并注册到BeanDefinitionRegistry。此外，还介绍了AbstractBeanDefinition的属性及其重要性。

摘要由CSDN通过智能技术生成

Spring源码分析：默认标签的解析

书接上回，提前提到Spring中的标签和自定义标签两种，而这两种标签的用法以及解析方式存在着很大的不同，本文重点分析默认标签的解析过程。

默认标签的解析是在parseDefaultElement方法中进行，方法的逻辑清晰明了（原来像Spring这么牛逼的代码也用这么多if else），这里分别对四种不同标签（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)) {
      // recurse
      doRegisterBeanDefinitions(ele);
   }
}

bean标签的解析及注册

显然，这四种标签里，bean标签的解析最为重要，但是也是最复杂的，那么我们首先探索一下bean标签的解析。我们步入processBeanDefinition（）方法：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
   if (bdHolder != null) {
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
      try {
         //注册最终装饰的实例。
    BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
      }
      catch (BeanDefinitionStoreException ex) {
         getReaderContext().error("Failed to register bean definition with name '" +
               bdHolder.getBeanName() + "'", ele, ex);
      }
      // 发送注册事件.
      getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
   }
}

总结一下大致的逻辑：

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

换了个软件画时序图（好像画的好看点了）：
在这里插入图片描述

解析BeanDefinition

接下来我们就对各个操作步骤具体分析，先从元素分析及信息提取开始，步入第一句：

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

再步入：

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

   List<String> aliases = new ArrayList<>();
   if (StringUtils.hasLength(nameAttr)) {
      String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
      aliases.addAll(Arrays.asList(nameArr));
   }

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

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

   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);
               // 如果生成器返回了类名加后缀，则仍然可以为普通bean类名注册一个别名。对于Spring 1.22.0向后兼容，这是预期的。
               String beanClassName = beanDefinition.getBeanClassName();
               if (beanClassName != null &&
                     beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                     !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
                  aliases.add(beanClassName);
               }
            }
            if (logger.isTraceEnabled()) {
               logger.trace("Neither XML 'id' nor 'name' specified - " +
                     "using generated bean name [" + beanName + "]");
            }
         }
         catch (Exception ex) {
            error(ex.getMessage(), ele);
            return null;
         }
      }
      String[] aliasesArray = StringUtils.toStringArray(aliases);
      return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
   }

   return null;
}

这里我们只能看到对属性id以及name的解析，这段代码的主要工作主要包括以下内容：

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

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

@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 {
       //创建GenericBeanDefinition实例
      AbstractBeanDefinition bd = createBeanDefinition(className, parent);
	//硬编码解析默认bean的各种属性
      parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
     //提取decription
       bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
	//解析元数据
      parseMetaElements(ele, bd);
       //解析lookup-method
      parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
       //解析replaced-method
      parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
		//解析构造函数参数
      parseConstructorArgElements(ele, bd);
       //解析property子元素
      parsePropertyElements(ele, bd);
       //解析qualifier子元素
      parseQualifierElements(ele, bd);

      bd.setResource(this.readerContext.getResource());
      bd.setSource(extractSource(ele));

      return bd;
   }
   catch (ClassNotFoundException ex) {
      error("Bean class [" + className + "] not found", ele, ex);
   }
   catch (NoClassDefFoundError err) {
      error("Class that bean class [" + className + "] depends on not found", ele, err);
   }
   catch (Throwable ex) {
      error("Unexpected failure during bean definition parsing", ele, ex);
   }
   finally {
      this.parseState.pop();
   }

   return null;
}

终于，bean标签的所有属性，不论是常用的还是不常用的我们都看到了，尽管有些复杂的属性还需要进一步的解析，接下来我们继续。

创建用于属性承载的BeanDefinition

BeanDefiniton是一个接口，在Spring中存在三种实现（存疑，书上这么写的，应该是七种实现）：RootBeanDefinition，ChildBeanDefinition以及GenericBeanDefinition。这三种实现均继承了AbstractBeanDefinition，其中BeanDefiniton是配置文件袁术标签在容器中的内部表示形式。标签拥有class、scope（作用域，Spring有五种作用域：singleton、prototype、session、request、global session，这里复习一下）、lazy-init等配置属性，BeanDefinition则提供了响应的beanClass、scope、lazyInit属性，BeanDefinition和中的属性是一一对应的。其中RootBeanDefinition是最常用的实现类。

在配置文件中可以定义父和子，父用RootBeanDefinition表示，而子用ChildBeanDefinition表示，如果没有夫bean就是用RootBeanDefinition表示。然后AbstractBeanDefinition对两者共同的类信息进行抽象。直接上类图：

在这里插入图片描述
接下来我们继续看代码：

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

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

这段代码用于创建GenericBeanDefinition，继续步入：

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

为给定的父名称和类名称创建一个新的GenericBeanDefinition，如果已指定ClassLoader，则热切加载bean类。

参数：
parentName –父bean的名称（如果有）
className – Bean类的名称（如果有）
classLoader –用于加载Bean类的ClassLoader（可以为null以仅按名称注册Bean类）

解析各种属性

创建了bean信息的承载实例（GenericBeanDefinition）后，便可以解析bean的各种属性了，我们步入parseBeanDefinitionAttributes(ele, beanName, containingBean, bd)方法，该方法是对element所有元素属性进行解析。

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
      @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
	//解析scope属性
    //如果使用了singleton标签就会报错
   if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
      error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
   }
   else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
      bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
   }
   else if (containingBean != null) {
       //在嵌入式beanDefinition情况下且没有单独指定scope属性，则使用父类默认的属性
      // 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));
   }
	//解析autowireCandidate属性 spring <bean>标签的 autowire-candidate属性设置为false，容器在查找自动装配对象时，将不考虑该bean，即该bean不会被作为其它bean自动装配的候选者，但该bean本身还是可以使用自动装配来注入其它bean的。
   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)));
   }
	//解析initMethodName属性
   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);
   }
	//解析FactoryMethod属性
   if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
      bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
   }
   if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
      bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
   }

   return bd;
}

一眼看过去全是if，而且好多属性都没听说过，不过代码还是很清晰的。

解析子元素meta

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);
          //构造BeanMetaDataAttribute
         BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
         attribute.setSource(extractSource(metaElement));
          //记录信息
         attributeAccessor.addMetadataAttribute(attribute);
      }
   }
}

这里的 BeanMetadataAttributeAccessor其实就是GenericBeanDefinition。本人没有用过meta标签，用法如下：

<bean id="test" class="com.qust.test.TestBean">
   <meta key="testStr" value="test"/>
</bean>

这段代码不会体现在test这个bean中，是一个额外的声明，当需要的时候可以用BeanDefinition的getAttribute(key)方法进行获取。

解析子元素lookup-method

又是一个没有用过的元素。。lookup-method通常被称为获取器注入。spring in action中对它的描述是，一种特殊的方法注入，它是把一个方法声明为返回某种类型的bean，而实际要返回的bean是在配置文件里面配置的，可用在设计可插拔的功能上，接触程序依赖。写个demo：

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

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

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

<?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/tool"
      xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tool http://www.springframework.org/schema/tool/spring-tool.xsd">
   <bean id="getBeanTest" class="com.qust.test.GetBeanTest">
      <lookup-method name="getBean" bean="teacher"/>
   </bean>
   <bean id="teacher" class="com.qust.test.Teacher"/>
</beans>

这就很神奇！Spring实例化了一个抽象类，通过这个例子，我们可以看出来lookup-method的作用是给一个抽象类注入一个实体类。

我们看源代码：

public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
   NodeList nl = beanEle.getChildNodes();
   for (int i = 0; i < nl.getLength(); i++) {
      Node node = nl.item(i);
      if (isCandidateElement(node) && nodeNameEquals(node, LOOKUP_METHOD_ELEMENT)) {
         Element ele = (Element) node;
         String methodName = ele.getAttribute(NAME_ATTRIBUTE);
         String beanRef = ele.getAttribute(BEAN_ELEMENT);
         LookupOverride override = new LookupOverride(methodName, beanRef);
         override.setSource(extractSource(ele));
         overrides.addOverride(override);
      }
   }
}

与parseMetaElements有点像。在数据存储上面通过LookupOverride类型的实体类来进行数据承载并记录在AbstractBeanDefinition中的methodOverrides中。

解析子元素replaced-method

又是一个没有用过的标签，强烈怀疑自己的水平！首先学习以下这个元素的用法：可以在运行时用新的方法替换现有的方法。与之前的look-up不同的是，replaced-method不但可以动态地替换返回实体bean，而且还能动态地更改原有方法的逻辑。以下是示例：

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

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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tool"
      xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tool http://www.springframework.org/schema/tool/spring-tool.xsd">
   <bean id="testChangeMethod" class="com.qust.test.TestChangeMethod">
      <replaced-method name="changeMe" replacer="replacer"/>
   </bean>
   <bean id="replacer" class="com.qust.test.TestMethodReplacer"/>
</beans>

可以替换方法，有动态代理的意思。

看一下源代码：

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.
         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，这里先不进行详细介绍，在后续的文章中再进行详细的介绍。

解析子元素constructor-arg（构造方法注入）

对构造函数的解析是非常常用的，同时也是非常复杂的。这里直接上代码：

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)) {
         parseConstructorArgElement((Element) node, bd);
      }
   }
}

这个结构似乎我们可以想象到，遍历所有子元素，也就是提取所有constructor-arg，然后进行解析，但是具体的解析却被放置到了另一个函数

parseConstructorArgElement中，我们继续步入：

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

又是好长的代码。。。虽然很长很复杂，但是涉及的逻辑并不复杂，首先是提取constructor-arg上必要的属性（index、type、name）

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

可以看出，对于是否指定index属性，spring的处理流程是不同的，关键在于属性信息被保存的位置。

那么了解了整个流程后，我们尝试者进一步了解解析构造函数配置中子元素的过程，首先先看parsePropertyValue：

@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);
   if ((hasRefAttribute && hasValueAttribute) ||
         ((hasRefAttribute || hasValueAttribute) && subElement != null)) {
       //在constructor-arg上不存在：1、同时既有ref属性又有value属性 2、存在ref属性或者value属性且又有子元素  
       //否则就会报错
      error(elementName +
            " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
   }

   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 {
       //既没有ref也没有value也没有子元素，spring蒙圈了！！！！！！
      // 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属性，以便于根据规则验证正确性，其规则为在constructor-arg上不存在以下情况：1、同时既有ref属性又有value属性 2、存在ref属性或者value属性且又有子元素
ref属性的处理，使用RuntimeBeanReference封装对应的ref名称，如
- ```
<constructor-arg ref="a">
```
value属性的处理，使用TypedStringValue封装，如
- ```
<constructor-arg value="a">
```

子元素的处理，如

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

对于子元素的处理，我们步入parsePropertySubElement方法：

@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.
       //对任何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.
          //对父上下文中另一个bean的ID的引用。
          //解析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对象中，以保留源位置。
      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;
   }
}

可以看到，在上面的方法中实现了所有可支持的子类的分类处理，到这里，我们已经理清了构造方法的解析流程，这里就不继续深入了。

解析子元素perperty

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

这个函数不难理解，无非是提取所有peoperty的子元素，然后调用parsePropertyElement处理，parsePropertyElement代码如下：

public void parsePropertyElement(Element ele, BeanDefinition bd) {
    //获取配置元素中的name的值
   String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
   if (!StringUtils.hasLength(propertyName)) {
      error("Tag 'property' must have a 'name' attribute", ele);
      return;
   }
   this.parseState.push(new PropertyEntry(propertyName));
   try {
       //不允许多次对同一属性配置
      if (bd.getPropertyValues().contains(propertyName)) {
         error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
         return;
      }
      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();
   }
}

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

解析子元素qualifier

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

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

解析过程不多说了，和之前差不多。

AbstractBeanDefinition属性

到这里我就完成了XML到GenericBeanDefinition，也就是说到这里，XMl中所有的配置都可以在GenericBeanDefinition的实例类中找到对应的配置。

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

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
      implements BeanDefinition, Cloneable {

   //此处省略静态变量以及final常量
	
   //bean的作用范围，对应bean属性scope
   @Nullable
   private String scope = SCOPE_DEFAULT;
	//是否是抽象，对应abstract
   private boolean abstractFlag = false;
	
    //是否延迟加载，对应lazy-init
   @Nullable
   private Boolean lazyInit;
	//自动注入模式，对应autowire
   private int autowireMode = AUTOWIRE_NO;
	//依赖检查，spring3.0后弃用
   private int dependencyCheck = DEPENDENCY_CHECK_NONE;
	//用来表示一个bean的实例化依靠另一个bean先实例化，对应bean属性depend-on
   @Nullable
   private String[] dependsOn;
	//为flase时会在容器查找自动装配对象时，将不考虑该bean，对应autowire-candidate
   private boolean autowireCandidate = true;
	//自动装配时出现多个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
   private boolean lenientConstructorResolution = true;
	//对应factory-bean
   @Nullable
   private String factoryBeanName;
	//对应factory-method
   @Nullable
   private String factoryMethodName;
	//记录构造方法注入属性，对应constructor-arg
   @Nullable
   private ConstructorArgumentValues constructorArgumentValues;
	//普通属性集合
   @Nullable
   private MutablePropertyValues propertyValues;
	//方法重写的持有者，记录lookup-method、replaced-method元素
   private MethodOverrides methodOverrides = new MethodOverrides();
	//初始化方法、对应init-method
   @Nullable
   private String initMethodName;
	//销毁方法，对应destory-method
   @Nullable
   private String destroyMethodName;
	//是否执行init-method
   private boolean enforceInitMethod = true;
	//是否执行destroy-method
   private boolean enforceDestroyMethod = true;
	//是否是用户定义的而不是程序本身定义的，创建AOP时为true
   private boolean synthetic = false;
	//定义这个bean的应用，APPLICATION：用户 INFRASTRUCTURE：完全内部使用 SUPPORT：某些复杂配置的一部分
   private int role = BeanDefinition.ROLE_APPLICATION;
	//bean的描述信息
   @Nullable
   private String description;
	//这个bean定义的资源
   @Nullable
   private Resource resource;
    
    //省略set/get以及其他方法
}

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

到这里我们已经完成了默认标签的解析与提取过程，我不由得想问自己一个问题，我看到哪了？？？？没错，是这：

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

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

<bean id="test" class="com.qust.test.TestBean">
   <mybean:user username="aaa"/>
</bean>

当Spring中的bean使用的是默认的标签配置，但是其中的子元素却使用了自定义的配置时，这句代码便会起作用了，当然，这里的自定义类型其实是属性。那么我们继续分析下面这段代码：

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

又是常见的重载，这里将方法的第三个参数设置为空，那么第三个参数是做什么用的呢，其实这第三个参数是父类bean，当对某个嵌套配置进行分析时，这里需要传递父类beanDefinition。分析源码得知这里传递的参数其实是为了使用父类的scope属性，以备子类没有设置scope时默认使用父类的属性，这里分析的是顶层配置，所以传递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方法的调用，我们继续跟踪代码：

public BeanDefinitionHolder decorateIfRequired(
      Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {
	//获取自定义标签的命名空间
   String namespaceUri = getNamespaceURI(node);
    //对与非默认标签进行修饰
   if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {
       //根据命名空间找到对应的处理器
      NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
      if (handler != null) {
          //进行修饰
         BeanDefinitionHolder decorated =
               handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
         if (decorated != null) {
            return decorated;
         }
      }
      else if (namespaceUri.startsWith("http://www.springframework.org/schema/")) {
         error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
      }
      else {
         // A custom namespace, not to be handled by Spring - maybe "xml:...".
         // 一个自定义的名称空间，Spring不会处理-可能是“ xml：...”
         if (logger.isDebugEnabled()) {
            logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
         }
      }
   }
   return originalDef;
}

程序走到这里，条理其实已经非常清楚了，首先获取属性或者元素的命名空间，以此来判断该元素或者属性适用于自定义标签的解析条件，找出自定义类型所对应的NamespaceHandler并进一步解析。这里在后面自定义标签的解析文章中详细探讨，这里先略过。

注册解析的BeanDefinition

对于配置文件，解析也解析完了，装饰也装饰完了，对于得到的beanDefinition已经满足后续的使用要求了，唯一还剩下的工作就是注册了，也就是processBeanDefinition方法中的BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry())，我们来到这个方法

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

   // Register bean definition under primary name.
    //使用beanName做唯一标识注册
   String beanName = definitionHolder.getBeanName();
   registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

   // 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中，而且与beanDefinition的注册分成了两部分：通过beanName的注册以及通过别名的注册。

通过beanName注册BeanDefinition

对于beanDefinition的注册，获取很多人认为的方式是将beanDefinition直接放入map中，使用beanName作为key。确实，Spring就是这么做的，只不过除此之外，Spring还做了点别的事情：

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

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

   if (beanDefinition instanceof AbstractBeanDefinition) {
      try {
          //注册前的最后一校验，这里的校验不同于之前的XML文件校验。
          //主要是对于AbstractBeanDefinition属性中的methodOverrides校验。
          //校验methodOverrrides是否与工厂方法并存或者methodOverrrides对应的方法根本不存在。
         ((AbstractBeanDefinition) beanDefinition).validate();
      }
      catch (BeanDefinitionValidationException ex) {
         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
               "Validation of bean definition failed", ex);
      }
   }
	
   BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    
   if (existingDefinition != null) {
      if (!isAllowBeanDefinitionOverriding()) {
         throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
      }
      else if (existingDefinition.getRole() < beanDefinition.getRole()) {
         // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
          //例如是ROLE_APPLICATION，现在已被ROLE_SUPPORT或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 {
      if (hasBeanCreationStarted()) {
         // Cannot modify startup-time collection elements anymore (for stable iteration)
          //无法再修改启动时收集元素（用于稳定的迭代）
         synchronized (this.beanDefinitionMap) {
            this.beanDefinitionMap.put(beanName, beanDefinition);
            List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
            updatedDefinitions.addAll(this.beanDefinitionNames);
            updatedDefinitions.add(beanName);
            this.beanDefinitionNames = updatedDefinitions;
            removeManualSingletonName(beanName);
         }
      }
      else {
         // Still in startup registration phase
          //仍处于启动注册阶段
         //注册beanDefinition
         this.beanDefinitionMap.put(beanName, beanDefinition);
          //记录beanName
         this.beanDefinitionNames.add(beanName);
         removeManualSingletonName(beanName);
      }
      this.frozenBeanDefinitionNames = null;
   }

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

对于bean的注册处理方式上，主要进行了几个步骤：

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

通过别名注册BeanDefinition

@Override
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;
            }
             //如果alias不允许被覆盖则抛出异常
            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);
         this.aliasMap.put(alias, name);
         if (logger.isTraceEnabled()) {
            logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
         }
      }
   }
}

注册alias的步骤如下：

alias与beanName相同情况处理。若alias与beanName名称相同则不需要处理并删除原有alias。
alias覆盖处理。若aliasName已经使用并已经指向了另一beanName则需要用户的设置进行处理。
alias循环检查。
注册alias。

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

getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));

这里的实现只是为了扩展，需要开放人员对注册BeanDefinition事件进行监听时可以通过注册监听器的方式并将处理逻辑写入监听器中，目前在Spring中并没有任何逻辑处理。

alias标签的处理

alias标签的用法就不多说了，就是个bean添加别名，用处和bean标签中name差不多，我们直接看代码：

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 {
         getReaderContext().getRegistry().registerAlias(name, alias);
      }
      catch (Exception ex) {
         getReaderContext().error("Failed to register alias '" + alias +
               "' for bean with name '" + name + "'", ele, ex);
      }
      getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
   }
}

和之前bean中的alias解析大同小异，这里不再赘述。

import标签的解析

由于XML配置文件已经很少使用了，这里就不再过多叙述了（其实只是因为我懒！）。

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

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

   Set<Resource> actualResources = new LinkedHashSet<>(4);
	//判定location是绝对URI还是相对URI
   // Discover whether the location is an absolute or relative 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?
    //如果是绝对URI则直接根据地址加载对应的配置文件
   if (absoluteLocation) {
      try {
         int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
         if (logger.isTraceEnabled()) {
            logger.trace("Imported " + importCount + " bean definitions from URL location [" + location + "]");
         }
      }
      catch (BeanDefinitionStoreException ex) {
         getReaderContext().error(
               "Failed to import bean definitions from URL location [" + location + "]", ele, ex);
      }
   }
   else {
      // No URL -> considering resource location as relative to the current file.
       //如果是相对地址，则根据相对地址计算出绝对地址
      try {
         int importCount;
          //Resource有多个实现类，这里先使用子类的方法尝试解析
         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));
}

Spring进行解析的步骤大体如下：

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

嵌入式beans标签的解析

没有大多可说的，与单独的配置文件并没有太大的差别，无非是递归调用beans的解析过程。

到这里我们就完成了默认标签的解析，虽然经过好几天还停留在XML的解析阶段，但是我们已经看到了胜利的曙光，下一篇文章将继续探究自定义标签的解析。

kinron_

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
三、Spring源码分析：IOC-默认标签的解析

Spring源码分析：默认标签的解析文章目录Spring源码分析：默认标签的解析bean标签的解析及注册解析BeanDefinition创建用于属性承载的BeanDefinition解析各种属性解析子元素meta解析子元素lookup-method解析子元素replaced-method解析子元素constructor-arg（构造方法注入）解析子元素perperty解析子元素qualifierAbstractBeanDefinition属性解析默认标签中的自定义标签元素注册解析的BeanDefiniti
复制链接

扫一扫