Spring源码阅读之如何将标签解析成BeanDefinition定义

上一篇文章我们讲到了BeanFactory的创建和BeanDefinition的创建。本文接着上一篇文章，来看看一个<bean>标签是如何被解析成BeanDefinition对象并注册到BeanFactory里面

1. 为了方便讲解，在开始<bean>标签解析前我们稍微对测试代码做一点小调整，在配置文件中新增两个<property>属性，对应的userService相应的增加两个对应的属性字段。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd"
>
    <bean id="userService" class="UserServiceImpl">
        // userService增加两个属性
        <property name="name" value="z小赵"/>
        <property name="age" value="27"/>
    </bean>
</beans>

// UserServiceImpl增加两个字段，并声明了对应的set方法
public class UserServiceImpl implements UserService {
    private String name;
    private int age;
    @Override
    public void save(String name, int age) {
        System.out.println("name:" + name + ",age:" + age);
    }

    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

---

1. 遍历 Document 的所有子节点，针对不同的标签执行不同的解析逻辑，我们侧重来看下平时最常用的<bean>标签是怎么被解析的。

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    // Step1：如果 “import” 标签
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
      importBeanDefinitionResource(ele);
    }
    // Step2：如果是 “alias” 标签
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
      processAliasRegistration(ele);
    }
    // Step3：如果是 “bean” 标签
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
      processBeanDefinition(ele, delegate);
    }
    // Step4：如果是 “beans” 标签
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
      // recurse
      doRegisterBeanDefinitions(ele);
    }
}

---

1. 看看processBeanDefinition是怎么把<bean>标签解析成 BeanDefinition 并注册到 BeanFactory 里，重点在第一步解析<bean>标签和第三步注册BeanDefinition。

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    // Step1：创建一个BeanDefinitionHolder，从名字看就是创建了一个BeanDefinition对象持有者
    // 它包含了创建出来的BeanDefinition定义，还有beanName等等属性
    // 最后会从这个对象里面获取beanName和BeanDefinition定义，并将其注册到BeanFactory里面
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
      // Step2：对创建出来的BeanDefinitionHolder做一些装饰操作，如果有必要的话.
      // 比如 “autowire" "id" "lazy-init"等等node做一些额外的装饰操作
      // 还有，如果当前element还有子节点并且子节点也是element，则对子节点进行装饰操作
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
      try {
        // Register the final decorated instance.
        // Step3：注册BeanDefinition到BeanFactory里面
        BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
      }
      catch (BeanDefinitionStoreException ex) {
        getReaderContext().error("Failed to register bean definition with name '" +
            bdHolder.getBeanName() + "'", ele, ex);
      }
      // Send registration event.
      // Step4：发送一个注册完成事件
      getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

---

1. 接着上面先来看第一步<bean>标签是怎么被解析成BeanDefinition对象的。

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
    // Step1：获取当前bean标签的id和name（这个name其实就是我们在xml文件里面指定的别名）属性
    String id = ele.getAttribute(ID_ATTRIBUTE);
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
    // Step2：解析别名，我们没有配置，所以不会走这里
    List<String> aliases = new ArrayList<>();
    if (StringUtils.hasLength(nameAttr)) {
      String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
      aliases.addAll(Arrays.asList(nameArr));
    }

    // Step3：默认使用id作为beanName，beanName就是我们在代码里面指定要获取那个，Bean实例的名字
    String beanName = id;
    // 这里是如果没有指定id && 指定了name属性，则使用别名作为beanName
    // 所以从这里也可以看出，如果同时指定id和name，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) {
      // Step4：检查beanName和alias是否是唯一的。
      // 如果发现在之前已经初始化了一个相同名字的bean定义，则抛出异常
      // 反之，将当前的beanName添加到BeanDefinitionParseDelegate里面
      checkNameUniqueness(beanName, aliases, ele);
    }

    // Step5：根据element构建出BeanDefinition对象，前面一直说的BeanDefinition对象就是在这个方法里面创建出来的
    // 后面会对这个方法展开具体讲解
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    // Step6：如果创建BeanDefinition对象的时候报错有可能会返回null
    if (beanDefinition != null) {
      // Step6.1：如果当前beanName为空，
      if (!StringUtils.hasText(beanName)) {
        try {
          // Step6.1.1：containingBean不为null，则从containingBean定义生成一个beanName， 一般这里走不到，因为我们在xml里面都会指定id或者name属性
          if (containingBean != null) {
            beanName = BeanDefinitionReaderUtils.generateBeanName(
                beanDefinition, this.readerContext.getRegistry(), true);
          }
          else {
            // Step6.1.2：否则利用BeanDefinition定义生成一个beanName
            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;
        }
      }
      // Step6.2：将创建出来的BeanDefinition定义、beanName、alias等封装成一个BeanDefinitionHolder返回
      String[] aliasesArray = StringUtils.toStringArray(aliases);
      return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
    }

    return null;
}

---

1. 在进一步深入看看根据 element 是如何创建出BeanDefinition对象的，即parseBeanDefinitionElement方法的具体实现逻辑是怎样的。

public AbstractBeanDefinition parseBeanDefinitionElement(
      Element ele, String beanName, @Nullable BeanDefinition containingBean) {

    this.parseState.push(new BeanEntry(beanName));

    // Step1：首先获取class属性值，如果存在的话
    String className = null;
    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
      className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    }
    // Step2：获取parent属性，如果指定了的话，我们在xml里面定义的时候可以指定parent属性。感兴趣的可以试试
    String parent = null;
    if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
      parent = ele.getAttribute(PARENT_ATTRIBUTE);
    }

    try {
      // Step3：根据当前element对应的className和其对应的父name，创建一个GenericBeanDefintion对象，
      // 因为GenricBeanDefintion继承了AbstractBeanDefinition，
      // 所以返回了AbstractBeanDefinition对象
      AbstractBeanDefinition bd = createBeanDefinition(className, parent);
      // Step4：有了BeanDefinition定义后，开始解析一些其他属性
      // 比如是否指定了 init-method方法、destory-method方法、depends-on等等属性
      // 如果指定了，则把指定的相关信息设置到BeanDefinition定义上
      parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
      // Step5：设置描述
      bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
      // Step6：解析元数据
      parseMetaElements(ele, bd);
      // Step7：解析 override 的方法
      parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
      // Step8：解析 replaced-method 的方法
      parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
      // Step9：解析构造器的参数，及 constructor-arg标签
      parseConstructorArgElements(ele, bd);
      // Step10：解析property属性，其实就是解析我们的测试例子指定了下面的这个属性的，其他的解析类似。感兴趣的可以自己研究
      // <property name="name" value="z小赵">
      // <property name="age" value="27">
      // 将解析后的结果构建成一个个PropertyValue对象，
      // 然后将该对象设置到BeanDefinition的property字段上
      parsePropertyElements(ele, bd);
      // Step11：解析qualifier属性
      parseQualifierElements(ele, bd);

      bd.setResource(this.readerContext.getResource());
      bd.setSource(extractSource(ele));
      // Step12：经过上面一系列的填充之后获得BeanDefinition对象，然后将其返回
      return bd;
    }
    catch (ClassNotFoundException ex) {
      error("Bean class [" + className + "] not found", ele, ex);
    }
    catch (NoClassDefFoundError err) {
      error("Class that bean class [" + className + "] depends on not found", ele, err);
    }
    catch (Throwable ex) {
      error("Unexpected failure during bean definition parsing", ele, ex);
    }
    finally {
      this.parseState.pop();
    }

    return null;
}

---

1. 到这里我们创建出了BeanDefinition对象，然后接着第 3 步，对创建出来的BeanDefinition对象在做一些装饰操作，如果有必要的话。具体在这里就不深究了，感兴趣的同学自行研究一下。我们重点来看下对经过一系列操作后得到最终的BeanDefinition定义是怎么被注册到BeanFactory里面的。

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

    // Register bean definition under primary name.
    // Step1：获取当前BeanDefinition对应的beanName，
    // 然后使用registry将BeanDefinition注册到BeanFactory里面
    String beanName = definitionHolder.getBeanName();
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

    // Register aliases for bean name, if any.
    // Step2：如果有别名的，同时也将别名注册到BeanFactory里面
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
      for (String alias : aliases) {
        registry.registerAlias(beanName, alias);
      }
    }
}

---

1. 那我们重点看下如何通过registry将BeanDefinition定义注册到BeanFactory里面，因为我们最开始的时候创建了BeanFactory是DefaultListableBeanFactory，所以这里调用了DefaultListableBeanFactory的registryBeanDefinition方法进行注册的。

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");
    // Step1：当前BeanDefinition是否实现或继承了AbstractBeanDefinition对象
    // 从我们上面分析代码可以看出是继承了AbstractBeanDefinition类的
    if (beanDefinition instanceof AbstractBeanDefinition) {
      try {
        // Step1.1：对将要注册的BeanDefinition定义进行校验操作。
        // 其实主要校验的就是提前指定了classLoader的那种bean
        ((AbstractBeanDefinition) beanDefinition).validate();
      }
      catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
            "Validation of bean definition failed", ex);
      }
    }

    BeanDefinition oldBeanDefinition;
    // Step2：根据beanName获取旧的BeanDefinition，如果已经存在了并且不允许被覆盖的话，就抛出异常。正常情况下这个oldBeanDefinition是为null的
    oldBeanDefinition = this.beanDefinitionMap.get(beanName);
    if (oldBeanDefinition != null) {
      if (!isAllowBeanDefinitionOverriding()) {
        throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
            "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
            "': There is already [" + oldBeanDefinition + "] bound.");
      }
      else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
        // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
        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 {
      // Step3：检查一下bean的创建工作是否已经开始,这里大白话解释一下
      // 从else的注释可以看出，这里其实想表达的意思应该是BeanFactory创建BeanDefinition定义的阶段已经完成了
      // 但是此时还想再注册BeanDefinition定义，则走if条件。如有理解不对请指正
      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;
          if (this.manualSingletonNames.contains(beanName)) {
            Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
            updatedSingletons.remove(beanName);
            this.manualSingletonNames = updatedSingletons;
          }
        }
      }
      else {
        // Step4：正常注册流程走的else，因为当前阶段正是在启动BeanFactory和注册BeanDefinition的时候
        // 从代码可以看出注册其实就是将创建出来的BeanDefinition放到BeanFactory的map里面，就这么简单而已
        // Still in startup registration phase
        this.beanDefinitionMap.put(beanName, beanDefinition);
        this.beanDefinitionNames.add(beanName);
        this.manualSingletonNames.remove(beanName);
      }
      this.frozenBeanDefinitionNames = null;
    }

    if (oldBeanDefinition != null || containsSingleton(beanName)) {
      resetBeanDefinition(beanName);
    }
}

---

总结

到此，我们关于BeanFactory创建，BeanDefinition定义创建及注册工作就全部做完了，关于 <import>、<benas> 标签的解析处理工作，大致流程都是差不多的，就不在一一展开了，有兴趣的同学可以自行阅读以下，只要搞懂了<bean>的构建流程，相信关于其他标签的构建也就比较容易了。

接下来两篇文章我们接着讲和我们常见的<bean>标签解析不同的另外一种自定义标签，比如<cotext:component-scan>标签的实现原理；讲完非默认标签解析后，讲讲如果想实现一个自定义标签，那该怎么做呢？相信大家见过各种各样的自定义标签名，比如如果你用过motan的话，会遇到过类似如下的这种标签。如果想知道这种自定义标签是怎么被解析的，那就跟着我继续深入学习吧。

<motan:referer id="userService" interface="com.xxx.UserService">

欢迎关注我，一起学习