SpringBoot Bean 扫描注册核心之：ConfigurationClassPostProcessor 详解

（SpringBoot 版本：2.2.2.RELEASE）

可以说 @Configuration 是 SpringBoot 配置的基石，自然 @Configuration 类的处理是很有必要研究的。

@Configuration 类的处理是由 ConfigurationClassPostProcessor 来处理的。

以如下工程结构来分析：

问题驱动：

ServiceA 在按条件加载时（@ConditionalOnBean）有时生效，有时不生效，为了研究原因，新建了如上一个简单工程来模拟场景。其中 Config1,Config3,Config4,Config5 都是 @Import 进来的，ServiceB 以 @Bean 的方式定义在 Config4 中，Config6, ServiceC 都是由 Config5 上的 @ComponentScan("com.kvn.other2") 加载的

得到如下结果：

//@ConditionalOnBean(Config1.class)
//@ConditionalOnBean(Config2.class) // 在 PlainApplication 所在的包（或子包）下面的 bean，可以正常使用 @ConditionalOnBean
//@ConditionalOnBean(Config3.class)
//@ConditionalOnBean(ServiceB.class)
//@ConditionalOnBean(ServiceC.class)  // 在 PlainApplication 所在的包外面，只有 @ComponentScan 这种方式是可以的
//@ConditionalOnBean(Config5.class)
@ConditionalOnBean(Config6.class) // 在 PlainApplication 所在的包外面，只有 @ComponentScan 这种方式是可以的
// 有一点是值得注意的：即使 @ComponentScan 扫描 Config5 类自身，@ConditionalOnBean(Config5.class) 条件也为失败
// 但是其他 @Configuration 类做为条件是可以的
@Service
public class ServiceA {
......
}

// 处理 @Configuration 类的导入，将 bean 注册到容器中
org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
    String[] candidateNames = registry.getBeanDefinitionNames();

    // 1. 检索所有的配置类
    for (String beanName : candidateNames) {
        BeanDefinition beanDef = registry.getBeanDefinition(beanName);
        if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
            if (logger.isDebugEnabled()) {
                logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
            }
        }
        else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
        }
    }

    // Return immediately if no @Configuration classes were found
    if (configCandidates.isEmpty()) {
        return;
    }

    // Sort by previously determined @Order value, if applicable
    // 2. 对所有的配置类进行排序。（按 @Order 的顺序排，@Configuration 类的顺序决定了后面的处理顺序）
    configCandidates.sort((bd1, bd2) -> {
        int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
        int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
        return Integer.compare(i1, i2);
    });

    // Detect any custom bean name generation strategy supplied through the enclosing application context
    SingletonBeanRegistry sbr = null;
    if (registry instanceof SingletonBeanRegistry) {
        sbr = (SingletonBeanRegistry) registry;
        if (!this.localBeanNameGeneratorSet) {
            BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
                    AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
            if (generator != null) {
                this.componentScanBeanNameGenerator = generator;
                this.importBeanNameGenerator = generator;
            }
        }
    }

    if (this.environment == null) {
        this.environment = new StandardEnvironment();
    }

    // Parse each @Configuration class
    ConfigurationClassParser parser = new ConfigurationClassParser(
            this.metadataReaderFactory, this.problemReporter, this.environment,
            this.resourceLoader, this.componentScanBeanNameGenerator, registry);

    Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
    Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
    do {
        // 3. 解析所有的配置类，其中包括 @PropertySource、@ComponentScan、@Import、@ImportResource、@Bean 等的处理，这些 bean 全部都会被封装成一个 ConfigurationClass 实例，包括普通 bean 和 @Configuration 标记的类
        // 需要注意的是，SpringBoot 的启动类（这里指：PlainApplication）是最先开始解析的
        // 特别需要注意的是：@ComponentScan 扫描出来的 bean 会在这一步中优先注册到容器中（DefaultListableBeanFactory#beanDefinitionMap）
        // 有些 bean (比如：serviceA)是带条件注册的（指：@ConditionalOnXxx），比如条件是 @ConditionalOnBean(x.y)，则有可能达不到预期
        // 达不到预期的场景：x.y 这个 bean 不是 @ComponentScan 扫描出来的 bean，而是通过 @Import、@ImportResource、@Bean 等方式产生的，则 serviceA 不会被注册到容器中。
        // 那么，如何修正或者规避这类问题呢？答案是将 x.y 这个 bean 使用 @ComponentScan 的方式扫描进行注册
        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());
        }
        // 4. 将所有的 ConfigurationClass 实例时行加载，即将定义的 bean 注册到容器中
        // a. 判断是否要 skip
        // b. 处理 import 导入的 @Configuration 类，将它注册到容器中。beanName 默认为类的全限定名，如：com.kvn.other.Config1
        // c. 将 ConfigurationClass 中的 BeanMethod 类型的 bean（即 @Bean 标记的方法）注册到容器中
        // d. 将 @ImportResources 中的 bean 注册到容器中
        // e. 注册 ImportBeanDefinitionRegistrar 接口中手动注册的 bean
        this.reader.loadBeanDefinitions(configClasses);
        alreadyParsed.addAll(configClasses);

        candidates.clear();
        if (registry.getBeanDefinitionCount() > candidateNames.length) {
            String[] newCandidateNames = registry.getBeanDefinitionNames();
            Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
            Set<String> alreadyParsedClasses = new HashSet<>();
            for (ConfigurationClass configurationClass : alreadyParsed) {
                alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
            }
            for (String candidateName : newCandidateNames) {
                if (!oldCandidateNames.contains(candidateName)) {
                    BeanDefinition bd = registry.getBeanDefinition(candidateName);
                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
                            !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                        candidates.add(new BeanDefinitionHolder(bd, candidateName));
                    }
                }
            }
            candidateNames = newCandidateNames;
        }
    }
    while (!candidates.isEmpty());

    // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
    if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
        sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
    }

    ......
}

3. org.springframework.context.annotation.ConfigurationClassParser#parse(Set<BeanDefinitionHolder> configCandidates) // 最先处理 PlainApplication，它本身就是一个 @Configuration class
    3.1 org.springframework.context.annotation.ConfigurationClassParser#parse(..., String beanName)
        3.1.1 org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass()  // 处理 @PropertySource -> @ComponentScan -> @Import -> @ImportResource -> @Bean -> 处理 Java 8+ ConfigurationClass 实现的接口上的 @Bean -> 处理 supper class
            3.1.1.1 org.springframework.beans.factory.support.DefaultListableBeanFactory#registerBeanDefinition // 注册 @ComponentScan 扫描出来的 bean，即 PlainApplication 所在的包（com.kvn.boot）及子包下的 bean
    3.2 org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorHandler#process() // 迟延导入选择器处理，导入通过 PlainApplication 扫描出来的 @Configuration Class
        3.2.1 org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGroupingHandler#processGroupImports()
            3.2.1.1 处理 ImportSelector 
            3.2.1.2 处理 ImportBeanDefinitionRegistrar
            3.2.1.3 其他情况，按照 @Configuration 来处理
                3.2.1.3.1 org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass // 回到 3.1.1 的处理

3. org.springframework.context.annotation.ConfigurationClassParser#parse(Set<BeanDefinitionHolder> configCandidates)

public void parse(Set<BeanDefinitionHolder> configCandidates) {
    for (BeanDefinitionHolder holder : configCandidates) {
        BeanDefinition bd = holder.getBeanDefinition();
        try {
            if (bd instanceof AnnotatedBeanDefinition) {
                parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
            }
            else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
                parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
            }
            else {
                parse(bd.getBeanClassName(), holder.getBeanName());
            }
        }
        catch (BeanDefinitionStoreException ex) {
            throw ex;
        }
        catch (Throwable ex) {
            throw new BeanDefinitionStoreException(
                    "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
        }
    }
    
    // 迟延导入选择器处理程序，导入 PlainApplication 扫描出来的 Configuration Class
    this.deferredImportSelectorHandler.process();
}

3.1.1 org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass()

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
        throws IOException {

    if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
        // Recursively process any member (nested) classes first
        processMemberClasses(configClass, sourceClass);
    }

    // Process any @PropertySource annotations
    // 处理 @PropertySource
    for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
            sourceClass.getMetadata(), PropertySources.class,
            org.springframework.context.annotation.PropertySource.class)) {
        if (this.environment instanceof ConfigurableEnvironment) {
            processPropertySource(propertySource);
        }
        else {
            logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
                    "]. Reason: Environment must implement ConfigurableEnvironment");
        }
    }

    // Process any @ComponentScan annotations
    // 处理 @ComponentScan。@ComponentScan 扫描出来的 bean 会优先注册到容器中。
    // 此时，扫描出来的 bean 如果使用条件加载的方式（即：@ConditionalOnXxx）进行注册，则有可能达不到预期。（原因见上面）
    Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
            sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
    if (!componentScans.isEmpty() &&
            !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
        for (AnnotationAttributes componentScan : componentScans) {
            // The config class is annotated with @ComponentScan -> perform the scan immediately
            // 立马执行 scan 扫描
            Set<BeanDefinitionHolder> scannedBeanDefinitions =
                    this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
            // Check the set of scanned definitions for any further config classes and parse recursively if needed
            for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                if (bdCand == null) {
                    bdCand = holder.getBeanDefinition();
                }
                if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                    // @ComponentScan 扫描出来的 bean 最先注册到容器中
                    parse(bdCand.getBeanClassName(), holder.getBeanName());
                }
            }
        }
    }

    // Process any @Import annotations
    // 处理 @Import
    processImports(configClass, sourceClass, getImports(sourceClass), true);

    // Process any @ImportResource annotations
    // 处理 @ImportResource
    AnnotationAttributes importResource =
            AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
    if (importResource != null) {
        String[] resources = importResource.getStringArray("locations");
        Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
        for (String resource : resources) {
            String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
            configClass.addImportedResource(resolvedResource, readerClass);
        }
    }

    // Process individual @Bean methods
    // 处理 @Bean
    Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
    for (MethodMetadata methodMetadata : beanMethods) {
        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    }

    // Process default methods on interfaces
    // 处理接口中的 @Bean 方法（Java 8+ 支持接口使用默认实现方法）
    processInterfaces(configClass, sourceClass);

    // Process superclass, if any
    // 处理父类
    if (sourceClass.getMetadata().hasSuperClass()) {
        String superclass = sourceClass.getMetadata().getSuperClassName();
        if (superclass != null && !superclass.startsWith("java") &&
                !this.knownSuperclasses.containsKey(superclass)) {
            this.knownSuperclasses.put(superclass, configClass);
            // Superclass found, return its annotation metadata and recurse
            return sourceClass.getSuperClass();
        }
    }

    // No superclass -> processing is complete
    return null;
}

4. org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitions()
     4.1 org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForConfigurationClass()

private void loadBeanDefinitionsForConfigurationClass(
        ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

    // a. 判断是否要 skip
    if (trackedConditionEvaluator.shouldSkip(configClass)) {
        String beanName = configClass.getBeanName();
        if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
            this.registry.removeBeanDefinition(beanName);
        }
        this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
        return;
    }

    // b. 处理 import 导入的 @Configuration 类，将它注册到容器中。beanName 默认为类的全限定名，如：com.kvn.other.Config1
    if (configClass.isImported()) {
        registerBeanDefinitionForImportedConfigurationClass(configClass);
    }
    // c. 将 ConfigurationClass 中的 BeanMethod 类型的 bean（即 @Bean 标记的方法）注册到容器中
    for (BeanMethod beanMethod : configClass.getBeanMethods()) {
        loadBeanDefinitionsForBeanMethod(beanMethod);
    }

    // d. 将 @ImportResources 中的 bean 注册到容器中
    loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
    // e. 注册 ImportBeanDefinitionRegistrar 接口中手动注册的 bean
    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

附：

// bean name 生成规则
1. org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan()
    1.1 org.springframework.beans.factory.support.BeanNameGenerator#generateBeanName()