@Configuration 类型的 class 需要知道的细节

@Configuration
 public class AppConfig {
    @Bean
    public MyBean myBean() {
        // instantiate, configure and return bean ...
    }
}

PostProcessorRegistrationDelegate class
public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    ···
    // Invoke BeanDefinitionRegistryPostProcessors first, if any.
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        List currentRegistryProcessors = new ArrayList<>();

        // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); // (1)
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); // (2)
            }
        }
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        // 将@Configuration类生成BeanDefinition，此时的BeanDefinition.beanClass为原类class对象
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); // (3)

        // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
        // 将(3)处的BeanDefinition.beanClass赋值为proxy代理类
        nvokeBeanFactoryPostProcessors(registryProcessors, beanFactory);(4)
    }
    ···
}

PostProcessorRegistrationDelegate class
private static void invokeBeanDefinitionRegistryPostProcessors(
        Collection postProcessors, BeanDefinitionRegistry registry) {
    for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
        postProcessor.postProcessBeanDefinitionRegistry(registry);
    }
}

ConfigurationClassPostProcessor class
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    processConfigBeanDefinitions(registry);
}

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

    for (String beanName : candidateNames) {
        BeanDefinition beanDef = registry.getBeanDefinition(beanName);
        if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)){
            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));//(1)
        }
    }
    ··· 排序等
s
    // Parse each @Configuration class
    ConfigurationClassParser parser = new ConfigurationClassParser(
            this.metadataReaderFactory, this.problemReporter, this.environment,
            this.resourceLoader, this.componentScanBeanNameGenerator, registry);

    Set candidates = new LinkedHashSet<>(configCandidates);
    Set alreadyParsed = new HashSet<>(configCandidates.size());
    do {
        parser.parse(candidates); //(2)
        parser.validate();

        Set configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());

        // Read the model and create bean definitions based on its content
        this.reader = new ConfigurationClassBeanDefinitionReader(
                registry, this.sourceExtractor, this.resourceLoader, this.environment,
                this.importBeanNameGenerator, parser.getImportRegistry());

        this.reader.loadBeanDefinitions(configClasses); //(3)

    }
    while (!candidates.isEmpty());

    ··· ···
}

ConfigurationClassParser class
public void parse(Set configCandidates) {
    for (BeanDefinitionHolder holder : configCandidates) {
        BeanDefinition bd = holder.getBeanDefinition();
        if (bd instanceof AnnotatedBeanDefinition) {
            parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
        }
        ...
    }

    this.deferredImportSelectorHandler.process();
}

protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
    processConfigurationClass(new ConfigurationClass(metadata, beanName));
}

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
    // 评估标识@Configuration的类是否满足条件去加载，这是条件注解@ConditionalXXX起的作用
    // 实际开发中，我们可以依据这个功能实现灵活的加载配置(如让谁加载进来，不让谁加载进来^_^)
    if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
        return;
    }

    // Recursively process the configuration class and its superclass hierarchy.
    SourceClass sourceClass = asSourceClass(configClass);
    do {
        sourceClass = doProcessConfigurationClass(configClass, sourceClass);
    }
    while (sourceClass != null);

    // 所有加载的@Configuration类都会转为ConfigurationClass放入这个map中
    this.configurationClasses.put(configClass, configClass);
}

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass){
    // 为了集中说明意图，隐藏了代码
    // Recursively process any member (nested) classes first
    // Process any @PropertySource annotations
    // Process any @ComponentScan annotations
    for (AnnotationAttributes componentScan : componentScans) {
        for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
            if () {
                // 进入递归调用
                parse(bdCand.getBeanClassName(), holder.getBeanName());
            }
        }
    }

    // Process any @Import annotations
    // Process any @ImportResource annotations
    // Process individual @Bean methods
    // Process default methods on interfaces
    // Process superclass, if any
    // No superclass -> processing is complete
    return null;
}

ConfigurationClassBeanDefinitionReader class
public void loadBeanDefinitions(Set configurationModel) {
    TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
    for (ConfigurationClass configClass : configurationModel) {
        loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
    }
}

private void loadBeanDefinitionsForConfigurationClass(
        ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

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

    if (configClass.isImported()) {
        registerBeanDefinitionForImportedConfigurationClass(configClass);
    }
    for (BeanMethod beanMethod : configClass.getBeanMethods()) {
        loadBeanDefinitionsForBeanMethod(beanMethod);
    }

    loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

@Import(DispatcherServletConfiguration.class)
@ImportResource("classpath:/com/acme/database-config.xml")
protected static class DispatcherServletRegistrationConfiguration {

    @Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
    public DispatcherServletRegistrationBean dispatcherServletRegistration(){
        ...
    }
}

实现自BeanFactoryPostProcessor.postProcessBeanFactory
ConfigurationClassPostProcessor class
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 生成代理
    enhanceConfigurationClasses(beanFactory);
    beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}

ConfigurationClassPostProcessor.ConfigurationClassEnhancer class
public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
    Map configBeanDefs = new LinkedHashMap<>();
    for (String beanName : beanFactory.getBeanDefinitionNames()) {
        BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
        if (ConfigurationClassUtils.isFullConfigurationClass(beanDef)) {
            if (!(beanDef instanceof AbstractBeanDefinition)) {
                throw 
            }
            configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
        }
    }

    ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
    for (Map.Entry entry : configBeanDefs.entrySet()) {
        AbstractBeanDefinition beanDef = entry.getValue();
        // If a @Configuration class gets proxied, always proxy the target class
        beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
        // Set enhanced subclass of the user-specified bean class
        Class configClass = beanDef.resolveBeanClass(this.beanClassLoader);
        if (configClass != null) {
            Class enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
            if (configClass != enhancedClass) {
                beanDef.setBeanClass(enhancedClass);
            }
        }
    }
}

ConfigurationClassPostProcessor.ConfigurationClassEnhancer class
public Class enhance(Class configClass, @Nullable ClassLoader classLoader) {
    if (EnhancedConfiguration.class.isAssignableFrom(configClass)) {
        return configClass;
    }
    Class enhancedClass = createClass(newEnhancer(configClass, classLoader));
    return enhancedClass;
}

ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
            componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
Set beanDefinitions = scanner.doScan(StringUtils.toStringArray(basePackages));
如此两行代码就实现了加载package目录下的.class文件的功能。详见ComponentScanAnnotationParser.parse()方法

source: //yaoyuanyy.github.io/2019/12/12/springboot%20@Configuration类型的class需要知道的细节