作用
1. 细粒度控制 Bean 生命周期
Spring 容器在创建 Bean 的过程中，会经过实例化、属性赋值、初始化等多个步骤。BeanPostProcessor 允许开发者在 Bean 初始化前后这两个关键节点插入自定义逻辑，对 Bean 进行定制化处理。
- 实例化和属性赋值后干预：在 Bean 的构造函数执行完毕且属性赋值完成后，postProcessBeforeInitialization 方法会被调用。这为开发者提供了在 Bean 正式初始化之前进行最后修改的机会，例如根据某些条件修改 Bean 的属性值。
- 初始化方法执行后增强：postProcessAfterInitialization 方法在 Bean 的初始化方法（如 init-method 或 @PostConstruct 注解标注的方法）执行之后被调用。此时可以对已经完成初始化的 Bean 进行增强，比如添加代理对象，为 Bean 增加额外的功能。
2. 非侵入式扩展
使用 BeanPostProcessor 可以在不修改 Bean 本身代码的情况下，对其进行功能扩展。这符合面向对象编程中的开闭原则，即对扩展开放，对修改关闭。例如，在一个已有的项目中，需要为所有实现了某个接口的 Bean 添加日志记录功能，通过实现 BeanPostProcessor 可以轻松实现，而不需要修改这些 Bean 的源代码。
主要子类及详细分析
1. ApplicationContextAwareProcessor
- 功能：该处理器主要用于处理实现了一系列 Aware 接口的 Bean。Aware 接口是 Spring 提供的一种回调机制，允许 Bean 获取 Spring 容器的相关信息。ApplicationContextAwareProcessor 会在 Bean 初始化过程中，将 ApplicationContext、BeanFactory 等容器对象注入到实现了相应 Aware 接口的 Bean 中。
- 示例：当一个 Bean 实现了 ApplicationContextAware 接口时，ApplicationContextAwareProcessor 会调用该 Bean 的 setApplicationContext 方法，将 ApplicationContext 实例传递给它。
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
@Component
public class MyAwareBean implements ApplicationContextAware {
private ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) {
this.applicationContext = applicationContext;
// 可以使用 applicationContext 进行其他操作
}
}2. InitDestroyAnnotationBeanPostProcessor
- 功能：负责处理带有 @PostConstruct 和 @PreDestroy 注解的 Bean。这两个注解是 Java EE 规范中定义的，用于标记 Bean 的初始化和销毁方法。InitDestroyAnnotationBeanPostProcessor 会在 Bean 的生命周期中相应的阶段调用这些方法。
- 示例：
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.springframework.stereotype.Component;
@Component
public class MyAnnotatedBean {
@PostConstruct
public void init() {
System.out.println("Initializing MyAnnotatedBean");
}
@PreDestroy
public void destroy() {
System.out.println("Destroying MyAnnotatedBean");
}
}3. AutowiredAnnotationBeanPostProcessor
- 功能：处理带有 @Autowired、@Resource、@Inject 等依赖注入注解的 Bean。它会在 Bean 实例化后，根据注解信息从 Spring 容器中查找并注入相应的依赖对象。
- 示例：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class MyAutowiredBean {
private AnotherBean anotherBean;
@Autowired
public MyAutowiredBean(AnotherBean anotherBean) {
this.anotherBean = anotherBean;
}
}
使用场景
1. AOP 实现细节
- 代理创建：在 Spring AOP 中，BeanPostProcessor 用于创建代理对象。当一个 Bean 需要被 AOP 增强时，AbstractAutoProxyCreator（它是 BeanPostProcessor 的子类）会在 Bean 初始化后，根据配置的切面信息，为该 Bean 创建代理对象。代理对象会拦截目标 Bean 的方法调用，并在调用前后执行切面逻辑，如日志记录、事务管理等。
- 示例配置：
上述配置会自动注册一个
AnnotationAwareAspectJAutoProxyCreator，它是 AbstractAutoProxyCreator 的子类，负责处理基于注解的 AOP 配置。
2. 数据校验
- 实现方式：可以在 postProcessAfterInitialization 方法中对 Bean 的属性进行校验。例如，使用 Java 的 Validator 框架对 Bean 的属性进行验证，如果验证不通过，可以抛出异常或者进行默认值设置。
- 示例代码：
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import java.util.Set;
public class ValidationBeanPostProcessor implements BeanPostProcessor {
private final Validator validator;
public ValidationBeanPostProcessor() {
ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
this.validator = factory.getValidator();
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
Set<ConstraintViolation<Object>> violations = validator.validate(bean);
if (!violations.isEmpty()) {
StringBuilder errorMessage = new StringBuilder();
for (ConstraintViolation<Object> violation : violations) {
errorMessage.append(violation.getPropertyPath()).append(": ").append(violation.getMessage()).append("\n");
}
throw new IllegalArgumentException("Validation failed for bean " + beanName + ": " + errorMessage.toString());
}
return bean;
}
}
3. 资源注入
- 自定义资源注入：除了 Spring 内置的依赖注入方式，还可以使用 BeanPostProcessor 实现自定义的资源注入。例如，从外部配置文件或者数据库中读取一些配置信息，并注入到相应的 Bean 中。
- 示例代码：
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class CustomResourceInjector implements BeanPostProcessor {
private final Properties properties;
public CustomResourceInjector() {
properties = new Properties();
try (InputStream inputStream = getClass().getClassLoader().getResourceAsStream("config.properties")) {
if (inputStream != null) {
properties.load(inputStream);
}
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof CustomResourceAware) {
((CustomResourceAware) bean).setCustomResource(properties.getProperty("custom.resource"));
}
return bean;
}
public interface CustomResourceAware {
void setCustomResource(String resource);
}
}
使用方法
1. 创建自定义的 BeanPostProcessor 实现类
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class CustomBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
// 可以根据 bean 的类型或名称进行不同的处理
if (bean instanceof MyCustomBean) {
// 对 MyCustomBean 进行特殊处理
((MyCustomBean) bean).setSomeProperty("Modified value");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof MyCustomBean) {
// 可以在这里添加代理对象或进行其他增强操作
}
return bean;
}
}2. 注册自定义的 BeanPostProcessor
- 基于 XML 配置
- 基于 Java 配置
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
public CustomBeanPostProcessor customBeanPostProcessor() {
return new CustomBeanPostProcessor();
}
}