Spring的bean后处理器和容器后处理器

目录(?)[-]

1. Spring后处理器的作用
   1. Bean后处理器即当Spring容器实例化Bean实例之后进行的增强处理
   2. 容器后处理器对容器本身进行处理并总是在容器实例化其他任何Bean之前读取配置文件的元数据并可能修改这些数据
   3. 通过使用后处理器可以模拟Spring的AOP切面编程
2. bean后处理器BeanPostProcessor
3. BeanPostProcessor后处理器的使用
4. 后处理器的使用实例
   1. 通过结果可以看出后处理器-bean自身定义的方法-bean调用的方法
5. 多个后处理器的结合使用
   1. 当需要定义多个后处理器时在xml配置所有的后处理器之后还需要指定他们的执行顺序
   2. 通过实现Ordered接口并重写getOrder属性就可以来指定它们的执行顺序了order的值越小越先执行
6. 容器后处理器
   1. 容器后处理器实现的是BeanFactoryPostProcessor接口其余的和bean后处理器的相关类似
7. 容器后处理器使用实例
8. 文档参考
   1. Spring中BeanPostProcessors1简单预处理
   2. Spring Bean 后置处理器
   3. Spring Bean后处理器以及容器后处理器

Spring后处理器的作用

Bean后处理器：即当Spring容器实例化Bean实例之后进行的增强处理。

容器后处理器：对容器本身进行处理，并总是在容器实例化其他任何Bean之前读取配置文件的元数据并可能修改这些数据。

通过使用后处理器，可以模拟Spring的AOP切面编程

bean后处理器：BeanPostProcessor

BeanPostProcessor 接口定义回调方法，你可以实现该方法来提供自己的实例化逻辑，依赖解析逻辑等。你也可以在 Spring 容器通过插入一个或多个 BeanPostProcessor 的实现来完成实例化，配置和初始化一个bean之后实现一些自定义逻辑回调方法。

有时希望在spring IoC容器初始化受管Bean前、属性设置后对该Bean先做一些预处理，或者在容器销毁受管Bean之前自己释放资源。Spring IoC提供了BeanPostProcessor接口用于实现该操作

若这个接口的某个实现类被注册到某个容器，那么该容器的每个受管Bean在调用初始化方法前，都会获得该接口实现类的一个回调。容器调用接口定义的方法时会将该受管Bean的实例和名字通过参数传入方法，经过处理后通过方法的返回值返回给容器。根据这个原理就可以很轻松的自定义受管Bean

BeanPostProcessor后处理器的使用

要使用BeanPostProcessor回调，就必须先在容器中注册实现该接口的类。BeanFactory和ApplicationContext容器的注册方式是不一样的：若使用BeanFactory，则必须要显示的调用其addBeanPostProcessor()方法进行注册。若使用ApplicationContext，那么容器会在配置文件在中自动寻找实现了BeanPostProcessor接口的Bean，然后自动注册。

后处理器的使用实例

//bean
public class HelloPost {

    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

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

    public void destroy(){
        System.out.println("调用自身的destroy方法");
    }

    public void show(){
        System.out.println("hello world->"+message);
    }
}


//bean后处理器
public class HelloHander implements BeanPostProcessor,Ordered {


    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {

        System.out.println("正在调用postProcessAfterInit->"+beanName);
        return bean;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {

        System.out.println("正在调用postProcessBeforeInit->"+beanName);
        return bean;
    }

    @Override
    public int getOrder() {
        // TODO Auto-generated method stub
        return 1;
    }

}


//配置文件
<beans ...>
    <bean id="helloPost" class="org.spring.PostBean.HelloPost" init-method="init" destroy-method="destroy">
            <property name="message" value="测试后处理器" />
        </bean>
        <!-- 后处理器的配置 -->
        <bean class="org.spring.PostBean.HelloHander" />
</beans>


//测试主程序
public class TestMain {

    public static void main(String[] args){

        AbstractApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        HelloPost post = context.getBean("helloPost",HelloPost.class);

        System.out.println("post.message->"+post.getMessage());

        //关闭hook的方法，必须注册为AbstractApplicationContext才可以调用
        context.registerShutdownHook();
    }
}

//输出结果:
    正在调用postProcessBeforeInit->helloPost
    调用自身的init方法
    正在调用postProcessAfterInit->helloPost
    post.message->测试后处理器
    //调用registerShutdownHook()工作中
    调用自身的destroy方法
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

通过结果可以看出：后处理器->bean自身定义的方法->bean调用的方法

多个后处理器的结合使用

当需要定义多个后处理器时，在xml配置所有的后处理器之后，还需要指定他们的执行顺序

通过实现Ordered接口并重写getOrder()属性就可以来指定它们的执行顺序了。order的值越小，越先执行

容器后处理器

容器后处理器实现的是BeanFactoryPostProcessor接口，其余的和bean后处理器的相关类似

容器后处理器使用实例

//容器后处理器
public class FactoryPost implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory arg0)
            throws BeansException {

        System.out.println("对容器进行处理");
    }

}

//xml配置
<!-- 容器后处理器的配置 -->
        <bean class="org.spring.PostFactory.FactoryPost" />

//测试主程序
public class TestMain {

    public static void main(String[] args){

        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    }
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

文档参考

Spring中BeanPostProcessors【1】简单预处理

Spring Bean 后置处理器

Spring Bean后处理器以及容器后处理器