【Spring】BeanPostProcessor后置处理器

BeanPostProcessor后置处理器可以在Bean初始化前后做一些事情，注意这里是bean的初始化，不是实例化，BeanPostProcessor是一个接口，里面提供了两个方法，分别为postProcessBeforeInitialization（初始化之前）和postProcessAfterInitialization（初始化之后），在方法入参中有两个参数，一个bean对象，一个bean名称，这里也可以看出，在初始化之前应该已经完成了bean的实例化，这里把实例化的bean对象作为参数传了进来：

1. public interface BeanPostProcessor {
2.     @Nullable
3.     default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
4.         return bean;
5.     }
7.     @Nullable
8.     default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
9.         return bean;
10.     }
11. }

复制代码

来看一个例子，首先创建一个Bean，使用@Component将该bean交给Spring容器管理：

1. // 使用@Component将该bean交给Spring管理
2. @Component
3. public class User {
5.     private String name;
7.     public User() {
8.         System.out.println("调用User构造函数");
9.     }
10.     public String getName() {
11.         return name;
12.     }
14.     public void setName(String name) {
15.         this.name = name;
16.     }
17. }

复制代码

接下来创建一个自定义的Bean后置处理器，实现BeanPostProcessor接口，并实现postProcessBeforeInitialization和postProcessAfterInitialization方法，使用@Component将该bean交给Spring管理，Spring会获取后置处理器，在bean进行初始化前后触发对应的方法。
为了打印便于观察输出结果，这里对Bean类型进行了判断，只有User类型才打印日志：

1. // 使用@Component将该bean交给Spring管理
2. @Component
3. public class MyBeanPostProcessor implements BeanPostProcessor {
4.     @Override
5.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
6.         // 只处理User类型
7.         if (bean instanceof User) {
8.             System.out.println("【后置处理器】postProcessBeforeInitialization");
9.         }
10.         return bean;
11.     }
13.     @Override
14.     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
15.         // 只处理User类型
16.         if (bean instanceof User) {
17.             System.out.println("【后置处理器】postProcessBeforeInitialization");
18.         }
19.         return bean;
20.     }
21. }

复制代码

进行测试，从容器中获取user对象：

1. // 注意这里要扫描包
2. @ComponentScan(basePackages = {"com.example.demo"})
3. @SpringBootTest
4. class SpringbootWebApplicationTests {
6.         @Test
7.         void contextLoads() {
8.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringbootWebApplicationTests.class);
9.                 User User = (User) applicationContext.getBean("user", User.class);
10.                 System.out.println("userName:" + User.getName());
11.         }
13. }

复制代码

打印结果：

1. 调用User构造函数
2. 【后置处理器】postProcessBeforeInitialization
3. 【后置处理器】postProcessBeforeInitialization
4. userName:null

复制代码

从结果中也可以看出，后置处理器中的方法，是在bean已经完成了实例化之后触发的，所以通过后置处理器可以对bean的属性进行设置，甚至可以更改bean对象本身。
比如在postProcessBeforeInitialization方法中，为User设置名称：

1. // 使用@Component将该bean交给Spring管理
2. @Component
3. public class MyBeanPostProcessor implements BeanPostProcessor {
4.     @Override
5.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
6.         // 只处理User类型
7.         if (bean instanceof User) {
8.             User user = (User) bean;
9.             user.setName("zhangsm");
10.             System.out.println("【后置处理器】postProcessBeforeInitialization");
11.             return user;
12.         }
13.         return bean;
14.     }
15. }

复制代码

再次运行将会输出以下内容：

1. 调用User构造函数
2. 【后置处理器】postProcessBeforeInitialization
3. 【后置处理器】postProcessBeforeInitialization
4. userName:zhangsm

复制代码

再看一下对bean本身进行更改的例子，再新增一个AdminUser类，继承User，注意AdminUser没有使用注解，也就是没有交给Spring进行管理，之后我们通过手动实例化的方式，将Spring容器中User改成AdminUser类型：

1. public class AdminUser extends User {
2. }

复制代码

修改MyBeanPostProcessor中的postProcessAfterInitialization方法，方法的返回值是Object类型，在这里更改bean对象并返回进行替换：

1. @Component
2. public class MyBeanPostProcessor implements BeanPostProcessor {
3.     @Override
4.     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
5.         if (bean instanceof User) {
6.             // 这里手动创建了一个AdminUser并返回
7.             AdminUser user = new AdminUser();
8.             user.setName("administator");
9.             System.out.println("【后置处理器】postProcessBeforeInitialization");
10.             return user;
11.         }
12.         return bean;
13.     }
14. }

复制代码

修改测试类，这次把class信息也打印：

1. @ComponentScan(basePackages = {"com.example.demo"})
2. @SpringBootTest
3. class SpringbootWebApplicationTests {
5.         @Test
6.         void contextLoads() {
7.                 AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringbootWebApplicationTests.class);
8.                 User User = (User) applicationContext.getBean("user", User.class);
9.                 System.out.println("userClass:" + User.getClass());
10.                 System.out.println("userName:" + User.getName());
11.         }
13. }

复制代码

运行结果，可以看到拿到的bean已经是更改后的AdminUser

1. 调用User构造函数          // 这里是User实例化时输出的
2. 【后置处理器】postProcessBeforeInitialization
3. 调用User构造函数         // 这里是AdminUser实例化时输出的
4. 【后置处理器】postProcessBeforeInitialization
5. userClass:class com.example.demo.model.AdminUser
6. userName:administator

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！