深入探索Spring后置处理器：解析作用与实际应用场景

Apple_Web

已于 2023-08-19 15:58:24 修改

阅读量1.5k

点赞数 6

分类专栏：深入学习Spring 文章标签： spring java 后端

于 2023-08-19 15:05:15 首次发布

本文链接：https://blog.csdn.net/belongtocode/article/details/132380073

版权

深入学习Spring 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

前言

BeanDefinitionRegistryPostProcessor ， BeanFactoryPostProcessor ，InstantiationAwareBeanPostProcessor， BeanPostProcessor是spring生命周期中常见的4个后置处理器，但是对于其作用和执行顺序很多人还不是非常清楚，这里给大家讲解一下其作用以及执行顺序，并带上实操。

生命周期图：

作用及其执行顺序

BeanDefinitionRegistryPostProcessor 是一个扩展了 BeanFactoryPostProcessor 的接口，它可以在 Spring 容器加载了所有的 bean 定义之后，但是在 bean 实例化之前，对 bean 的定义进行修改或者添加。它的 postProcessBeanDefinitionRegistry 方法会在所有的 bean 定义被加载后，但是在任何 bean 实例化之前被调用。它的 postProcessBeanFactory 方法会在所有的 bean 实例化之后被调用。因此，它的执行顺序是最先执行 postProcessBeanDefinitionRegistry 方法，然后执行 postProcessBeanFactory 方法。
BeanFactoryPostProcessor 是一个可以在 Spring 容器加载了所有的 bean 定义之后，但是在 bean 实例化之前，对 bean 的定义进行修改或者添加的接口。它的 postProcessBeanFactory 方法会在所有的 bean 定义被加载后，但是在任何 bean 实例化之前被调用。因此，它的执行顺序是在 BeanDefinitionRegistryPostProcessor 的 postProcessBeanDefinitionRegistry 方法之后，但是在 BeanDefinitionRegistryPostProcessor 的 postProcessBeanFactory 方法之前。
InstantiationAwareBeanPostProcessor 是一个扩展了 BeanPostProcessor 的接口，它可以在 Spring 容器实例化 bean 的过程中，对 bean 进行修改或者增强。它有四个方法：postProcessBeforeInstantiation、postProcessAfterInstantiation、postProcessPropertyValues 和 postProcessBeforeInitialization。它的执行顺序是：
- 在每个 bean 实例化之前，调用 postProcessBeforeInstantiation 方法，如果该方法返回非空对象，则跳过后续的实例化过程。
- 在每个 bean 实例化之后，调用 postProcessAfterInstantiation 方法，如果该方法返回 false，则跳过后续的属性注入过程。
- 在每个 bean 属性注入之前，调用 postProcessPropertyValues 方法，如果该方法返回非空属性值，则使用返回的属性值进行注入。
- 在每个 bean 初始化之前，调用 postProcessBeforeInitialization 方法，如果该方法返回非空对象，则使用返回的对象作为初始化结果。
BeanPostProcessor 是一个可以在 Spring 容器实例化和初始化 bean 的过程中，对 bean 进行修改或者增强的接口。它有两个方法：postProcessBeforeInitialization 和 postProcessAfterInitialization。它的执行顺序是：
- 在每个 bean 初始化之前，调用 postProcessBeforeInitialization 方法，如果该方法返回非空对象，则使用返回的对象作为初始化结果。
- 在每个 bean 初始化之后，调用 postProcessAfterInitialization 方法，如果该方法返回非空对象，则使用返回的对象作为最终结果。

总结一下，这几个接口的执行顺序和作用如下：

BeanDefinitionRegistryPostProcessor： 最先执行，在所有的 bean 定义被加载后，可以修改或者添加 bean 的定义。
BeanFactoryPostProcessor： 其次执行，在所有的 bean 定义被加载后，可以修改或者添加 bean 的定义。
InstantiationAwareBeanPostProcessor： 第三执行，在每个 bean 实例化和初始化的过程中，可以修改或者增强 bean 的对象和属性。
BeanPostProcessor： 最后执行，在每个 bean 初始化的过程中，可以修改或者增强 bean 的对象。

PostProcessor 类型	处理目标	执行时机	可操作的空间
BeanDefinitionRegistryPostProcessor	BeanDefinition、.class 文件等	配置文件、配置类已解析完毕并注册进 BeanFactory，但还没有被 BeanFactoryPostProcessor 处理	向 BeanFactory 中注册新的 BeanDefinition
BeanFactoryPostProcessor	BeanDefinition	BeanDefinition 解析完毕并注册进 BeanFactory 之后（此时 bean 未实例化）	给 BeanDefinition 中增删属性、移除 BeanDefinition 等
InstantiationAwareBeanPostProcessor	bean 实例	bean 的实例化阶段前后（在实例化 bean 对象之前和之后）	在 bean 实例化的过程中，可以对实例化的 bean 进行定制化的操作，例如自定义实例化逻辑、修改实例化后的属性值等
BeanPostProcessor	bean 实例	bean 的初始化阶段前后（已创建出 bean 对象）	给 bean 的属性赋值、创建代理对象等

举例说明实际应用场景

BeanDefinitionRegistryPostProcessor： 这个后置处理器可以在 bean 定义加载后，创建并注册新的 bean 定义，或者修改或者删除已有的 bean 定义。它可以用于动态地根据条件或者配置来增加或者减少 bean 的数量和类型。例如，我们可以根据不同的环境（开发、测试、生产）来注册不同的数据源或者缓存 bean，或者根据不同的功能模块来注册不同的服务 bean。一个具体的例子是 Spring Boot 的自动配置功能，它使用了一个名为 AutoConfigurationImportSelector 的 BeanDefinitionRegistryPostProcessor 来根据条件注解和配置文件来自动导入和注册合适的自动配置类。
BeanFactoryPostProcessor： 这个后置处理器可以在 bean 定义加载后，修改或者添加已有的 bean 定义，但是不能创建或者删除 bean 定义。它可以用于修改 bean 的属性值、作用域、初始化方法等元数据信息。例如，我们可以根据外部的配置文件或者环境变量来修改 bean 的属性值，或者根据需要来改变 bean 的单例或者原型模式。一个具体的例子是 Spring 的 PropertyPlaceholderConfigurer 类，它使用了一个 BeanFactoryPostProcessor 来解析和替换 bean 定义中的占位符为实际的属性值。
InstantiationAwareBeanPostProcessor： 这个后置处理器可以在每个 bean 实例化和初始化的过程中，修改或者增强 bean 的对象和属性。它可以用于控制 bean 的实例化过程，或者对 bean 的属性进行自定义的注入或者验证。例如，我们可以使用它来实现一些特殊的注解功能，如 @Autowired 或者 @Value，或者使用它来实现一些代理功能，如 AOP 或者事务管理。一个具体的例子是 Spring 的 AutowiredAnnotationBeanPostProcessor 类，它使用了一个 InstantiationAwareBeanPostProcessor 来实现了 @Autowired 和 @Value 注解的功能。
BeanPostProcessor： 这个后置处理器可以在每个 bean 初始化的过程中，修改或者增强 bean 的对象。它可以用于对 bean 进行一些额外的配置或者初始化操作，或者对 bean 进行一些装饰或者代理操作。例如，我们可以使用它来执行一些初始化方法，如 @PostConstruct 或者 init-method，或者使用它来实现一些代理功能，如 AOP 或者事务管理。一个具体的例子是 Spring 的 InitDestroyAnnotationBeanPostProcessor 类，它使用了一个 BeanPostProcessor 来实现了 @PostConstruct 和 @PreDestroy 注解的功能。

实操

首先，我们需要创建一个 Spring Boot 项目，并在 pom.xml 中添加以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>

然后，我们需要定义以下四个后置处理器的实现类，并使用 @Component 注解标注它们，以便让 Spring 自动扫描并注册它们：

MyBeanDefinitionRegistryPostProcessor：用于在 bean 定义加载后，创建并注册新的 bean 定义

@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        System.out.println("MyBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry");
        // 创建一个新的 bean 定义
        BeanDefinition beanDefinition = new RootBeanDefinition(MyNewBean.class);
        // 注册到容器中
        registry.registerBeanDefinition("myNewBean", beanDefinition);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("MyBeanDefinitionRegistryPostProcessor.postProcessBeanFactory");
        // 修改已有的 bean 定义
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition("helloService");
        beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
    }
}

MyBeanFactoryPostProcessor：用于在 bean 定义加载后，修改或者添加已有的 bean 定义

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor.postProcessBeanFactory");
        // 修改已有的 bean 定义
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition("worldService");
        beanDefinition.setLazyInit(true);
    }
}

MyInstantiationAwareBeanPostProcessor：用于在每个 bean 实例化和初始化的过程中，修改或者增强 bean 的对象和属性

@Component
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        System.out.println("MyInstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation: " + beanName);
        // 如果返回非空对象，则跳过后续的实例化过程
        if (beanName.equals("myNewBean")) {
            return new MyNewBean("Created by postProcessBeforeInstantiation");
        }
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        System.out.println("MyInstantiationAwareBeanPostProcessor.postProcessAfterInstantiation: " + beanName);
        // 如果返回 false，则跳过后续的属性注入过程
        if (beanName.equals("helloService")) {
            return false;
        }
        return true;
    }

    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        System.out.println("MyInstantiationAwareBeanPostProcessor.postProcessPropertyValues: " + beanName);
        // 如果返回非空属性值，则使用返回的属性值进行注入
        if (beanName.equals("worldService")) {
            return new MutablePropertyValues().add("message", "Modified by postProcessPropertyValues");
        }
        return pvs;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("MyInstantiationAwareBeanPostProcessor.postProcessBeforeInitialization: " + beanName);
        // 如果返回非空对象，则使用返回的对象作为初始化结果
        if (beanName.equals("myNewBean")) {
            return new MyNewBean("Modified by postProcessBeforeInitialization");
        }
        return bean;
    }
}

MyBeanPostProcessor：用于在每个 bean 初始化的过程中，修改或者增强 bean 的对象

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("MyBeanPostProcessor.postProcessBeforeInitialization: " + beanName);
        // 如果返回非空对象，则使用返回的对象作为初始化结果
        if (beanName.equals("helloService")) {
            return new HelloService("Modified by postProcessBeforeInitialization");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("MyBeanPostProcessor.postProcessAfterInitialization: " + beanName);
        // 如果返回非空对象，则使用返回的对象作为最终结果
        if (beanName.equals("worldService")) {
            return new WorldService("Modified by postProcessAfterInitialization");
        }
        return bean;
    }
}

接下来，我们需要定义以下四个普通的 bean 类，并使用 @Component 或者 @Service 注解标注它们，以便让 Spring 自动扫描并注册它们：

HelloService：用于测试 MyBeanFactoryPostProcessor 和 MyInstantiationAwareBeanPostProcessor 的修改效果

@Service
public class HelloService {

    private String message;

    public HelloService() {
        this.message = "Hello, Spring!";
    }

    public HelloService(String message) {
        this.message = message;
    }

    public void sayHello() {
        System.out.println(message);
    }
}

WorldService：用于测试 MyBeanFactoryPostProcessor 和 MyBeanPostProcessor 的修改效果

@Service
public class WorldService {

    private String message;

    public WorldService() {
        this.message = "World, Spring!";
    }

    public WorldService(String message) {
        this.message = message;
    }

    public void sayWorld() {
        System.out.println(message);
    }
}

MyNewBean：用于测试 MyBeanDefinitionRegistryPostProcessor 和 MyInstantiationAwareBeanPostProcessor 的创建和修改效果

public class MyNewBean {

    private String message;

    public MyNewBean() {
        this.message = "This is a new bean!";
    }

    public MyNewBean(String message) {
        this.message = message;
    }

    public void saySomething() {
        System.out.println(message);
    }
}

TestController：用于测试各个 bean 的实际表现

@RestController
public class TestController {

    @Autowired
    private HelloService helloService;

    @Autowired
    private WorldService worldService;

    @Autowired
    private MyNewBean myNewBean;

    @GetMapping("/test")
    public String test() {
        helloService.sayHello();
        worldService.sayWorld();
        myNewBean.saySomething();
        return "Test done!";
    }
}

最后，我们可以运行 Spring Boot 项目，并访问 http://localhost:8080/test ，观察控制台的输出，以及各个后置处理器的执行顺序和作用。我们可以看到以下结果：

MyBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry
MyBeanFactoryPostProcessor.postProcessBeanFactory
MyInstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation: helloService
MyInstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation: worldService
MyInstantiationAwareBeanPostProcessor.postProcessAfterInstantiation: worldService
MyInstantiationAwareBeanPostProcessor.postProcessPropertyValues: worldService
MyInstantiationAwareBeanPostProcessor.postProcessBeforeInitialization: worldService
MyBeanPostProcessor.postProcessBeforeInitialization: worldService
MyInstantiationAwareBeanPostProcessor.postProcessAfterInitialization: worldService
MyBeanPostProcessor.postProcessAfterInitialization: worldService
MyInstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation: myNewBean
MyInstantiationAwareBeanPostProcessor.postProcessBeforeInitialization: myNewBean
MyInstantiationAwareBeanPostProcessor.postProcessAfterInitialization: myNewBean

Modified by postProcessBeforeInitialization
Modified by postProcessPropertyValues and postProcessAfterInitialization
Modified by postProcessBeforeInitialization

Test done!

从上面的结果可以看出，这四个后置处理器的执行顺序和作用如下：

MyBeanDefinitionRegistryPostProcessor：最先执行，在所有的 bean 定义被加载后，创建并注册了一个名为 myNewBean 的新的 bean 定义，并修改了 helloService 的 scope 为 prototype。
MyBeanFactoryPostProcessor：其次执行，在所有的 bean 定义被加载后，修改了 worldService 的 lazyInit 为 true。
MyInstantiationAwareBeanPostProcessor：第三执行，在每个 bean 实例化和初始化的过程中，修改或者增强 bean 的对象和属性。它的 postProcessBeforeInstantiation 方法返回了一个非空对象，导致 myNewBean 的实例化过程被跳过。它的 postProcessAfterInstantiation 方法返回了 false，导致 helloService 的属性注入过程被跳过。它的 postProcessPropertyValues 方法返回了一个非空属性值，导致 worldService 的 message 属性被修改。它的 postProcessBeforeInitialization 方法返回了一个非空对象，导致 myNewBean 的初始化结果被修改。
MyBeanPostProcessor：最后执行，在每个 bean 初始化的过程中，修改或者增强 bean 的对象。它的 postProcessBeforeInitialization 方法返回了一个非空对象，导致 helloService 的初始化结果被修改。它的 postProcessAfterInitialization 方法返回了一个非空对象，导致 worldService 的最终结果被修改。

Apple_Web

关注

6
点赞
踩
14

收藏

觉得还不错? 一键收藏
打赏
0
评论
深入探索Spring后置处理器：解析作用与实际应用场景

BeanDefinitionRegistryPostProcessor BeanFactoryPostProcessor InstantiationAwareBeanPostProcessor BeanPostProcessor是spring生命周期中常见的4个后置处理器，但是对于其作用和执行顺序很多人还不是非常清楚，这里给大家讲解一下其作用以及执行顺序，并带上实操。
复制链接

扫一扫