Spring源码解析（六）-解析bean标签

Spring版本

5.2.5.RELEASE

参考

学习Spring源码（二）自定义标签属性

源码解读

在Spring源码中，bean标签的解析交由processBeanDefinition处理：

    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        // 解析bean，如果解析成功，获得持有name和alias的BeanDefinitionHolder，即BeanDefinitionHolder对象，解析失败返回null
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            // bean支持定义属性和内部嵌套自定义标签，进行这一部分的处理
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                // 注册bean
                // Register the final decorated instance.
                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));
        }
    }

该方法主要做了以下三点：

• 解析bean标签
• 解析bean标签的自定义属性和bean标签下嵌套的自定义标签
• 注册bean，并且在注册成功之后通知监听器注册事件

1. parseBeanDefinitionElement

    @Nullable
    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
        return parseBeanDefinitionElement(ele, null);
    }

继续交由重载方法：

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

        // 将name属性值进行切割，塞进别名集合
        List aliases = new ArrayList<>();
        if (StringUtils.hasLength(nameAttr)) {
            String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
            aliases.addAll(Arrays.asList(nameArr));
        }

        // 如果没有声明id属性，将上面解析出来的第一个别名当成beanName
        String beanName = id;
        if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
            beanName = aliases.remove(0);
            if (logger.isTraceEnabled()) {
                logger.trace("No XML 'id' specified - using '" + beanName +
                        "' as bean name and " + aliases + " as aliases");
            }
        }

        if (containingBean == null) {
            // 检查beanName和aliases中的元素是否唯一
            checkNameUniqueness(beanName, aliases, ele);
        }

        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
        if (beanDefinition != null) {
            if (!StringUtils.hasText(beanName)) {
                try {
                    if (containingBean != null) {
                        // 生成唯一beanName
                        beanName = BeanDefinitionReaderUtils.generateBeanName(
                                beanDefinition, this.readerContext.getRegistry(), true);
                    }
                    else {
                        // 生成唯一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.isTraceEnabled()) {
                        logger.trace("Neither XML 'id' nor 'name' specified - " +
                                "using generated bean name [" + beanName + "]");
                    }
                }
                catch (Exception ex) {
                    error(ex.getMessage(), ele);
                    return null;
                }
            }
            String[] aliasesArray = StringUtils.toStringArray(aliases);
            // 构建BeanDefinitionHolder对象，返回
            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
        }

        return null;
    }

逻辑在于构建一个包含beanDefinition、beanName和aliasesArray的BeanDefinitionHolder对象，因此，整个过程也就可以拆分成三个部分来查看：

• 生成aliasesArray
• 解析获取beanDefinition对象
• 生成beanName

1.1 生成aliasesArray

        // 将name属性值进行切割，塞进别名集合
        List aliases = new ArrayList<>();
        if (StringUtils.hasLength(nameAttr)) {
            String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
            aliases.addAll(Arrays.asList(nameArr));
        }

获取到name属性的值，之后切割并组装成List类型的aliases，在构建BeanDefinitionHolder的时候，将List类型的aliases转化为数组类型并作为构造参数：

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

1.2 解析获取beanDefinition对象

核心方法在于：

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

查看parseBeanDefinitionElement方法：

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

        // ParseState的定义生命信息如下：
        // Simple {@link LinkedList}-based structure for tracking the logical position during a parsing process.
        // 看起来，parseState是用于追踪bean解析过程中的逻辑位置
        // 追踪parseState的使用方式，应该是解析过程报错的情况下可以轻易找到当前正在被解析的bean吧
        this.parseState.push(new BeanEntry(beanName));

        String className = null;
        if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
            className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
        }
        String parent = null;
        if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
            parent = ele.getAttribute(PARENT_ATTRIBUTE);
        }

        try {
            // createBeanDefinition用于创建一个AbstractBeanDefinition对象，且将className进行加载，设置进该对象的beanClass属性，同时将parent设置进去parentName属性
            AbstractBeanDefinition bd = createBeanDefinition(className, parent);

            // 解析bean的各种属性，比如autowire，lazyinit，设置到bd中
            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
            // 解析description子元素内容，getChildElementValueByTagName可以从ele中找到符合DESCRIPTION_ELEMENT的第一个子元素的内容文本值
            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

            // 解析meta子元素
            parseMetaElements(ele, bd);
            // 解析lookup-method子元素
            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
            // 解析replace-method子元素
            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

            // 解析construct-arg子元素
            parseConstructorArgElements(ele, bd);
            // 解析property子元素
            parsePropertyElements(ele, bd);
            // 解析qualifier子元素
            parseQualifierElements(ele, bd);

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

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

逻辑可以归纳为以下几个步骤：

• 将当前解析的beanName压入parseState栈中，方便解析过程报错的时候定位到当前被解析元素
• 获取class属性和parent属性，调用createBeanDefinition方法构建AbstractBeanDefinition对象，在调用createBeanDefinition方法的时候，对className进行了加载
• 解析bean标签的属性
• 解析bean标签下的子标签
• 解析完毕，从parseState中退栈

1.2.1 createBeanDefinition

    public static AbstractBeanDefinition createBeanDefinition(
            @Nullable String parentName, @Nullable String className, @Nullable 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;
    }

可以看到，该方法构建一个GenericBeanDefinition对象，之后如果className和classLoader不为空，则加载类，并设置为beanClass属性，否则将className设置进beanClassName属性

1.2.2 parseBeanDefinitionAttributes

解析bean标签的众多属性，包含：

• scope
• abstract
• lazy-init
• autowire
• depends-on
• autowire-candidate
• primary
• init-method
• destroy-method
• factory-method
• factory-bean
  代码逻辑较为简单，不赘述

1.2.3 生成beanName

首先获取id属性作为beanName：

String beanName = id;

如果没有生命id属性，则使用别名的第一个元素作为beanName：

        if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
            beanName = aliases.remove(0);
            if (logger.isTraceEnabled()) {
                logger.trace("No XML 'id' specified - using '" + beanName +
                        "' as bean name and " + aliases + " as aliases");
            }
        }

在上述beanName的基础上生成一个唯一的beanName：

                    if (containingBean != null) {
                        // 生成唯一beanName
                        beanName = BeanDefinitionReaderUtils.generateBeanName(
                                beanDefinition, this.readerContext.getRegistry(), true);
                    }
                    else {
                        // 生成唯一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);
                        }
                    }

2. decorateBeanDefinitionIfRequired

bean标签支持自定义属性，我们简单使用一个demo演示该部分内容：

2.1 demo

2.1.1 Student

public class Student {

    private String id;

    private String name;

    private String desc;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
}

2.1.2 student.xsd

2.1.3 StudentNamespaceHandler

public class StudentNamespaceHandler extends NamespaceHandlerSupport {
    @Override
    public void init() {
        registerBeanDefinitionDecoratorForAttribute("student-desc", new StudentBeanDefinitionDecorator());
    }
}

2.1.4 StudentBeanDefinitionDecorator

public class StudentBeanDefinitionDecorator implements BeanDefinitionDecorator {
    @Override
    public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definition, ParserContext parserContext) {
        definition.getBeanDefinition().getPropertyValues().add("desc", ((Attr)node).getValue());
        return definition;
    }
}

2.1.5 spring.handlers

http\://www.customAttribute.com/schema/student-desc=com.kungyu.custom.element.StudentNamespaceHandler

2.1.6 spring.schemas

http\://www.customAttribute.com/schema/student.xsd=META-INF/student.xsd

2.1.7 spring.xml

2.1.8 测试

public class Test {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.getId() + "----" + student.getName() + "---" + student.getDesc());
    }
}

2.1.9 结果

bean自定义属性结果

在spring.xml中，我们并没有为id为student的bean指定desc属性的值，而是通过自定义属性student-desc，之后交由在StudentNamespaceHandler中注册的StudentBeanDefinitionDecorator进行处理，在StudentBeanDefinitionDecorator的decorate中给BeanDefinition定义student的desc属性的值。

2.2 源码解读

    public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
            Element ele, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {

        BeanDefinitionHolder finalDefinition = originalDef;

        // 解析bean标签里面的自定义属性
        // Decorate based on custom attributes first.
        NamedNodeMap attributes = ele.getAttributes();
        for (int i = 0; i < attributes.getLength(); i++) {
            Node node = attributes.item(i);
            finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
        }

        // 解析嵌套在bean标签里面的自定义标签
        // Decorate based on custom nested elements.
        NodeList children = ele.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            Node node = children.item(i);
            if (node.getNodeType() == Node.ELEMENT_NODE) {
                finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
            }
        }
        return finalDefinition;
    }

俩个步骤：

• 解析bean标签的自定义属性
• 解析bean标签内部嵌套的自定义标签
  以上俩个步骤都通过decorateIfRequired方法实现：

    public BeanDefinitionHolder decorateIfRequired(
            Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {

        String namespaceUri = getNamespaceURI(node);
        if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {
            // 同解析自定义标签一样，获取自定义的handler
            NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
            if (handler != null) {
                // 调用自定义handler的decorate方法
                BeanDefinitionHolder decorated =
                        handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
                if (decorated != null) {
                    return decorated;
                }
            }
            else if (namespaceUri.startsWith("http://www.springframework.org/schema/")) {
                error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
            }
            else {
                // A custom namespace, not to be handled by Spring - maybe "xml:...".
                if (logger.isDebugEnabled()) {
                    logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
                }
            }
        }
        return originalDef;
    }

该方法很明显逻辑在于：

• 查找到自定义的handler
• 通过handler，调用自定义的decorate方法

3. registerBeanDefinition

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

        // Register bean definition under primary name.
        String beanName = definitionHolder.getBeanName();
        // 注册，将beanName和beanDefinition写入缓存map中
        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);
            }
        }
    }

逻辑都比较简单，就直接贴代码了

3.1 registerBeanDefinition

        @Override
    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 {
                // 对methodOverrides进行校验
                ((AbstractBeanDefinition) beanDefinition).validate();
            }
            catch (BeanDefinitionValidationException ex) {
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                        "Validation of bean definition failed", ex);
            }
        }

        // 获取缓存
        BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
        // 如果缓存存在
        if (existingDefinition != null) {
            // 如果不允许BeanDefinition覆盖，抛出异常
            if (!isAllowBeanDefinitionOverriding()) {
                throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
            }
            else if (existingDefinition.getRole() < beanDefinition.getRole()) {
                // 如果缓存的BeanDefinition角色比注册的BeanDefinition的角色d低
                // 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)) {
                // 如果俩个BeanDefinition不同
                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 {
            // 如果不存在缓存
            // 判断是否已经开始Bean创建的进程
            if (hasBeanCreationStarted()) {
                // 如果已开始，进行同步控制
                // Cannot modify startup-time collection elements anymore (for stable iteration)
                synchronized (this.beanDefinitionMap) {
                    // 写入缓存
                    this.beanDefinitionMap.put(beanName, beanDefinition);
                    // 将beanName加入beanDefinitionNames
                    List updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                    updatedDefinitions.addAll(this.beanDefinitionNames);
                    updatedDefinitions.add(beanName);
                    this.beanDefinitionNames = updatedDefinitions;
                    removeManualSingletonName(beanName);
                }
            }
            else {
                // 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);
        }
    }

核心其实就是将BeanDefinition写入缓存中：

this.beanDefinitionMap.put(beanName, beanDefinition);

3.2 registerAlias

该方法在《Spring源码解析（五）-解析alias标签》已经讲述过了，感兴趣可以戳