【Spring】重復的beanName覆蓋原則（九）

　　在Spring中，可以有由於存在重復的beanName會有一些問題

　　下面看看，Spring是怎么處理重復的beanName的

1、Spring容器內置了 ConfigurationClassPostProcessor 配置類工廠bean后置處理器，在Bean工廠准備好后，調用 postProcessBeanDefinitionRegistry() 方法來后置處理bean工廠

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    int registryId = System.identityHashCode(registry);
    if (this.registriesPostProcessed.contains(registryId)) {
        throw new IllegalStateException(
                "postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
    }
    if (this.factoriesPostProcessed.contains(registryId)) {
        throw new IllegalStateException(
                "postProcessBeanFactory already called on this post-processor against " + registry);
    }
    // 給后置處理器，添加注冊ID
    this.registriesPostProcessed.add(registryId);
    // 解析配置的bean定義
    processConfigBeanDefinitions(registry);
}

2、processConfigBeanDefinitions() 處理配置bean定義

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    
    ......

    // Parse each @Configuration class
    // 創建一個配置類解析器對象
    ConfigurationClassParser parser = new ConfigurationClassParser(
            this.metadataReaderFactory, this.problemReporter, this.environment,
            this.resourceLoader, this.componentScanBeanNameGenerator, registry);

    // 創建一個集合用於保存配置類BeanDefinitionHolder集合默認長度是配置類集合的長度
    Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
    // 創建一個集合用於保存已經解析的配置類，長度默認為解析出來默認的配置類的集合長度
    Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
    //do while 會進行第一次解析
    do {
        // 使用配置類解析器，解析配置類
        parser.parse(candidates);
        // 使用配置類解析器，驗證
        parser.validate();
        // 解析出來的配置類，即從解析器的配置類屬性中獲取解析出來的配置類
        Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
        configClasses.removeAll(alreadyParsed);

        // Read the model and create bean definitions based on its content
        if (this.reader == null) {
            this.reader = new ConfigurationClassBeanDefinitionReader(
                    registry, this.sourceExtractor, this.resourceLoader, this.environment,
                    this.importBeanNameGenerator, parser.getImportRegistry());
        }
        // 真正的把解析出來的配置類注冊到容器中
        this.reader.loadBeanDefinitions(configClasses);

        ....
    }
    // 存在沒有解析過的 需要循環解析
    while (!candidates.isEmpty());

    .....
}

3、解析出來后，通過 loadBeanDefinitions() 方法，把bean定義注冊到容器中

　　loadBeanDefinitions() -> loadBeanDefinitionsForConfigurationClass() -> loadBeanDefinitionsForBeanMethod()

　　加載被@Bean修飾的方法 bean定義時

// 從Bean方法中加載Bean定義
private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
    
    ......

    // Has this effectively been overridden before (e.g. via XML)?
    // 是否覆蓋已經存在的Bean定義
    /**
     * 0、不存在相同Bean定義名稱的，則返回false。繼續添加bean定義
     * 1、配置類的名字相同，則報錯
     * 2、同一個配置類中的@Bean名字相同，則返回true，意思是以先加載的@Bean方法為准
     * 3、不同的配置類中的@Bean名字相同，則返回false，意思是可以被覆蓋，已后被加載的@Bean方法為准
     */
    if (isOverriddenByExistingDefinition(beanMethod, beanName)) {
        // 配置類名稱相同報異常
        if (beanName.equals(beanMethod.getConfigurationClass().getBeanName())) {
            throw new BeanDefinitionStoreException(beanMethod.getConfigurationClass().getResource().getDescription(),
                    beanName, "Bean name derived from @Bean method '" + beanMethod.getMetadata().getMethodName() +
                    "' clashes with bean name for containing configuration class; please make those names unique!");
        }
        return;
    }

    // 創建配置類的Bean定義
    ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata);

    ......

    // 注冊Bean定義
    this.registry.registerBeanDefinition(beanName, beanDefToRegister);
}

4、isOverriddenByExistingDefinition() 判斷是否覆蓋已經存在的Bean定義的方法

// 是否覆蓋已經存在的Bean定義
protected boolean isOverriddenByExistingDefinition(BeanMethod beanMethod, String beanName) {
    if (!this.registry.containsBeanDefinition(beanName)) {
        return false;
    }
    BeanDefinition existingBeanDef = this.registry.getBeanDefinition(beanName);

    // 存在的Bean定義 是否是 配置類Bean定義類型
    if (existingBeanDef instanceof ConfigurationClassBeanDefinition) {
        ConfigurationClassBeanDefinition ccbd = (ConfigurationClassBeanDefinition) existingBeanDef;
        // 是否是同一個配置類名
        if (ccbd.getMetadata().getClassName().equals(
                beanMethod.getConfigurationClass().getMetadata().getClassName())) {
            if (ccbd.getFactoryMethodMetadata().getMethodName().equals(ccbd.getFactoryMethodName())) {
                ccbd.setNonUniqueFactoryMethodName(ccbd.getFactoryMethodMetadata().getMethodName());
            }
            return true;
        }
        else {
            return false;
        }
    }

    // 屬性掃描生成的Bean定義
    if (existingBeanDef instanceof ScannedGenericBeanDefinition) {
        return false;
    }

    // 現有的bean定義bean是否標記為框架生成的bean
    if (existingBeanDef.getRole() > BeanDefinition.ROLE_APPLICATION) {
        return false;
    }

    
    if (this.registry instanceof DefaultListableBeanFactory &&
            !((DefaultListableBeanFactory) this.registry).isAllowBeanDefinitionOverriding()) {
        throw new BeanDefinitionStoreException(beanMethod.getConfigurationClass().getResource().getDescription(),
                beanName, "@Bean definition illegally overridden by existing bean definition: " + existingBeanDef);
    }
    if (logger.isDebugEnabled()) {
        logger.debug(String.format("Skipping bean definition for %s: a definition for bean '%s' " +
                "already exists. This top-level bean definition is considered as an override.",
                beanMethod, beanName));
    }
    return true;
}

5、注冊bean定義方法 registerBeanDefinition()

// 在Bean工廠中注冊bean定義
@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");

    // 判斷bean定義 屬於抽象的bean定義
    if (beanDefinition instanceof AbstractBeanDefinition) {
        try {
            // 驗證bean定義
            ((AbstractBeanDefinition) beanDefinition).validate();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Validation of bean definition failed", ex);
        }
    }

    // 根據bean名字獲取已經存在的bean定義
    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    if (existingDefinition != null) {
        // 是否允許覆蓋Bean定義  allowBeanDefinitionOverriding默認值為true
        if (!isAllowBeanDefinitionOverriding()) {
            throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
        }
        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 + "]");
            }
        }
        else if (!beanDefinition.equals(existingDefinition)) {
            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工廠是否已經開始創建Bean了
        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;
                removeManualSingletonName(beanName);
            }
        }
        else {
            
            // 放入到bean工廠的bean定義的Map集合中
            this.beanDefinitionMap.put(beanName, beanDefinition);
            // 添加beanName 到 名稱集合中
            this.beanDefinitionNames.add(beanName);
            // 刪除手動單例名稱
            removeManualSingletonName(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }

    if (existingDefinition != null || containsSingleton(beanName)) {
        // 重置Bean定義
        resetBeanDefinition(beanName);
    }