（Spring源碼分析）默認標籤的解析

在上一節XmlBeanFactory容器分析中，在parseDefaultElement方法中是對默認的標籤進行解析的

• 默認的標籤解析是在parseDefaultElement方法進行的

/**
 * 對四種不同的標籤進行處理
 *
 * @param ele
 * @param 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標籤進行處理
        processAliasRegistration(ele);
    }
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { // 對bean標籤進行處理
        processBeanDefinition(ele, delegate);
    }
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { // 對beans標籤進行處理
        doRegisterBeanDefinitions(ele);
    }
}

在parseDefaultElement對四種不同的標籤進行處理

• 對bean標籤的解析

對bean標籤的解析最爲複雜也最爲重要，理解了bean標籤的解析，其他標籤解析就很輕鬆了

/**
 * 調用decorateBeanDefinitionIfRequired方法解析bean標籤並調用registerBeanDefinition方法註冊bean
 */
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); // 對Element對象進行解析，返回BeanDefinitionHolder對象，BeanDefinitionHolder對象中已經包含了class、name、id、alias之類的屬性
    if (bdHolder != null) {
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); // 當存在默認標籤的子節點下還有自定義屬性時，再對其進行解析
        try {
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); // 將解析後的bdHolder進行註冊
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name '" +
                                     bdHolder.getBeanName() + "'", ele, ex);
        }
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder)); // 發出響應事件，通知相關的監聽器，這個bean已經加載完成了
    }
}

下面主要看一下parseBeanDefinitionElement()方法和registerBeanDefinition()方法的源碼

• 先來看一下parseBeanDefinitionElement()方法的源碼

/**
 * 在BeanDefinitionParserDelegate類中
 */
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
    return parseBeanDefinitionElement(ele, null);
}

/**
 * 解析bean元素標籤中各種屬性
 */
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
    String id = ele.getAttribute(ID_ATTRIBUTE); // 解析id屬性
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE); // 解析name屬性

    // 分割name屬性
    List<String> aliases = new ArrayList<>();
    if (StringUtils.hasLength(nameAttr)) {
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
        aliases.addAll(Arrays.asList(nameArr));
    }

    String beanName = id;
    if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
        beanName = aliases.remove(0); // bean的名稱默認是爲<bean>標籤的id，如果alias存在的話就是alias
        if (logger.isDebugEnabled()) {
            logger.debug("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases + " as aliases");
        }
    }

    if (containingBean == null) {
        checkNameUniqueness(beanName, aliases, ele);
    }

    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); // 解析BeanDefinition元素
    if (beanDefinition != null) {
        if (!StringUtils.hasText(beanName)) {
            try {
                if (containingBean != null) { // 如果beanName不存在，那麼按照Spring提供的命名規則爲當前bean生成對應的beanName
                    beanName = BeanDefinitionReaderUtils.generateBeanName(
                        beanDefinition, this.readerContext.getRegistry(), true);
                }
                else {
                    beanName = this.readerContext.generateBeanName(beanDefinition);
                    String beanClassName = beanDefinition.getBeanClassName();
                    if (beanClassName != null &&
                        beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                        !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
                        aliases.add(beanClassName);
                    }
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("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);
        return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
    }
    return null;
}

/**
 * 解析BeanDefinition元素
 */
@Nullable
public AbstractBeanDefinition parseBeanDefinitionElement(
    Element ele, String beanName, @Nullable BeanDefinition containingBean) {

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

    String className = null;
    // 解析class屬性
    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    }
    String parent = null;
    // 解析parent屬性
    if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
        parent = ele.getAttribute(PARENT_ATTRIBUTE);
    }

    try {
        // 創建用於保存bean屬性的AbstractBeanDefinition子類GenericBeanDefinition對象
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);

        // 硬編碼解析默認bean的各種屬性
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
        // 提取description
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
        // 解析元數據
        parseMetaElements(ele, bd);
        // 解析lookup-method屬性
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
        // 解析replaced-method屬性
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

        parseConstructorArgElements(ele, bd);
        parsePropertyElements(ele, bd);
        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;
}

parseBeanDefinitionElement()方法主要是解析Bean標籤的屬性，然後封裝到BeanDefinition類中

• 再來看一下registerBeanDefinition()方法的源碼

/**
 * 在BeanDefinitionReaderUtils類中
 * 將bean的信息和bean的別名註冊到BeanDefinitionRegistry中
 */
public static void registerBeanDefinition(
    BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
    throws BeanDefinitionStoreException {

    String beanName = definitionHolder.getBeanName();
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); // 將bean的信息註冊到BeanDefinitionRegistry中

    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias); // 將bean的別名註冊到BeanDefinitionRegistry中
        }
    }
}

registerBeanDefinition主要是將封裝好的BeanDefinition對象進行註冊

• 再來看一下registerBeanDefinition()方法的源碼

/**
 * 在DefaultListableBeanFactory類中
 * 註冊bean到beanDefinitionMap中，beanDefinitionMap是Spring容器實際存儲bean的map集合
 */
@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 {
            ((AbstractBeanDefinition) beanDefinition).validate();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", ex);
        }
    }

    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName); // 先從beanDefinitionMap中根據beanName獲取value值
    if (existingDefinition != null) { // 當beanDefinitionMap中已經存在該bean
        if (!isAllowBeanDefinitionOverriding()) { // 不允許覆蓋bean時
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName + "': There is already [" + existingDefinition + "] bound.");
        }
        else if (existingDefinition.getRole() < beanDefinition.getRole()) {
            if (logger.isWarnEnabled()) {
                logger.warn("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.isInfoEnabled()) {
                logger.info("Overriding bean definition for bean '" + beanName + "' with a different definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
            }
        }
        else {
            if (logger.isDebugEnabled()) {
                logger.debug("Overriding bean definition for bean '" + beanName + "' with an equivalent definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
            }
        }
        this.beanDefinitionMap.put(beanName, beanDefinition); // 當允許覆蓋bean時覆蓋該bean
    }
    else { // 當beanDefinitionMap中已經不存在該bean
        if (hasBeanCreationStarted()) {
            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 {
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            this.manualSingletonNames.remove(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }

    if (existingDefinition != null || containsSingleton(beanName)) {
        resetBeanDefinition(beanName);
    }
}

registerBeanDefinition方法主要是具體實現將BeanDefinition註冊到beanDefinitionMap，beanDefinitionMap是BeanDefinitionRegistry中的屬性，beanDefinitionMap實現是一個ConcurrentHashMap，key爲beanName，value爲BeanDefinition對象，在Spring容器中，bean屬性都儲存在beanDefinitionMap中

總結

在默認標籤的解析過程中，有三個類或者變量很重要

• BeanDefinition

BeanDefinition是一個接口，是元素標籤在Spring容器的內部表現形式。在Spring中存在三種實現RootBeanDefinition、ChildBeanDefinition、GenericBeanDefinition，均繼承了AbstractBeanDefinition抽象類，在元素標籤中的class、scope、lazy-init等配置屬性，在BeanDefinition提供了相應了beanClass、scope、lazyInit屬性。BeanDefinition中的屬性是通過集成父類AbstractBeanDefinition中的和配置屬性保持一一對應。

private volatile Object beanClass; // 對應class屬性

private String scope = SCOPE_DEFAULT; // 對應scope屬性

private boolean lazyInit = false; // 對lazy-init屬性
......

• BeanDefinitionRegistry

Spring通過BeanDefinition將配置文件中的配置信息轉換爲容器的內部表示，並將這些BeanDefinition註冊到BeanDefinitionRegistry中，Spring容器的BeanDefinitionRegistry就像是Spring配置信息的內存數據庫，主要以map的形式保存，從Spring容器中獲取bean也是從BeanDefinitionRegistry中獲取bean的信息的，對外提供對BeanDefinition的增刪改查操作

XmlBeanFactory繼承了實現了BeanDefinitionRegistry接口的父類DefaultListableBeanFactory，在接口中定義了對BeanDefinition的增刪改查操作

void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException; // 註冊BeanDefinition

void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; // 移除BeanDefinition

BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; // 獲取BeanDefinition

boolean containsBeanDefinition(String beanName); // 判斷是否包含BeanDefinition

String[] getBeanDefinitionNames(); // 獲取beanName

int getBeanDefinitionCount(); // 獲取BeanDefinition總數

• beanDefinitionMap

beanDefinitionMap是BeanDefinitionRegistry中的屬性，beanDefinitionMap實現是一個ConcurrentHashMap，key爲beanName，value爲BeanDefinition對象，bean屬性都儲存在beanDefinitionMap中

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);