Spring IoC 默认标签解析

前言

本系列全部基于 Spring 5.2.2.BUILD-SNAPSHOT 版本。因为 Spring 整个体系太过于庞大，所以只会进行关键部分的源码解析。

本篇文章主要介绍 Spring IoC 容器怎么解析默认标签的。

正文

所谓的默认标签就是 import 、 alias 、 bean 、 beans 这四个标签。

DefaultBeanDefinitionDocumentReader#parseDefaultElement

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)) {

        doRegisterBeanDefinitions(ele);

    }

}

上面 parseDefaultElement 方法中对 bean 标签的处理方法 processBeanDefinition 最为重要，下面来着重分析一下。

DefaultBeanDefinitionDocumentReader#processBeanDefinition

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {

    // 将ele解析成BeanDefinitionHolder，见下文详解

    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

    if (bdHolder != null) {

        // 若存在默认标签下的子节点下不再有自定义属性，需要再次对自定义标签再进行解析(基本不用，不做深入分析)

        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

        try {

            // 注册最终的BeanDefinition，见下文详解

            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

        }

        catch (BeanDefinitionStoreException ex) {

            getReaderContext().error("Failed to register bean definition with name '" +

                                     bdHolder.getBeanName() + "'", ele, ex);

        }

        // 发出响应事件，通知相关监听器，这个bean已经注册完

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

    }

}

BeanDefinitionParseDelegate#parseBeanDefinitionElement

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {

    // 解析元素，封装成BeanDefinitionHolder

    return parseBeanDefinitionElement(ele, null);

}

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

    // 将name属性所有的名称按照逗号或者分号(,;)，分割成数组放入别名集合aliases

    if (StringUtils.hasLength(nameAttr)) {

        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);

        aliases.addAll(Arrays.asList(nameArr));

    }

    // beanName默认使用id

    String beanName = id;

    // 没有指定id属性 && 指定了name属性

    if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {

        // 如果没有指定id，beanName等于第一个别名，剩下的依然作为别名使用

        beanName = aliases.remove(0);

    }

    if (containingBean == null) {

        // 验证beanName和aliases是否在同一个<beans>下已经存在

        checkNameUniqueness(beanName, aliases, ele);

    }

    // 将元素解析成GenericBeanDefinition

    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

    if (beanDefinition != null) {

        // 如果不存在beanName会根据Spring的命名规则生成一个

        if (!StringUtils.hasText(beanName)) {

            try {

                if (containingBean != null) {

                    beanName = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, this.readerContext.getRegistry(), true);

                }

                else {

                    beanName = this.readerContext.generateBeanName(beanDefinition);

                    String beanClassName = beanDefinition.getBeanClassName();

                    if (beanClassName != null && beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() && !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {

                        aliases.add(beanClassName);

                    }

                }

            }

            catch (Exception ex) {

                error(ex.getMessage(), ele);

                return null;

            }

        }

        String[] aliasesArray = StringUtils.toStringArray(aliases);

        // 用beanDefinition和beanName以及aliasesArray构建BeanDefinitionHolder

        return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);

    }

    return null;

}

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

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

    String className = null;

    // 获取class属性

    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {

        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();

    }

    String parent = null;

    // 获取parent属性

    if (ele.hasAttribute(PARENT_ATTRIBUTE)) {

        parent = ele.getAttribute(PARENT_ATTRIBUTE);

    }

    try {

        // 创建用于承载属性的AbstractBeanDefinition类型的GenericBeanDefinition

        AbstractBeanDefinition bd = createBeanDefinition(className, parent);

        // 解析默认bean的各种属性，见下文详解

        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);

        // 提取description

		bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

        // 解析元数据，见下文详解

        parseMetaElements(ele, bd);

        // 解析lookup-method属性，很少使用，不具体介绍

        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());

        // 解析replaced-method属性，很少使用，不具体介绍

        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

        // 解析constructor-arg属性，见下文详解

        parseConstructorArgElements(ele, bd);

        // 解析property属性，见下文详解

        parsePropertyElements(ele, bd);

        // 解析qualifier属性，见下文详解

        parseQualifierElements(ele, bd);

        bd.setResource(this.readerContext.getResource());

        bd.setSource(extractSource(ele));

        return bd;

    }

    // 省略异常处理...

    finally {

        this.parseState.pop();

    }

    return null;

}

上面方法中的 BeanDefinitionReaderUtils.generateBeanName() 方法会为 bean 生成一个默认的名称，主要规则如下：

1. 获取 bean 的全类名，例如 com.leisurexi.ioc.domain.User ；如果 bean 的 parent 不为空那么 bean 的名称为 parentName 加上 $child ，例如 user 的 parent 是名称为 parentUser 的 bean ，那么当 user 未指定 beanName 时会其生成一个 parentUser$child 的名称；如果 bean 的 parent 为空但 factory-bean 属性不为空，那就用该名称加上 $created 为其生成名称。
2. 未指定 parent 和 factory-bean 属性，那么如果是内嵌 bean 则用全类名加上 # 和转换为十六进制字符串的 hashcode 拼成的字符串当做名称；不是内嵌 bean 就用全类名加上 # 和数字当做名称，如第一个 User 类型的自动生成的名称为 com.leisurexi.ioc.domain.User#0 ，第二个就是 com.leisurexi.ioc.domain.User#1 。

我们这边可以简单看一下 BeanDefinitionHolder 的属性，如下：

public class BeanDefinitionHolder implements BeanMetadataElement {

    // bean 的定义元信息

    private final BeanDefinition beanDefinition;

    // bean 的名称

    private final String beanName;

    // bean 的别名数组

    @Nullable

    private final String[] aliases;

    // 省略其它代码...

}

BeanDefinitionParserDelegate#parseBeanDefinitionAttributes

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

    // 解析singleton属性

    if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {

        // singleton属性已经不支持了，使用了会直接抛出异常，请使用scope属性替代

        error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);

    }

    // 解析scope属性

    else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {

        bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));

    }

    // 如果是内嵌bean，则使用上级bean的scope值

    else if (containingBean != null) {

        bd.setScope(containingBean.getScope());

    }

    // 解析abstract属性

    if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {

        bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));

    }

    // 解析lazy属性

    String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);

    // 若没有设置或者设置成其他字符都会被设置为默认值false

    if (isDefaultValue(lazyInit)) {

        lazyInit = this.defaults.getLazyInit();

    }

    bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

    // 解析autowire属性

    String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);

    bd.setAutowireMode(getAutowireMode(autowire));

	// 解析depends-on属性

    if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {

        String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);

        bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));

    }

    // 解析autowire-candidate属性，该属性为false代表该bean不会被选为依赖注入的对象，默认为true

    String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);

    if (isDefaultValue(autowireCandidate)) {

        String candidatePattern = this.defaults.getAutowireCandidates();

        if (candidatePattern != null) {

            String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);

            bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));

        }

    }

    else {

        bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));

    }

    // 解析primary属性

    if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {

        bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));

    }

    // 解析init-method属性

    if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {

        String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);

        bd.setInitMethodName(initMethodName);

    }

    // 如果bean没有指定init-method属性，但beans标签指定了default-init-method属性，则会使用该属性

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

    }

    // 如果bean没有指定destroy-method属性，但beans标签指定了default-destroy-method属性，则会使用该属性

    else if (this.defaults.getDestroyMethod() != null) {

        bd.setDestroyMethodName(this.defaults.getDestroyMethod());

        bd.setEnforceDestroyMethod(false);

    }

    // 解析factory-method属性

    if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {

        bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));

    }

    // 解析factory-bean属性

    if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {

        bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));

    }

    return bd;

}

上面方法完成了对所有 bean 标签属性的解析。值得注意的地方是如果同时指定了 bean 标签的 init-method 和 beans 标签的 default-init-method 属性，那么优先使用前者， destory-mehtod 标签也是一样。

大家可以去看一下 AbstractBeanDefinition 中定义的属性就一目了然了，这里限于篇幅原因就不展示了。

BeanDefinitionParserDelegate#parseConstructorArgElements

public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {

    // 获取所有子节点

    NodeList nl = beanEle.getChildNodes();

    for (int i = 0; i < nl.getLength(); i++) {

        Node node = nl.item(i);

        // 提取 constructor-arg

        if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {

            // 解析 constructor-arg

            parseConstructorArgElement((Element) node, bd);

        }

    }

}

// <constructor-arg index="0" type="" value=""/>

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

    // index 不为空

    if (StringUtils.hasLength(indexAttr)) {

        try {

            // 转换为 int 类型

            int index = Integer.parseInt(indexAttr);

            if (index < 0) {

                error("'index' cannot be lower than 0", ele);

            }

            else {

                try {

                    this.parseState.push(new ConstructorArgumentEntry(index));

                    // 解析属性值，见下文详解

                    Object value = parsePropertyValue(ele, bd, null);

                    // 使用 ConstructorArgumentValues.ValueHolder 类型来封装解析出来的元素

                    ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);

                    // 如果 type 不为空，设置 ValueHolder 的 type

                    if (StringUtils.hasLength(typeAttr)) {

                        valueHolder.setType(typeAttr);

                    }

                    // 如果 name 不为空，设置 ValueHolder 的 name

                    if (StringUtils.hasLength(nameAttr)) {

                        valueHolder.setName(nameAttr);

                    }

                    valueHolder.setSource(extractSource(ele));

                    // 判断 index 是否重复，重复则抛出异常

                    if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {

                        error("Ambiguous constructor-arg entries for index " + index, ele);

                    }

                    // 将 index 和 valueHolder 以 key-value的形式 添加到 BeanDefinition 的 ConstructorArgumentValues 当中

                    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 {

        try {

            // 这里就是 constructor-arg 标签中没有指定 index 属性

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

            // 将 valueHolder 添加 BeanDefinition 的 GenericArgumentValue 中

            // 这里和上面的 IndexedArgumentValue 类似，只不过上面是 Map，这里是 List

            bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);

        }

        finally {

            this.parseState.pop();

        }

    }

}

上面代码首先提取 constructor-arg 标签中必要的属性 ( index 、 type 、 name )。

• 如果指定了 index 属性：
  1. 解析 constructor-arg 的子元素。
  2. 使用 ConstructorArgumentsValues.ValueHolder 类型来封装解析出来的元素。
  3. 将 type 、 name 和 index 属性一并封装在 ConstructorArgumentsValues.ValueHolder 类型中，并添加到当前 BeanDefinition 的 ConstructorArgumentValues 中的 LinkedHashMap 类型的属性 indexedArgumentValues 中。
• 如果没有指定 index 属性：
  1. 解析 constructor-arg 的子元素。
  2. 使用 ConstructorArgumentsValues.ValueHolder 类型来封装解析出来的元素。
  3. 将 type 、 name 和 index 属性一并封装在 ConstructorArgumentsValues.ValueHolder 类型中，并添加到当前 BeanDefinition 的 ConstructorArgumentValues 中的 ArrayList 类型的属性 genericArgumentValues 中。

BeanDefinitionParserDelegate#parsePropertyValue

public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {

    String elementName = (propertyName != null ?

                          "<property> element for property '" + propertyName + "'" :

                          "<constructor-arg> element");

    // 获取所有子节点，例如list、map等

    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;

            }

        }

    }

    // 提取 ref 属性

    boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);

    // 提取 value 属性

    boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);

    // 如果同时有 ref 和 value 属性 || 有 ref 或 value 属性同时又有子元素，抛出异常

    if ((hasRefAttribute && hasValueAttribute) ||

        ((hasRefAttribute || hasValueAttribute) && subElement != null)) {

        error(elementName +

              " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);

    }

    // 只有 ref 属性，使用 RuntimeBeanReference 封装对应的 ref 名称 (该 ref 值指向另一个 bean 的 beanName)

    // RuntimeBeanReference 起到占位符的作用， ref 指向的 beanName 将在运行时被解析成真正的 bean 实例引用

    if (hasRefAttribute) {

        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;

    }

    // 只有 value 属性，使用 TypedStringValue 封装

    else if (hasValueAttribute) {

        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，直接抛出异常

        error(elementName + " must specify a ref or value", ele);

        return null;

    }

}

public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd) {

    return parsePropertySubElement(ele, bd, null);

}

public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {

    // 校验是否为默认的命名空间，如果不是则走解析自定义节点代码

    if (!isDefaultNamespace(ele)) {

        return parseNestedCustomElement(ele, bd);

    }

    // 解析 bean 节点

    else if (nodeNameEquals(ele, BEAN_ELEMENT)) {

        BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);

        if (nestedBd != null) {

            nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);

        }

        return nestedBd;

    }

    // 解析 ref 节点

    else if (nodeNameEquals(ele, REF_ELEMENT)) {

        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.

            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)) {

        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;

    }

}

从上面的代码来看，对构造函数中属性元素的解析，步骤如下：

1. 略过 description 或者 meta 。
2. 提取 constructor-arg 上的 ref 和 value 属性，以便于根据规则验证正确性。其规则为在 constructor-arg 上不存在以下情况：
   • 同时存在 ref 和 value 属性。
   • 存在 ref 或者 value 属性，并且又有子元素。

BeanDefinitionParserDelegate#parsePropertyElements

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)) {

            // 解析 property 节点

            parsePropertyElement((Element) node, bd);

        }

    }

}

// 这里是解析 property 标签，<property name="..." value="..."/>

public void parsePropertyElement(Element ele, BeanDefinition bd) {

    // 获取 name 属性

    String propertyName = ele.getAttribute(NAME_ATTRIBUTE);

    // name 为空，抛出异常

    if (!StringUtils.hasLength(propertyName)) {

        error("Tag 'property' must have a 'name' attribute", ele);

        return;

    }

    this.parseState.push(new PropertyEntry(propertyName));

    try {

        // 出现两个 name 相同的抛出异常

        if (bd.getPropertyValues().contains(propertyName)) {

            error("Multiple 'property' definitions for property '" + propertyName + "'", ele);

            return;

        }

        // 解析属性值，跟构造器解析一样

        Object val = parsePropertyValue(ele, bd, propertyName);

        // 用 name 和 val 封装成 PropertyValue

        PropertyValue pv = new PropertyValue(propertyName, val);

        // 解析元数据，跟 beans 标签内的 meta 一样

        parseMetaElements(ele, pv);

        pv.setSource(extractSource(ele));

        // 添加到 BeanDefinition 的 PropertyValues 属性中

        bd.getPropertyValues().addPropertyValue(pv);

    }

    finally {

        this.parseState.pop();

    }

}

上面方法主要是遍历 property 节点，然后解析属性值封装成 PropertyValue 添加到 BeanDefinition 的 PropertyValues 中。

注意： property 标明的属性必需有 set 方法否则在赋值阶段会抛出异常。

BeanDefinitionParserDelegate#parseQualifierElements

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)) {

            // 解析 qualifier 节点

            parseQualifierElement((Element) node, bd);

        }

    }

}

public void parseQualifierElement(Element ele, AbstractBeanDefinition bd) {

    // 提取 type

    String typeName = ele.getAttribute(TYPE_ATTRIBUTE);

    // type 为空抛出异常

    if (!StringUtils.hasLength(typeName)) {

        error("Tag 'qualifier' must have a 'type' attribute", ele);

        return;

    }

    this.parseState.push(new QualifierEntry(typeName));

    try {

        AutowireCandidateQualifier qualifier = new AutowireCandidateQualifier(typeName);

        qualifier.setSource(extractSource(ele));

        // 提取 value

        String value = ele.getAttribute(VALUE_ATTRIBUTE);

        // value 不为空，设置到 AutowireCandidateQualifier 的 attribute 中

        if (StringUtils.hasLength(value)) {

            qualifier.setAttribute(AutowireCandidateQualifier.VALUE_KEY, value);

        }

        // 获取子节点

        NodeList nl = ele.getChildNodes();

        for (int i = 0; i < nl.getLength(); i++) {

            Node node = nl.item(i);

            // 如果是有 attribute 节点，进行解析，提取值放入到 AutowireCandidateQualifier 的MetadataAttribute 中

            if (isCandidateElement(node) && nodeNameEquals(node, QUALIFIER_ATTRIBUTE_ELEMENT)) {

                Element attributeEle = (Element) node;

                String attributeName = attributeEle.getAttribute(KEY_ATTRIBUTE);

                String attributeValue = attributeEle.getAttribute(VALUE_ATTRIBUTE);

                if (StringUtils.hasLength(attributeName) && StringUtils.hasLength(attributeValue)) {

                    BeanMetadataAttribute attribute = new BeanMetadataAttribute(attributeName, attributeValue);

                    attribute.setSource(extractSource(attributeEle));

                    qualifier.addMetadataAttribute(attribute);

                }

                else {

                    error("Qualifier 'attribute' tag must have a 'name' and 'value'", attributeEle);

                    return;

                }

            }

        }

        // 设置 BeanDefinition 的 qualifier

        bd.addQualifier(qualifier);

    }

    finally {

        this.parseState.pop();

    }

}

对于 qualifier 元素的获取，我们大多数接触的更多是注解的形式，在使用 Spring 框架中进行自动注入时，Spring 容器中匹配的候选 Bean 必需有且只有一个。如果存在多个类型相同的 Bean ，且按照类型注入时，Spring 允许通过 qualifier 指定注入 Bean 的名称，这样歧义就消除了。

BeanDefinitionReaderUtils#registerBeanDefinition

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

    // Register bean definition under primary name.

    // 获取 beanName

    String beanName = definitionHolder.getBeanName();

    // 以 key-value 的形式注册，key 为 beanName，value 为 BeanDefinition。见下文详解

    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

    // Register aliases for bean name, if any.

    // 注册 bean 的别名

    String[] aliases = definitionHolder.getAliases();

    if (aliases != null) {

        for (String alias : aliases) {

            // 以 key-value 的形式注册 bean 的别名，key 为别名，value 为 beanName。见下文详解

            registry.registerAlias(beanName, alias);

        }

    }

}

// DefaultListableBeanFactory.java

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 {

            // 验证 Bean 的格式是否正确

            ((AbstractBeanDefinition) beanDefinition).validate();

        }

        catch (BeanDefinitionValidationException ex) {

            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,

                                                   "Validation of bean definition failed", ex);

        }

    }

    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);

    // 这里判断 BeanDefinition 是否存在

    if (existingDefinition != null) {

        // 这里就是如果 Bean 定义以及存在，判断是否可以覆盖，默认是可以的

        // Spring Boot 2.1开始这里会手动设置 allowBeanDefinitionOverriding 的值为 false

        if (!isAllowBeanDefinitionOverriding()) {

            throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);

        }

        // 将 beanName 和 BeanDefinition 以 key-value 形式放入beanDefinitionMap 缓存中

        this.beanDefinitionMap.put(beanName, beanDefinition);

    }

    else {

        // bean 是否已经开始创建

        if (hasBeanCreationStarted()) {

            synchronized (this.beanDefinitionMap) {

                // 将 beanName 和 BeanDefinition 以 key-value 形式放入beanDefinitionMap 缓存中

                this.beanDefinitionMap.put(beanName, beanDefinition);

                // 这里将 beanDefinitionNames 写时复制一份，类似于 CopyOnWriteArrayList

                List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);

                updatedDefinitions.addAll(this.beanDefinitionNames);

                updatedDefinitions.add(beanName);

                this.beanDefinitionNames = updatedDefinitions;

                // 从单例 Bean 注册名称列表中删除当前 beanName

                removeManualSingletonName(beanName);

            }

        }

        // bean 不在创建状态中

        else {

            // Still in startup registration phase

            this.beanDefinitionMap.put(beanName, beanDefinition);

            // 因为 ConcurrentHashMap 是无序的，这里将 beanName 放入 ArrayList，记录注册顺序

            this.beanDefinitionNames.add(beanName);

            // 从单例 Bean 注册名称列表中删除当前 beanName

            removeManualSingletonName(beanName);

        }

        this.frozenBeanDefinitionNames = null;

    }

    // 如果存在相同的 beanName 的 BeanDefinition，或者 beanName 已经存在单例对象，则将该 beanName 对应的缓存信息、单例对象清除，因为这些对象都是由老的 BeanDefinition 创建的，需要被覆盖掉。再用新的 BeanDefinition 来创建这些缓存和单例对象

    if (existingDefinition != null || containsSingleton(beanName)) {

        resetBeanDefinition(beanName);

    }

}

// SimpleAliasRegistry.java

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 相同，从缓存中移除

        if (alias.equals(name)) {

            this.aliasMap.remove(alias);

        }

        else {

            String registeredName = this.aliasMap.get(alias);

            // 如果别名以及注册过，直接返回

            if (registeredName != null) {

                if (registeredName.equals(name)) {

                    // An existing alias - no need to re-register

                    return;

                }

                // 如果不允许覆盖，抛出异常

                if (!allowAliasOverriding()) {

                    throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" + name + "': It is already registered for name '" + registeredName + "'.");

                }

            }

            // 检查 name 和 alias 是否存在循环引用。例如 A 的别名为 B，B的别名为A

            checkForAliasCircle(name, alias);

            // 将 alias 和 name 以 key-value 对放入到 aliasMap 中，进行缓存

            this.aliasMap.put(alias, name);

            }

        }

    }

}

上面代码有两个变量比较重要 beanDefinitionMap 和 beanDefinitionNames ，下面代码是这两个属性在 DefaultListableBeanFactory 中的定义：

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory

		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

    // 缓存 BeanDefinition 的 Map，key 为 beanName，value 为 BeanDefinition

    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

    // 保存 BeanDefinition 的注册顺序，保存的是 beanName

    private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

}

上面方法的主要流程如下：

1. 如果 BeanDefinition 是 AbstractBeanDefinition 类型，验证 Bean 的格式是否正确。

   这次效验主要是对于 AbstractBeanDefinition 属性中的 methodOverrides 的校验，校验 methodOverrides 是否与 工厂方法 并存或者 methodOverrides 中的方法根本不存在。

2. 判断该 beanName 的 BeanDefinition 是否已经注册过；如果存在判断是否允许覆盖，允许的话直接替换，不允许直接抛出异常。

   默认的情况下是允许的，但是在 Spring Boot 2.1 开始这里会手动的设置为不允许。

3. beanName 对应的 BeanDefinition 以前没有注册过，判断 bean 是否已经开始创建；如果在创建中对 beanDefinitionMap 进行加锁 (这里虽然 beanDefinitionMap 是线程安全的 ConcurrentHashMap ，单个操作是线程安全的但多个操作不是，所以这里手动加锁)，然后将 beanName 和 BeanDefinition 以 key-value 形式放入 beanDefinitionMap 缓存中，然后写时复制一份 beanDefinitionNames ，将 beaName 缓存进去，记录 bean 的注册顺序；如果不在创建中直接将 BeanDefinition 和 beanName 分别放入 beanDefinitionMap 和 beanDefinitionNames 中。

4. 最后判断如果 BeanDefinition 已经注册过，或者 beanName 已经存在单例对象，则将该 beanName 对应的缓存信息、单例对象清除，因为这些对象都是由老的 BeanDefinition 创建的，需要被覆盖掉。再用新的 BeanDefinition 来创建这些缓存和单例对象。

总结

本文主要介绍了 Spring 对 XML 文件中 <bean> 标签的解析，我们可以重新梳理一下思路：

1. 解析 <bean> 标签，构建成 AbstractBeanDefinition (GenericBeanDefinition) 对象来存放所有解析出来的属性。

2. 将 AbstractBeanDefinition 、 beanName 、 aliasesArray 构建成 BeanDefinitionHolder 对象。

3. 最后通过 BeanDefinitionHolder 将 beanName 和 BeanDefinition 注册到 DefaultListableBeanFactory 中，也就是保存起来。

   上文提到的两个比较重要的属性 beanDefinitionNames 和 beanDefinitionMap ，在后面都会多次用到，可以重点关注一下。

最后，我模仿 Spring 写了一个精简版，代码会持续更新。地址：https://github.com/leisurexi/tiny-spring。

参考

• 《Spring 源码深度解析》—— 郝佳

• https://blog.csdn.net/v123411739/article/details/86669952