Spring5源码分析（二） IOC 容器的初始化（四）

迈不过友情╰ 2022-05-24 12:05 224阅读 0赞

承接上一篇文章继续分析FileSystemXmlApplicationContext IOC容器创建的流程。

#### 2.12 BeanDefinitionParserDelegate 解析元素 ####

BeanDefinitionParserDelegate 在解析调用 parsePropertyElements 方法解析元素中的属性子元素，解析源码如下：

//解析<Bean>元素中的<property>子元素
    public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
        //获取<Bean>元素中所有的子元素
        NodeList nl = beanEle.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            //如果子元素是<property>子元素，则调用解析<property>子元素方法解析
            if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
                parsePropertyElement((Element) node, bd);
            }
        }
    }
    
    //解析<property>元素
    public void parsePropertyElement(Element ele, BeanDefinition bd) {
        //获取<property>元素的名字
        String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
        if (!StringUtils.hasLength(propertyName)) {
            error("Tag 'property' must have a 'name' attribute", ele);
            return;
        }
        this.parseState.push(new PropertyEntry(propertyName));
        try {
            //如果一个Bean中已经有同名的property存在，则不进行解析，直接返回。
            //即如果在同一个Bean中配置同名的property，则只有第一个起作用
            if (bd.getPropertyValues().contains(propertyName)) {
                error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
                return;
            }
            //解析获取property的值
            Object val = parsePropertyValue(ele, bd, propertyName);
            //根据property的名字和值创建property实例
            PropertyValue pv = new PropertyValue(propertyName, val);
            //解析<property>元素中的属性
            parseMetaElements(ele, pv);
            pv.setSource(extractSource(ele));
            bd.getPropertyValues().addPropertyValue(pv);
        }
        finally {
            this.parseState.pop();
        }
    }
    
    
    //解析获取property值
    @Nullable
    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.
        //获取<property>的所有子元素，只能是其中一种类型:ref,value,list,etc等
        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 {
                    //当前<property>元素包含有子元素
                    subElement = (Element) node;
                }
            }
        }
    
        //判断property的属性值是ref还是value，不允许既是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，创建一个ref的数据对象RuntimeBeanReference
        //这个对象封装了ref信息
        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的数据对象是被当前的property对象所引用
            ref.setSource(extractSource(ele));
            return ref;
        }
        //如果属性是value，创建一个value的数据对象TypedStringValue
        //这个对象封装了value信息
        else if (hasValueAttribute) {
            //一个持有String类型值的对象
            TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
            //设置这个value数据对象是被当前的property对象所引用
            valueHolder.setSource(extractSource(ele));
            return valueHolder;
        }
        //如果当前<property>元素还有子元素
        else if (subElement != null) {
            //解析<property>的子元素
            return parsePropertySubElement(subElement, bd);
        }
        else {
            // Neither child element nor "ref" or "value" attribute found.
            //propery属性中既不是ref，也不是value属性，解析出错返回null
            error(elementName + " must specify a ref or value", ele);
            return null;
        }
    }

通过对上述源码的分析，我们可以了解在 Spring 配置文件中，元素中元素的相关配置是如何处理的：  
a.ref 被封装为指向依赖对象一个引用。  
b.value 配置都会封装成一个字符串类型的对象。  
c.ref 和 value 都通过“解析的数据类型属性值.setSource(extractSource(ele));”方法将属性值/引用与所引用的属性关联起来。  
在方法的最后对于元素的子元素通过 parsePropertySubElement 方法解析，我们继续分析该方法的源码，了解其解析过程。

#### 2.13 解析元素的子元素 ####

在 BeanDefinitionParserDelegate 类中的 parsePropertySubElement 方法对中的子元素解析，源码如下：

//解析<property>元素中ref,value或者集合等子元素
    @Nullable
    public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {
        //如果<property>没有使用Spring默认的命名空间，则使用用户自定义的规则解析内嵌元素
        if (!isDefaultNamespace(ele)) {
            return parseNestedCustomElement(ele, bd);
        }
        //如果子元素是bean，则使用解析<Bean>元素的方法解析
        else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
            BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
            if (nestedBd != null) {
                nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
            }
            return nestedBd;
        }
        //如果子元素是ref，ref中只能有以下3个属性：bean、local、parent
        else if (nodeNameEquals(ele, REF_ELEMENT)) {
            // A generic reference to any name of any bean.
            //可以不再同一个Spring配置文件中，具体请参考Spring对ref的配置规则
            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.
                //获取<property>元素中parent属性值，引用父级容器中的Bean
                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;
            }
            //创建ref类型数据，指向被引用的对象
            RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
            //设置引用类型值是被当前子元素所引用
            ref.setSource(extractSource(ele));
            return ref;
        }
        //如果子元素是<idref>，使用解析ref元素的方法解析
        else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
            return parseIdRefElement(ele);
        }
        //如果子元素是<value>，使用解析value元素的方法解析
        else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
            return parseValueElement(ele, defaultValueType);
        }
        //如果子元素是null，为<property>设置一个封装null值的字符串数据
        else if (nodeNameEquals(ele, NULL_ELEMENT)) {
            // It's a distinguished null value. Let's wrap it in a TypedStringValue
            // object in order to preserve the source location.
            TypedStringValue nullHolder = new TypedStringValue(null);
            nullHolder.setSource(extractSource(ele));
            return nullHolder;
        }
        //如果子元素是<array>，使用解析array集合子元素的方法解析
        else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
            return parseArrayElement(ele, bd);
        }
        //如果子元素是<list>，使用解析list集合子元素的方法解析
        else if (nodeNameEquals(ele, LIST_ELEMENT)) {
            return parseListElement(ele, bd);
        }
        //如果子元素是<set>，使用解析set集合子元素的方法解析
        else if (nodeNameEquals(ele, SET_ELEMENT)) {
            return parseSetElement(ele, bd);
        }
        //如果子元素是<map>，使用解析map集合子元素的方法解析
        else if (nodeNameEquals(ele, MAP_ELEMENT)) {
            return parseMapElement(ele, bd);
        }
        //如果子元素是<props>，使用解析props集合子元素的方法解析
        else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
            return parsePropsElement(ele);
        }
        //既不是ref，又不是value，也不是集合，则子元素配置错误，返回null
        else {
            error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
            return null;
        }
    }

通过上述源码分析，我们明白了在 Spring配置文件中，对元素中配置的array、list、set、map、prop等各种集合子元素的都通过上述方法解析，生成对应的数据对象，比如 ManagedList、ManagedArray、ManagedSet 等，这些 Managed 类是 Spring 对象 BeanDefiniton 的数据封装，对集  
合数据类型的具体解析有各自的解析方法实现，解析方法的命名非常规范，一目了然，我们对集合元素的解析方法进行源码分析，了解其实现过程。

#### 2.14 解析子元素 ####

在 BeanDefinitionParserDelegate 类中的 parseListElement 方法就是具体实现解析元素中的集合子元素，源码如下：

//解析<list>集合子元素
    public List<Object> parseListElement(Element collectionEle, @Nullable BeanDefinition bd) {
        //获取<list>元素中的value-type属性，即获取集合元素的数据类型
        String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);
        //获取<list>集合元素中的所有子节点
        NodeList nl = collectionEle.getChildNodes();
        //Spring中将List封装为ManagedList
        ManagedList<Object> target = new ManagedList<>(nl.getLength());
        target.setSource(extractSource(collectionEle));
        //设置集合目标数据类型
        target.setElementTypeName(defaultElementType);
        target.setMergeEnabled(parseMergeAttribute(collectionEle));
        //具体的<list>元素解析
        parseCollectionElements(nl, target, bd, defaultElementType);
        return target;
    }
    
    //具体解析<list>集合元素，<array>、<list>和<set>都使用该方法解析
    protected void parseCollectionElements(
            NodeList elementNodes, Collection<Object> target, @Nullable BeanDefinition bd, String defaultElementType) {
        //遍历集合所有节点
        for (int i = 0; i < elementNodes.getLength(); i++) {
            Node node = elementNodes.item(i);
            //节点不是description节点
            if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT)) {
                //将解析的元素加入集合中，递归调用下一个子元素
                target.add(parsePropertySubElement((Element) node, bd, defaultElementType));
            }
        }
    }

经过对 Spring Bean 定义资源文件转换的 Document 对象中的元素层层解析，Spring IOC 现在已经将XML 形式定义的 Bean 定义资源文件转换为 Spring IOC 所识别的数据结构——BeanDefinition，它是Bean定义资源文件中配置的POJO对象在SpringIOC容器中的映射，我们可以通过AbstractBeanDefinition为入口，看到了 IOC 容器进行索引、查询和操作。  
通过 Spring IOC 容器对 Bean 定义资源的解析后，IOC容器大致完成了管理Bean对象的准备工作，即初始化过程，但是最为重要的依赖注入还没有发生，现在在 IOC 容器中 BeanDefinition 存储的只是一些静态信息，接下来需要向容器注册 Bean 定义信息才能全部完成 IOC 容器的初始化过程.

#### 2.15 解析过后的 BeanDefinition 在 IOC 容器中的注册 ####

让我们继续跟踪程序的执行顺序，接下来我们来分析 DefaultBeanDefinitionDocumentReader 对Bean 定义转换的 Document 对象解析的流程中，在其 parseDefaultElement 方法中完成对 Document对象的解析后得到封装BeanDefinition 的 BeanDefinitionHold 对 象 ，然后调用BeanDefinitionReaderUtils 的 registerBeanDefinition 方法向 IOC 容器注册解析的 Bean，BeanDefinitionReaderUtils 的注册的源码如下：

//将解析的BeanDefinitionHold注册到容器中
    public static void registerBeanDefinition(
            BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
            throws BeanDefinitionStoreException {
    
        // Register bean definition under primary name.
        //获取解析的BeanDefinition的名称
        String beanName = definitionHolder.getBeanName();
        //向IOC容器注册BeanDefinition
        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
    
        // Register aliases for bean name, if any.
        //如果解析的BeanDefinition有别名，向容器为其注册别名
        String[] aliases = definitionHolder.getAliases();
        if (aliases != null) {
            for (String alias : aliases) {
                registry.registerAlias(beanName, alias);
            }
        }
    }

当调用 BeanDefinitionReaderUtils 向 IOC 容器注册解析的 BeanDefinition 时，真正完成注册功能的是 DefaultListableBeanFactory。

#### 2.15 DefaultListableBeanFactory 向IOC容器注册解析后的BeanDefinition ####

DefaultListableBeanFactory 中使用一个 HashMap 的集合对象存放 IOC 容器中注册解析的BeanDefinition，向 IOC 容器注册的主要源码如下：

//向IOC容器注册解析的BeanDefiniton
    @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");
    
        //校验解析的BeanDefiniton
        if (beanDefinition instanceof AbstractBeanDefinition) {
            try {
                ((AbstractBeanDefinition) beanDefinition).validate();
            }
            catch (BeanDefinitionValidationException ex) {
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                        "Validation of bean definition failed", ex);
            }
        }
    
        BeanDefinition oldBeanDefinition;
    
        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 {
            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 {
                // Still in startup registration phase
                this.beanDefinitionMap.put(beanName, beanDefinition);
                this.beanDefinitionNames.add(beanName);
                this.manualSingletonNames.remove(beanName);
            }
            this.frozenBeanDefinitionNames = null;
        }
    
        //检查是否有同名的BeanDefinition已经在IOC容器中注册
        if (oldBeanDefinition != null || containsSingleton(beanName)) {
            //重置所有已经注册过的BeanDefinition的缓存
            resetBeanDefinition(beanName);
        }
    }

至此，Bean 定义资源文件中配置的 Bean 被解析过后，已经注册到 IOC 容器中，被容器管理起来，真正完成了 IOC 容器初始化所做的全部工作。现在 IOC 容器中已经建立了整个 Bean 的配置信息，这些BeanDefinition 信息已经可以使用，并且可以被检索，IOC 容器的作用就是对这些注册的 Bean 定义  
信息进行处理和维护。这些的注册的 Bean 定义信息是 IOC 容器控制反转的基础，正是有了这些注册的数据，容器才可以进行依赖注入。

由于IOC 容器的初始化内容比较多一次文章无法写完，所以分了五篇进行讲解此篇为第四篇。

文档有参考其他资料，如果问题请联系我，进行删除！