定制化Bean的利器：BeanPostProcessor、BeanFactoryPostProcessor

前言：

Spring的面试中，一般都会问到IOC和AOP，大部分同学都能回答出这些知识点的基本运用，如果再多问一句，AOP的底层实现方式，大部分人都会回答动态代理。那么动态代理是如何被使用到Bean上的呢？到这里可能要刷掉一大部分人，如果没有看过Spring的源码的话，这个是比较难回答的。

实际就是今天要了解的BeanPostProcessor，这是一个比较神奇的接口，实现AOP功能主要就是依靠这个接口。

在Spring官方文档中，这两个知识点被当做扩展知识点来介绍的。

1.BeanPostProcessor介绍

该接口定义了两个回调方法用于用户实现，我们可以在里面定义一系列的实现。

public interface BeanPostProcessor {

	Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

	Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

如果我们自定义了BeanPostProcessor的实现，并注册到容器中，则bean的加载过程中，相关方法的调用顺序为：

* 容器实例化bean

* 调用BeanPostProcessor.postProcessBeforeInitialization()前置方法

* 调用bean的初始化方法

* 调用BeanPostProcessor.postProcessAfterInitialization()后置方法

Spring提供了这么一个接口，允许我们自定义实现，我们可以在自己的实现中修改bean相关属性，打印日志等一系列操作。

下面通过一个示例看下BeanPostProcessor的使用

1）定义BeanPostProcessor实现

public class HelloBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("before...");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("after...");

        if (bean instanceof Student){
            bean = (Student)bean;
            ((Student) bean).setName("test:" + ((Student) bean).getName());
        }
        return bean;
    }
}

2）定义测试Bean

@Data
public class Student implements Serializable {
    private static final long serialVersionUID = -2088281526481179972L;
    private int id;
    private String name;
    private int age;
    public Student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
        System.out.println("allArgsConstructor...");
    }
    public Student() {
        System.out.println("noArgsConstructor...");
    }
    public void init(){
        System.out.println("student init...");
    }

    public void destroy(){
        System.out.println("student destroy...");
    }

}

3）将bean添加到容器中，使用JavaConfig的方式

@Configuration
public class SpringConfiguration {

    @Bean(name = "stu",autowire = Autowire.BY_TYPE,initMethod = "init")
    @Scope(value = "singleton")
    public Student student(){
        return new Student(11,"jack",22);
    }

    @Bean
    public HelloBeanPostProcessor helloBeanPostProcessor(){
        return new HelloBeanPostProcessor();
    }
}

4）测试

@Test
public void testProcessor(){
    AnnotationConfigApplicationContext applicationContext
        = new AnnotationConfigApplicationContext(SpringConfiguration.class);
    Student bean = applicationContext.getBean(Student.class);
    System.out.println(bean);
}
// res
allArgsConstructor...
before...
16:55:14,929 DEBUG main support.DefaultListableBeanFactory:1731 - Invoking init method  'init' on bean with name 'stu'
student init...
after...
    
16:47:19,927 DEBUG main support.DefaultListableBeanFactory:483 - Finished creating instance of bean 'stu'
16:47:19,928 DEBUG main support.DefaultListableBeanFactory:251 - Returning cached instance of singleton bean 'helloBeanPostProcessor'
16:47:19,936 DEBUG main support.DefaultListableBeanFactory:251 - Returning cached instance of singleton bean 'org.springframework.context.event.internalEventListenerFactory'
16:47:19,990 DEBUG main support.DefaultListableBeanFactory:251 - Returning cached instance of singleton bean 'lifecycleProcessor'
16:47:20,003 DEBUG main support.DefaultListableBeanFactory:251 - Returning cached instance of singleton bean 'stu'
    
Student(id=11, name=test:jack, age=22)

总结：通过结果可以看到我们之前所定义的结论是正确的。

先调用构造方法实例化bean，然后是BeanPostProcessor的before方法，紧接着就是Bean的初始化方法（本例中的Student.init），最后就是BeanPostProcessor的after方法

2.BeanFactoryPostProcessor

之前面试的时候被问到过这个接口，当场就蒙了。

这个接口与我们上面的BeanPostProcessor只差了一个Factory，那么它们的功能呢？有什么相似点，又有什么不同点呢？

我们来看下Spring官方文档对其的描述

BeanFactoryPostProcessor operates on the bean configuration metadata; that is, the Spring IoC container allows a BeanFactoryPostProcessor to read the configuration metadata and potentially change it before the container instantiates any beans other than BeanFactoryPostProcessors.

主要就是说：BeanFactoryPostProcessor主要操作的是bean的元数据。

什么是bean的元数据？我们可以理解为这个bean有哪些属性，属性的类型，属性的scope等等。

下面我们就来测试一下

1）实现接口BeanFactoryPostProcessor

public class HelloBeanFactoryPostProcessor  implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryPostProcessor.postProcessBeanFactory()");

        String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
        for (String beanName: beanDefinitionNames) {
            if ("stu".equals(beanName)){
                BeanDefinition student = beanFactory.getBeanDefinition(beanName);
                MutablePropertyValues propertyValues = student.getPropertyValues();

                // 修改scope
                student.setScope("prototype");
            }
        }
    }
}

我们在这里修改一下stu这个bean的scope，原来为singleton，现在修改为prototype

2）在SpringConfiguration中添加该bean

     @Bean
    public HelloBeanFactoryPostProcessor helloBeanFactoryPostProcessor(){
        return new HelloBeanFactoryPostProcessor();
    }

3）测试

@Test
public void testProcessor(){
    AnnotationConfigApplicationContext applicationContext
        = new AnnotationConfigApplicationContext(SpringConfiguration.class);
    Student bean = applicationContext.getBean(Student.class);

    Student bean2 = applicationContext.getBean(Student.class);
    System.out.println(bean);
    System.out.println(bean == bean2);
}

// res
allArgsConstructor...
before...
student init...
after...
Student(id=11, name=test:jack, age=22)
false

可以看到，最终返回的是false，说明两次生成的对象不是同一个对象，也说明我们修改stu1这个bean的scope成功了。

3.官方对这两个接口的应用

BeanPostProcessor：AOP

BeanFactoryPostProcessor：PropertyPlaceholderConfigurer

以后笔者再详细分析一下PropertyPlaceholderConfigurer的应用