后置处理器

一个类，实现了接口 BeanPostProcessor 定义的两个方法，这两个方法分别是：postProcessBeforeInitialization 和 postProcessAfterInitialization，顾名思义，就是分别在 bean 的 init-method 前后进行分别执行这两个方法。

多后置处理器的有序性的 bean 在使用的过程中可以经过多个后置预处理的处理，但是，一般情况下，多个实现后置处理器接口的类是有先后顺序的，为了让 IOC 明白后置处理器之间的先后顺序，类还要实现 Ordered 接口，通过接口里的 order 属性来控制后处理器的先后顺序，默认为 0，为最高优先级。

同一个容器中的后置处理器是通用的一个 context 中的后置处理器实现类不是针对某一个的 bean，这个 context 中的所有 bean 的产生过程都回去调用这个后置处理器，为了有针对性，可以通过 bean 的 id 来执行特异话的操作。

后置处理器实现类

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

可见，返回值必须为非 null，且必须是 Object 类型，和从 context 中 get 出来的一致。由于是有默认实现，因此，不是必须要重写方法的。现在看一个后处理器类的实例：

package 后置处理器;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class PostProcessorExample implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("chinese".equals(beanName)) {
            System.out.println("后置处理器，初始化前处理的bean的id是：" + beanName);
        } else {
            System.out.println("后置处理器，初始化前处理的bean的id是：" + beanName);
        }
        return bean;
    }

}

通过 beanName 对处理的 bean 进行针对性的区分、处理。

后置处理器实现类 bean 配置

<?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="chinese" class="初始化和销毁回调.Chinese">
    </bean>

    <bean id="american" class="初始化和销毁回调.American">
    </bean>

    <bean id="beanPostProcessor" class="后置处理器.PostProcessorExample">
    </bean>

</beans>

运行调用

package 后置处理器;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class PostProcessorExample implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("chinese".equals(beanName)) {
            System.out.println("后置处理器，初始化前处理的bean的id是：" + beanName);
        } else {
            System.out.println("后置处理器，初始化前处理的bean的id是：" + beanName);
        }

        return bean;
    }

}

其中 America 类实现了 InitializingBean, DisposableBean 这两个接口，xml 配置元数据中不配置也自带初始化和销毁方法，Chinese 完全没有指定初始化和销毁方法，因此，控制台输出是：

后置处理器，初始化前处理的 bean 的 id 是：chinese
后置处理器，初始化前处理的 bean 的 id 是：american
American 初始化回调函数
American 销毁回调函数

多后置处理器调用

最理想的情况下，让实现类去实现 Ordered 最理想的，但是，在默认情况下，Spring 容器会根据后置处理器的定义顺序来依次调用，比如：

<?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定义 -->  
  <bean id="narCodeService" class="com.test.service.impl.NarCodeServiceImpl">
  </bean>
  <bean id="postProcessor" class="com.test.spring.PostProcessor"/>
  <bean id="postProcessorB" class="com.test.spring.PostProcessorB"/>
</beans>
1
2
3
4
5
6
7
8
9
10

在 bean 配置元数据，就回让 IOC 容器最后再调用B后置处理器。