转载

Spring拓展点：BeanFactoryPostProcessor及其子接口

BeanFactoryPostProcessor

BeanFactoryPostProcessor 是一个函数式接口，里面只有一个方法：

@FunctionalInterface
public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

再看一下doc文档上的相关描述：

Allows for custom modification of an application context's bean definitions, adapting the bean property values of the context's underlying bean factory. Application contexts can auto-detect BeanFactoryPostProcessor beans in their bean definitions and apply them before any other beans get created. A BeanFactoryPostProcessor may interact with and modify bean definitions, but never bean instances. Doing so may cause premature bean instantiation, violating the container and causing unintended side-effects. If bean instance interaction is required, consider implementing BeanPostProcessor instead.

机器翻译：允许自定义修改应用程序上下文的bean定义，调整上下文的基础bean工厂的bean属性值。应用程序上下文可以在其bean定义中自动检测BeanFactoryPostProcessor bean，并在创建任何其他bean之前先创建BeanFactoryPostProcessor。BeanFactoryPostProcessor可以与bean定义交互并修改bean定义，但绝不能与bean实例交互。这样做可能会导致bean过早实例化，违反容器并导致意外的副作用。如果需要bean实例交互，请考虑实现BeanPostProcessor。实现该接口，可以允许我们的程序获取到 BeanFactory ，从而修改 BeanFactory ，可以实现编程式的往Spring容器中添加Bean。

总结，也就是说，我们可以通过实现 BeanFactoryPostProcessor 接口，获取 BeanFactory ，操作 BeanFactory 对象，修改 BeanDefinition ，但不要去实例化bean。

BeanDefinitionRegistryPostProcessor

BeanDefinitionRegistryPostProcessor 是 BeanFactoryPostProcessor 的子类，在父类的基础上，增加了新的方法，允许我们获取到 BeanDefinitionRegistry ，从而编码动态修改 BeanDefinition 。例如往 BeanDefinition 中添加一个新的 BeanDefinition 。

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
    void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}

Extension to the standard BeanFactoryPostProcessor SPI, allowing for the registration of further bean definitions before regular BeanFactoryPostProcessor detection kicks in. In particular, BeanDefinitionRegistryPostProcessor may register further bean definitions which in turn define BeanFactoryPostProcessor instances.

机器翻译：对标准BeanFactoryPostProcessor SPI的扩展，允许在进行常规BeanFactoryPostProcessor检测之前注册其他Bean定义。特别是，BeanDefinitionRegistryPostProcessor可以注册其他Bean定义，这些定义又定义了BeanFactoryPostProcessor实例。

执行时机

那么 BeanFactoryPostProcessor 和 BeanDefinitionRegistryPostProcessor 接口是在什么时候被回调的呢？

看过我之前文章的小伙伴不知道还记不得的，这两个接口是在 AbstractApplicationContext#refresh 方法中执行到 invokeBeanFactoryPostProcessors(beanFactory); 方法时被执行的。Spring的编码取名真的很艺术，方法名虽然很长，但是一看就知道在做什么。

举个例子

@Repository
public class OrderDao {

    public void query() {
        System.out.println("OrderDao query...");
    }
}
public class OrderService {

    private OrderDao orderDao;

    public void setDao(OrderDao orderDao) {
        this.orderDao = orderDao;
    }

    public void init() {
        System.out.println("OrderService init...");
    }

    public void query() {
        orderDao.query();
    }
}
@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        //向Spring容器中注册OrderService
        BeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(OrderService.class)
                //这里的属性名是根据setter方法
                .addPropertyReference("dao", "orderDao")
                .setInitMethodName("init")
                .setScope(BeanDefinition.SCOPE_SINGLETON)
                .getBeanDefinition();

        registry.registerBeanDefinition("orderService", beanDefinition);

    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 在这里修改orderService bean的scope为PROTOTYPE
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition("orderService");
        beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
    }
}

OrderService 通过 MyBeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry 注册到了容器中，又通过 MyBeanDefinitionRegistryPostProcessor#postProcessBeanFactory 方法修改了其Scope。最后运行主方法：

@Configuration
@ComponentScan
public class Main {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Main.class);
        //能成功从容器中获取orderService,并成功调用orderService.query();方法
        OrderService orderService = context.getBean(OrderService.class);
        orderService.query();
        OrderService orderService2 = context.getBean(OrderService.class);
        //false,orderService已经不是单例
        System.out.println(orderService == orderService2);
        context.close();
    }
}

典型应用：ConfigurationClassPostProcessor

在Spring中 ConfigurationClassPostProcessor 同时实现了 BeanDefinitionRegistryPostProcessor 接口和其父类接口中的方法。

ConfigurationClassPostProcessor#postProcessBeanFactory ：主要负责对Full Configuration 配置进行增强，拦截 @Bean 方法来确保增强执行 @Bean 方法的语义。
ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry ：负责扫描我们的程序，根据程序的中Bean创建 BeanDefinition ，并注册到容器中。

欢迎各位关注公众号：

Spring拓展点：BeanFactoryPostProcessor及其子接口