死磕Spring之IoC篇 - BeanDefinition 的決議階段（XML 檔案）-有解無憂

該系列文章是本人在學習 Spring 的程序中總結下來的，里面涉及到相關原始碼，可能對讀者不太友好，請結合我的原始碼注釋 Spring 原始碼分析 GitHub 地址進行閱讀

Spring 版本：5.1.14.RELEASE

開始閱讀這一系列文章之前，建議先查看《深入了解 Spring IoC（面試題）》這一篇文章

該系列其他文章請查看：《死磕 Spring 之 IoC 篇 - 文章導讀》

BeanDefinition 的決議階段（XML 檔案）

上一篇文章《BeanDefinition 的加載階段（XML 檔案）》獲取到 org.w3c.dom.Document 物件后，需要通過 DefaultBeanDefinitionDocumentReader 進行決議，決議出 XML 檔案中定義的 BeanDefinition 并進行注冊，先來回顧一下上一篇文章中的這段代碼：

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    // <1> 創建 BeanDefinitionDocumentReader 物件
    BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    // <2> 獲取已注冊的 BeanDefinition 數量
    int countBefore = getRegistry().getBeanDefinitionCount();
    // <3> 創建 XmlReaderContext 物件（讀取 Resource 資源的背景關系物件）
    // <4> 根據 Document、XmlReaderContext 決議出所有的 BeanDefinition 并注冊
    documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    // <5> 計算新注冊的 BeanDefinition 數量
    return getRegistry().getBeanDefinitionCount() - countBefore;
}

本文開始分析第 4 步，BeanDefinition 的決議階段，其中 BeanDefinitionDocumentReader 只有 DefaultBeanDefinitionDocumentReader 一個默認實作類

BeanDefinitionDocumentReader 介面

org.springframework.beans.factory.xml.BeanDefinitionDocumentReader，決議 DOM document 中的 BeanDefinition 并注冊，代碼如下：

public interface BeanDefinitionDocumentReader {

	/**
	 * Read bean definitions from the given DOM document and
	 * register them with the registry in the given reader context.
	 * @param doc the DOM document
	 * @param readerContext the current context of the reader
	 * (includes the target registry and the resource being parsed)
	 * @throws BeanDefinitionStoreException in case of parsing errors
	 */
	void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) throws BeanDefinitionStoreException;

}

DefaultBeanDefinitionDocumentReader

org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader，Spring 默認的 BeanDefinitionDocumentReader 實作類，從 XML 檔案中決議出 BeanDefinition 并注冊

建構式

public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocumentReader {

    /** bean */
	public static final String BEAN_ELEMENT = BeanDefinitionParserDelegate.BEAN_ELEMENT;

	public static final String NESTED_BEANS_ELEMENT = "beans";

	public static final String ALIAS_ELEMENT = "alias";

	public static final String NAME_ATTRIBUTE = "name";

	public static final String ALIAS_ATTRIBUTE = "alias";

	public static final String IMPORT_ELEMENT = "import";

	public static final String RESOURCE_ATTRIBUTE = "resource";

	public static final String PROFILE_ATTRIBUTE = "profile";

	@Nullable
	private XmlReaderContext readerContext;

	/**
	 * XML 檔案的 BeanDefinition 決議器
	 */
	@Nullable
	private BeanDefinitionParserDelegate delegate;
}

上面定義了 XML 檔案中常用的標簽

1. registerBeanDefinitions 方法

registerBeanDefinitions(Document doc, XmlReaderContext readerContext) 方法，根據 Document、XmlReaderContext 決議出所有的 BeanDefinition 并注冊，方法如下：

@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
    this.readerContext = readerContext;
    // 獲得 XML Document Root Element
    // 執行注冊 BeanDefinition
    doRegisterBeanDefinitions(doc.getDocumentElement());
}

/**
 * Register each bean definition within the given root {@code <beans/>} element.
 */
@SuppressWarnings("deprecation")  // for Environment.acceptsProfiles(String...)
protected void doRegisterBeanDefinitions(Element root) {
    // 記錄老的 BeanDefinitionParserDelegate 物件，避免再次呼叫當前方法時決議出現問題（默認值可能不同）
    BeanDefinitionParserDelegate parent = this.delegate;
    // <1> 創建 BeanDefinitionParserDelegate 物件 `delegate`，并初始化默認值
    this.delegate = createDelegate(getReaderContext(), root, parent);

    // <2> 檢查 <beans /> 根標簽的命名空間是否為空，或者是 http://www.springframework.org/schema/beans
    if (this.delegate.isDefaultNamespace(root)) {
        // <2.1> 獲取 `profile` 屬性
        String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
        if (StringUtils.hasText(profileSpec)) {
            // <2.2> 使用分隔符切分，可能有多個 `profile`
            String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
            // We cannot use Profiles.of(...) since profile expressions are not supported
            // in XML config. See SPR-12458 for details.
            // <2.3> 根據 Spring Environment 進行校驗，如果所有 `profile` 都無效，則不進行注冊
            if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                            "] not matching: " + getReaderContext().getResource());
                }
                return;
            }
        }
    }
    // <3> 決議前處理
    preProcessXml(root);
    // <4> 決議出 XML Document 中的 BeanDefinition 并注冊
    parseBeanDefinitions(root, this.delegate);
    // <5> 決議后處理
    postProcessXml(root);
    // 設定 delegate 回老的 BeanDefinitionParserDelegate 物件
    this.delegate = parent;
}

首先獲取 XML Document 的最頂層的標簽，也就是 <beans />，然后對其子標簽進行決議，這里的程序大致如下：

創建 BeanDefinitionParserDelegate 物件 delegate，并初始化默認值
檢查 <beans /> 根標簽是否是默認命名空間（xmlns 屬性，為慷訓者是 http://www.springframework.org/schema/beans），是的話進行校驗
1. 獲取 profile 屬性，使用分隔符切分
2. 根據 Spring Environment 進行校驗，如果所有 profile 都無效，則不進行注冊
決議前處理，空方法，暫時忽略
決議出 XML Document 中的 BeanDefinition 并注冊，呼叫 parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) 方法
決議后處理，空方法，暫時忽略

2. parseBeanDefinitions 方法

parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) 方法，決議 XML Document 的最頂層的標簽，決議出 BeanDefinition 并注冊，方法如下：

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    // <1> 如果根節點使用默認命名空間，執行默認決議
    if (delegate.isDefaultNamespace(root)) {
        // <1.1> 遍歷所有的子節點
        NodeList nl = root.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (node instanceof Element) {
                Element ele = (Element) node;
                // <1.2> 如果該節點使用默認命名空間，執行默認決議
                if (delegate.isDefaultNamespace(ele)) {
                    parseDefaultElement(ele, delegate);
                }
                // <1.3> 如果該節點非默認命名空間，執行自定義決議
                else {
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    // <2> 如果根節點非默認命名空間，執行自定義決議
    else {
        delegate.parseCustomElement(root);
    }
}

決議程序大致如下：

如果根節點使用默認命名空間，執行默認決議
1. 遍歷所有的子節點
2. 如果該節點使用默認命名空間，執行默認決議，呼叫 parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) 方法
3. 如果該節點非默認命名空間，執行自定義決議，呼叫 BeanDefinitionParserDelegate#parseCustomElement(Element ele) 方法
如果根節點非默認命名空間，執行自定義決議，呼叫 BeanDefinitionParserDelegate#parseCustomElement(Element ele) 方法

命名空間是什么？

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">
	<context:component-scan base-package="org.geekbang.thinking.in.spring.ioc.overview" />

    <bean id="user" >
        <property name="id" value="https://www.cnblogs.com/lifullmoon/p/1"/>
        <property name="name" value="https://www.cnblogs.com/lifullmoon/p/小馬哥"/>
    </bean>
</beans>

在 XML 檔案中的標簽的 xmlns 可以定義默認的命名空間，xmlns:context 定義 context 的命名空間，xsi:schemaLocation 定義了命名空間對應的 XSD 檔案（校驗 XML 內容），

上面的 <beans /> 和 <bean> 標簽的命名空間為 http://www.springframework.org/schema/beans，其中 <context:component-scan /> 標簽的命名空間為 http://www.springframework.org/schema/context（不是默認命名空間）

本文主要分析默認命名空間的決議程序，其他命名空間（注解相關）在后面進行分析，基于 Extensible XML authoring 擴展 Spring XML 元素會進入這里，主要是通過 NamespaceHandler 這個介面實作的，例如 Spring 集成 Mybatis 專案中的 <mybatis:scan /> 就是擴展 Spring XML 元素，具體實作在后面分析；Spring 的<context:component-scan /> 最侄訓通過 ComponentScanBeanDefinitionParser 進行決議，ComponentScanBeanDefinitionParser 是將 @Component 注解標注的類轉換成 BeanDefinition 的決議器，

3. parseDefaultElement 方法

parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) 方法，處理默認命名空間的節點，方法如下：

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        // 決議 `<import />`
        importBeanDefinitionResource(ele);
    }
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        // 決議 `<alias />`，將 name 對應的 alias 別名進行注冊
        processAliasRegistration(ele);
    }
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
        // 決議 `<bean />`
        processBeanDefinition(ele, delegate);
    }
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
        // 回圈處理，決議 `<beans />`
        doRegisterBeanDefinitions(ele);
    }
}

決議下面四種標簽：

<import /> 標簽，例如這么配置：<import resource="dependency-lookup-context.xml"/>，那么這里會獲取到對應的 XML 檔案，然后進行相同的處理程序
<alias /> 標簽，將 name 對應的 alias 別名進行注冊，往 AliasRegistry 注冊（BeanDefinitionRegistry 繼承了它），也就是說你可以通過別名找到對應的 Bean
<bean /> 標簽，決議成 BeanDefinition 并注冊，呼叫 processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) 方法
<beans /> 標簽，回圈處理，和前面的步驟相同

4. processBeanDefinition 方法

processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) 方法，將 <bean /> 標簽決議成 BeanDefinition 并注冊，方法如下：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    // <1> 決議 `<bean />` 標簽，回傳 BeanDefinitionHolder 物件（包含 BeanDefinition、beanName、aliases）
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        // <2> 對該標簽進行裝飾，一般不會，暫時忽略
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            // Register the final decorated instance.
            // <3> 進行 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.
        // <4> 發出回應事件，通知相關的監聽器，已完成該 Bean 標簽的決議
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

程序如下：

決議 <bean /> 標簽，回傳 BeanDefinitionHolder 物件（包含 BeanDefinition、beanName、aliases），呼叫 BeanDefinitionParserDelegate#parseBeanDefinitionElement(Element ele) 方法
對該標簽進行裝飾，和上面處理自定義標簽類似，暫時忽略
進行 BeanDefinition 的注冊
發出回應事件，通知相關的監聽器，已完成該 Bean 標簽的決議

BeanDefinitionParserDelegate

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate，決議 XML Document 里面的 BeanDefinition

5. parseBeanDefinitionElement 方法

parseBeanDefinitionElement(Element ele) 方法，將 XML Document 里面的某個標簽決議成 BeanDefinition，方法如下：

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

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
    // <1> 計算 BeanDefinition 的 `beanName` 名稱和 `aliases` 別名集合
    // <1.1> 獲取標簽的 `id` 和 `name` 屬性
    String id = ele.getAttribute(ID_ATTRIBUTE);
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

    // <1.2> 將 `name` 屬性全部添加至別名集合
    List<String> aliases = new ArrayList<>();
    if (StringUtils.hasLength(nameAttr)) {
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
        aliases.addAll(Arrays.asList(nameArr));
    }

    // <1.3> 設定 Bean 的名稱，優先 `id` 屬性，其次 `name` 屬性
    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");
        }
    }

    // <1.4> 檢查 `beanName` 的唯一性
    if (containingBean == null) {
        checkNameUniqueness(beanName, aliases, ele);
    }

    // <2> 決議 `<bean />` 標簽相關屬性，構造出一個 GenericBeanDefinition 物件
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    if (beanDefinition != null) {
        // <3> 如果不存在 `beanName`，則根據 Class 物件的名稱生成一個
        if (!StringUtils.hasText(beanName)) {
            try {
                if (containingBean != null) { // 內部 Bean
                    // <3.1> 生成唯一的 `beanName`
                    beanName = BeanDefinitionReaderUtils.generateBeanName(
                            beanDefinition, this.readerContext.getRegistry(), true);
                }
                else {
                    // <3.2> 生成唯一的 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;
            }
        }
        // <4> 創建 BeanDefinitionHolder 物件，設定 `beanName` 名稱和 `aliases` 別名集合，回傳
        String[] aliasesArray = StringUtils.toStringArray(aliases);
        return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
    }

    return null;
}

程序如下：

計算 BeanDefinition 的 beanName 名稱和 aliases 別名集合
1. 獲取標簽的 id 和 name 屬性
2. 將 name 屬性全部添加至別名集合 aliases
3. 設定 Bean 的名稱 beanName，優先 id 屬性，其次 name 屬性
4. 檢查 beanName 的唯一性
決議 <bean /> 標簽相關屬性，構造出一個 GenericBeanDefinition 物件，呼叫 parseBeanDefinitionElement(Element ele, String beanName, @Nullable BeanDefinition containingBean) 方法
如果不存在 beanName，則根據 Class 物件的名稱生成一個
創建 BeanDefinitionHolder 物件，設定 beanName 名稱和 aliases 別名集合，回傳

6. parseBeanDefinitionElement 多載方法

parseBeanDefinitionElement(Element ele, String beanName, @Nullable BeanDefinition containingBean) 方法，決議 <bean /> 成 GenericBeanDefinition 物件，方法如下：

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

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

    // <1> 獲取 `class` 和 `parent` 屬性
    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 {
        // <2> 構建一個 GenericBeanDefinition 物件 `bd`
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);

        // <3> 決議 `<bean />` 的各種屬性并賦值
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
        // 提取 description
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

        // <4> 決議 `<bean />` 的子標簽，生成的物件設定到 `bd` 中

        // <4.1> 決議 `<meta />` 元資料標簽
        parseMetaElements(ele, bd);
        // <4.2> 決議 `<lookup-method />` 標簽
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
        // <4.3> 決議 `<replaced-method />` 標簽
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

        // <4.4> 決議 `<constructor-arg />` 建構式的引數集合標簽
        parseConstructorArgElements(ele, bd);
        // <4.5> 決議 `<property />` 屬性標簽
        parsePropertyElements(ele, bd);
        // <4.5> 決議 `<qualifier />` 標簽
        parseQualifierElements(ele, bd);

        // <5> 設定 Bean 的 `resource` 資源為 XML 檔案資源
        bd.setResource(this.readerContext.getResource());
        // <6> 設定 Bean 的 `source` 來源為 `<bean />` 標簽物件
        bd.setSource(extractSource(ele));

        return bd;
    }
    // ... 省略 catch 各種例外
    finally {
        this.parseState.pop();
    }

    return null;
}

程序如下：

獲取 class 和 parent 屬性
構建一個 GenericBeanDefinition 物件 bd，設定 parentName 和 beanClass（Class 物件）或者 className（Class 名稱）
決議 <bean /> 的各種屬性并賦值：scope、abstract、lazy-init、autowire、depends-on、autowire-candidate、primary、init-method、destroy-method、factory-method
決議 <bean /> 的子標簽，生成的物件設定到 bd 中
1. 決議 <meta /> 元資料標簽，將 key-value 保存至 Map 中
2. 決議 <lookup-method /> 標簽，決議成 LookupOverride 物件，用于實作 Bean 中的某個方法
3. 決議 <replaced-method /> 標簽，決議成 ReplaceOverride 物件，用于替換 Bean 中的某個方法
4. 決議 <constructor-arg /> 建構式的引數集合標簽，將各個引數決議出來，可根據 index 屬性進行排序
5. 決議 <property /> 屬性標簽，將各個屬性決議出來，每個屬性對應一個 PropertyValue，添加至 bd 的 MutablePropertyValues 屬性中
6. 決議 <qualifier /> 標簽，決議出需要注入的物件 AutowireCandidateQualifier
設定 Bean 的 resource 資源為 XML 檔案資源
設定 Bean 的 source 來源為 <bean /> 標簽物件

lookup-method，會被決議成 LookupOverride 物件，replaced-method 會被決議成 ReplaceOverride 物件，這兩個標簽不是很常用

lookup-method：例如一個在一個抽象類中定義了抽象方法，可以通過這個標簽定義一個 Bean 實作這個方法，Spring 會動態改變抽象類該方法的實作

replace-method：通過這個標簽定義一個 Bean，去覆寫對應的方法，Spring 會動態替換類的這個方法

BeanDefinitionReaderUtils

org.springframework.beans.factory.support.BeanDefinitionReaderUtils，BeanDefinition 的決議程序中的工具類

7. registerBeanDefinition 方法

registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)，注冊 BeanDefinition，方法如下：

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

    // <1> 注冊 BeanDefinition
    // Register bean definition under primary name.
    String beanName = definitionHolder.getBeanName();
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

    // <2> 注冊 alias 別名
    // Register aliases for bean name, if any.
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias);
        }
    }
}

程序如下：

注冊 BeanDefinition，呼叫 BeanDefinitionRegistry#registerBeanDefinition(String beanName, BeanDefinition beanDefinition) 方法
注冊 alias 別名，呼叫 BeanDefinitionRegistry#registerAlias(String name, String alias) 方法

這里的 BeanDefinitionRegistry 實作類是 DefaultListableBeanFactory，它是 Spring 底層 IoC 容器，還繼承了 SimpleAliasRegistry（AliasRegistry 實作類）

8. 注冊 BeanDefinition

// org.springframework.beans.factory.support.DefaultListableBeanFactory
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException {

    // 校驗 beanName 與 beanDefinition 非空
    Assert.hasText(beanName, "Bean name must not be empty");
    Assert.notNull(beanDefinition, "BeanDefinition must not be null");

    // <1> 校驗 BeanDefinition
    // 這是注冊前的最后一次校驗了，主要是對屬性 methodOverrides 進行校驗
    if (beanDefinition instanceof AbstractBeanDefinition) {
        try {
            ((AbstractBeanDefinition) beanDefinition).validate();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Validation of bean definition failed", ex);
        }
    }

    // <2> 從快取中獲取指定 beanName 的 BeanDefinition
    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    // <3> 如果已經存在
    if (existingDefinition != null) {
        // 如果存在但是不允許覆寫，拋出例外
        if (!isAllowBeanDefinitionOverriding()) {
            throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
        }
        // 覆寫 beanDefinition 大于 被覆寫的 beanDefinition 的 ROLE ，列印 info 日志
        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 + "]");
            }
        }
        // 覆寫 beanDefinition 與 被覆寫的 beanDefinition 不相同，列印 debug 日志
        else if (!beanDefinition.equals(existingDefinition)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Overriding bean definition for bean '" + beanName +
                        "' with a different definition: replacing [" + existingDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        // 其它，列印 debug 日志
        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);
    }
    // <4> 如果未存在
    else {
        // 檢測創建 Bean 階段是否已經開啟，如果開啟了則需要對 beanDefinitionMap 進行并發控制
        if (hasBeanCreationStarted()) {
            // beanDefinitionMap 為全域變數，避免并發情況
            // Cannot modify startup-time collection elements anymore (for stable iteration)
            synchronized (this.beanDefinitionMap) {
                // 添加到 BeanDefinition 到 beanDefinitionMap 中
                this.beanDefinitionMap.put(beanName, beanDefinition);
                // 添加 beanName 到 beanDefinitionNames 中
                List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                updatedDefinitions.addAll(this.beanDefinitionNames);
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions;
                // 從 manualSingletonNames 移除 beanName
                removeManualSingletonName(beanName);
            }
        }
        else {
            // 添加到 BeanDefinition 到 beanDefinitionMap 中
            // Still in startup registration phase
            this.beanDefinitionMap.put(beanName, beanDefinition);
            // 添加 beanName 到 beanDefinitionNames 中，保證注冊順序
            this.beanDefinitionNames.add(beanName);
            // 從 manualSingletonNames 移除 beanName
            removeManualSingletonName(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }

    // <5> 重新設定 beanName 對應的快取
    if (existingDefinition != null || containsSingleton(beanName)) {
        resetBeanDefinition(beanName);
    }
}

邏輯不復雜，主要是對 beanName 和該 BeanDefinition 物件的校驗，最終將其映射保存在 beanDefinitionMap 中（ConcurrentHashMap），key 就是 beanName

9. 注冊 alias 別名

// org.springframework.core.SimpleAliasRegistry
@Override
public void registerAlias(String name, String alias) {
   // 校驗 name 、 alias
   Assert.hasText(name, "'name' must not be empty");
   Assert.hasText(alias, "'alias' must not be empty");
   synchronized (this.aliasMap) {
      // name == alias 則去掉alias
      if (alias.equals(name)) {
         this.aliasMap.remove(alias);
         if (logger.isDebugEnabled()) {
            logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
         }
      }
      else {
         // 獲取 alias 已注冊的 beanName
         String registeredName = this.aliasMap.get(alias);
         // 已存在
         if (registeredName != null) {
            // 相同，則 return ，無需重復注冊
            if (registeredName.equals(name)) {
               // An existing alias - no need to re-register
               return;
            }
            // 不允許覆寫，則拋出 IllegalStateException 例外
            if (!allowAliasOverriding()) {
               throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
                     name + "': It is already registered for name '" + registeredName + "'.");
            }
            if (logger.isDebugEnabled()) {
               logger.debug("Overriding alias '" + alias + "' definition for registered name '" +
                     registeredName + "' with new target name '" + name + "'");
            }
         }
         // 校驗，是否存在回圈指向
         checkForAliasCircle(name, alias);
         // 注冊 alias
         this.aliasMap.put(alias, name);
         if (logger.isTraceEnabled()) {
            logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
         }
      }
   }
}

邏輯不復雜，將 alias 與 beanName 映射保存至 aliasMap 中（ConcurrentHashMap）

總結

決議出 XML 檔案中的 BeanDefinition 并注冊的整個程序大致如下：

根據 XSD 檔案對 XML 檔案進行校驗
將 XML 檔案資源轉換成 org.w3c.dom.Document 物件
根據 Document 物件決議 <beans /> 標簽，遍歷所有的子標簽
1. 如果是子標簽是默認的命名空間（為慷訓者 http://www.springframework.org/schema/beans）則進行處理，例如：<import>、<alias />、<bean />和<beans />，其中 <bean /> 會被決議出一個 GenericBeanDefinition 物件，然后進行注冊
2. 否則，找到對應的 NamespaceHandler 物件進行決議，例如：<context:component-scan /> 、<context:annotation-config />、<util:list />，這些非默認命名空間的標簽都會有對應的 BeanDefinitionParser 決議器

至此，我們通過 XML 檔案定義的 Bean 已經轉換成了 Bean 的“前身”，也就是 BeanDefinition 物件，接下來會分析在 XML 檔案中，非默認命名空間的標簽是如何進行處理的，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/263186.html

標籤：Java

上一篇：架構設計：資料服務系統0到1落地實作方案

下一篇：HTTP/1.1報文詳解