死磕Spring之IoC篇 - @Bean 等注解的实现原理

该系列文章是本人在学习 Spring 的过程中总结下来的，里面涉及到相关源码，可能对读者不太友好，请结合我的源码注释 Spring 源码分析 GitHub 地址进行阅读

Spring 版本：5.1.14.RELEASE

开始阅读这一系列文章之前，建议先查看《深入了解 Spring IoC（面试题）》这一篇文章

该系列其他文章请查看：《死磕 Spring 之 IoC 篇 - 文章导读》

@Bean 等注解的实现原理

通过前面的一系列文章我们了解到 @Component 注解（及其派生注解）标注的 Class 类都会被解析成 BeanDefinition（Bean 的“前身”），然后会被初始化成 Bean 对象。那么 @Bean 注解不是 @Component 的派生注解，且用于标注方法，该注解的解析过程在前面的文章中没有提到，那么在 Spring 中是如何解析 @Bean 注解的呢？

可以先回顾一下《Spring 应用上下文 ApplicationContext》文章“BeanFactory 后置处理阶段”的小节中讲到，在创建好 BeanFactory 后会调用所有的 BeanFactoryPostProcessor 处理器对其进行后置处理。@Bean 注解就是在这个过程被解析的，解析过程大致就是遍历所有的 BeanDefinition，如果其内部包含 @Bean 标注的注解，则会将该方法解析出一个 BeanDefinition 对象并注册。当然，除了 @Bean 注解外，例如 @ComponentScan、@Import、@ImportResource、@PropertySource 注解都是在该过程中进行解析的。那么接下来将分析整个的解析过程，入口在 ConfigurationClassPostProcessor 这个处理器中。

概览

主要涉及以下几个类：

org.springframework.context.annotation.ConfigurationClassPostProcessor，处理 Spring 应用上下文中的配置类，解析 @Bean 等注解，并进行 CGLIB 提升
org.springframework.context.annotation.ConfigurationClass，根据前面提到的配置类解析出来的对象，包含各种注解的信息，例如 @Bean、@Import
org.springframework.context.annotation.ConfigurationClassParser，解析配置类，生成 ConfigurationClass 对象并保存
org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader，配置类中 BeanDefinition 的读取器，根据 ConfigurationClass 解析出 BeanDefinition 并注册

配置类：带有 @Configuration 注解的类，如果这个类带有 @Component | @ComponentScan | @Import | @ImportSource 注解，或者内部存在 @Bean 的方法都算配置类

几个关键处理器的注册

处理器

关键的处理器：

ConfigurationClassPostProcessor：处理 Spring 应用上下文中的配置类，解析 @Bean 等注解，并进行 CGLIB 提升
AutowiredAnnotationBeanPostProcessor：解析 @Autowired 和 @Value 注解标注的属性，获取对应属性值，进行依赖注入
CommonAnnotationBeanPostProcessor：会解析 @Resource 注解标注的属性，获取对应的属性值，进行依赖注入
EventListenerMethodProcessor：解析 @EventListener 注解标注的方法，会将其解析成 Spring 事件监听器并注册
DefaultEventListenerFactory：帮助 EventListenerMethodProcessor 将 @EventListener 注解标注的方法生成事件监听器

注册过程

在《BeanDefinition 的解析过程（面向注解）》文章中讲到，如果在 XML 配置文件中配置了 <context:component-scan /> 标签，会通过 ClassPathBeanDefinitionScanner 扫描器进行解析；在《Spring 应用上下文 ApplicationContext》文章的“BeanFactory 创建阶段”小节中讲到，支持注解配置的 Spring 应用上下文会通过 ClassPathBeanDefinitionScanner 扫描器进行扫描。

在 ClassPathBeanDefinitionScanner 的扫描过程中会调用 AnnotationConfigUtils#registerAnnotationConfigProcessors(BeanDefinitionRegistry) 方法，如下：

public int scan(String... basePackages) {

    // <1> 获取扫描前的 BeanDefinition 数量

    int beanCountAtScanStart = this.registry.getBeanDefinitionCount();

    // <2> 进行扫描，将过滤出来的所有的 .class 文件生成对应的 BeanDefinition 并注册

    doScan(basePackages);

    // Register annotation config processors, if necessary.

    // <3> 如果 `includeAnnotationConfig` 为 `true`（默认），则注册几个关于注解的 PostProcessor 处理器（关键）

    // 在其他地方也会注册，内部会进行判断，已注册的处理器不会再注册

    if (this.includeAnnotationConfig) {

        AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

    }

    // <4> 返回本次扫描注册的 BeanDefinition 数量

    return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);

}

我们再来看到 AnnotationConfigUtils 的这个方法，如下：

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {

    registerAnnotationConfigProcessors(registry, null);

}

/**

 * Register all relevant annotation post processors in the given registry.

 * @param registry the registry to operate on

 * @param source the configuration source element (already extracted)

 * that this registration was triggered from. May be {@code null}.

 * @return a Set of BeanDefinitionHolders, containing all bean definitions

 * that have actually been registered by this call

 */

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(

        BeanDefinitionRegistry registry, @Nullable Object source) {

    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);

    if (beanFactory != null) {

        if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {

            beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);

        }

        if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {

            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());

        }

    }

    Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

    // 处理 Spring 应用上下文中的配置类

    if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {

        RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);

        def.setSource(source);

        beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));

    }

    // 处理 @Autowired 以及 @Value 注解

    if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {

        RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);

        def.setSource(source);

        beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));

    }

    // （条件激活）处理 JSR-250 注解 @Resource，如 @PostConstruct、@PreDestroy 等

    // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.

    if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {

        RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);

        def.setSource(source);

        beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));

    }

    // Processor 对象（条件激活）处理 JPA 注解场景

    // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.

    if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {

        RootBeanDefinition def = new RootBeanDefinition();

        try {

            def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,

                    AnnotationConfigUtils.class.getClassLoader()));

        }

        catch (ClassNotFoundException ex) {

            throw new IllegalStateException(

                    "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);

        }

        def.setSource(source);

        beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));

    }

    // 处理标注 @EventListener 的 Spring 事件监听方法

    if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {

        RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);

        def.setSource(source);

        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));

    }

    // 用于 @EventListener 标注的事件监听方法构建成 ApplicationListener 对象

    if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {

        RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);

        def.setSource(source);

        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));

    }

    return beanDefs;

}

private static BeanDefinitionHolder registerPostProcessor(

        BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

    definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

    registry.registerBeanDefinition(beanName, definition);

    return new BeanDefinitionHolder(definition, beanName);

}

整个过程就是将上面“处理器”小节中讲到的几个处理器进行注册

ConfigurationClassPostProcessor

org.springframework.context.annotation.ConfigurationClassPostProcessor，BeanDefinitionRegistryPostProcessor 处理器，解析配置类

构造方法

public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,

		PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {

	private static final String IMPORT_REGISTRY_BEAN_NAME =

			ConfigurationClassPostProcessor.class.getName() + ".importRegistry";

	private SourceExtractor sourceExtractor = new PassThroughSourceExtractor();

	private ProblemReporter problemReporter = new FailFastProblemReporter();

	@Nullable

	private Environment environment;

	private ResourceLoader resourceLoader = new DefaultResourceLoader();

	@Nullable

	private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();

	private MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory();

	private boolean setMetadataReaderFactoryCalled = false;

    /** 已处理过的 BeanDefinitionRegistry 的 ID */

	private final Set<Integer> registriesPostProcessed = new HashSet<>();

    /** 已处理过的 ConfigurableListableBeanFactory 的 ID */

	private final Set<Integer> factoriesPostProcessed = new HashSet<>();

    /** 用于扫描出 ConfigurationClass 中的 BeanDefinition 并注册 */

	@Nullable

	private ConfigurationClassBeanDefinitionReader reader;

	private boolean localBeanNameGeneratorSet = false;

	/* Using short class names as default bean names */

	private BeanNameGenerator componentScanBeanNameGenerator = new AnnotationBeanNameGenerator();

}

实现了 BeanDefinitionRegistryPostProcessor 接口（继承了 BeanFactoryPostProcessor 接口）

在《Spring 应用上下文 ApplicationContext》文章“BeanFactory 后置处理阶段”的小节可以知道，BeanDefinitionRegistryPostProcessor 优先于 BeanFactoryPostProcessor，所以我们先来看到前者的实现

1. postProcessBeanDefinitionRegistry 方法

postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) 方法，对 BeanDefinitionRegistry 的后置处理，其实这个入参就是 DefaultListableBeanFactory，如下：

@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);

    }

    // 保证不被二次处理

    this.registriesPostProcessed.add(registryId);

    // 处理**配置类**

    processConfigBeanDefinitions(registry);

}

使用 registry 的哈希值作为 ID 保存在 registriesPostProcessed，保证同一个 BeanDefinitionRegistry 不会被重复处理，最后调用 processConfigBeanDefinitions(BeanDefinitionRegistry) 方法

2. processConfigBeanDefinitions 方法

processConfigBeanDefinitions(BeanDefinitionRegistry) 方法，处理配置类（过程有点长），如下：

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {

    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();

    // <1> 获取已有的 BeanDefinition 名称的集合

    String[] candidateNames = registry.getBeanDefinitionNames();

    // <2> 找出是**配置类**的 BeanDefinition 对象们

    for (String beanName : candidateNames) {

        BeanDefinition beanDef = registry.getBeanDefinition(beanName);

        // 判断是否已经处理过，已处理则不再处理，保证不被二次处理

        if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||

                ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {

            if (logger.isDebugEnabled()) {

                logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);

            }

        }

        // 检查是否带有 @Configuration 注解，设置 isFullConfigurationClass

        // 或者带有 @Component | @ComponentScan | @Import | @ImportSource | 内部存在 @Bean 的方法，设置为 isLiteConfigurationClass

        // 符合上面其中一个条件都算**配置类**，需要进行处理

        else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {

            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));

        }

    }

    // Return immediately if no @Configuration classes were found

    // <3> 没有需要处理的**配置类**则直接 `return`

    if (configCandidates.isEmpty()) {

        return;

    }

    // Sort by previously determined @Order value, if applicable

    // <4> 根据 @Order 注解进行排序

    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) {

            // 探测名称为 org.springframework.context.annotation.internalConfigurationBeanNameGenerator 的自定义 Bean 名称生成器

            BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(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

    // <5> 创建一个 `ConfigurationClassParser` 对象，用于解析符合条件的**配置类**

    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 {

        /**

         * <5.1>

         * 对所有的**配置类**进行解析，解析其内部的注解（@PropertySource、@ComponentScan、@Import、@ImportResource、@Bean）

         * 每个**配置类**会生成一个 {@link ConfigurationClass} 对象

         * 其中 @Bean 标注的方法转换成 {@link BeanMethod} 对象保存在 {@link ConfigurationClass#beanMethods} 集合中

         */

        parser.parse(candidates);

        /**

         * <5.2>

         * 对所有的 {@link ConfigurationClass} 对象进行校验

         * Class 对象不能被 final 修饰，@Bean 标注的方法不能被 private 修饰

         */

        parser.validate();

        // <5.3> 获取解析出来的 ConfigurationClass 们，并移除已经处理过的对象

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

        configClasses.removeAll(alreadyParsed);

        // Read the model and create bean definitions based on its content

        /*

         * <5.4>

         * 创建一个 ConfigurationClassBeanDefinitionReader 对象，用于扫描出 ConfigurationClass 中的 BeanDefinition 并注册

         * 例如 @Bean 标注的方法需要注册、@ImportResource 注解配置的资源文件中配置的 Bean 需要注册

         */

        if (this.reader == null) {

            this.reader = new ConfigurationClassBeanDefinitionReader(

                    registry, this.sourceExtractor, this.resourceLoader, this.environment,

                    this.importBeanNameGenerator, parser.getImportRegistry());

        }

        /*

         * <5.4.1>

         * 扫描所有的 ConfigurationClass，注册相应的 BeanDefinition，主要有以下来源：

         * 1. @Import 注解导入对象

         * 2. 其内部定义的带有 @Bean 注解的方法

         * 3. @ImportResource 注解导入资源

         * 4. @Import 注解导入的 ImportBeanDefinitionRegistrar 接口的实现类可自定义实现注册相关 BeanDefinition

         */

        this.reader.loadBeanDefinitions(configClasses);

        // <5.5> 将这些 ConfigurationClass 保存至已解析的集合中

        alreadyParsed.addAll(configClasses);

        candidates.clear();

        /*

         * <6>

         * 从上述过程注册的 BeanDefinition 中，找到没有还解析过的 BeanDefinition 们，再循环解析

         * 例如 @Bean 标注的方法是新注册的 BeanDefinition，也可能是一个**配置类**，但是还没有被这里解析过

         */

        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());

    }

    if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {

        // Clear cache in externally provided MetadataReaderFactory; this is a no-op

        // for a shared cache since it'll be cleared by the ApplicationContext.

        // <7> 清理上述解析过程中产生的元数据缓存

        ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();

    }

}

过程如下：

获取所有的 BeanDefinition 名称的集合
找出是配置类的 BeanDefinition 对象们，保存至 configCandidates 集合中
- 判断是否已经处理过，已处理则不再处理，保证不被二次处理，否则
- 检查是否带有 @Configuration 注解，或者带有 @Component | @ComponentScan | @Import | @ImportSource | 内部存在 @Bean 的方法，符合前面其中一个条件都算配置类，需要进行处理
上一步没有找到需要处理的配置类，则直接 return 返回
根据 @Order 注解对 configCandidates 集合中的配置类进行排序

创建一个 ConfigurationClassParser 对象，用于解析符合条件的配置类，会先生成 ConfigurationClass 对象保存至其内部，然后通过 ConfigurationClassBeanDefinitionReader 读取器从这些 ConfigurationClass 对象中解析出 BeanDefinition
1. 【核心】对所有的配置类进行解析，调用 ConfigurationClassParser#parse(Set<BeanDefinitionHolder>) 方法，解析其内部的注解（@PropertySource、@ComponentScan、@Import、@ImportResource、@Bean）。每个配置类会生成一个 ConfigurationClass 对象，其中 @Bean 标注的方法转换成 BeanMethod 对象保存在 ConfigurationClass.beanMethods 集合中
2. 对所有的 ConfigurationClass 对象进行校验：Class 对象不能被 final 修饰，@Bean 标注的方法不能被 private 修饰
3. 获取上面解析出来的 ConfigurationClass 们，放入 configClasses 集合中，并移除已经处理过的对象
4. 创建一个 ConfigurationClassBeanDefinitionReader 对象，调用其 loadBeanDefinitions(Set<ConfigurationClass>) 方法，扫描出 ConfigurationClass 中的 BeanDefinition 并注册。例如 @Bean 标注的方法需要注册、@ImportResource 注解配置的资源文件中配置的 Bean 需要注册
  1. 【核心】扫描所有的 ConfigurationClass，注册相应的 BeanDefinition，主要有以下来源：
    - @Import 注解导入对象
    - 其内部定义的带有 @Bean 注解的方法
    - @ImportResource 注解导入资源
    - @Import 注解导入的 ImportBeanDefinitionRegistrar 接口的实现类可自定义实现注册相关 BeanDefinition
5. 将这些 ConfigurationClass 保存至 alreadyParsed 已解析的集合中
从上述过程注册的 BeanDefinition 中，找到没有还解析过的 BeanDefinition 们，再循环解析。例如 @Bean 标注的方法是新注册的 BeanDefinition，也可能又是一个配置类，但是还没有被这里解析过，所以需要再次扫描，如果还有未处理的配置类则需要进行处理
清理上述解析过程中产生的元数据缓存，例如通过 ASM 从 .class 文件中获取到的 Class 信息，需要清理

总结：先根据配置类生成 ConfigurationClass 对象，然后根据该对象解析出 BeanDefinition 并注册

配置类：带有 @Configuration 注解的类，如果这个类带有 @Component | @ComponentScan | @Import | @ImportSource 注解，或者内部存在 @Bean 的方法都算配置类

上面的第 5.1 和 5.4 分别对应 ConfigurationClassParser 和 ConfigurationClassBeanDefinitionReader 两个类，接下来会依次分析

3. postProcessBeanFactory 方法

postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 方法，对 ConfigurableListableBeanFactory 的后置处理，其实这个入参就是 DefaultListableBeanFactory，和 postProcessBeanDefinitionRegistry(BeanDefinitionRegistry) 方法是同一个入参，如下：

@Override

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {

    int factoryId = System.identityHashCode(beanFactory);

    if (this.factoriesPostProcessed.contains(factoryId)) {

        throw new IllegalStateException(

                "postProcessBeanFactory already called on this post-processor against " + beanFactory);

    }

    this.factoriesPostProcessed.add(factoryId);

    if (!this.registriesPostProcessed.contains(factoryId)) {

        // BeanDefinitionRegistryPostProcessor hook apparently not supported...

        // Simply call processConfigurationClasses lazily at this point then.

        processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);

    }

    // CGLIB 提升

    enhanceConfigurationClasses(beanFactory);

    beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));

}

如果这个 DefaultListableBeanFactory 没有处理过，这里会和上面的过程一样调用 processConfigBeanDefinitions(BeanDefinitionRegistry) 方法进行处理。接下来，会调用 enhanceConfigurationClasses(ConfigurableListableBeanFactory) 方法对 @Configuration 注解的配置类进行 CGLIB 提升，主要帮助实现 AOP 特性

4. enhanceConfigurationClasses 方法

enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) 方法，对 @Configuration 注解的配置类进行 CGLIB 提升，如下：

public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {

    Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();

    for (String beanName : beanFactory.getBeanDefinitionNames()) {

        BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);

        /*

         * 如果配置了 @Configuration 注解

         */

        if (ConfigurationClassUtils.isFullConfigurationClass(beanDef)) {

            /*

             * 如果不是 AbstractBeanDefinition（Spring 内部 BeanDefinition 实现类都是它的子类），则抛出异常

             */

            if (!(beanDef instanceof AbstractBeanDefinition)) {

                throw new BeanDefinitionStoreException("Cannot enhance @Configuration bean definition '" +

                        beanName + "' since it is not stored in an AbstractBeanDefinition subclass");

            }

            /*

             * 如果这个 Bean 已经初始化了

             */

            else if (logger.isInfoEnabled() && beanFactory.containsSingleton(beanName)) {

                logger.info("Cannot enhance @Configuration bean definition '" + beanName +

                        "' since its singleton instance has been created too early. The typical cause " +

                        "is a non-static @Bean method with a BeanDefinitionRegistryPostProcessor " +

                        "return type: Consider declaring such methods as 'static'.");

            }

            configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);

        }

    }

    if (configBeanDefs.isEmpty()) {

        // nothing to enhance -> return immediately

        /*

         * 没有需要 CGLIB 提升的类则直接返回

         */

        return;

    }

    ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();

    for (Map.Entry<String, AbstractBeanDefinition> 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);

        try {

            // Set enhanced subclass of the user-specified bean class

            // 通过类加载器获取这个 BeanDefinition 的 Class 对象

            Class<?> configClass = beanDef.resolveBeanClass(this.beanClassLoader);

            if (configClass != null) {

                // 通过 CGLIB 创建一个子类（代理类）

                Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);

                if (configClass != enhancedClass) {

                    if (logger.isTraceEnabled()) {

                        logger.trace(String.format("Replacing bean definition '%s' existing class '%s' with " +

                                "enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName()));

                    }

                    // 设置该 BeanDefinition 的 Class 对象为 CGLIB 子类（代理类），用于帮助实现 AOP 特性

                    beanDef.setBeanClass(enhancedClass);

                }

            }

        }

        catch (Throwable ex) {

            throw new IllegalStateException("Cannot load configuration class: " + beanDef.getBeanClassName(), ex);

        }

    }

}

整个过程大致就是：如果是 @Configuration 注解标注的类，则通过 CGLIB 创建一个子类（代理类）并设置到这个 BeanDefinition 的 beanClass 属性中。这样一来， @Configuration 注解标注的类就得到了 CGLIB 的提升，主要帮助实现 AOP 相关特性，这里不做详细展述，具体过程请期待后续的 Spring AOP 相关文章

ConfigurationClass

org.springframework.context.annotation.ConfigurationClass，根据前面提到的配置类解析出来的对象，如下：

final class ConfigurationClass {

	/**

	 * 元数据信息，根据通过它获取**配置类** Class 对象的所有信息

	 */

	private final AnnotationMetadata metadata;

	private final Resource resource;

	@Nullable

	private String beanName;

	/**

	 * 假如这个 Class 对象是通过 @Import 注解被导入的

	 * 那么这个集合保存的就是该 @Import 注解标注的配置类，表示谁把它导入的

	 */

	private final Set<ConfigurationClass> importedBy = new LinkedHashSet<>(1);

	/**

	 * 带有 @Bean 注解的方法集合

	 */

	private final Set<BeanMethod> beanMethods = new LinkedHashSet<>();

	/**

	 * 需要导入的资源集合

	 */

	private final Map<String, Class<? extends BeanDefinitionReader>> importedResources = new LinkedHashMap<>();

	/**

	 * {@link Import} 注解导入的 ImportBeanDefinitionRegistrar 类型的对象

	 */

	private final Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> importBeanDefinitionRegistrars = new LinkedHashMap<>();

	/**

	 * 需要跳过的 @Bean 注解的方法集合

	 */

	final Set<String> skippedBeanMethods = new HashSet<>();

	/**

	 * Create a new {@link ConfigurationClass} with the given name.

	 * @param metadataReader reader used to parse the underlying {@link Class}

	 * @param beanName must not be {@code null}

	 * @see ConfigurationClass#ConfigurationClass(Class, ConfigurationClass)

	 */

	public ConfigurationClass(MetadataReader metadataReader, String beanName) {

		Assert.notNull(beanName, "Bean name must not be null");

		this.metadata = metadataReader.getAnnotationMetadata();

		this.resource = metadataReader.getResource();

		this.beanName = beanName;

	}

    // ... 省略相关构造函数、getter、setter 方法

	public void validate(ProblemReporter problemReporter) {

		// A configuration class may not be final (CGLIB limitation)

		if (getMetadata().isAnnotated(Configuration.class.getName())) {

			if (getMetadata().isFinal()) {

				problemReporter.error(new FinalConfigurationProblem());

			}

		}

		for (BeanMethod beanMethod : this.beanMethods) {

			beanMethod.validate(problemReporter);

		}

	}

	@Override

	public boolean equals(Object other) {

		return (this == other || (other instanceof ConfigurationClass &&

				getMetadata().getClassName().equals(((ConfigurationClass) other).getMetadata().getClassName())));

	}

	@Override

	public int hashCode() {

		return getMetadata().getClassName().hashCode();

	}

}

重写了 equals 方法，是同一个 Class 对象也是相等的

ConfigurationClassParser

org.springframework.context.annotation.ConfigurationClassParser，解析配置类，生成 ConfigurationClass 对象并保存

构造方法

class ConfigurationClassParser {

	private static final PropertySourceFactory DEFAULT_PROPERTY_SOURCE_FACTORY = new DefaultPropertySourceFactory();

	private static final Comparator<DeferredImportSelectorHolder> DEFERRED_IMPORT_COMPARATOR =

			(o1, o2) -> AnnotationAwareOrderComparator.INSTANCE.compare(o1.getImportSelector(), o2.getImportSelector());

	private final MetadataReaderFactory metadataReaderFactory;

	private final ProblemReporter problemReporter;

	private final Environment environment;

	private final ResourceLoader resourceLoader;

	private final BeanDefinitionRegistry registry;

	private final ComponentScanAnnotationParser componentScanParser;

	private final ConditionEvaluator conditionEvaluator;

	/**

	 * 保存**配置类**解析出来的 ConfigurationClass 对象

	 */

	private final Map<ConfigurationClass, ConfigurationClass> configurationClasses = new LinkedHashMap<>();

	/**

	 * 保存**配置类**的父类对应的 ConfigurationClass 对象，也就是这个配置类对应的

	 */

	private final Map<String, ConfigurationClass> knownSuperclasses = new HashMap<>();

	private final List<String> propertySourceNames = new ArrayList<>();

	private final ImportStack importStack = new ImportStack();

	private final DeferredImportSelectorHandler deferredImportSelectorHandler = new DeferredImportSelectorHandler();

	public ConfigurationClassParser(MetadataReaderFactory metadataReaderFactory,

			ProblemReporter problemReporter, Environment environment, ResourceLoader resourceLoader,

			BeanNameGenerator componentScanBeanNameGenerator, BeanDefinitionRegistry registry) {

		this.metadataReaderFactory = metadataReaderFactory;

		this.problemReporter = problemReporter;

		this.environment = environment;

		this.resourceLoader = resourceLoader;

		this.registry = registry;

		this.componentScanParser = new ComponentScanAnnotationParser(

				environment, resourceLoader, componentScanBeanNameGenerator, registry);

		this.conditionEvaluator = new ConditionEvaluator(registry, environment, resourceLoader);

	}

}

1. parse 方法

parse(Set<BeanDefinitionHolder> configCandidates) 方法，对这些配置类进行解析，如下：

public void parse(Set<BeanDefinitionHolder> configCandidates) {

    // 遍历所有的 BeanDefinition

    for (BeanDefinitionHolder holder : configCandidates) {

        BeanDefinition bd = holder.getBeanDefinition();

        try {

            if (bd instanceof AnnotatedBeanDefinition) {

                // 解析，生成的 ConfigurationClass 对象保存在 `configurationClasses` 集合中

                parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());

            }

            else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {

                // 解析，生成的 ConfigurationClass 对象保存在 `configurationClasses` 集合中

                parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());

            }

            else {

                // 解析，生成的 ConfigurationClass 对象保存在 `configurationClasses` 集合中

                parse(bd.getBeanClassName(), holder.getBeanName());

            }

        }

        catch (BeanDefinitionStoreException ex) {

            throw ex;

        }

        catch (Throwable ex) {

            throw new BeanDefinitionStoreException(

                    "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);

        }

    }

    this.deferredImportSelectorHandler.process();

}

遍历这些配置类，调用 parse(...) 不同的重载方法进行解析，如下：

protected final void parse(@Nullable String className, String beanName) throws IOException {

    Assert.notNull(className, "No bean class name for configuration class bean definition");

    MetadataReader reader = this.metadataReaderFactory.getMetadataReader(className);

    processConfigurationClass(new ConfigurationClass(reader, beanName));

}

protected final void parse(Class<?> clazz, String beanName) throws IOException {

    processConfigurationClass(new ConfigurationClass(clazz, beanName));

}

protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {

    processConfigurationClass(new ConfigurationClass(metadata, beanName));

}

先为这个 配置类 创建一个 ConfigurationClass 对象，然后再调用 processConfigurationClass(ConfigurationClass) 方法进行解析

2. processConfigurationClass 方法

processConfigurationClass(ConfigurationClass configClass) 方法，解析配置类，所有信息都保存在这个 ConfigurationClass 中，如下：

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {

    // @Conditional 的处理，是否需要跳过

    if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {

        return;

    }

    ConfigurationClass existingClass = this.configurationClasses.get(configClass);

    if (existingClass != null) {

        if (configClass.isImported()) {

            if (existingClass.isImported()) {

                existingClass.mergeImportedBy(configClass);

            }

            // Otherwise ignore new imported config class; existing non-imported class overrides it.

            return;

        }

        else {

            // Explicit bean definition found, probably replacing an import.

            // Let's remove the old one and go with the new one.

            this.configurationClasses.remove(configClass);

            this.knownSuperclasses.values().removeIf(configClass::equals);

        }

    }

    // Recursively process the configuration class and its superclass hierarchy.

    // 获取这个 ConfigurationClass 配置类的所在 Class 对象

    SourceClass sourceClass = asSourceClass(configClass);

    do {

        // 解析 ConfigurationClass 对象，对相关注解（@PropertySource、@ComponentScan、@Import、@ImportResource、@Bean）进行解析

        // 其中解析出带有 @Bean 注解方法保存至其中，@ImportResource 配置的资源也保存其中

        sourceClass = doProcessConfigurationClass(configClass, sourceClass);

    }

    // 父类循环解析

    while (sourceClass != null);

    // 将该 ConfigurationClass 配置类保存

    this.configurationClasses.put(configClass, configClass);

}

过程如下：

会先根据 @Conditional 注解判断是否需要跳过
调用 doProcessConfigurationClass(ConfigurationClass, SourceClass) 方法进行解析，会遍历父类
将配置类对应的 ConfigurationClass 对象保存至 configurationClasses 集合中

3. doProcessConfigurationClass 方法

doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) 方法，解析配置类，所有信息都保存在这个 ConfigurationClass 中，如下：

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)

        throws IOException {

    // <1> 先处理内部成员类

    if (configClass.getMetadata().isAnnotated(Component.class.getName())) {

        // Recursively process any member (nested) classes first

        processMemberClasses(configClass, sourceClass);

    }

    // Process any @PropertySource annotations

    // <2> 处理 @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

    // <3> 处理 @ComponentScan 注解，扫描出指定包路径下的 BeanDefinition 们

    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

            // 底层会通过 ClassPathBeanDefinitionScanner 扫描指定的包路径，注册相关 BeanDefinition 们

            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)) {

                    parse(bdCand.getBeanClassName(), holder.getBeanName());

                }

            }

        }

    }

    // Process any @Import annotations

    // <4> 处理 @Import 注解，ImportSelector 和 ImportBeanDefinitionRegistrar 类型会有相关处理

    // 注解中的 Class 对象也会生成一个 ConfigurationClass 对象，再进行处理

    // 这个对象不同的是其内部 `importedBy` 属性不为空，保存了是被谁 Import 的

    processImports(configClass, sourceClass, getImports(sourceClass), true);

    // Process any @ImportResource annotations

    // <5> 处理 @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

    // <6> 解析出所有带有 @Bean 注解的方法，通过 ASM 保证每个方法定义的顺序

    Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);

    for (MethodMetadata methodMetadata : beanMethods) {

        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));

    }

    // Process default methods on interfaces

    // <6> 解析接口中带有 @Bean 注解的默认方法

    processInterfaces(configClass, sourceClass);

    // Process superclass, if any

    // <7> 如果有父类，则返回父类，再进行解析

    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

    // <8> 已经是顶部类，表示解析完成

    return null;

}

过程大致如下：

先处理内部成员类，调用 processMemberClasses(...) 方法，如果内部成员类也是配置类，同样调用前面的 processConfigurationClass(ConfigurationClass)方法进行处理，这里不展开讲述
处理 @PropertySource 注解，加载出对应的 Resource 资源，将其添加至 Environment 环境中，这里不展开讲述
处理 @ComponentScan 注解，通过 ComponentScanAnnotationParser 扫描出指定包路径下的 BeanDefinition 们并注册，然后再遍历处理，如果是配置类，同样调用前面的 parse(...) 方法，这里不展开讲述
处理 @Import 注解中的 Class 对象，调用 processImports(...) 方法，这里不展开讲述，分为下面几种情况：
- ImportSelector 的实现类：调用其 selectImports(AnnotationMetadata) 方法获取需要导入的 Class 类名，再次调用 processImports(...) 方法进行处理
- ImportBeanDefinitionRegistrar 的实现类：将这个实现类保存在 ConfigurationClass.importBeanDefinitionRegistrars 集合中
- 否则，为 @Import 注解中的 配置类 创建 ConfigurationClass 对象，同样调用processConfigurationClass(ConfigurationClass)方法进行处理
处理 @ImportResource 注解，获取需要导入的资源配置信息，将这些配置信息添加至 ConfigurationClass.importedResources 集合中
解析出所有带有 @Bean 注解的方法，底层通过 ASM（Java 字节码操作和分析框架）进行解析，然后将这些方法封装成 BeanMethod 对象，并保存至 ConfigurationClass.beanMethods 集合中，这里不展开讲述
如果有父类，则循环进行解析

整个过程就是解析配置类中的各种注解，解析结果都保存在 ConfigurationClass 中，所以说整个过程就是为配置类生成一个 ConfigurationClass 对象，将这些信息生成对应的 BeanDefinition 对象并注册到 Spring 上下文的过程还在后面，也就是下面要讲的 ConfigurationClassBeanDefinitionReader 读取器

ConfigurationClassBeanDefinitionReader

org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader，配置类中 BeanDefinition 的读取器，根据 ConfigurationClass 解析出 BeanDefinition 并注册

1. loadBeanDefinitions 方法

loadBeanDefinitions(Set<ConfigurationClass>) 方法，从 ConfigurationClass 中加载出 BeanDefinition，如下：

public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {

    // 创建 @Conditional 注解的计算器

    TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();

    // 遍历所有的 ConfigurationClass，进行处理

    for (ConfigurationClass configClass : configurationModel) {

        loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);

    }

}

遍历所有的 ConfigurationClass 对象，调用 loadBeanDefinitionsForConfigurationClass(...) 方法

2. loadBeanDefinitionsForConfigurationClass 方法

loadBeanDefinitionsForConfigurationClass(ConfigurationClass, TrackedConditionEvaluator) 方法，从 ConfigurationClass 中加载出 BeanDefinition 并注册，如下：

private void loadBeanDefinitionsForConfigurationClass(

        ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

    // <1> 如果不符合 @Conditional 注解的条件，则跳过

    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;

    }

    // <2> 如果当前 ConfigurationClass 是通过 @Import 注解被导入的

    if (configClass.isImported()) {

        // <2.1> 根据该 ConfigurationClass 对象生成一个 BeanDefinition 并注册

        registerBeanDefinitionForImportedConfigurationClass(configClass);

    }

    // <3> 遍历当前 ConfigurationClass 中所有的 @Bean 注解标注的方法

    for (BeanMethod beanMethod : configClass.getBeanMethods()) {

        // <3.1> 根据该 BeanMethod 对象生成一个 BeanDefinition 并注册（注意这里有无 static 修饰会有不同的配置）

        loadBeanDefinitionsForBeanMethod(beanMethod);

    }

    // <4> 对 @ImportResource 注解配置的资源进行处理，对里面的配置进行解析并注册 BeanDefinition

    loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());

    // <5> 通过 @Import 注解导入的 ImportBeanDefinitionRegistrar 实现类往 BeanDefinitionRegistry 注册 BeanDefinition

    // Mybatis 集成 Spring 就是基于这个实现的，可查看 Mybatis-Spring 项目中的 MapperScannerRegistrar 这个类

    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());

}

过程大致如下：

如果不符合 @Conditional 注解的条件，则跳过

如果当前 ConfigurationClass 是通过 @Import 注解被导入的

根据该 ConfigurationClass 对象生成一个 BeanDefinition 并注册，调用 registerBeanDefinitionForImportedConfigurationClass(ConfigurationClass) 方法，如下：

private void registerBeanDefinitionForImportedConfigurationClass(ConfigurationClass configClass) {

    AnnotationMetadata metadata = configClass.getMetadata();

    // 为该 ConfigurationClass 配置类创建一个 BeanDefinition 对象

    AnnotatedGenericBeanDefinition configBeanDef = new AnnotatedGenericBeanDefinition(metadata);

    ScopeMetadata scopeMetadata = scopeMetadataResolver.resolveScopeMetadata(configBeanDef);

    configBeanDef.setScope(scopeMetadata.getScopeName());

    // 生成一个 Bean 的名称

    String configBeanName = this.importBeanNameGenerator.generateBeanName(configBeanDef, this.registry);

    // 设置一些配置信息（没有配置则会有默认值）

    AnnotationConfigUtils.processCommonDefinitionAnnotations(configBeanDef, metadata);

    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(configBeanDef, configBeanName);

    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);

    // 注册该 BeanDefinition 对象

    this.registry.registerBeanDefinition(definitionHolder.getBeanName(), definitionHolder.getBeanDefinition());

    // 设置 Bean 的名称

    configClass.setBeanName(configBeanName);

}

根据这个类的元信息生成一个 AnnotatedGenericBeanDefinition 对象，并注册

遍历当前 ConfigurationClass 中所有的 @Bean 注解标注的方法
1. 根据该 BeanMethod 对象生成一个 BeanDefinition 并注册（注意这里有无 static 修饰会有不同的配置），调用 loadBeanDefinitionsForBeanMethod(BeanMethod) 方法，在后面分析
对 @ImportResource 注解配置的资源进行处理，对里面的配置进行解析并注册 BeanDefinition，通过 XmlBeanDefinitionReader 对该配置文件进行扫描，在前面的《BeanDefinition 的加载阶段（XML 文件）》文章中已经分析过
通过 @Import 注解导入的 ImportBeanDefinitionRegistrar 实现类往 BeanDefinitionRegistry 注册 BeanDefinition，也就是调用这个实现类的 registerBeanDefinitions(AnnotationMetadata, BeanDefinitionRegistry) 方法，自定义注册 BeanDefinition

该过程会把 ConfigurationClass 中的信息解析成 BeanDefinition 并注册，其中第 5 步可参考 Mybatis 集成 Spring 的项目中的 MapperScannerRegistrar 类，可参考我的另一篇文章《精尽MyBatis源码分析 - MyBatis-Spring 源码分析》

3. loadBeanDefinitionsForBeanMethod 方法

loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) 方法，将 @Bean 注解标注的方法解析成 BeanDefinition 并注册，如下：

private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {

    ConfigurationClass configClass = beanMethod.getConfigurationClass();

    MethodMetadata metadata = beanMethod.getMetadata();

    String methodName = metadata.getMethodName();

    // Do we need to mark the bean as skipped by its condition?

    // 如果不符合 @Conditional 注解的条件，则跳过

    if (this.conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {

        configClass.skippedBeanMethods.add(methodName);

        return;

    }

    if (configClass.skippedBeanMethods.contains(methodName)) {

        return;

    }

    // 获取 @Bean 注解元信息

    AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);

    Assert.state(bean != null, "No @Bean annotation attributes");

    // Consider name and any aliases

    List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));

    String beanName = (!names.isEmpty() ? names.remove(0) : methodName);

    // Register aliases even when overridden

    for (String alias : names) {

        this.registry.registerAlias(beanName, alias);

    }

    // Has this effectively been overridden before (e.g. via XML)?

    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;

    }

    // 为该 BeanMethod 创建一个 BeanDefinition 对象

    ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata);

    beanDef.setResource(configClass.getResource());

    beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));

    /*

     * 如果该方法被 static 修饰

     * 直接设置 `beanClassName` 和 `factoryMethodName` 属性，通过这两者就可以创建当前方法 Bean 对象

     */

    if (metadata.isStatic()) {

        // static @Bean method

        beanDef.setBeanClassName(configClass.getMetadata().getClassName());

        beanDef.setFactoryMethodName(methodName);

    }

    /*

     * 否则，为内部方法

     * 这里是设置 `factoryBeanName` 和 `factoryMethodName` 属性，通过这两者就可以创建当前 Bean 对象

     * 和被 static 修饰的方法 Bean 对象不同的是，`factoryBeanName` 指定的 Bean 需要先被初始化，然后调用该方法创建当前方法 Bean 对象

     * 而被 static 修饰可以直接通过其 Class 对象调用方法，无需先初始化 Bean 对象

     */

    else {

        // instance @Bean method

        beanDef.setFactoryBeanName(configClass.getBeanName());

        beanDef.setUniqueFactoryMethodName(methodName);

    }

    // 设置注入模式为构造器注入，因为方法可能带有参数，需要注入

    beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);

    beanDef.setAttribute(org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.

            SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);

    // 设置一些配置信息（没有配置则会有默认值）

    AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);

    // 如果配置了注入模式，则覆盖上面的'构造器注入'

    Autowire autowire = bean.getEnum("autowire");

    if (autowire.isAutowire()) {

        beanDef.setAutowireMode(autowire.value());

    }

    boolean autowireCandidate = bean.getBoolean("autowireCandidate");

    if (!autowireCandidate) {

        beanDef.setAutowireCandidate(false);

    }

    // 如果配置了 `initMethod`，则设置初始化方法名称

    String initMethodName = bean.getString("initMethod");

    if (StringUtils.hasText(initMethodName)) {

        beanDef.setInitMethodName(initMethodName);

    }

    // 如果配置了 `destroyMethod`，则设置销毁方法名称

    String destroyMethodName = bean.getString("destroyMethod");

    beanDef.setDestroyMethodName(destroyMethodName);

    // Consider scoping

    // 如果配置了 @Scope 注解，则进行相关配置

    ScopedProxyMode proxyMode = ScopedProxyMode.NO;

    AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);

    if (attributes != null) {

        beanDef.setScope(attributes.getString("value"));

        proxyMode = attributes.getEnum("proxyMode");

        if (proxyMode == ScopedProxyMode.DEFAULT) {

            proxyMode = ScopedProxyMode.NO;

        }

    }

    // Replace the original bean definition with the target one, if necessary

    BeanDefinition beanDefToRegister = beanDef;

    if (proxyMode != ScopedProxyMode.NO) {

        BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy(

                new BeanDefinitionHolder(beanDef, beanName), this.registry,

                proxyMode == ScopedProxyMode.TARGET_CLASS);

        beanDefToRegister = new ConfigurationClassBeanDefinition(

                (RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata);

    }

    // 注册该 BeanDefinition 对象

    this.registry.registerBeanDefinition(beanName, beanDefToRegister);

}

整个过程并不复杂，大致如下：

如果不符合 @Conditional 注解的条件，则跳过
获取 @Bean 注解元信息
为 @Bean 标注的方法（被封装成了 BeanMethod 对象）创建一个 ConfigurationClassBeanDefinition 对象
根据注解元信息设置各种配置，例如 autowire（注入模式）、initMethod（初始化方法）、destroyMethod（销毁方法），对于 static 修饰的方法有区别，如下：
- 静态方法会设置 beanClass（Class 对象）和 factoryMethodName（方法名称），可以直接调用 Class 对象的这个方法获取 Bean
- 非静态方法需要设置 factoryBeanName（该方法所属 Bean 的名称）和 factoryMethodName（方法名称），需要先初始化这个所属 Bean，才能调用这个方法获取 Bean
注册这个 ConfigurationClassBeanDefinition 对象

总结

在 《Spring 应用上下文 ApplicationContext》中有一个“BeanFactory 后置处理阶段”，在创建好 DefaultListableBeanFactory 后会调用所有的 BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor 对其进行处理，前者优先。

Spring 应用上下文中的 ConfigurationClassPostProcessor 就是一个 BeanDefinitionRegistryPostProcessor 处理器，它会对所有的配置类（包括其内部成员类）进行处理，会做以下事情：

加载 @PropertySource 注解配置的资源到 Environment 环境中
扫描 @ComponentScan 注解指定路径下的 BeanDefinition 们，如果也是配置类，会进行同样的处理过程
解析出 @Import 注解配置的配置类，解析成 AnnotatedGenericBeanDefinition 并注册；其中配置的是 ImportSelector 实现类，则调用其selectImports(AnnotationMetadata) 方法获取配置类；如果配置的是 ImportBeanDefinitionRegistrar 实现类，则调用其registerBeanDefinitions(AnnotationMetadata, BeanDefinitionRegistry) 方法，自定义注册 BeanDefinition
解析 @ImportResource 注解，加载配置的 XML 文件，解析出 BeanDefinition 们
将这些配置类中 @Bean 注解的方法解析成 ConfigurationClassBeanDefinition 并注册

配置类：带有 @Configuration 注解的类，如果这个类带有 @Component | @ComponentScan | @Import | @ImportSource 注解，或者内部存在 @Bean 的方法都算配置类

除了上面这些处理，如果是 @Configuration 注解标注的类，还会进行 CGLIB 提升，主要帮助实现 AOP 相关特性，这里没有详细展述，具体过程请期待后续的 Spring AOP 相关文章

至此，Spring IoC 的相关文章已全部完成，希望这一系列文章可以让读者对 Spring 有更加全面的认识，如有错误或者疑惑的地方，欢迎指正！！！共勉 ‍