BeanPostProcessor

BeanPostProcessor在Bean实例化后介入，可修改或包装Bean实例。

接口定义

public interface BeanPostProcessor {
    // 初始化前处理
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        return bean;
    }

    // 初始化后处理
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        return bean;
    }
}

执行时机

┌─────────────────────────────────────┐
│  Bean实例化                          │
├─────────────────────────────────────┤
│  属性注入                            │
├─────────────────────────────────────┤
│  Aware接口回调                       │
├─────────────────────────────────────┤
│  BeanPostProcessor.postProcessBeforeInitialization │
├─────────────────────────────────────┤
│  @PostConstruct                      │
├─────────────────────────────────────┤
│  InitializingBean.afterPropertiesSet │
├─────────────────────────────────────┤
│  BeanPostProcessor.postProcessAfterInitialization │
├─────────────────────────────────────┤
│  Bean就绪                            │
└─────────────────────────────────────┘

基本实现

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("初始化前: " + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("初始化后: " + beanName);
        return bean;
    }
}

注解处理实现

@Component
public class MyAnnotationPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        Class<?> clazz = bean.getClass();

        // 处理字段注解
        for (Field field : clazz.getDeclaredFields()) {
            if (field.isAnnotationPresent(MyInject.class)) {
                field.setAccessible(true);
                try {
                    Object value = resolveValue(field);
                    field.set(bean, value);
                } catch (IllegalAccessException e) {
                    throw new RuntimeException(e);
                }
            }
        }

        return bean;
    }

    private Object resolveValue(Field field) {
        MyInject annotation = field.getAnnotation(MyInject.class);
        String name = annotation.value();
        return applicationContext.getBean(name);
    }
}

创建代理对象

@Component
public class ProxyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        Class<?> clazz = bean.getClass();

        // 检查是否需要代理
        if (clazz.isAnnotationPresent(RequireProxy.class)) {
            return createProxy(bean);
        }

        return bean;
    }

    private Object createProxy(Object target) {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            (proxy, method, args) -> {
                // 前置逻辑
                System.out.println("调用方法: " + method.getName());
                Object result = method.invoke(target, args);
                // 后置逻辑
                return result;
            }
        );
    }
}

过滤特定Bean

@Component
public class ServiceBeanPostProcessor implements BeanPostProcessor, BeanFactoryAware {

    private BeanFactory beanFactory;

    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        // 只处理Service类型的Bean
        if (beanFactory.getType(beanName) != null &&
            beanFactory.getType(beanName).isAnnotationPresent(Service.class)) {
            // 对Service Bean进行处理
            processService(bean);
        }
        return bean;
    }
}

Spring内置BeanPostProcessor

实际应用示例

日志记录增强

@Component
public class LoggingBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean.getClass().isAnnotationPresent(Logging.class)) {
            return createLoggingProxy(bean);
        }
        return bean;
    }

    private Object createLoggingProxy(Object target) {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            (proxy, method, args) -> {
                long start = System.currentTimeMillis();
                try {
                    return method.invoke(target, args);
                } finally {
                    long elapsed = System.currentTimeMillis() - start;
                    System.out.println(target.getClass().getSimpleName() +
                        "." + method.getName() + " 执行耗时: " + elapsed + "ms");
                }
            }
        );
    }
}

属性校验

@Component
public class ValidationBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        // 校验Bean属性
        validateProperties(bean);
        return bean;
    }

    private void validateProperties(Object bean) {
        Class<?> clazz = bean.getClass();
        for (Field field : clazz.getDeclaredFields()) {
            if (field.isAnnotationPresent(NotNull.class)) {
                field.setAccessible(true);
                try {
                    Object value = field.get(bean);
                    if (value == null) {
                        throw new IllegalStateException(
                            field.getName() + " 不能为空");
                    }
                } catch (IllegalAccessException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

与BeanFactoryPostProcessor对比

要点总结

• postProcessBeforeInitialization在@PostConstruct前执行
• postProcessAfterInitialization在初始化方法后执行
• 可返回包装对象（如代理）替换原Bean
• Spring核心功能（AOP、注解处理）基于此接口
• 与BeanFactoryPostProcessor时机和对象不同