【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);
    }