Spring源码解析笔记2——默认标签的解析

继续前面的this.parseDefaultElement(ele, delegate)讨论。

//分别对4种不同的标签（import，alias，bean，beans）做了不同的处理。
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        if(delegate.nodeNameEquals(ele, "import")) {
            this.importBeanDefinitionResource(ele);
        } else if(delegate.nodeNameEquals(ele, "alias")) {
            this.processAliasRegistration(ele);
        } else if(delegate.nodeNameEquals(ele, "bean")) {
            this.processBeanDefinition(ele, delegate);
        } else if(delegate.nodeNameEquals(ele, "beans")) {
            this.doRegisterBeanDefinitions(ele);
        }

    }

重点研究如何处理bean标签，import和alias和beans放在最后说明，继续this.processBeanDefinition(ele, delegate)方法。

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        //返回的bdHolder实例已经包含配置文件中的各种属性了，class，name等。
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if(bdHolder != null) {
            //对自定义标签进行解析。
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

            try {
            //注册解析的BeanDefinition
               BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry());
            } catch (BeanDefinitionStoreException var5) {
                this.getReaderContext().error("Failed to register bean definition with name \'" + bdHolder.getBeanName() + "\'", ele, var5);
            }
            //通知监听器，这个bean已经加载完了
            this.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }
}

1.根据以上步骤分析，首先分析parseBeanDefinitionElement(Element ele)：

• parseBeanDefinitionElement(Element ele)方法：

  public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
       //提取元素中的id以及name。
      String id = ele.getAttribute("id");
      String nameAttr = ele.getAttribute("name");
      ArrayList aliases = new ArrayList();
      if(StringUtils.hasLength(nameAttr)) {
          String[] beanName = StringUtils.tokenizeToStringArray(nameAttr, ",; ");
          aliases.addAll(Arrays.asList(beanName));
      }
  
      String beanName1 = id;
      if(!StringUtils.hasText(id) && !aliases.isEmpty()) {
          beanName1 = (String)aliases.remove(0);
          if(this.logger.isDebugEnabled()) {
              this.logger.debug("No XML \'id\' specified - using \'" + beanName1 + "\' as bean name and " + aliases + " as aliases");
          }
      }
  
      if(containingBean == null) {
          this.checkNameUniqueness(beanName1, aliases, ele);
      }
  
      //核心方法，进一步解析其他所有属性并统一封装至GenericBeanDefinition类型的实例。
      AbstractBeanDefinition beanDefinition = this.parseBeanDefinitionElement(ele, beanName1, containingBean);
      if(beanDefinition != null) {
          if(!StringUtils.hasText(beanName1)) {
              try {
                  if(containingBean != null) {
                      beanName1 = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, this.readerContext.getRegistry(), true);
                  } else {
                      beanName1 = this.readerContext.generateBeanName(beanDefinition);
                      String aliasesArray = beanDefinition.getBeanClassName();
                      if(aliasesArray != null && beanName1.startsWith(aliasesArray) && beanName1.length() > aliasesArray.length() && !this.readerContext.getRegistry().isBeanNameInUse(aliasesArray)) {
                          aliases.add(aliasesArray);
                      }
                  }
  
                  if(this.logger.isDebugEnabled()) {
                      this.logger.debug("Neither XML \'id\' nor \'name\' specified - using generated bean name [" + beanName1 + "]");
                  }
              } catch (Exception var9) {
                  this.error(var9.getMessage(), ele);
                  return null;
              }
          }
  
          String[] aliasesArray1 = StringUtils.toStringArray(aliases);
          //将结果封装到BeanDefinitionHolder类中。
          return new BeanDefinitionHolder(beanDefinition, beanName1, aliasesArray1);
      } else {
          return null;
      }
  }

• 上一步的核心方法：parseBeanDefinitionElement(ele, beanName1, containingBean)，将其他所有属性统一封装至GenericBeanDefinition类型中。

  public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean) {
      this.parseState.push(new BeanEntry(beanName));
      String className = null;
      //解析class属性
      if(ele.hasAttribute("class")) {
          className = ele.getAttribute("class").trim();
      }
  
      try {
          String ex = null;
          //解析parent属性
          if(ele.hasAttribute("parent")) {
              ex = ele.getAttribute("parent");
          }
  
          //核心方法1，生成GenericBeanDefinition，要解析属性，就必须先要创建用于承载属性的实例。
          AbstractBeanDefinition bd = this.createBeanDefinition(className, ex);
  
          //硬编码解析默认的bean的各种属性。
          this.parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
    bd.setDescription(DomUtils.getChildElementValueByTagName(ele, "description"));
  
          //解析元数据
          this.parseMetaElements(ele, bd);
  
          //解析lookup-method属性
          this.parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
  
          //解析replaced-method属性。
          this.parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
  
          //解析构造函数参数
          this.parseConstructorArgElements(ele, bd);
  
          //解析property子元素
          this.parsePropertyElements(ele, bd);
  
          //解析qualifier子元素
          this.parseQualifierElements(ele, bd);
  
          bd.setResource(this.readerContext.getResource());
          bd.setSource(this.extractSource(ele));
          AbstractBeanDefinition var7 = bd;
          return var7;
      } catch (ClassNotFoundException var13) {
          this.error("Bean class [" + className + "] not found", ele, var13);
      } catch (NoClassDefFoundError var14) {
          this.error("Class that bean class [" + className + "] depends on not found", ele, var14);
      } catch (Throwable var15) {
          this.error("Unexpected failure during bean definition parsing", ele, var15);
      } finally {
          this.parseState.pop();
      }
  
      return null;
  }

  • this.createBeanDefinition(className, ex)是生成GenericBeanDefinition类型的实例。

    关于GenericBeanDefinition
    
    BeanDefinition是配置文件bean>元素标签在容器中的内部表现形式。bean>元素标签拥有的class，scope，lazy-init等配置属性对应BeanDefinition中的beanClass，scope，lazyInit属性。

    在bean>标签中，父bean>用RootBeanDefinition表示，子bean>用ChildBeanDefinition表示，没有父bean>的bean>就使用RootBeanDefinition表示。AbstractBeanDefinition对两者共同的类信息进行了抽象。

    ChildBeanDefinition和RootBeanDefinition在spring2.5以后就被GenericBeanDefinition代替了，GenericBeanDefinition相比于RootBeanDefinition和ChildBeanDefinition在定义的时候就必须硬编码，GenericBeanDefinition的优点可以动态的为GenericBeanDefinition设置parent。

    //父bean的实例：
    <bean id="abstractServiceThread" class="com.project.schedual.ServiceThread" abstract="true">  
            <property name="baseDao" ref="baseDAO"></property>  
    </bean>  
    //子bean的实例
    <bean id="docReceiveFlowThread" parent="abstractServiceThread">  
            <property name="svc" ref="docReceiveFlowService"></property>  
    </bean>  
    .
    //createBeanDefinition源码：
    public static AbstractBeanDefinition createBeanDefinition(String parentName, String className, 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;
    }

  • 解析各种属性this.parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);

    public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName, BeanDefinition containingBean, AbstractBeanDefinition bd) {
        if(ele.hasAttribute("singleton")) {
            //scope与singleton两个属性只能指定其一，不能同时出现，否则报异常。
            this.error("Old 1.x \'singleton\' attribute in use - upgrade to \'scope\' declaration", ele);
        } else if(ele.hasAttribute("scope")) {
            bd.setScope(ele.getAttribute("scope"));
        } else if(containingBean != null) {
            //在嵌入beanDifinition的情况下没有单独指定scope属性则使用父类默认的属性。
            bd.setScope(containingBean.getScope());
        }
    
        if(ele.hasAttribute("abstract")) {
            bd.setAbstract("true".equals(ele.getAttribute("abstract")));
        }
    
        //解析lazy-init属性
        String lazyInit = ele.getAttribute("lazy-init");
        if("default".equals(lazyInit)) {
            lazyInit = this.defaults.getLazyInit();
        }
    
        //如果没有设置或者设置为其他字符都会被设置成false
        bd.setLazyInit("true".equals(lazyInit));
    
        //解析autowire属性
        String autowire = ele.getAttribute("autowire");
        bd.setAutowireMode(this.getAutowireMode(autowire));
    
        //解析dependency-check属性
        String dependencyCheck = ele.getAttribute("dependency-check");
        bd.setDependencyCheck(this.getDependencyCheck(dependencyCheck));
        String autowireCandidate;
    
        //解析depends-on属性
        if(ele.hasAttribute("depends-on")) {
            autowireCandidate = ele.getAttribute("depends-on");
            bd.setDependsOn(StringUtils.tokenizeToStringArray(autowireCandidate, ",; "));
        }
    
        //解析autowire-candidate属性
        autowireCandidate = ele.getAttribute("autowire-candidate");
        String destroyMethodName;
        if(!"".equals(autowireCandidate) && !"default".equals(autowireCandidate)) {
            bd.setAutowireCandidate("true".equals(autowireCandidate));
        } else {
            destroyMethodName = this.defaults.getAutowireCandidates();
            if(destroyMethodName != null) {
                String[] patterns = StringUtils.commaDelimitedListToStringArray(destroyMethodName);
                bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
            }
        }
    
        //解析primary属性
        if(ele.hasAttribute("primary")) {
            bd.setPrimary("true".equals(ele.getAttribute("primary")));
        }
    
        //解析init-method属性
        if(ele.hasAttribute("init-method")) {
            destroyMethodName = ele.getAttribute("init-method");
            if(!"".equals(destroyMethodName)) {
                bd.setInitMethodName(destroyMethodName);
            }
        } else if(this.defaults.getInitMethod() != null) {
            bd.setInitMethodName(this.defaults.getInitMethod());
            bd.setEnforceInitMethod(false);
        }
    
        //解析destroy-method属性
        if(ele.hasAttribute("destroy-method")) {
            destroyMethodName = ele.getAttribute("destroy-method");
            bd.setDestroyMethodName(destroyMethodName);
        } else if(this.defaults.getDestroyMethod() != null) {
            bd.setDestroyMethodName(this.defaults.getDestroyMethod());
            bd.setEnforceDestroyMethod(false);
        }
    
        //解析factory-method属性
        if(ele.hasAttribute("factory-method")) {
            bd.setFactoryMethodName(ele.getAttribute("factory-method"));
        }
    
        //解析factory-bean属性
        if(ele.hasAttribute("factory-bean")) {
            bd.setFactoryBeanName(ele.getAttribute("factory-bean"));
        }
    
        return bd;
    }
    

  • this.parseMetaElements(ele, bd); 解析子元素meta，元数据属性。

    //meta标签使用举例
    <bean id="myTestBean" class="bean.MyTestBean">
        <meta key="testStr" value="aaaaa">
    </bean> 
    
    
    public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {
        NodeList nl = ele.getChildNodes();
    
        for(int i = 0; i < nl.getLength(); ++i) {
            Node node = nl.item(i);
            if(this.isCandidateElement(node) && this.nodeNameEquals(node, "meta")) {
                Element metaElement = (Element)node;
                String key = metaElement.getAttribute("key");
                String value = metaElement.getAttribute("value");
                BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
                attribute.setSource(this.extractSource(metaElement));
                attributeAccessor.addMetadataAttribute(attribute);
            }
        }
    }

  • this.parseLookupOverrideSubElements(ele, bd.getMethodOverrides());解析子元素lookup-method ,

    首先解释一下lookup-method这个子元素的作用，通常被称为获取器注入。

    // 定义一个水果类
    public class Fruit {
          public Fruit() {
              System.out.println("I got Fruit");
          }
    }
    
    // 苹果
    public class Apple extends Fruit {
        public Apple() {
           System.out.println("I got a fresh apple");
        }
    }
    
    // 香蕉
    public class Bananer extends Fruit {
          public Bananer () {
               System.out.println("I got a  fresh bananer");
          }
    }
    
       //水果盘，可以拿到水果
       public abstract class FruitPlate{
       // 抽象方法获取新鲜水果
       protected abstract Fruit getFruit();
    }
    
    
    
    <bean id="fruitPlate1" class="cn.com.willchen.test.di.FruitPlate">
        <lookup-method name="getFruit" bean="apple"/>
    </bean>
    <bean id="fruitPlate2" class="cn.com.willchen.test.di.FruitPlate">
        <lookup-method name="getFruit" bean="bananer"/>
    </bean>
    
    
    public static void main(String[] args) {
       ApplicationContext app = new >ClassPathXmlApplicationContext("classpath:resource/applicationContext.xml");
    
       FruitPlate fp1= (FruitPlate)app.getBean("fruitPlate1");
       FruitPlate fp2 = (FruitPlate)app.getBean("fruitPlate2");
    
       fp1.getFruit();
       fp2.getFruit();
    }
    

  • this.parseLookupOverrideSubElements(ele, bd.getMethodOverrides());方法源码

    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(this.isCandidateElement(node) && this.nodeNameEquals(node, "lookup-method")) {
                Element ele = (Element)node;
                String methodName = ele.getAttribute("name");
                String beanRef = ele.getAttribute("bean");
                LookupOverride override = new LookupOverride(methodName, beanRef);
                override.setSource(this.extractSource(ele));
                overrides.addOverride(override);
            }
        }
    
    }

  • 解析子元素replaced-method

    解释replaced-method的作用

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

    //配置文件
    <bean id="testChangeMethod" class="com.demo3.TestChangeMethod">
        <replaced-method name="changeMe" replacer="replacer"/>
    </bean>
    <bean id="replacer" class="com.demo3.TestMethodReplacer"></bean>
    

    //测试
    public static void main(String[] args){
    
        ApplicationContext bf = new ClassPathXmlApplicationContext("springContext.xml");
        TestChangeMethod test = (TestChangeMethod )bf.getBean("testChangeMethod");
    }

  • this.parseReplacedMethodSubElements(ele, bd.getMethodOverrides());方法源码

     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(this.isCandidateElement(node) && this.nodeNameEquals(node, "replaced-method")) {
                Element replacedMethodEle = (Element)node;
                String name = replacedMethodEle.getAttribute("name");
                String callback = replacedMethodEle.getAttribute("replacer");
                ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
                List argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, "arg-type");
                Iterator var11 = argTypeEles.iterator();
    
                while(var11.hasNext()) {
                    Element argTypeEle = (Element)var11.next();
                    String match = argTypeEle.getAttribute("match");
                    match = StringUtils.hasText(match)?match:DomUtils.getTextValue(argTypeEle);
                    if(StringUtils.hasText(match)) {
                        replaceOverride.addTypeIdentifier(match);
                    }
                }
    
                replaceOverride.setSource(this.extractSource(replacedMethodEle));
                overrides.addOverride(replaceOverride);
            }
        }
    
    }

  • 解析子元素constructor-arg

    ......
    <beans>
    <!-- 默认的情况是按照参数的顺序注入，当指定index索引后就可以改变注入参数的顺序 -->
        <bean id="helloBean" class="com.HelloBean">
            <constructor-arg index="0">
                <value>张三</value>
            </constructor-arg>
            <constructor-arg index="1">
                <value>李四</value>
            </constructor-arg>
        </bean>
    ......
    </beans>
    <!--上面的配置实现的功能就是对HelloBean自动寻找对应的构造函数，并在初始化的时候设置参数传进去-->

  • this.parseConstructorArgElements(ele, bd);的源码：

    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(this.isCandidateElement(node) && this.nodeNameEquals(node, "constructor-arg")) {
                //解析constructor-arg
                this.parseConstructorArgElement((Element)node, bd);
            }
        }
    
    }
    
    //this.parseConstructorArgElement((Element)node, bd);源码
    public void parseConstructorArgElement(Element ele, BeanDefinition bd) {
        String indexAttr = ele.getAttribute("index");
        String typeAttr = ele.getAttribute("type");
        String nameAttr = ele.getAttribute("name");
        if(StringUtils.hasLength(indexAttr)) {
            try {
                int value = Integer.parseInt(indexAttr);
                if(value < 0) {
                    this.error("\'index\' cannot be lower than 0", ele);
                } else {
                    try {
                        this.parseState.push(new ConstructorArgumentEntry(value));
                        //解析constructor-arg
                        Object valueHolder = this.parsePropertyValue(ele, bd, (String)null);
                        //将type，name，index属性一并封装到valueHolder类型中。
                        ValueHolder valueHolder1 = new ValueHolder(valueHolder);
                        if(StringUtils.hasLength(typeAttr)) {
                            valueHolder1.setType(typeAttr);
                        }
    
                        if(StringUtils.hasLength(nameAttr)) {
                            valueHolder1.setName(nameAttr);
                        }
    
                        valueHolder1.setSource(this.extractSource(ele));
                        if(bd.getConstructorArgumentValues().hasIndexedArgumentValue(value)) {
                            this.error("Ambiguous constructor-arg entries for index " + value, ele);
                        } else {
                        //将valueHolder里面的type，name，index等，添加到BeanDefinition的ConstructorArgumentValues的IndexedArgumentValue属性中。       bd.getConstructorArgumentValues().addIndexedArgumentValue(value, valueHolder1);
                        }
                    } finally {
                        this.parseState.pop();
                    }
                }
            } catch (NumberFormatException var19) {
                this.error("Attribute \'index\' of tag \'constructor-arg\' must be an integer", ele);
            }
        } else {
            //如果没有index属性则自动寻找
            try {
                this.parseState.push(new ConstructorArgumentEntry());
                //解析constructor-arg
                Object value1 = this.parsePropertyValue(ele, bd, (String)null);
                ValueHolder valueHolder2 = new ValueHolder(value1);
                if(StringUtils.hasLength(typeAttr)) {
                    valueHolder2.setType(typeAttr);
                }
    
                if(StringUtils.hasLength(nameAttr)) {
                    valueHolder2.setName(nameAttr);
                }
    
                valueHolder2.setSource(this.extractSource(ele));
                //将valueHolder里面的type，name，index等，添加到BeanDefinition的ConstructorArgumentValues的genericArgumentValue属性中。                       bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder2);
            } finally {
                this.parseState.pop();
            }
        }
    
    }
    

  • 关于 this.parseConstructorArgElements(ele, bd);的源码中的parsePropertyValue(Element ele, BeanDefinition bd, String propertyName)方法源码：

    public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {
        String elementName = propertyName != null?"<property> element for property \'" + propertyName + "\'":"<constructor-arg> element";
        NodeList nl = ele.getChildNodes();
        Element subElement = null;
    
        for(int hasRefAttribute = 0; hasRefAttribute < nl.getLength(); ++hasRefAttribute) {
            Node hasValueAttribute = nl.item(hasRefAttribute);
            //对应的description或者meta不处理。
            if(hasValueAttribute instanceof Element && !this.nodeNameEquals(hasValueAttribute, "description") && !this.nodeNameEquals(hasValueAttribute, "meta")) {
                if(subElement != null) {
                    this.error(elementName + " must not contain more than one sub-element", ele);
                } else {
                    subElement = (Element)hasValueAttribute;
                }
            }
        }
    
        //解析constructor-arg的ref属性
        boolean var11 = ele.hasAttribute("ref");
        //解析constructor-arg的value属性
        boolean var12 = ele.hasAttribute("value");
        if(var11 && var12 || (var11 || var12) && subElement != null) {
            //如果同时有ref属性又有value属性，或者存在ref属性的同时有value属性且又有子元素，报错。
            this.error(elementName + " is only allowed to contain either \'ref\' attribute OR \'value\' attribute OR sub-element", ele);
        }
    
        if(var11) {
            String var13 = ele.getAttribute("ref");
            if(!StringUtils.hasText(var13)) {
                this.error(elementName + " contains empty \'ref\' attribute", ele);
            }
            //使用RuntimeBeanReference封装对应的ref名称<constructor-arg ref="a">
            RuntimeBeanReference ref = new RuntimeBeanReference(var13);
            ref.setSource(this.extractSource(ele));
            return ref;
        } else if(var12) {
            //使用TypedStringValue封装对应的value名称<constructor-arg value="a">
            TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute("value"));
            valueHolder.setSource(this.extractSource(ele));
            return valueHolder;
        } else if(subElement != null) {
            //子元素的处理
            /**
            <constructor-arg>
                <map>
                    <entry key="key" value="value">
                </map>
            </constructor-arg>
            **/
            return this.parsePropertySubElement(subElement, bd);
        } else {
            //没有ref也没有value也没有子元素，spring报错。
            this.error(elementName + " must specify a ref or value", ele);
            return null;
        }
    }

  • 子元素的处理 this.parsePropertySubElement(subElement, bd)源码根据源码可以看到constructor-arg支持的子元素

    public Object parsePropertySubElement(Element ele, BeanDefinition bd) {
        return this.parsePropertySubElement(ele, bd, (String)null);
    }
    
    public Object parsePropertySubElement(Element ele, BeanDefinition bd, String defaultValueType) {
        if(!this.isDefaultNamespace((Node)ele)) {
            return this.parseNestedCustomElement(ele, bd);
        } else if(this.nodeNameEquals(ele, "bean")) {
            BeanDefinitionHolder nullHolder2 = this.parseBeanDefinitionElement(ele, bd);
            if(nullHolder2 != null) {
                nullHolder2 = this.decorateBeanDefinitionIfRequired(ele, nullHolder2, bd);
            }
    
            return nullHolder2;
        } else if(this.nodeNameEquals(ele, "ref")) {
            String nullHolder1 = ele.getAttribute("bean");
            boolean toParent = false;
            if(!StringUtils.hasLength(nullHolder1)) {
                nullHolder1 = ele.getAttribute("local");
                if(!StringUtils.hasLength(nullHolder1)) {
                    nullHolder1 = ele.getAttribute("parent");
                    toParent = true;
                    if(!StringUtils.hasLength(nullHolder1)) {
                        this.error("\'bean\', \'local\' or \'parent\' is required for <ref> element", ele);
                        return null;
                    }
                }
            }
    
            if(!StringUtils.hasText(nullHolder1)) {
                this.error("<ref> element contains empty target attribute", ele);
                return null;
            } else {
                RuntimeBeanReference ref = new RuntimeBeanReference(nullHolder1, toParent);
                ref.setSource(this.extractSource(ele));
                return ref;
            }
        } else if(this.nodeNameEquals(ele, "idref")) {
            return this.parseIdRefElement(ele);
        } else if(this.nodeNameEquals(ele, "value")) {
            return this.parseValueElement(ele, defaultValueType);
        } else if(this.nodeNameEquals(ele, "null")) {
            TypedStringValue nullHolder = new TypedStringValue((String)null);
            nullHolder.setSource(this.extractSource(ele));
            return nullHolder;
        } else if(this.nodeNameEquals(ele, "array")) {
            return this.parseArrayElement(ele, bd);
        } else if(this.nodeNameEquals(ele, "list")) {
            return this.parseListElement(ele, bd);
        } else if(this.nodeNameEquals(ele, "set")) {
            return this.parseSetElement(ele, bd);
        } else if(this.nodeNameEquals(ele, "map")) {
            return this.parseMapElement(ele, bd);
        } else if(this.nodeNameEquals(ele, "props")) {
            return this.parsePropsElement(ele);
        } else {
            this.error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
            return null;
        }
    }

  • 解析子元素property，property的作用如下。

    <bean id="test" class="test.TestClass">
        <property name="testStr" value="aaa" />
    </bean>
    或者
    <bean id="a">
        <property name="p">
            <list>
                <value>aa</value>
                <value>bb</value>
            </list>
        </property>
    </bean>

  • 解析property的方法this.parsePropertyElements(ele, bd)源码为:

    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(this.isCandidateElement(node) && this.nodeNameEquals(node, "property")) {
                this.parsePropertyElement((Element)node, bd);
            }
        }
    
    }
    
    //this.parsePropertyElement((Element)node, bd)的源码：
    public void parsePropertyElement(Element ele, BeanDefinition bd) {
        String propertyName = ele.getAttribute("name");
        if(!StringUtils.hasLength(propertyName)) {
            this.error("Tag \'property\' must have a \'name\' attribute", ele);
        } else {
            this.parseState.push(new PropertyEntry(propertyName));
    
            try {
                if(!bd.getPropertyValues().contains(propertyName)) {
                    Object val = this.parsePropertyValue(ele, bd, propertyName);
                    //将返回值使用PropertyValue进行封装，并记录在了BeanDefinition中的PropertyValues属性中。
                    PropertyValue pv = new PropertyValue(propertyName, val);
                    this.parseMetaElements(ele, pv);
                    pv.setSource(this.extractSource(ele));
                    bd.getPropertyValues().addPropertyValue(pv);
                    return;
                }
    
                this.error("Multiple \'property\' definitions for property \'" + propertyName + "\'", ele);
            } finally {
                this.parseState.pop();
            }
    
        }
    }
    

  • 解析子元素qualifier，该元素的作用是，大多数时候都用注解的方式。解析的过程与前面相似。

    public interface EmployeeService {
        public EmployeeDto getEmployeeById(Long id);
    }
    //上述接口的实现类
    @Service("service")
    public class EmployeeServiceImpl implements EmployeeService {
        public EmployeeDto getEmployeeById(Long id) {
            return new EmployeeDto();
        }
    }
    //上述接口的第二个实现类
    @Service("service1")
    public class EmployeeServiceImpl1 implements EmployeeService {
        public EmployeeDto getEmployeeById(Long id) {
            return new EmployeeDto();
        }
    }
    //控制层的调用代码如下：
    @Controller
    @RequestMapping("/emplayee.do")
    public class EmployeeInfoControl {
        @Autowired
        EmployeeService employeeService;
    
    }
    /**
    此时启动tomcat会报错，因为该接口有两个实现类，spring不知道该去绑定哪一个，此时需要使用qualifier注解；问题解决。
    **/
    @Controller
    @RequestMapping("/emplayee.do")
    public class EmployeeInfoControl {
    
        @Autowired
        @Qualifier("service")
        EmployeeService employeeService;
    }

  • Qualifier的配置文件使用方法。

    <bean id="myTestBean" class="bean.MyTestBean">
    <qualifier type="org.Springframework.beans.factory.annotation.Qualifier" value="qf" />
    </bean>

  
  

2.根据文章开头processBeanDefinition方法下面的bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder)的decorateBeanDefinitionIfRequired方法:该方法是用来解析默认标签中的自定义标签。

<!--解释一下此处的自定义标签，spring中以bean形式出现的标签分为默认和自定义，
    而默认的bean中也有一些自定义标签，例如bean的属性。-->
<!--实例：默认的bean标签自定义属性标签-->
<bean id="test" class="test.MyClass">
      <mybean:user username="aaa">
</bean>

//追踪decorateBeanDefinitionIfRequired方法
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder) {
        return this.decorateBeanDefinitionIfRequired(ele, definitionHolder, (BeanDefinition)null);
    }

/**
   可以看到decorateBeanDefinitionIfRequired的第三个参数是null，这里需要传>的是父类的beanDefinition,其实是为了使用父类的scope属性，以备子类没有设>置scope时默认使用父类的属性，此处是顶层配置，所以传递null。
**/

//继续跟踪decorateBeanDefinitionIfRequired
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, >BeanDefinitionHolder definitionHolder, BeanDefinition containingBd) {
       BeanDefinitionHolder finalDefinition = definitionHolder;
       NamedNodeMap attributes = ele.getAttributes();

       //遍历所有属性，看看是否有适用于修饰的属性
       for(int children = 0; children < attributes.getLength(); ++children) {
           Node i = attributes.item(children);
           finalDefinition = this.decorateIfRequired(i, finalDefinition, >containingBd);
       }

       NodeList var9 = ele.getChildNodes();
       //遍历所有的子节点，看看是否有适用于修饰的子元素。
       for(int var10 = 0; var10 < var9.getLength(); ++var10) {
           Node node = var9.item(var10);
           if(node.getNodeType() == 1) {
               finalDefinition = this.decorateIfRequired(node, finalDefinition, >containingBd);
           }
       }

       return finalDefinition;
   }


 //继续跟踪decorateIfRequired方法
 public BeanDefinitionHolder decorateIfRequired(Node node, BeanDefinitionHolder originalDef, BeanDefinition containingBd) {
        //获取自定义标签的命名空间
        String namespaceUri = this.getNamespaceURI(node);

        //对于非默认标签进行修饰。
        if(!this.isDefaultNamespace(namespaceUri)) {
            //根据命名空间找到对应的处理器。
            NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
            if(handler != null) {
                //进行修饰。此处在后面自定义标签处详细说明。
                return handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
            }

            if(namespaceUri != null && namespaceUri.startsWith("http://www.springframework.org/")) {
                this.error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
            } else if(this.logger.isDebugEnabled()) {
                this.logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
            }
        }

        return originalDef;
    }

3.根据文章开头processBeanDefinition方法下面的BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry())追踪：

public static void registerBeanDefinition(BeanDefinitionHolder >definitionHolder, BeanDefinitionRegistry registry) throws >BeanDefinitionStoreException {
       String beanName = definitionHolder.getBeanName();
       //使用beanName做唯一标识。此处可以看出解析的beanDefinition都会被注册在BeanDefinitionRegistry类型的registry中。
       registry.registerBeanDefinition(beanName, >definitionHolder.getBeanDefinition());

       //注册所有的别名。
       String[] aliases = definitionHolder.getAliases();
       if(aliases != null) {
          String[] var4 = aliases;
          int var5 = aliases.length;
           for(int var6 = 0; var6 < var5; ++var6) {
               String alias = var4[var6];
               registry.registerAlias(beanName, alias);
           }
       }
   }

 /**
     对于beanDefinition的注册，其实就是将beanDefinition直接放入map中，使用beanName作为key。除此之外，spring还利用registerBeanDefinition做了一些其他的事。
 **/    

//继续追踪registerBeanDefinition方法：
 public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
       Assert.hasText(beanName, "Bean name must not be empty");
       Assert.notNull(beanDefinition, "BeanDefinition must not be null");
       if(beanDefinition instanceof AbstractBeanDefinition) {
           try {
         /**
             注册前的最后一次校验，此处的校验不同于之前的XML文件校验
             主要是对于AbstractBeanDefinition属性中的methodOverrides校验
             校验methodOverrides是否与工厂方法并存或者methodOverrides对应方法根本不存在。
         **/
               ((AbstractBeanDefinition)beanDefinition).validate();
           } catch (BeanDefinitionValidationException var9) {
               throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", var9);
            }
        }

       BeanDefinition oldBeanDefinition = (BeanDefinition)this.beanDefinitionMap.get(beanName);
        if(oldBeanDefinition != null) {
            //如果对应的BeanName已经注册且在配置中配置了bean不允许被覆盖，则抛异常。
            if(!this.isAllowBeanDefinitionOverriding()) {
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition [" + beanDefinition + "] for bean \'" + beanName + "\': There is already [" + oldBeanDefinition + "] bound.");
            }

           if(oldBeanDefinition.getRole() < beanDefinition.getRole()) {
                if(this.logger.isWarnEnabled()) {
                    this.logger.warn("Overriding user-defined bean definition for bean \'" + beanName + "\' with a framework-generated bean definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
                }
            } else if(!beanDefinition.equals(oldBeanDefinition)) {
                if(this.logger.isInfoEnabled()) {
                    this.logger.info("Overriding bean definition for bean \'" + beanName + "\' with a different definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
               }
            } else if(this.logger.isDebugEnabled()) {
                this.logger.debug("Overriding bean definition for bean \'" + >beanName + "\' with an equivalent definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
            }

           this.beanDefinitionMap.put(beanName, beanDefinition);
        } else {
            if(this.hasBeanCreationStarted()) {
                Map var4 = this.beanDefinitionMap;
                //beanDefinitionMap是全局变量，存在并发的情况。
                synchronized(this.beanDefinitionMap) {
                    this.beanDefinitionMap.put(beanName, beanDefinition);
                    ArrayList updatedDefinitions = new ArrayList(this.beanDefinitionNames.size() + 1);
                   updatedDefinitions.addAll(this.beanDefinitionNames);
                    updatedDefinitions.add(beanName);
                    this.beanDefinitionNames = updatedDefinitions;
                   if(this.manualSingletonNames.contains(beanName)) {
                        LinkedHashSet updatedSingletons = new LinkedHashSet(this.manualSingletonNames);
                        updatedSingletons.remove(beanName);
                        this.manualSingletonNames = updatedSingletons;
                    }
                }
            } else {
               //注册beanDefinition
               this.beanDefinitionMap.put(beanName, beanDefinition);

               //记录对应的beanName
               this.beanDefinitionNames.add(beanName);
               this.manualSingletonNames.remove(beanName);
           }

          this.frozenBeanDefinitionNames = null;
       }

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

  }

   //继续追踪前一步的registerAlias方法，注册别名的方法：
   public void registerAlias(String name, String alias) {
       Assert.hasText(name, "\'name\' must not be empty");
       Assert.hasText(alias, "\'alias\' must not be empty");
       if(alias.equals(name)) {
           this.aliasMap.remove(alias);
       } else {
           String registeredName = (String)this.aliasMap.get(alias);
           if(registeredName != null) {
               if(registeredName.equals(name)) {
                   return;
               }
               //如果alias不允许覆盖则抛出异常。
               if(!this.allowAliasOverriding()) {
                   throw new IllegalStateException("Cannot register alias \'" + >alias + "\' for name \'" + name + "\': It is already registered for name \'" + >registeredName + "\'.");
               }
           }
           //循环检查，A——>B存在时，如果再次出现A——>C——>B时则会抛出异常。
           this.checkForAliasCircle(name, alias);
           this.aliasMap.put(alias, name);
       }

   }

4.最开始只解析了bean标签，此处补充alias和import和beans标签。

• alias标签的解析。
  首先解释一下alias的作用，在对bean进行定义时，除了使用id属性来指定名称以外，为了提供多个名称，可以使用alias标签来指定。

  <!--例如-->
  <bean id="testBean" class="com.test">
  
  <!--给这个JavaBean添加别名的第一种方式-->
  <bean id="testBean" name="testBean,testBean2" class="com.test"/>
  
  <!--给这个JavaBean添加别名的第二种方式-->
  <bean id="testBean" class="com.test"/>
  <alias name="testBean" alias="testBean,testBean2"/>
  
  <!--第二个例子：组件A在XML配置文件中定义了一个名为componentA的DataSource类型的bean，但是组件B却想在其XML文件中以componentB命名来引用此bean。而且在主程序MyApp的XML配置文件中，希望以myApp的名字来引用此bean。最后容器加载3个XML来生成最终的ApplicationContext。-->
  <alias name="componentA" alias="componentB"/>
  <alias name="componentA" alias="myApp"/>

  • 查看this.processAliasRegistration(ele)源码
    

    protected void processAliasRegistration(Element ele) {
        //读取beanName
        String name = ele.getAttribute("name");
        //获取alias
        String alias = ele.getAttribute("alias");
        boolean valid = true;
        if(!StringUtils.hasText(name)) {
            this.getReaderContext().error("Name must not be empty", ele);
            valid = false;
        }
    
        if(!StringUtils.hasText(alias)) {
            this.getReaderContext().error("Alias must not be empty", ele);
            valid = false;
        }
    
        if(valid) {
            try {
                this.getReaderContext().getRegistry().registerAlias(name, alias);
            } catch (Exception var6) {
                this.getReaderContext().error("Failed to register alias \'" + alias + "\' for bean with name \'" + name + "\'", ele, var6);
            }
    
            //别名注册以后通知监听器做相应处理。
            this.getReaderContext().fireAliasRegistered(name, alias, this.extractSource(ele));
        }
    
    }

• impot标签的解析
  首先解释一下import标签的作用，将配置文件分块，利用import导入多个配置文件。

  <?xml version="1.0" encoding="gb2312"?>
  <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
  <beans>
  
  <import resource="CTIContext.xml" />
  <import resource="customerContext.xml" />
  <import resource="customerServingContext.xml" />
  <import resource="manageContext.xml" />
  <import resource="routineContext.xml" />
  <import resource="systemContext.xml" />
  ...........
  </beans>

  • this.importBeanDefinitionResource(ele)的源码:
    

    protected void importBeanDefinitionResource(Element ele) {
        //获取resource属性。
        String location = ele.getAttribute("resource");
    
        //如果不存在resource属性则不做任何处理。
        if(!StringUtils.hasText(location)) {
            this.getReaderContext().error("Resource location must not be empty", ele);
        } else {
    
            //解析系统属性，格式如:"${user.dir}"
            location = this.getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);
    
            //判定location是URI是绝对的还是相对的。
            boolean absoluteLocation = false;
    
            try {
                absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
            } catch (URISyntaxException var11) {
                ;
            }
    
            int actResArray;
            //如果是绝对URI则直接根据地址加载对应的配置文件。
            if(absoluteLocation) {
                try {
                    actResArray = this.getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
                    if(this.logger.isDebugEnabled()) {
                        this.logger.debug("Imported " + actResArray + " bean definitions from URL location [" + location + "]");
                    }
                } catch (BeanDefinitionStoreException var10) {
                    this.getReaderContext().error("Failed to import bean definitions from URL location [" + location + "]", ele, var10);
                }
            } else {
                //如果是相对地址则根据相对地址计算出绝对地址。
                try {
                    Resource relativeResource = this.getReaderContext().getResource().createRelative(location);
                    if(relativeResource.exists()) {
                        actResArray = this.getReaderContext().getReader().loadBeanDefinitions(relativeResource);
                        actualResources.add(relativeResource);
                    } else {
                        //如果解析不成功，则使用默认的解析器
                        String baseLocation = this.getReaderContext().getResource().getURL().toString();
                        actResArray = this.getReaderContext().getReader().loadBeanDefinitions(StringUtils.applyRelativePath(baseLocation, location), actualResources);
                    }
    
                    if(this.logger.isDebugEnabled()) {
                        this.logger.debug("Imported " + actResArray + " bean definitions from relative location [" + location + "]");
                    }
                } catch (IOException var8) {
                    this.getReaderContext().error("Failed to resolve current resource location", ele, var8);
                } catch (BeanDefinitionStoreException var9) {
                    this.getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]", ele, var9);
                }
            }
            //解析后进行监听器激活处理。
            Resource[] actResArray1 = (Resource[])actualResources.toArray(new Resource[actualResources.size()]);
            this.getReaderContext().fireImportProcessed(location, actResArray1, this.extractSource(ele));
        }
    }

• 嵌入式beans标签的解析
  xbeans标签与单独的配置文件并没有太大差别，是递归调用bean的解析过程。