Spring之BeanFactoryPostProcessor和BeanPostProcessor

文章目录

概述

BeanFactoryPostProcessor 和 BeanPostProcessor 这两个接口，都是 Spring 初始化 bean 时对外暴露的扩展点，一般叫做 Spring 的 Bean 后置处理器接口，作用是为 Bean 的初始化前后提供可扩展的空间。两个接口名称看起来很相似，但作用和使用场景却略有不同。

Spring 中 bean 的生命周期图：

由上图可以看到，Spring 中的 BeanFactoryPostProcessor 在实例化之前被调用，而 BeanPostProcessor 则是在实例化过程中使用。

BeanFactoryPostProcessor

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

实现该接口，可以在 Spring 创建 bean 之前修改 bean 的定义属性。也就是说，Srping 允许 BeanFactoryPostProcessor 在容器实例化 bean 之前读取配置元数据，并可以根据需要进行修改。例如可以把 bean 的 Scope 从 singleton 改为 prototype ，也可以把 property 的值给修改掉。另外可以同时配置多个 BeanFactoryPostProcessor，并通过 order 属性来控制 BeanFactoryPostProcessor 的执行顺序（在实现 BeanFactoryPostProcessor 时应该考虑实现 Ordered 接口）。

BeanFactoryPostProcessor 是在 Spring 容器加载了定义 bean 的 XML 文件之后，在 bean 实例化之前执行的。接口方法的入参是 ConfigurrableListableBeanFactory 类型，使用该参数可以获取到相关的 bean 的定义信息。

实际分析

XML 文件配置

首先是 XML 文件，

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="com.msdn.bean.User">
        <!--<property name="name" value="hresh" />-->
        <property name="name" value="${user.name}" />
    </bean>

</beans>

这其中出现了变量：user.name，这是 spring 的分散配置，可以在另外的配置文件中为 user.name 指定值，例如在 bean.properties 文件中定义：

user.name = hresh

当访问名为 user 的 bean 时，其 name 属性就会被字符串 hresh 替换，那 spring 框架是怎么知道存在这样的配置文件呢，这个就是 PropertyPlaceholderConfigurer，需要在配置文件中添加一下代码：

<bean id="userHandler" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
        <list>
            <value>classpath:bean.properties</value>
        </list>
    </property>
</bean>

PropertyPlaceholderConfigurer

在这个 bean 中指定了配置文件的位置。其实还是有个问题，这个 userHandler 只不过是 spring 框架管理的一个 bean，并没有被别的 bean 或者对象引用，spring 的beanFactory 是怎么知道这个需要从这个 bean 中获取配置信息呢？我们看下 PropertyPlaceholderConfigurer 这个类的层次结构，如下图：

从上图可以看到 PropertyPlaceholderConfigurer 间接的继承了 BeanFactoryPostProcessor 接口，这是一个特别的接口，当 Spring 加载任何实现了该接口的 bean 的配置时，都会在 bean 工厂载入所有 bean 的配置之后执行 postProcessBeanFactory 方法。在 PropertyResourceConfigurer 类中实现了 postProcessBeanFactory 方法，该方法中先后调用了 mergeProperties、convertProperties、processProperties 这三个方法，先得到配置，将得到的配置转换为合适的类型，最后将配置内容告知 BeanFactory。

正是通过实现 BeanFactoryPostProcessor 接口，BeanFactory 会在实例化任何 bean之前获得配置信息，从而能够正确的解析 bean 描述文件中的变量引用。

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    try {
        Properties mergedProps = this.mergeProperties();
        this.convertProperties(mergedProps);
        this.processProperties(beanFactory, mergedProps);
    } catch (IOException var3) {
        throw new BeanInitializationException("Could not load properties", var3);
    }
}

关于 PropertyPlaceholderConfigurer 类的详细解析，有兴趣的朋友可以阅读：

【Spring源码分析】.properties文件读取及占位符${…}替换源码解析

自定义BeanFactoryPostProcessor

编写实现了 BeanFactoryPostProcessor 接口的 MyBeanFactoryPostProcessor 的容器后处理器，如下代码：

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("对容器进行处理后。。。。。");
    }
}

然后在配置文件中注册这个 bean，如下：

<bean id="myPost" class="com.msdn.processor.MyBeanFactoryPostProcessor"></bean>

最后编写测试代码：

@Test
public void MyBean(){
    //解析application_context.xml文件 , 生成管理相应的Bean对象
    ApplicationContext context = new ClassPathXmlApplicationContext("application_context.xml");

    User user = (User) context.getBean("user");
    System.out.println(user);
    System.out.println(user.hashCode());

    User user1 = (User) context.getBean("user");
    System.out.println(user1);
    System.out.println(user1.hashCode());

}

此时的执行结果为：

对容器进行处理后。。。。。
User{name='hresh'}
681384962
User{name='hresh'}
681384962

再编写一个实现了 BeanFactoryPostProcessor 接口的 UserFactoryPostProcessor 类，用来修改 bean 的属性和 Scope。

public class UserFactoryPostProcessor implements BeanFactoryPostProcessor {
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("调用UserFactoryPostProcessor的postProcessBeanFactory方法");
        BeanDefinition beanDefinition = configurableListableBeanFactory.getBeanDefinition("user");
        MutablePropertyValues pv = beanDefinition.getPropertyValues();
        if (pv.contains("name")){
            pv.addPropertyValue("name","acorn");
        }
        beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);

    }
}

然后在配置文件中注册这个 bean，如下：

 <bean id="myUser" class="com.msdn.processor.UserFactoryPostProcessor"></bean>

调用测试代码，结果为：

对容器进行处理后。。。。。
调用UserFactoryPostProcessor的postProcessBeanFactory方法
User{name='acorn'}
586084331
User{name='acorn'}
399534175

如果要控制 BeanFactoryPostProcessor 的实现类的执行顺序，可以这样来修改代码：

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor,Ordered {
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("对容器进行处理后。。。。。");
    }

    public int getOrder() {
        return 1;
    }
}

public class UserFactoryPostProcessor implements BeanFactoryPostProcessor,Ordered {
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("调用UserFactoryPostProcessor的postProcessBeanFactory方法");
        BeanDefinition beanDefinition = configurableListableBeanFactory.getBeanDefinition("user");
        MutablePropertyValues pv = beanDefinition.getPropertyValues();
        if (pv.contains("name")){
            pv.addPropertyValue("name","acorn");
        }
        beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);

    }

    public int getOrder() {
        return 0;
    }
}

再次调用测试代码，输出结果为：

调用UserFactoryPostProcessor的postProcessBeanFactory方法
对容器进行处理后。。。。。
User{name='acorn'}
586084331
User{name='acorn'}
399534175

从结果可以看出，通过实现 Ordered 接口，并重写 getOrder 方法，UserFactoryPostProcessor 比 MyBeanFactoryPostProcessor 更早执行。

BeanPostProcessor

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;
    }
}

BeanPostProcessor 可以在 spring 容器实例化 bean 之后，在执行 bean 的初始化方法前后，添加一些自己的处理逻辑。这里说的初始化方法，指的是以下两种：

bean 实现了 InitializingBean 接口，对应的方法为 afterPropertiesSet 。
在 XML 文件中定义 bean 的时候，标签有个属性叫做 init-method，来指定初始化方法。

注意：BeanPostProcessor 是在 spring 容器加载了 bean 的定义文件并且实例化 bean 之后执行的。BeanPostProcessor 的执行顺序是在 BeanFactoryPostProcessor 之后。

实战分析

首先我们定义一个 bean 类：

public class Person implements InitializingBean {
    private String name;
    private int age;

    public Person() {
        System.out.println("Person的无参构造函数");
    }

    public Person(String name, int age) {
        System.out.println("Person的有参构造函数，正在创建Person对象");
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("调用afterPropertiesSet方法，此时用来修改name属性值");
        this.name = "acorn";
    }

    public void init(){
        System.out.println("调用init方法");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

接着再定义一个 BeanFactoryPostProcessor 实现类：

public class PersonFactoryPostProcessor implements BeanFactoryPostProcessor {
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("调用PersonFactoryPostProcessor的postProcessBeanFactory方法");
        BeanDefinition beanDefinition = configurableListableBeanFactory.getBeanDefinition("person");
        MutablePropertyValues pv = beanDefinition.getPropertyValues();
        if (pv.contains("age")){
            pv.addPropertyValue("age","23");
        }
        beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
    }
}

再定义一个 BeanPostProcessor 实现类：

public class PersonPostProcessor implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor，对象" + beanName + "调用初始化方法之前的数据： " + bean.toString());
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor，对象" + beanName + "调用初始化方法之后的数据：" + bean.toString());
        Person person = (Person) bean;
        person.setName("clearLove");
        return person;
    }
}

修改 XML 文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


    <bean id="personPostProcessor" class="com.msdn.processor.PersonPostProcessor" />
    <bean id="personFactoryPostProcessor" class="com.msdn.processor.PersonFactoryPostProcessor" />
    <bean id="person" class="com.msdn.bean.Person" init-method="init">
        <property name="name" value="hresh" />
        <property name="age" value="18" />
    </bean>

</beans>

最后编写测试代码：

@Test
public void MyBean(){
    //解析application_context.xml文件 , 生成管理相应的Bean对象
    ApplicationContext context = new ClassPathXmlApplicationContext("application_context.xml");

    Person person = (Person) context.getBean("person");
    System.out.println(person);
    System.out.println(person.hashCode());

    //        Person person2 = (Person) context.getBean("person");
    //        System.out.println(person2);
    //        System.out.println(person2.hashCode());

}

执行结果为：

调用PersonFactoryPostProcessor的postProcessBeanFactory方法
Person的无参构造函数
BeanPostProcessor，对象person调用初始化方法之前的数据： Person{name='hresh', age=23}
调用afterPropertiesSet方法，此时用来修改name属性值
调用init方法
BeanPostProcessor，对象person调用初始化方法之后的数据：Person{name='acorn', age=23}
Person{name='clearLove', age=23}
2015781843

分析

从上述结果可以看出， BeanFactoryPostProcessor 在 bean 实例化之前被调用，注意在 PersonFactoryPostProcessor 的 postProcessBeanFactory 方法中只是修改了 bean 的定义信息，即将 age 值由18改为23，此时 bean 还未实例化。之后实例化bean，在此过程中，先调用 BeanPostProcessor 实现类中的 postProcessBeforeInitialization 方法，然后调用实现了 InitializingBean接口的 bean 类中的 afterPropertiesSet 方法，如果设置的有 init-method 方法，则也会被调用，最后再调用 BeanPostProcessor 实现类中的 postProcessAfterInitialization 方法。

如果有多个 bean 类的情况呢，BeanFactoryPostProcessor 和 BeanPostProcessor 又是如何工作的？

复用上文中的 User 类和 UserFactoryPostProcessor，然后修改 PersonFactoryPostProcessor 。

public class PersonFactoryPostProcessor implements BeanFactoryPostProcessor {
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("调用PersonFactoryPostProcessor的postProcessBeanFactory方法");
        BeanDefinition beanDefinition = configurableListableBeanFactory.getBeanDefinition("person");
        MutablePropertyValues pv = beanDefinition.getPropertyValues();
        if (pv.contains("age")){
            pv.addPropertyValue("age","23");
        }

    }
}

在 XML 文件中增加对 User 类的定义

<bean id="user" class="com.msdn.bean.User">
    <property name="name" value="hresh" />
</bean>
<bean id="myUser" class="com.msdn.processor.UserFactoryPostProcessor"></bean>

修改测试代码

@Test
public void MyBean(){
    //解析application_context.xml文件 , 生成管理相应的Bean对象
    ApplicationContext context = new ClassPathXmlApplicationContext("application_context.xml");

	User user1 = (User) context.getBean("user");
    System.out.println(user1);
    System.out.println(user1.hashCode());
        
    Person person = (Person) context.getBean("person");
    System.out.println(person);
    System.out.println(person.hashCode());

    //        Person person2 = (Person) context.getBean("person");
    //        System.out.println(person2);
    //        System.out.println(person2.hashCode());

}

执行结果为：

调用UserFactoryPostProcessor的postProcessBeanFactory方法
调用PersonFactoryPostProcessor的postProcessBeanFactory方法
Person的无参构造函数
BeanPostProcessor，对象person调用初始化方法之前的数据： Person{name='hresh', age=23}
调用afterPropertiesSet方法，此时用来修改name属性值
调用init方法
BeanPostProcessor，对象person调用初始化方法之后的数据：Person{name='acorn', age=23}
BeanPostProcessor，对象user调用初始化方法之前的数据： User{name='acorn'}
BeanPostProcessor，对象user调用初始化方法之后的数据：User{name='acorn'}
User{name='acorn'}
1682463303
Person{name='acorn', age=23}
633075331

从结果中可以得知，BeanFactoryPostProcessor 的实现类都需要在 XML 文件中进行配置。当你有多个 bean 类时，就需要实现多个 BeanFactoryPostProcessor ，然后在 XML 文件中进行配置，当然你也可以只写在一个实现类当中，比如说在 PersonFactoryPostProcessor 类中这样定义：

public class PersonFactoryPostProcessor implements BeanFactoryPostProcessor {
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("调用PersonFactoryPostProcessor的postProcessBeanFactory方法");
        BeanDefinition beanDefinition = configurableListableBeanFactory.getBeanDefinition("person");
        MutablePropertyValues pv = beanDefinition.getPropertyValues();
        if (pv.contains("age")){
            pv.addPropertyValue("age","23");
        }

        beanDefinition = configurableListableBeanFactory.getBeanDefinition("user");
        MutablePropertyValues pv2 = beanDefinition.getPropertyValues();
        if (pv2.contains("name")){
            pv2.addPropertyValue("name","acorn22");
        }

    }
}

这样就不用在 XML 文件中配置，但是这样不利于代码的维护。

反观 BeanPostProcessor，只需要定义一个实现类，如果需要对实例化的 bean 对象进行修改，可以让 bean 类实现 InitializingBean 接口，然后编写 afterPropertiesSet 方法，这样遇到多个 bean 类的时候也比较方便处理。

总结

BeanFactoryPostProcessor 和 BeanPostProcessor 都是服务于 bean 的生命周期中的，只是使用场景和作用略有不同。

BeanFactoryPostProcessor 作用于 bean 实例化之前，读取配置元数据，并且可以修改；而 BeanPostProcessor 作用于 bean 的实例化过程中，然后可以改变 bean 实例（例如从配置元数据创建的对象）。

原文链接：https://blog.csdn.net/Herishwater/article/details/103864534