一文学会Spring的@Configuration配置类解析

╰+哭是因爲堅強的太久メ 2024-03-25 21:34 36阅读 0赞

![format_png][]

--------------------

### 前言 ###

本篇文章将详细分析**Spring**中如何加载并解析由@**Configuration**注解修饰的配置类。

@**Configuration**注解是**Spring**中特别重要且知名的注解，大家都知道怎么使用，作用就是可以向容器注册**bean**，并且就像“**每一个成功的男人背后都有一个优秀的女人在支持**”，@**Configuration**注解的背后也有一个功能强大的类在支撑，那就是**ConfigurationClassPostProcessor**，所以本文的重点就是**ConfigurationClassPostProcessor**如何解析由@**Configuration**注解修饰的配置类。

本文的一个思维导图如下所示。

![format_png 1][]

最后，请务必知道**Spring**的**BeanDefinition**是什么，不能只知道**Spring**有**bean**但不知道**bean**的前生**BeanDefinition**，如果真不知道，可以看一下[超详细分析Spring的BeanDefinition][Spring_BeanDefinition]

**Springboot**版本：**2.4.1**

**Spring**版本：**5.3.2**

### 正文 ###

#### 一. 示例工程搭建 ####

在进行**ConfigurationClassPostProcessor**源码分析前，需要搭建示例工程来演示**ConfigurationClassPostProcessor**的执行逻辑。

定义如下几个业务类。

public class MyController {}
    
    @Service
    public class MyService {}
    
    public class MyDao {}
    复制代码

配置类如下所示。

@ComponentScan
    @Configuration
    @Import({MyImportBeanDefinitionRegistrar.class,
                MyImportSelector.class})
    public class MyConfig {
    
        @Bean
        public MyDao myDao() {
            return new MyDao();
        }
    
    }
    复制代码

**MyImportBeanDefinitionRegistrar**实现了**ImportBeanDefinitionRegistrar**接口，定义如下。

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    
        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
                                            BeanDefinitionRegistry registry) {
            BeanDefinition beanDefinition = new RootBeanDefinition(MyController.class);
            registry.registerBeanDefinition("myController", beanDefinition);
        }
    
    }
    复制代码

**MyImportSelector**实现了**ImportSelector**接口，定义如下。

public class MyImportSelector implements ImportSelector {
    
        @Override
        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            return new String[] {
                    "com.learn.beanfactory.postprocessor.further.MyFurtherConfig"
            };
        }
    
    }
    复制代码

上面中的**MyFurtherConfig**也是一个配置类，定义如下。

@Configuration
    public class MyFurtherConfig {
    
        @Bean
        public MyFurtherService myFurtherService() {
            return new MyFurtherService();
        }
    
    }
    复制代码

**MyFurtherService**是一个业务类，定义如下。

public class MyFurtherService {}
    复制代码

测试类定义如下。

public class MyTest {
    
        public static void main(String[] args) {
            ApplicationContext applicationContext
                    = new AnnotationConfigApplicationContext(MyConfig.class);
        }
    
    }
    复制代码

示例工程目录结构如下所示。

![format_png 2][]

#### 二. BeanFactoryPostProcessor ####

**Spring**中提供了大量的扩展点，而**ConfigurationClassPostProcessor**的扩展点类型叫做**bean**工厂后置处理器，也就是**BeanFactoryPostProcessor**。

先观察一下**BeanFactoryPostProcessor**的类图，如下所示。

![format_png 3][]

**BeanFactoryPostProcessor**接口允许其实现类修改**注册表**中的**BeanDefinition**，这里的注册表指**ConfigurableListableBeanFactory**接口的实现类，通常为**DefaultListableBeanFactory**（如果不知道这是什么，可以就理解为我们常说的**Spring**容器）。

**Spring**启动并初始化容器阶段，会调用到**AbstractApplicationContext\#refresh**方法来刷新容器，在**AbstractApplicationContext\#refresh**方法中，会先执行**invokeBeanFactoryPostProcessors()** 方法来执行每一个**BeanFactoryPostProcessor**的逻辑，并且这一步在初始化**bean**之前完成。

**refresh()** 方法简要表示如下。

public void refresh() throws BeansException, IllegalStateException {
            
        ......
    
        // 执行bean工厂后置处理器逻辑
        invokeBeanFactoryPostProcessors(beanFactory);
    
        ......
    
        // 添加bean后置处理器到容器
        registerBeanPostProcessors(beanFactory);
    
        ......
        
        // 初始化bean
        finishBeanFactoryInitialization(beanFactory);
    
        ......
    
    }
    复制代码

既然**BeanFactoryPostProcessor**接口允许其实现类修改**注册表**中的**BeanDefinition**，但是在**Spring**启动并且初始化容器的最开始阶段，**Spring**容器持有的注册表**DefaultListableBeanFactory**中是没有**BeanDefinition**的，那么肯定有一个时机存在一个类完成了将**BeanDefinition**加载到注册表中，时机就是**invokeBeanFactoryPostProcessors()** 方法的调用，类则是**ConfigurationClassPostProcessor**。

**ConfigurationClassPostProcessor**用于解析由@**Configuration**注解修饰的类（称为**配置类**），其类图如下所示。

![format_png 4][]

**ConfigurationClassPostProcessor**实现了**BeanDefinitionRegistryPostProcessor**接口，**BeanDefinitionRegistryPostProcessor**接口继承于**BeanFactoryPostProcessor**接口，所以**ConfigurationClassPostProcessor**有如下两层身份。

1.  **ConfigurationClassPostProcessor**是一个**bean**工厂后置处理器；
2.  **ConfigurationClassPostProcessor**具备向容器注册**BeanDefinition**的功能。

所以在**Spring**启动并初始化容器的最开始阶段，**Spring**会执行**ConfigurationClassPostProcessor**的逻辑来解析配置类，并且**Spring**还会通过流程控制，让**BeanDefinitionRegistryPostProcessor**的执行先于非**BeanDefinitionRegistryPostProcessor**的**bean**工厂后置处理器。

***`小结`***

1.  **BeanFactoryPostProcessor**叫做**bean**工厂后置处理器，**ConfigurationClassPostProcessor**是由**Spring**提供的可以实现向容器注册**BeanDefinition**功能的**bean**工厂后置处理器；
2.  **ConfigurationClassPostProcessor**的执行先于非**BeanDefinitionRegistryPostProcessor**的**bean**工厂后置处理器；
3.  **ConfigurationClassPostProcessor**向容器注册**BeanDefinition**是通过解析配置类来实现。

#### 三. BeanFactoryPostProcessor执行顺序 ####

前文已知**ConfigurationClassPostProcessor**就是一个**Spring**内置的**BeanFactoryPostProcessor**，但是**Spring**中有那么多的**BeanFactoryPostProcessor**，包括**Spring**内置提供的，用户自定义的，这些**BeanFactoryPostProcessor**之间的执行肯定有一个先后，本节将对**BeanFactoryPostProcessor**执行顺序进行一个分析。

在示例工程中，创建**AnnotationConfigApplicationContext**容器时传入了**MyConfig**配置类的**Class**对象，称创建容器时传入的配置类为**初始配置类**，下面再给出初始配置类**MyConfig**的定义，如下所示。

在**MyConfig**的定义中，使用了如下注解。

1.  @**ComponentScan**注解。默认将配置类所在包及其子包下所有由@**Component**，@**Controller**，@**Service**，@**Repository**，@**Configuration**注解修饰的类注册为容器中的**bean**；
2.  @**Configuration**注解。表示当前类是一个配置类，配置类也会被注册为容器中的**bean**；
3.  @**Import**注解。通过@**Import**注解可以导入**ImportBeanDefinitionRegistrar**和**ImportSelector**的实现类，并通过它们的实现类来向容器注册**bean**或配置类；
4.  @**Bean**注解。在配置类中所有由@**Bean**注解修饰的方法的返回值，会被注册为容器中的**bean**。

在配置类中，有两种方式来向容器注册**bean**。

1.  通过配置类直接向容器注册**bean**。例如使用@**Bean**注解，使用@**ComponentScan**注解和使用@**Import**(**业务类.class**)；
2.  通过配置类向容器注册配置类从而间接注册**bean**。被注册的配置类也会被解析，从而被注册的配置类所配置的**bean**也会被注册到容器中，**Springboot**中的自动装配就是这样实现的。

上述讨论的通过配置类向容器注册**bean**，并且可以使用多种注解和基于多种方式，能够实现这样的功能，实际是依赖的**ConfigurationClassPostProcessor**。在**Spring**中，**new**一个容器就会触发这个容器的初始化逻辑，例如示例工程中**AnnotationConfigApplicationContext**的构造函数会调用到**AbstractApplicationContext**的**refresh()** 方法，在**refresh()** 方法中会在初始化**bean**之前调用到**invokeBeanFactoryPostProcessors()** 方法来执行**bean**工厂后置处理器的逻辑，**invokeBeanF**

[format_png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/76646a11a3ab4471b85b6908aa92e1b1.png
[format_png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d05a37f8c19041dfab34d88b102f40aa.png
[Spring_BeanDefinition]: https://juejin.cn/post/7202172872369815612
[format_png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/7cd198b79244427599e01dc06c4e4cad.png
[format_png 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/c8fdf83f86b743bfa896a02e4f52adcf.png
[format_png 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/11547b710221491abbb163b76bde25eb.png