Spring经典扩展接口应用：BeanPostProcessor

备注：新进行基本思路总结，四五月总结完

一、BeanPostProcessor基本知识总结

BeanPostProcessor是Bean级处理器，用于在bean实例化后、初始化后自定义修改bean实例，如属性校验、针对自定义bean做统一处理等。

BeanPostProcessor接口中定义了两个方法：

• postProcessBeforeInitialization 方法，在任何bean初始化回调「如InitializingBean接口的afterPropertiesSet方法、自定义的初始化方法」之前，使BeanPostProcessor应用于给定的bean实例，其返回值可以是bean本身或其包装类。

• postProcessAfterInitialization 方法，在bean回调初始化方法后调用。

实现过程：注册-执行postProcessBeforeInitialization-执行postProcessAfterInitialization

如果我们想在Spring容器中完成bean实例化、配置以及其他初始化方法前后要添加一些自己逻辑处理。我们需要定义一个或多个BeanPostProcessor接口实现类，然后注册到Spring IoC容器中。

Spring中Bean的实例化过程图示：

 注意：

1、接口中的两个方法都要将传入的bean返回，而不能返回null，如果返回的是null那么我们通过getBean方法将得不到目标。

2、BeanFactory和ApplicationContext对待bean后置处理器稍有不同。ApplicationContext会自动检测在配置文件中实现了BeanPostProcessor接口的所有bean，并把它们注册为后置处理器，然后在容器创建bean的适当时候调用它，因此部署一个后置处理器同部署其他的bean并没有什么区别。而使用BeanFactory实现的时候，bean 后置处理器必须通过代码显式地去注册，在IoC容器继承体系中的ConfigurableBeanFactory接口中定义了注册方法

/**  * Add a new BeanPostProcessor that will get applied to beans created  * by this factory. To be invoked during factory configuration.  * <p>Note: Post-processors submitted here will be applied in the order of  * registration; any ordering semantics expressed through implementing the  * {@link org.springframework.core.Ordered} interface will be ignored. Note  * that autodetected post-processors (e.g. as beans in an ApplicationContext)  * will always be applied after programmatically registered ones.  * @param beanPostProcessor the post-processor to register  */    
void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

另外，不要将BeanPostProcessor标记为延迟初始化。因为如果这样做，Spring容器将不会注册它们，自定义逻辑也就无法得到应用。假如你在<beans />元素的定义中使用了'default-lazy-init'属性，请确信你的各个BeanPostProcessor标记为'lazy-init="false"'。

二、BeanPostProcessor实际应用分析

BeanPostProcessor 接口在 Spring 框架中的实际应用场景有很多，以下是一些举例：

1. 属性注入：可以通过实现 BeanPostProcessor 接口，在 Bean 实例化后、初始化之前，对 Bean 的属性进行自定义注入。例如，可以在 BeanPostProcessor 的 postProcessBeforeInitialization 方法中，对 Bean 的属性进行修改或赋值，从而实现属性注入的定制化需求。
2. AOP 预处理：可以通过实现 BeanPostProcessor 接口，在 Bean 实例化后、初始化之前，对 Bean 进行 AOP 相关的预处理。例如，可以在 BeanPostProcessor 的 postProcessBeforeInitialization 方法中，为 Bean 动态生成代理对象，实现 AOP 面向切面的功能。
3. 定制初始化逻辑：可以通过实现 BeanPostProcessor 接口，在 Bean 初始化阶段，对 Bean 进行自定义的初始化逻辑。例如，可以在 BeanPostProcessor 的 postProcessAfterInitialization 方法中，执行一些初始化操作，例如数据初始化、资源加载等。
4. 数据校验：可以通过实现 BeanPostProcessor 接口，在 Bean 初始化后，对 Bean 中的数据进行校验。例如，可以在 BeanPostProcessor 的 postProcessAfterInitialization 方法中，对 Bean 中的数据进行验证，确保数据的合法性和完整性。
5. 资源回收：可以通过实现 BeanPostProcessor 接口，在 Bean 销毁前，对 Bean 中的资源进行回收操作。例如，可以在 BeanPostProcessor 的 postProcessBeforeDestruction 方法中，执行资源的释放、关闭等操作，确保资源的合理释放。

需要注意的是，实现 BeanPostProcessor 接口时，需要谨慎处理 Bean 的生命周期，避免引入不必要的副作用和潜在的问题。在使用 BeanPostProcessor 接口时，应该根据具体需求，仔细考虑是否真正需要对 Bean 进行自定义处理，以及处理的时机和方式。

三、实际应用展示

（一）属性注入

可以通过实现 BeanPostProcessor 接口，在 Bean 实例化后、初始化之前，对 Bean 的属性进行自定义注入。例如，可以在 BeanPostProcessor 的 postProcessBeforeInitialization 方法中，对 Bean 的属性进行修改或赋值，从而实现属性注入的定制化需求。

定义MyBeanPostProcessor 实现了 BeanPostProcessor 接口，并重写了其中的两个方法postProcessBeforeInitialization 和 postProcessAfterInitialization。

在 postProcessBeforeInitialization 方法中，对 MyBean 类型的 Bean 进行了属性的自定义注入，实现了属性注入的定制化需求（这里只是简单的示例，实际应用中的处理逻辑可能更加复杂，根据具体需求进行自定义处理。）

package org.zyf.javabasic.springextend.beanpostprocessorext;import lombok.Data;/*** @author yanfengzhang* @description* @date 2023/4/16  23:54*/
@Data
public class MyBean {private String myProperty;public void doSomething(){System.out.println("MyBean.doSomething()执行，myProperty="+myProperty);}
}

实际应用中，MyBean 可以是业务对象，例如一个业务逻辑的实现类，一个数据访问对象等等，具体根据你的业务需求而定。MyBean 只是一个占位符，可以根据你的实际业务需求和业务对象的命名规范来定义和命名自己的 Bean 类型。在实际应用中，你需要替换 MyBean 为你实际使用的业务对象的类名，以便在 MyBeanPostProcessor 中进行相应的处理。

配置示例

要使用这个自定义的 BeanPostProcessor，需要将其注册到 Spring 容器中，有以下两种方式：

通过配置文件方式

<!-- 配置文件中的注册方式 -->
<bean class="org.zyf.javabasic.springextend.beanpostprocessorext.MyBeanPostProcessor" />

通过 Java 配置类的方式

package org.zyf.javabasic.springextend.beanpostprocessorext;import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;/*** @author yanfengzhang* @description* @date 2023/4/16  23:58*/
@Configuration
public class MyAppConfig {@Beanpublic MyBeanPostProcessor myBeanPostProcessor() {return new MyBeanPostProcessor();}
}

代码展示

package org.zyf.javabasic.springextend.beanpostprocessorext;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;/*** @author yanfengzhang* @description* @date 2023/4/16  23:53*/
public class MyBeanPostProcessor implements BeanPostProcessor {@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {// 在 Bean 初始化前的处理逻辑if (bean instanceof MyBean) {MyBean myBean = (MyBean) bean;// 对 MyBean 的属性进行自定义注入myBean.setMyProperty("自定义属性");}return bean;}@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {// 在 Bean 初始化后的处理逻辑return bean;}
}

这样，Spring 容器在实例化 Bean 并初始化之前，会调用 MyBeanPostProcessor 中的 postProcessBeforeInitialization 方法，从而实现属性注入的自定义处理。需要注意的是，MyBeanPostProcessor 需要在 Spring 容器中作为一个 Bean 进行注册，才能被 Spring 容器识别并执行其中的逻辑。

我们进行验证代码如下：

package org.zyf.javabasic;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.zyf.javabasic.springextend.beanpostprocessorext.MyBean;
import springfox.documentation.swagger2.annotations.EnableSwagger2;/*** 描述：启动入口类** @author yanfengzhang* @date 2019-12-19 18:11*/
@SpringBootApplication
@ComponentScan(basePackages = {"org.zyf.javabasic"})
@EnableAspectJAutoProxy(proxyTargetClass = true, exposeProxy = true)
@EnableSwagger2
public class ZYFApplication {public static void main(String[] args) {ApplicationContext context = SpringApplication.run(ZYFApplication.class, args);// 使用 MyBeanMyBean myBean = context.getBean(MyBean.class);myBean.doSomething(); // 调用 MyBean.doSomething() 方法}@Beanpublic MyBean myBean(){return new MyBean();}
}

具体返回中注意如下展示

 （二）AOP 预处理

可以通过实现 BeanPostProcessor 接口，在 Bean 实例化后、初始化之前，对 Bean 进行 AOP 相关的预处理。例如，可以在 BeanPostProcessor 的 postProcessBeforeInitialization 方法中，为 Bean 动态生成代理对象，实现 AOP 面向切面的功能

参考链接：

1.Spring实战系列（三）-BeanPostProcessor的妙用_轻鸿飘羽的博客-CSDN博客