Spring 是如何解析 <bean> 标签的？

前情回顾

上回「 Spring IoC 容器初始化（2） 」说到了 Spring 如何解析我们定义的 <bean> 标签，代码跟进了一层又一层，跋山涉水，最终来到了 BeanDefinitionParserDelegate#parseBeanDefinitionElement 方法。不过这个方法只是表面，并未深入解析 <bean> 中的 class 等属性以及 property 等子标签。

本文继续跟进。

嗯，还是要耐着点性子，最好写个 demo 打断点跟踪一下，这样理解起来才更深刻。

如何解析 <bean> 的内容？

继续看代码：

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

      String className = null;
      // 读取 <bean> 标签的 class 属性
      if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
      }
      String parent = null;
      // 读取 <bean> 标签的 parent 属性
      if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
        parent = ele.getAttribute(PARENT_ATTRIBUTE);
      }

      try {
        // 创建 BeanDefinition 对象（GenericBeanDefinition）
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);

        // 解析 scope、lazy-init、autowire 等属性
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

        // 解析 meta 标签
        parseMetaElements(ele, bd);
            
        // 解析 lookup-method 标签
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());

        // 解析 replace-method 标签
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

        // 解析 constructor-arg 标签
        parseConstructorArgElements(ele, bd);

        // 解析 property 标签
        parsePropertyElements(ele, bd);
            
        // 解析 qualifier 标签
        parseQualifierElements(ele, bd);

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

        return bd;
      }
      // catch ...
    }
}

这里才是真正解析 <bean> 标签内容的地方，比如常见的 class、parent、scope、lazy-init、autowire、property、constructor-arg 等，还有不常见的 lookup-method、replace-method 等。

该方法内部调用了一个个方法去解析不同的标签。这里我们只跟进常见的 property 如何解析，其他方法大体也都差不多，有兴趣可以自行研究。

parsePropertyElements 方法代码如下：

public class BeanDefinitionParserDelegate {
  // 解析 property 标签
  public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
    NodeList nl = beanEle.getChildNodes();
    for (int i = 0; i < nl.getLength(); i++) {
      Node node = nl.item(i);
      // 筛选 <property> 标签
      if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
        parsePropertyElement((Element) node, bd);
      }
    }
  }

  public void parsePropertyElement(Element ele, BeanDefinition bd) {
    // property 标签的 name 属性
    String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
    if (!StringUtils.hasLength(propertyName)) {
      // error
      return;
    }
    this.parseState.push(new PropertyEntry(propertyName));
    try {
      if (bd.getPropertyValues().contains(propertyName)) {
        // error
        return;
      }
      // 这里解析得到的是 RuntimeBeanReference 或者 TypedStringValue
      Object val = parsePropertyValue(ele, bd, propertyName);
      PropertyValue pv = new PropertyValue(propertyName, val);
      parseMetaElements(ele, pv);
      pv.setSource(extractSource(ele));
      // 将解析到的值添加到 BeanDefinition 的属性列表
      bd.getPropertyValues().addPropertyValue(pv);
    }
    finally {
      this.parseState.pop();
    }
  }    
}

这个方法主要做了什么呢？

1. 遍历节点并找到 property 标签

2. 解析 property 标签的 name 属性，将它对应的值封装为 RuntimeBeanReference 类型或者 TypedStringValue 类型（其中前者对应 ref 属性，后者对应 value 属性，可参考前文 application-ioc.xml 文件），然后再封装为 PropertyValue 类型，并保存到 BeanDefinition 的属性列表中。

解析 ref 和 value 的过程如下：

public class BeanDefinitionParserDelegate {

  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.
    NodeList nl = ele.getChildNodes();
    Element subElement = null;
    for (int i = 0; i < nl.getLength(); i++) {
      Node node = nl.item(i);
      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;
        }
      }
    }

    // ref 和 value 属性，二者不能并存
    boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
    boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
    if ((hasRefAttribute && hasValueAttribute) ||
        ((hasRefAttribute || hasValueAttribute) && subElement != null)) {
      error(elementName +
        " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
    }

    // ref 属性
    if (hasRefAttribute) {
      String refName = ele.getAttribute(REF_ATTRIBUTE);
      if (!StringUtils.hasText(refName)) {
        error(elementName + " contains empty 'ref' attribute", ele);
      }
      // 封装为 RuntimeBeanReference 类型
      RuntimeBeanReference ref = new RuntimeBeanReference(refName);
      ref.setSource(extractSource(ele));
      return ref;
    }
    // value 属性
    else if (hasValueAttribute) {
      // 封装为 TypedStringValue 类型
      TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
      valueHolder.setSource(extractSource(ele));
      return valueHolder;
    }
    // 若还有子元素，继续解析
    else if (subElement != null) {
      // 这里包含了 property 标签的子标签，例如 list、map、set 等
      return parsePropertySubElement(subElement, bd);
    }
    else {
      error(elementName + " must specify a ref or value", ele);
      return null;
    }
  }
}

property 标签的解析算是相对复杂的，其他标签（meta、constructor-arg 等）的解析过程大体是类似的，不再一一分析。

经过 BeanDefinitionParserDelegate#parseBeanDefinitionElement 方法的解析和封装后，就得到了保存我们自定义 bean 信息的 BeanDefinition，即 GenericBeanDefinition。Spring 又把 BeanDefinition 和别名信息封装成了 BeanDefinitionHolder：

public class BeanDefinitionParserDelegate {
  public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
    String id = ele.getAttribute(ID_ATTRIBUTE);
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

    // ...

    // 解析后得到的 BeanDefinition
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    if (beanDefinition != null) {
      // ...
      String[] aliasesArray = StringUtils.toStringArray(aliases);
      return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
    }

    return null;
  }
}

此外，在向 IoC 容器注册之前，还有一个 decorateBeanDefinitionIfRequired 方法，它主要是用来处理默认名称空间（即 http://www.springframework.org/schema/beans）之外的 bean 定义，比如 <tx>、<context> 等，这里仍然先沿着主线走，暂不深入分析。

接下来就是将 BeanDefinition 注册到 IoC 容器：

public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocumentReader {
  // ...
    
  protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    // 解析后的 BeanDefinition 封装成的 BeanDefinitionHolder
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
      try {
        // Register the final decorated instance.
        // 注册 BeanDefinition
        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));
    }
  }
}

public abstract class BeanDefinitionReaderUtils {
  // ...

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

    // Register bean definition under primary name.
    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);
      }
    }
  }
}

IoC 容器是哪个？如何注册呢？

前文提到过，Spring 默认的 IoC 容器是 DefaultListableBeanFactory，来看下它的继承结构：

可以看到 DefaultListableBeanFactory 实现了 BeanDefinitionRegistry 接口。

所谓的“注册”到 IoC 容器，其实就是把 BeanDefinition 保存到了 DefaultListableBeanFactory  持有的一个 Map 中，如下：

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
  implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
  // ...

  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 {
        ((AbstractBeanDefinition) beanDefinition).validate();
      }
      catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
          "Validation of bean definition failed", ex);
      }
    }

    // 获取已存在的 BeanDefinition
    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
        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 {
        // 注册到 Map 中
        // Still in startup registration phase
        this.beanDefinitionMap.put(beanName, beanDefinition);
        this.beanDefinitionNames.add(beanName);
        removeManualSingletonName(beanName);
      }
      this.frozenBeanDefinitionNames = null;
    }

    if (existingDefinition != null || containsSingleton(beanName)) {
      resetBeanDefinition(beanName);
    }
    else if (isConfigurationFrozen()) {
      clearByTypeCache();
    }
  }
}

上面几个异常信息是不是有点眼熟？

这个 beanDefinitionMap 是个什么呢？它就是个 Map：

/** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

小结

到这里，Spring 已经从我们定义的 application-ioc.xml 文件中读取和解析到了 <bean> 标签的信息，并将其转换为内部的数据结构 BeanDefinition，然后注册到了 IoC 容器（也就是 DefaultListableBeanFactory）。

为了有个整体的把握，这里把主要流程梳理成了一个思维导图：

其实前面几篇文章主要是第一个步骤，也就是「初始化 BeanFactory，注册 Bean 定义」，而且只是沿着一条主线走下来的，其它细节部分有兴趣的小伙伴可以自行研究。

IoC 容器已经建立，而且 BeanDefinition 也放进去了，如何从容器拿到我们想要的对象呢？

欲知后事如何，且听下回分解~

咱也来体验一下这个名片