Spring 源码解析 – BeanPostProcessor 扩展接口

一、BeanPostProcessor 扩展接口

BeanPostProcessor是Spring中的一个扩展接口，它可以在Spring容器实例化bean之后，在执行 bean的初始化方法前后，允许我们自定义修改新的 bean实例。比如修改 bean 的属性，将 bean 替换为动态代理等。其中 AOP 的底层创建代理实例，就是通过实现 BeanPostProcessor 来实现的。

BeanPostProcessor 包含两个方法：

public interface BeanPostProcessor {
    /**
     *  实例化及依赖注入完成后、bean 初始化方法触发之前执行
     */
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    /**
     *  bean 初始化方法触发后执行
     */
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

}

如果在 Bean 实例化、配置和其他初始化过程中有任何错误，由 Spring 抛出 BeansException 异常。由于 BeanPostProcessor 可以干预 Bean 实例化、配置和初始化的每个阶段，因此实现过程需要非常谨慎。

BeanPostProcessor 是怎么干预 Bean 实例化的呢？可以通过下面这个案例感受一下：

这里我们创建一个测试 bean：

@Component
public class Test {
    public void test() {
        System.out.println("test...");
    }
}

下面创建一个类实现 BeanPostProcessor 接口，在后通知中使用 CGLIB 创建一个动态代理对象：

@Component
public class TestBeanPostProcessor implements BeanPostProcessor {

    /**
     * 实例化及依赖注入完成后、bean 初始化方法触发之前执行
     */
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
       return bean;
    }

    /**
     * bean 初始化方法触发后执行
     */
    public Object postProcessAfterInitialization(final Object bean, String beanName) throws BeansException {
        Class beanClass = bean.getClass();
        if (beanClass == Test.class) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(beanClass);
            enhancer.setCallback((MethodInterceptor) (o, method, objects, methodProxy) -> {
                System.out.println("<目标方法之前开始执行....>");
                Object result = methodProxy.invokeSuper(o, objects);
                System.out.println("<目标方法之后开始执行....>");
                return result;
            });
            return enhancer.create();
        }
        return bean;
    }
}

下面测试下效果：

public class App {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext("com.example.demo.beanpost");
        Test hello = (Test) context.getBean("test");
        hello.test();
    }
}

这样是不是就感受到 BeanPostProcessor 扩展接口的强大之处了吧，可以看出它可以干预 Bean 的实例化，因此使用的话需要非常谨慎。

下面从源码角度分析下，在 Spring 中是如何使用 BeanPostProcessor 进行扩展的。

二、BeanPostProcessor 的注册

从上面的实例中可以感觉出来，我们并没有对 BeanPostProcessor 进行特殊处理，仅仅将其加入 Spring 容器中即会生效，那 Spring 是如何读取BeanPostProcessor 呢？

在本专栏的其他 Spring 源码分析的文章中，分析的入口都是基于 AbstractApplicationContext 中的 refresh() 方法，那现在也是从这里入手，主要逻辑在该方法下触发的 registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) 方法：

主要逻辑则在 PostProcessorRegistrationDelegate 下的 registerBeanPostProcessors 方法，源码如下：

public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

    // 从bean工厂中获取到所有实现了 BeanPostProcessor 接口的 beanName
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    // Register BeanPostProcessorChecker that logs an info message when
    // a bean is created during BeanPostProcessor instantiation, i.e. when
    // a bean is not eligible for getting processed by all BeanPostProcessors.
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    // 往bean工厂中添加一个BeanPostProcessor -> BeanPostProcessorChecker
    // BeanPostProcessorChecker 是一个在创建bean期间记录信息消息的 BeanPostProcessor
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    // Separate between BeanPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    // 存放实现了PriorityOrdered接口的BeanPostProcessor
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
    // 存放实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessor
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
    // 存放实现了Ordered接口的BeanPostProcessor
    List<String> orderedPostProcessorNames = new ArrayList<String>();
    // 存放普通的BeanPostProcessor
    List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
    for (String ppName : postProcessorNames) {
        // 如果实现了PriorityOrdered接口
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            // 从工厂中获取对应的 Bean实例
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);

            // 如果同时实现了MergedBeanDefinitionPostProcessor接口
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        // 如果实现了Ordered接口
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        // 普通的 BeanPostProcessor
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // 排序
    sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
    // 注册实现了PriorityOrdered 接口的 BeanPostProcessor
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // Next, register the BeanPostProcessors that implement Ordered.
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        // 如果同时实现了MergedBeanDefinitionPostProcessor接口
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    // 排序
    sortPostProcessors(beanFactory, orderedPostProcessors);
    //  注册实现了Ordered接口的BeanPostProcessor
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    // Now, register all regular BeanPostProcessors.
    // 注册其他普通的BeanPostProcessor
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        // 如果实现了 MergedBeanDefinitionPostProcessor 接口
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    // 通过 beanFactory.addBeanPostProcessor(postProcessor) 添加 BeanPostProcessor
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    // Finally, re-register all internal BeanPostProcessors.
    // 排序
    sortPostProcessors(beanFactory, internalPostProcessors);
    // 通过beanFactory.addBeanPostProcessor(postProcessor)添加BeanPostProcessor
    // 注册所有 BeanPostProcessor
    registerBeanPostProcessors(beanFactory, internalPostProcessors);

    // Re-register post-processor for detecting inner beans as ApplicationListeners,
    // moving it to the end of the processor chain (for picking up proxies etc).
    // 往bean工厂中添加一个BeanPostProcessor -> ApplicationListenerDetector
    // ApplicationListenerDetector主要是检测bean是否实现了ApplicationListener接口
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

三、BeanPostProcessor 触发点

BeanPostProcessor 与 bean 的实例化过程息息相关，因此可以从 bean 实例化的入口 AbstractAutowireCapableBeanFactory 类的 createBean 方法入手：

3.1 resolveBeforeInstantiation

首先看到 createBean 方法下触发的 resolveBeforeInstantiation 方法，主要是针对于 InstantiationAwareBeanPostProcessor 类型的 BeanPostProcessor ，并且使用是 postProcessBeforeInstantiation 和 postProcessAfterInitialization 方法，也是一种扩展通知，并且如果返回 bean 不为空则直接跳过 Spring 的实例化过程：

在这会尝试通过 BeanPostProcessors 获取一个对象，这个可能是代理实例也可能是其他实例：

这里判断如果有 InstantiationAwareBeanPostProcessor 类型的 BeanPostProcessor ，则尝试使用 postProcessBeforeInstantiation 方法获取一个代理实例。

3.2 getEarlyBeanReference

如果上面没有生成代理实例的话，再回到 createBean 方法中，在 doCreateBean 方法下，创建实例后，会曝光至三级缓存中：

在 getEarlyBeanReference 方法中，会尝试使用 SmartInstantiationAwareBeanPostProcessor 类型的 BeanPostProcessor 创建一个早期的实例，虽说 SmartInstantiationAwareBeanPostProcessor 没有直接实现 BeanPostProcessor 但其父类 InstantiationAwareBeanPostProcessor 实现了 BeanPostProcessor ：

Spring AOP 代理对象就是在此处获取，因此三级缓存存入ObjectFactory<?>而不是具体的 bean 的意义在此。

3.3 initializeBean

上面都是对特殊类型的 BeanPostProcessor 进行触发，在 doCreateBean 的 initializeBean 中则触发了全部的BeanPostProcessor ：

这里在 invokeInitMethods 方法前后触发了 BeanPostProcessor 的 postProcessBeforeInitialization 和 postProcessAfterInitialization：

四、Spring 中的 BeanPostProcessor 常用子类

从上面的触发点源码中，可以看出有些地方是触发的特定类型的 BeanPostProcessor 子类，而这些子类又有着不同的用途。

4.1 InstantiationAwareBeanPostProcessor

可以在Bean生命周期实例化Bean之前和实例化Bean之后对Bean进行操作，比如在上面源码中 createBean 方法下触发的 resolveBeforeInstantiation 方法。

InstantiationAwareBeanPostProcessor 类型的子类，会在目标Bean实例化之前尝试使用该类型的实例生成一个代理对象，如果方法返回的是一个非空对象, 将会跳过后续 Spring 默认的创建流程：

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {

    // 在目标Bean实例化之前执行尝试使用该类型的生成一个代理对象，如果方法返回的是一个非空对象, 将会跳过后续 Spring 默认的创建流程
    @Nullable
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    // 在目标Bean实例化之后、属性填充前执行，如果方法返回false,将会跳过后续的属性填充过程,通常情况下返回true
    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }

    // 允许对填充前的属性进行处理，比如对属性进行验证
    @Nullable
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
            throws BeansException {

        return null;
    }

    // 对属性值进行修改，通过基于原始的PropertyValues创建一个新的MutablePropertyValues实例，添加或删除特定的值
    // 已标记过期，官方推荐使用 postProcessProperties()方法
    @Deprecated
    @Nullable
    default PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        return pvs;
    }
}

4.2 SmartInstantiationAwareBeanPostProcessor

SmartInstantiationAwareBeanPostProcessor 也是一个接口继承了上面的 InstantiationAwareBeanPostProcessor 因此拥有 InstantiationAwareBeanPostProcessor 的特征，在此之外又提供了获取早期实例的方法。

在 Spring 的三级缓存中则会尝试使用 getEarlyBeanReference 获取一个早期实例。

public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {

    //在 Bean 实例化前预测最终返回的 Class 类型，触发时机是在InstantiationAwareBeanPostProcessor的 postProcessBeforeInstantiation()之前
    @Nullable
    default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    //决定使用哪个构造器构造Bean，如果不指定，默认为null，即bean的无参构造方法；
    @Nullable
    default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName)
            throws BeansException {

        return null;
    }

    //获得提前暴露的bean引用，主要用于 Spring 循环依赖问题的解决
    default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
        return bean;
    }

}

4.3 ApplicationContextAwareProcessor

应用上下文感知Bean后置处理器，在postProcessBeforeInitialization方法中通过invokeAwareInterfaces方法给目标 Bean 注入指定的属性值：

class ApplicationContextAwareProcessor implements BeanPostProcessor {

    private final ConfigurableApplicationContext applicationContext;

    private final StringValueResolver embeddedValueResolver;


    /**
     * Create a new ApplicationContextAwareProcessor for the given context.
     */
    public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
        this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
    }


    @Override
    @Nullable
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
                bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
                bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware ||
                bean instanceof ApplicationStartupAware)) {
            return bean;
        }

        AccessControlContext acc = null;

        if (System.getSecurityManager() != null) {
            acc = this.applicationContext.getBeanFactory().getAccessControlContext();
        }

        if (acc != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                invokeAwareInterfaces(bean);
                return null;
            }, acc);
        }
        else {
            invokeAwareInterfaces(bean);
        }

        return bean;
    }

    private void invokeAwareInterfaces(Object bean) {
        // 给bean设置Environment属性
        if (bean instanceof EnvironmentAware) {
            ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
        }
        // 给bean设置EmbeddedValueResolver属性
        if (bean instanceof EmbeddedValueResolverAware) {
            ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
        }
        // 给bean设置ResourceLoader属性
        if (bean instanceof ResourceLoaderAware) {
            ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
        }
        // 给bean设置ApplicationEventPublisher属性
        if (bean instanceof ApplicationEventPublisherAware) {
            ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
        }
        // 给bean设置MessageSource属性
        if (bean instanceof MessageSourceAware) {
            ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
        }
        // 给bean设置 ApplicationStartupAware属性
        if (bean instanceof ApplicationStartupAware) {
            ((ApplicationStartupAware) bean).setApplicationStartup(this.applicationContext.getApplicationStartup());
        }
        // 给bean设置ApplicationContext属性
        if (bean instanceof ApplicationContextAware) {
            ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
        }
    }

}

4.4 ApplicationListenerDetector

判断目标 Bean 是否实现 ApplicationListener ，如果有则注册事件：

class ApplicationListenerDetector implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor {

    private static final Log logger = LogFactory.getLog(ApplicationListenerDetector.class);

    private final transient AbstractApplicationContext applicationContext;

    private final transient Map<String, Boolean> singletonNames = new ConcurrentHashMap<>(256);


    public ApplicationListenerDetector(AbstractApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }


    @Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        if (ApplicationListener.class.isAssignableFrom(beanType)) {
            this.singletonNames.put(beanName, beanDefinition.isSingleton());
        }
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof ApplicationListener) {
            // potentially not detected as a listener by getBeanNamesForType retrieval
            Boolean flag = this.singletonNames.get(beanName);
            if (Boolean.TRUE.equals(flag)) {
                // 添加事件
                this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
            }
            else if (Boolean.FALSE.equals(flag)) {
                if (logger.isWarnEnabled() && !this.applicationContext.containsBean(beanName)) {
                    // inner bean with other scope - can't reliably process events
                    logger.warn("Inner bean '" + beanName + "' implements ApplicationListener interface " +
                            "but is not reachable for event multicasting by its containing ApplicationContext " +
                            "because it does not have singleton scope. Only top-level listener beans are allowed " +
                            "to be of non-singleton scope.");
                }
                this.singletonNames.remove(beanName);
            }
        }
        return bean;
    }

    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) {
        if (bean instanceof ApplicationListener) {
            try {
                ApplicationEventMulticaster multicaster = this.applicationContext.getApplicationEventMulticaster();
                multicaster.removeApplicationListener((ApplicationListener<?>) bean);
                multicaster.removeApplicationListenerBean(beanName);
            }
            catch (IllegalStateException ex) {
                // ApplicationEventMulticaster not initialized yet - no need to remove a listener
            }
        }
    }

    @Override
    public boolean requiresDestruction(Object bean) {
        return (bean instanceof ApplicationListener);
    }


    @Override
    public boolean equals(@Nullable Object other) {
        return (this == other || (other instanceof ApplicationListenerDetector &&
                this.applicationContext == ((ApplicationListenerDetector) other).applicationContext));
    }

    @Override
    public int hashCode() {
        return ObjectUtils.nullSafeHashCode(this.applicationContext);
    }

}

原文始发于微信公众号（狂热Java小毕超）：Spring 源码解析 – BeanPostProcessor 扩展接口