Spring高手之路13——BeanFactoryPostProcessor与BeanDefinitionRegistryPostProcessor解析

￡神魔★判官ぃ 2023-10-14 18:03 46阅读 0赞

#### 文章目录 ####

*  1. BeanFactoryPostProcessor 概览
 *   *  1.1 解读 BeanFactoryPostProcessor
     *  1.2. 如何使用 BeanFactoryPostProcessor
 *  2. BeanDefinitionRegistryPostProcessor 深入探究
 *   *  2.1 解读 BeanDefinitionRegistryPostProcessor
     *  2.2 BeanDefinitionRegistryPostProcessor 的执行时机
     *  2.3. 动态注册 Bean：BeanDefinitionRegistryPostProcessor 实践
 *  3. 三种后置处理器的对比
 *  4. 总结与洞见
 *   *  4.1. BeanFactoryPostProcessor 与 BeanPostProcessor 的差异
     *  4.2. BeanFactoryPostProcessor 与 BeanDefinitionRegistryPostProcessor 的关系

## 1. BeanFactoryPostProcessor 概览 ##

### 1.1 解读 BeanFactoryPostProcessor ###

`BeanFactoryPostProcessor`位于`org.springframework.beans.factory.config`包中。它与`BeanPostProcessor`有相似的核心逻辑，但它们之间的主要区别在于它们所操作的对象。`BeanFactoryPostProcessor`的主要目的是对`Bean`的配置元数据进行操作，这意味着它可以影响`Bean`的初始配置数据。

在`Spring IoC`容器实例化`beans`之前，特别是除了`BeanFactoryPostProcessor`之外的其他`beans`，`BeanFactoryPostProcessor`有权利修改这些`beans`的配置。在`Spring`中，所有的`beans`在被完全实例化之前都是以`BeanDefinition`的形式存在的。`BeanFactoryPostProcessor`为我们提供了一个机会，使我们能够在`bean`完全实例化之前调整和修改这些`BeanDefinition`。对`BeanDefinition`的任何修改都会影响后续的`bean`实例化和初始化过程。

### 1.2. 如何使用 BeanFactoryPostProcessor ###

来看看`BeanFactoryPostProcessor`能如何影响`BeanDefinition`。

假设我们需要为一系列的`Tint`对象赋值名字，这个名字就是`bean`的名字，而且要在`bean`实例化之前完成。

1.  **定义bean**

我们定义一个简单的`Tint`抽象类以及其两个子类`Blue`和`Yellow`:

package com.example.demo.bean;
    
    public abstract class Tint {
        
        protected String label;
        
        public String getLabel() {
        
            return label;
        }
        
        public void setLabel(String label) {
        
            this.label = label;
        }
    }

package com.example.demo.bean;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class Blue extends Tint {
        
        @Override
        public String toString() {
        
            return "Blue{" + "label='" + label + '\'' + "}";
        }
    }

package com.example.demo.bean;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class Yellow extends Tint {
        
        @Override
        public String toString() {
        
            return "Yellow{" + "label='" + label + '\'' + "}";
        }
    }

1.  **创建后置处理器**

思路是在后置处理器中，我们可以获取到`BeanFactory`，然后操作其中的`BeanDefinition`。

package com.example.demo.processor;
    
    import com.example.demo.bean.Tint;
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanDefinition;
    import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.stereotype.Component;
    import org.springframework.util.ClassUtils;
    
    /**
     * BeanFactory后置处理器，用于设置Tint子类bean的label属性。
     * label属性的值会设置为"postProcessBeanFactory_" + beanName。
     */
    @Component
    public class TintLabelSetterFactoryPostProcessor implements BeanFactoryPostProcessor {
        
    
        /**
         * 在所有BeanDefinition加载完成之后，但bean实例化之前，设置label属性。
         *
         * @param beanFactory 可配置的bean工厂，可以操作BeanDefinition。
         * @throws BeansException 处理过程中的异常。
         */
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        
            // 遍历所有bean的名字
            for (String beanName : beanFactory.getBeanDefinitionNames()) {
        
                BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
    
                // 检查bean的类名是否非空，且其父类是Tint
                if (beanDefinition.getBeanClassName() != null &&
                        ClassUtils.resolveClassName(beanDefinition.getBeanClassName(), this.getClass().getClassLoader())
                                .getSuperclass().equals(Tint.class)) {
        
    
                    // 添加或更新（如果属性已存在）label属性的值
                    beanDefinition.getPropertyValues().add("label", "postProcessBeanFactory_" + beanName);
                }
            }
        }
    }

1.  **运行测试**

启动`Spring`容器，查看结果：

package com.example.demo;
    
    import com.example.demo.bean.Blue;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    
    public class DemoApplication {
        
        public static void main(String[] args) {
        
            AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext("com.example.demo");
            Blue blue = ctx.getBean(Blue.class);
            System.out.println(blue);
        }
    
    }

运行之后，控制台打印`Blue`对象的`label`属性，显示后置处理器成功修改了`bean`的属性。

![在这里插入图片描述][bc9c1360c3e1456f9867ff5cf7ef38b4.png]

1.  **替代方法**

我们也可以使用`BeanPostProcessor`达到`BeanFactoryPostProcessor`相似的效果：

package com.example.demo.processor;
    
    import com.example.demo.bean.Tint;
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    import org.springframework.stereotype.Component;
    
    /**
     * TintLabelSetterPostProcessor类是一个BeanPostProcessor的实现，
     * 它为类型为Tint的bean设置'label'属性。该属性的值将被设置为"postProcessAfterInitialization_"加上bean的名称。
     * 这里是一个postProcessAfterInitialization方法，它会在bean初始化后，但在返回给调用者之前执行。
     */
    @Component
    public class TintLabelSetterPostProcessor implements BeanPostProcessor {
        
    
        /**
         * 对bean进行后初始化处理。如果bean是Tint类型，它的'label'属性将被设置。
         *
         * @param bean 将要处理的bean对象。
         * @param beanName bean的名称。
         * @return 可能已经修改过的bean。
         * @throws BeansException 如果在处理过程中出现错误。
         */
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        
            if (bean instanceof Tint) {
        
                Tint tint = (Tint) bean;
                tint.setLabel("postProcessAfterInitialization_" + beanName);
            }
            return bean;
        }
    }

运行结果：

![在这里插入图片描述][d1083beab941478289f6e25d21ce00c8.png]

1.  **BeanPostProcessor 与 BeanFactoryPostProcessor 的对比**

<table> 
 <thead> 
  <tr> 
   <th>特点</th> 
   <th><strong>BeanPostProcessor</strong></th> 
   <th><strong>BeanFactoryPostProcessor</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>处理目标</strong></td> 
   <td>主要关注已经实例化的 bean 对象。</td> 
   <td>针对 BeanDefinition，也就是 bean 的元数据或者说是配置信息。</td> 
  </tr> 
  <tr> 
   <td><strong>执行时机</strong></td> 
   <td>两个关键阶段：<br> 1. <strong>postProcessBeforeInitialization</strong>：在 Spring 完成 bean 的实例化、进行属性注入后，但在 bean 的自定义初始化（如通过@PostConstruct注解定义的方法或init-method方法）之前调用。<br> 2. <strong>postProcessAfterInitialization</strong>：在 bean 的自定义初始化方法执行后调用</td> 
   <td>在 BeanDefinition 已经完成加载、注册到 BeanDefinitionRegistry后，但在 bean 实例化之前。这一时期主要处理 bean 的元数据。</td> 
  </tr> 
  <tr> 
   <td><strong>可操作的空间</strong></td> 
   <td>可以操作实例化的 bean 对象，如修改属性或包裹生成代理对象。</td> 
   <td>主要用于修改或添加 BeanDefinition 的属性、移除某些 BeanDefinition 等。</td> 
  </tr> 
 </tbody> 
</table>

## 2. BeanDefinitionRegistryPostProcessor 深入探究 ##

### 2.1 解读 BeanDefinitionRegistryPostProcessor ###

`BeanDefinitionRegistryPostProcessor` 是 `Spring` 容器的一个扩展点，主要用于在 `Spring` 容器完成对 `Bean` 的定义信息的加载后、但在它们真正实例化之前，进行额外的操作。

为了更好地理解，让我们用一个图书馆的类比：

想象一个新的图书馆正在组织其图书收藏。这个过程可以分为几个步骤：

1.  制定书单：图书馆先列出了所有想要的书的名称和作者，但还没有实际购买书籍。在`Spring`中，这就类似于创建`BeanDefinition`。
2.  在这个步骤后，但在图书馆真正购买书籍之前，假设图书馆收到了一个特别的捐赠列表（`BeanDefinitionRegistryPostProcessor`）。这个捐赠列表允许图书馆在正式购买书籍之前添加或修改书单。在`Spring`中，这是使用`BeanDefinitionRegistryPostProcessor`在实际的`bean`实例化之前修改`bean`定义的时机。
3.  按书单采购：此时，图书馆会按照更新后的书单进行购书。这个过程在`Spring`中类似于`bean`的实例化和属性填充。

**更佳专业化的描述如下**：

`BeanDefinitionRegistryPostProcessor` 是`Spring`中的一个高级扩展接口，继承自 `BeanFactoryPostProcessor`。它提供了更为深入的方式来干预`bean`定义的注册过程。

这个接口定义于 `org.springframework.beans.factory.support` 包内，它的特殊之处在于，除了能够像 `BeanFactoryPostProcessor` 那样修改已经注册的`bean`定义（`BeanDefinition`），还能向注册中心 `BeanDefinitionRegistry` 中动态地添加或移除`bean`定义。

`BeanDefinitionRegistryPostProcessor` 提供了一个核心方法：`postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)`。通过该方法，我们可以直接操作 `BeanDefinitionRegistry`，这是一个专门用于`bean`定义注册的中心接口。它允许我们直接注册新的`bean`定义、修改已有的`bean`定义或者完全移除某些`bean`定义。

使用这个接口的常见场景包括基于项目的特定条件动态地注册`beans`，例如，可能只在某些环境中需要的`beans`，或者基于配置选项动态地选择实现类。

与 `BeanFactoryPostProcessor` 的关键区别在于其执行时机。`BeanDefinitionRegistryPostProcessor` 的方法在所有其他 `BeanFactoryPostProcessor` 方法之前执行，这确保了它可以在其他处理器操作前先注册或修改`bean`定义。

总的来说，`BeanDefinitionRegistryPostProcessor` 提供了一种在`Spring`容器配置解析阶段动态介入的能力，允许我们在其他配置处理器介入之前，进行更为深入的`bean`定义的调整和优化。

### 2.2 BeanDefinitionRegistryPostProcessor 的执行时机 ###

执行时机用一张流程图表示如下：

![在这里插入图片描述][a471a83b89124f68bac1a5e24587adc4.png]

1.  **加载配置**: `Spring`从各种来源（如`XML`文件、`Java`配置、注解）加载配置信息。
2.  **解析配置**: 根据加载的配置，`Spring`创建对应的`BeanDefinition`。
3.  **注册BeanDefinition**: 解析完成后，`Spring`将这些`BeanDefinition`对象注册到`BeanDefinitionRegistry`中。
4.  **执行BeanDefinitionRegistryPostProcessor**: 这个后置处理器提供了一个重要的扩展点，允许在所有`BeanDefinition`注册完毕后，但在`Bean`实例化之前进行一些操作。例如：注册新的`BeanDefinition`、修改或删除现有的`BeanDefinition`。
5.  **执行BeanFactoryPostProcessor**: 这个后置处理器提供了另一个扩展点，它主要允许查看或修改已经注册的`BeanDefinition`。例如，根据某些条件更改`Bean`的作用域或属性值。
6.  **实例化Bean**: 这是将`BeanDefinition`转换为实际的`Bean`实例的过程。
7.  **依赖注入**: 在这一步，`Spring` 框架会按照 `BeanDefinition` 的描述为 `bean` 实例注入所需的依赖。
8.  **Bean初始化**: 在所有依赖都注入后，特定的初始化方法（如通过`@PostConstruct`指定的）将会被调用，完成`Bean`的最后设置。
9.  **执行BeanPostProcessor的方法**: `BeanPostProcessor`提供了拦截的能力，允许在`Bean`初始化阶段结束之前和之后进行操作。
10. **Bean完全初始化**: 在此阶段，`Bean` 完全初始化并准备好被应用程序使用。

虚线解释：

*  **执行BeanDefinitionRegistryPostProcessor 到 执行BeanFactoryPostProcessor 之间的虚线**:

注册/修改/删除`BeanDefinition`: 在执行 `BeanDefinitionRegistryPostProcessor` 的过程中，除了执行已定义的操作外，还提供了一个重要的扩展点，允许我们注册新的 `BeanDefinition`、修改或删除已有的 `BeanDefinition`。这为我们提供了一个机会在后续的 `BeanFactoryPostProcessor` 执行前改变或增强我们的 `bean` 定义。

*  **执行BeanFactoryPostProcessor 到 实例化Bean 之间的虚线**:

查看/修改`BeanDefinition`: `BeanFactoryPostProcessor` 允许我们查看或修改已注册的 `BeanDefinition`。这意味着在 `bean` 实例化之前，我们还有最后一次机会修改 `bean` 的定义或属性。例如，根据某些运行时环境或条件更改 `bean` 的作用域。

### 2.3. 动态注册 Bean：BeanDefinitionRegistryPostProcessor 实践 ###

假设有一个`Fruit`的抽象水果类，以及两个具体的水果类：`Apple`和`Orange`。在最初，`IOC`容器中只注册了`Apple`，没有`Orange`。我们将使用`BeanDefinitionRegistryPostProcessor`来注册一个`Orange`的实例，然后利用`BeanFactoryPostProcessor`来为所有的`Fruit`实例设置属性。

1.  **声明Bean**

首先，我们定义抽象类`Fruit`及其属性：

package com.example.demo.bean;
    
    public abstract class Fruit {
        
        protected String type;
    
        public String getType() {
        
            return type;
        }
    
        public void setType(String type) {
        
            this.type = type;
        }
    }

package com.example.demo.bean;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class Apple extends Fruit {
        
        @Override
        public String toString() {
        
            return "Apple{" + "type='" + type + '\'' + "}";
        }
    }

package com.example.demo.bean;
    
    public class Orange extends Fruit {
        
        @Override
        public String toString() {
        
            return "Orange{" + "type='" + type + '\'' + '}';
        }
    }

`Orange`类没有标注`@Component`注解，`Spring`的组件扫描功能默认不会为其创建`bean`，这个例子中会在`OrangeRegisterPostProcessor` 里动态创建。

1.  **编写后置处理器**

使用后置处理器来注册`Orange`：

package com.example.demo.processor;
    
    import com.example.demo.bean.Orange;
    import org.springframework.beans.factory.config.BeanDefinition;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.beans.factory.support.BeanDefinitionBuilder;
    import org.springframework.beans.factory.support.BeanDefinitionRegistry;
    import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
    import org.springframework.stereotype.Component;
    
    
    /**
     * OrangeRegisterPostProcessor是一个BeanDefinitionRegistryPostProcessor。
     * 它的主要作用是检查IOC容器中是否已经包含了名为"orange"的bean定义。
     * 如果没有，它会动态创建一个Orange类的bean定义并注册到容器中。
     */
    @Component
    public class OrangeRegisterPostProcessor implements BeanDefinitionRegistryPostProcessor {
        
    
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        
            System.out.println("postProcessBeanDefinitionRegistry in OrangeRegisterPostProcessor started.");
    
            if (!registry.containsBeanDefinition("orange")) {
        
                BeanDefinition orangeDefinition = BeanDefinitionBuilder.genericBeanDefinition(Orange.class).getBeanDefinition();
                registry.registerBeanDefinition("orange", orangeDefinition);
            }
        }
        
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        
            System.out.println("postProcessBeanFactory in OrangeRegisterPostProcessor started.");
        }
    }

为所有的`Fruit`实例设置属性：

package com.example.demo.processor;
    
    import com.example.demo.bean.Fruit;
    import org.springframework.beans.factory.config.BeanDefinition;
    import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.stereotype.Component;
    
    
    /**
     * FruitTypeSetterPostProcessor是一个BeanFactoryPostProcessor。
     * 它的主要作用是为所有Fruit类型的bean（Apple和Orange）设置"type"属性。
     * 其中，属性的值与bean的名称相同。
     */
    @Component
    public class FruitTypeSetterPostProcessor implements BeanFactoryPostProcessor {
        
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        
            System.out.println("postProcessBeanFactory in FruitTypeSetterPostProcessor started.");
    
            String[] fruitNames = beanFactory.getBeanNamesForType(Fruit.class);
            for (String name : fruitNames) {
        
                BeanDefinition beanDefinition = beanFactory.getBeanDefinition(name);
                beanDefinition.getPropertyValues().add("type", name);
            }
        }
    }

1.  **测试运行**

package com.example.demo;
    
    import com.example.demo.bean.Apple;
    import com.example.demo.bean.Orange;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    public class DemoApplication {
        
    
        public static void main(String[] args) {
        
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.example.demo");
            Apple apple = context.getBean(Apple.class);
            System.out.println(apple);
            Orange orange = context.getBean(Orange.class);
            System.out.println(orange);
        }
    }

运行结果：

![在这里插入图片描述][78c9bb14b6dd41bfa45bfdb6fe6428be.png]

这段代码展示了如何使用`BeanDefinitionRegistryPostProcessor`来动态地注册`beans`和为其设置属性。

## 3. 三种后置处理器的对比 ##

<table> 
 <thead> 
  <tr> 
   <th>后置处理器</th> 
   <th>处理目标</th> 
   <th>执行时机</th> 
   <th>主要操作</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>BeanPostProcessor</strong></td> 
   <td>针对已经实例化但未完全初始化的 bean 对象</td> 
   <td>在bean的初始化过程中，具体是在bean生命周期的初始化方法前后执行</td> 
   <td>主要用于在bean初始化前后进行操作，如修改bean属性、生成代理对象等。</td> 
  </tr> 
  <tr> 
   <td><strong>BeanFactoryPostProcessor</strong></td> 
   <td>主要针对BeanDefinition，即bean的配置元数据</td> 
   <td>所有的 BeanDefinition 已加载到 BeanDefinitionRegistry 且已完成注册。此时机允许我们在bean真正实例化和初始化之前，对其配置元数据（即 BeanDefinition）进行修改或添加操作</td> 
   <td>修改已注册的 BeanDefinition。此操作可能包括修改属性、改变类的定义或者进行其他任何与 BeanDefinition 相关的操作</td> 
  </tr> 
  <tr> 
   <td><strong>BeanDefinitionRegistryPostProcessor</strong></td> 
   <td>主要针对BeanDefinitionRegistry，该处理器可以处理来自各种配置源（如配置文件、Java配置等）的BeanDefinition</td> 
   <td>在所有 BeanDefinition 被加载和注册之后，但在其他 BeanFactoryPostProcessor 执行之前</td> 
   <td>向 BeanDefinitionRegistry 注册、修改或移除 BeanDefinition</td> 
  </tr> 
 </tbody> 
</table>

## 4. 总结与洞见 ##

### 4.1. BeanFactoryPostProcessor 与 BeanPostProcessor 的差异 ###

`BeanFactoryPostProcessor` 和 `BeanPostProcessor` 都是 `Spring` 框架中为了增强容器的处理能力而提供的扩展点。它们都可以对 `Bean` 进行定制化处理，但它们的关注点和应用时机不同。

1.  **BeanFactoryPostProcessor**:

*  功能: 允许我们在 `Spring` 容器实例化任何 `bean` 之前读取 `bean` 的定义(`bean` 的元数据)并进行修改。
 *  作用时机: 它会在 `BeanFactory` 的标准初始化之后被调用，此时，所有的 `bean` 定义已经被加载到容器中，但还没有实例化任何 `bean`。此时我们可以添加、修改或移除某些 `bean` 的定义。
 *  常见应用: 动态修改 `bean` 的属性、改变 `bean` 的作用域、动态注册新的 `bean` 等。
 *  示例接口方法：`void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException`;

1.  **BeanPostProcessor**:

*  功能: 允许我们在 `Spring` 容器实例化 `bean` 之后对 `bean` 进行处理，提供了一种机会在 `bean` 的初始化前后插入我们的自定义逻辑。
 *  作用时机: 它在 `bean` 的生命周期中的两个时间点被调用，即在自定义初始化方法(如 `@PostConstruct`, `init-method`)之前和之后。
 *  常见应用: 对特定的 `bean` 实例进行一些额外处理，如进行某种代理、修改 `bean` 的状态等。
 *  示例接口方法：`Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException`; 和 `Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException`;

总结:

*  `BeanFactoryPostProcessor` 主要关注于整个容器的配置，允许我们修改 `bean` 的定义或元数据。它是容器级别的。
 *  `BeanPostProcessor` 主要关注于 `bean` 的实例，允许我们在初始化前后对 `bean` 实例进行操作。它是 `bean` 级别的。

### 4.2. BeanFactoryPostProcessor 与 BeanDefinitionRegistryPostProcessor 的关系 ###

`BeanFactoryPostProcessor` 和 `BeanDefinitionRegistryPostProcessor` 都是 `Spring` 中提供的两个重要的扩展点，它们都允许我们在 `Spring` 容器启动过程中对 `Bean` 的定义进行定制处理。但它们的应用时机和功能上存在一些不同。

1.  **BeanFactoryPostProcessor**:

*  功能: 允许我们在 `Spring` 容器实例化任何 `bean` 之前读取 `bean` 的定义 (`BeanDefinition`) 并进行修改。
 *  作用时机: 在所有的 `bean` 定义都被加载、但 `bean` 实例还未创建的时候执行。
 *  常见应用: 修改已加载到容器中的 `bean` 定义的属性，例如更改某个 `bean` 的作用域、属性值等。
 *  主要方法: `void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException`;

1.  **BeanDefinitionRegistryPostProcessor**:

*  功能: 扩展了 `BeanFactoryPostProcessor`，提供了一个新的方法来修改应用程序的上下文的 `bean` 定义。此外，还可以动态注册新的 `bean` 定义。
 *  作用时机: 它也是在所有 `bean` 定义被加载后执行，但在 `BeanFactoryPostProcessor` 之前。
 *  常见应用: 动态注册新的 `bean` 定义、修改或移除已有的 `bean` 定义。
 *  主要方法: `void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException`;

总结：

*  `BeanFactoryPostProcessor` 主要是用来修改已经定义的 `bean` 定义，而不是注册新的 `bean`。
 *  `BeanDefinitionRegistryPostProcessor` 是 `BeanFactoryPostProcessor` 的扩展，并提供了额外的能力来动态地注册、修改、移除 `bean` 定义。

在 `Spring` 容器的启动过程中，首先执行的是 `BeanDefinitionRegistryPostProcessor` 的方法，之后才是 `BeanFactoryPostProcessor` 的方法。

欢迎一键三连~  
  
有问题请留言，大家一起探讨学习  
  
\----------------------Talk is cheap, show me the code-----------------------

[bc9c1360c3e1456f9867ff5cf7ef38b4.png]: https://img-blog.csdnimg.cn/bc9c1360c3e1456f9867ff5cf7ef38b4.png
[d1083beab941478289f6e25d21ce00c8.png]: https://img-blog.csdnimg.cn/d1083beab941478289f6e25d21ce00c8.png
[a471a83b89124f68bac1a5e24587adc4.png]: https://img-blog.csdnimg.cn/a471a83b89124f68bac1a5e24587adc4.png
[78c9bb14b6dd41bfa45bfdb6fe6428be.png]: https://img-blog.csdnimg.cn/78c9bb14b6dd41bfa45bfdb6fe6428be.png