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

  承接上一篇文章繼續分析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 容器的初始化內容比較多一次文章沒法寫完，因此分了五篇進行講解此篇爲第四篇。

文檔有參考其餘資料，若是問題請聯繫我，進行刪除！