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

841 阅读4分钟

前情回顾

上回「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 ...

        return null;
	}
}

这里才是真正解析 <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 方法,它主要是用来处理默认名称空间(即 www.springframework.org/schema/bean… )之外的 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) {
            // 处理非默认名称空间的 bean
            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 也放进去了,如何从容器拿到我们想要的对象呢?

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