04Spring_bean 后处理器（后处理Bean），BeanPostProcessor ，bean创建时序，动态代理

这篇文章很重要，讲解的是动态代理，以及bean创建前后的所发生的事情。介绍一个接口：在Spring构造Bean对象过程中，有一个环节对Bean对象进行 后处理操作 （钩子函数） ----- Spring 提供 BeanPostProcessor 接口。我们可以自定义类，实现 BeanPostProcessor 接口，配置到Spring容器中，在构造对象时，spring容器会调用接口中方法。

这个接口两个方法public Object postProcessAfterInitialization(Object bean, String beanName) 方法以及public Object postProcessBeforeInitialization(final Object bean, String beanName) 这两个方法里面的bean就是spring IO容器创建对象，beanName就是Sring配置文件applicationContext.xml文件里面对应的bean id。

为了说明postProcessBeforeInitialization和postProcessAfterInitialization的具体调用顺序，举一个例子说明。

//applicationContext.xml
<bean id="teacherService" class="cn.csdn.cyclelife.TeacherService"  init-method="init" destroy-method="destroy">
<constructor-arg type="java.lang.Integer" index="0">
<value>20</value>
</constructor-arg>
<property name="name">
<value>Longmanfei</value>
</property>
</bean>
<bean id="postService"class="cn.csdn.cyclelife.PostService"></bean>
//TeacherService bean
public class TeacherService {

private String name;

private Integer age;

public void setName(String name){
System.out.println("----这是teacherservice的set方法----");
this.name=name;
}

public TeacherService(Integer age){
this.age=age;
}

public void init(){
System.out.println("--------这是teacherservice的init的方法-------------");
}

public void destroy(){
System.out.println("---------这是销毁（destroy）方法----------");
}

public void display(){
System.out.println(this.name+"-----------------"+this.age);
}
}
// 实现接口的BeanPostProcessor bean
public class PostService implements BeanPostProcessor{

/**在初始化之后调用这个方法*/
@Override
public Object postProcessAfterInitialization(Object bean, String arg1)
throws BeansException {
System.out.println("----这是init之后执行的方法postProcessAfterInitialization----");
return bean;
}

/**在初始bean之前调用的这个方法 在init方法之前执行,在set方法之后*/
@Override
public Object postProcessBeforeInitialization(Object bean, String arg1)
throws BeansException {
/**instanceof 判断前者是否是后者的一个实例*/
if(bean instanceof TeacherService){
System.out.println("--这是在init之前进行修改bean的属性值--");
/*这里我们不能直接new一个对象 因为bean本身就是一个对象，直接转换就可以了*/
((TeacherService)bean).setName("Longmanfei");
}
System.out.println("---这是init之前执行的方法postProcessBeforeInitialization---");
return bean;
}
}
//Junit 测试方法
public class App {

@Test
public void test1(){
/**加载容器*/
ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"applic*.xml"});
/**调用getbean方法*/
TeacherService ts = (TeacherService) ac.getBean("teacherService");

ts.display();

/**调用close方法关闭bean*/
AbstractApplicationContext aac =(AbstractApplicationContext) ac;
aac.close();
}

}
//这是执行结果(当加载容器的时候会判断是否有实现接口的BeanPostProcessor bean,如果有其他Bean就会按照特定的顺序去执行，并且执行实现接口的bean里的方法)
----这是teacherservice的set方法----
--这是在init之前进行修改bean的属性值--
----这是teacherservice的set方法----
---这是init之前执行的方法postProcessBeforeInitialization---
--------这是teacherservice的init的方法-------------
----这是init之后执行的方法postProcessAfterInitialization----
Longmanfei-----------------20
---------这是销毁（destroy）方法----------

这个例子里面可以看到Spring先会创造bean的实例对象，然后调用postProcessBeforeInitialization，然后再调用init-method="init"方法，然后再调用postProcessAfterInitialization方法。

这里我给一个bean的创建流程图



这个图对上面的例子的代码运行结果给出了很好的解释。（这个博客非常不错http://uule.iteye.com/blog/2094609）

换句话说我们在执行public Object postProcessBeforeInitialization(final Object bean, String beanName)方法时，传入的值bean就是IOC容器已经给我们创建好的对象了，

那么我们可以拿这个对象做什么呢?很重要的一点就是动态代理，我们可以给这个bean对象做个动态代理。

先给出具体代码我在做分析：

做动态代理必须要接口，所以我先给出抽象角色（接口）

package cn.itcast.spring.d_lifecycle;

public interface IHello {
public void sayHello();

public void setup();

public void teardown();
}

再给出真实角色：

package cn.itcast.spring.d_lifecycle;

/**
* Bean对象，初始化和销毁方法 （无返回值、无参数、非静态）
*
* @author seawind
*
*/
public class LifeCycleBean implements IHello {
public LifeCycleBean() {
System.out.println("LifeCycleBean 构造...");
}
//配置文件中init-method="setup"
public void setup() {
System.out.println("LifeCycleBean 初始化...");
}
//配置文件中destroy-method="teardown"

public void teardown() {
System.out.println("LifeCycleBean 销毁...");
}
//被代理的方法
@Override
public void sayHello()
{

System.out.println("hello ,itcast...");

}
}

再给出实现了BeanPostProcessor接口的方法：

package cn.itcast.spring.d_lifecycle;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

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

/**
* 后处理器
*
* @author seawind
*
*/
public class MyBeanPostProcessor implements BeanPostProcessor {
static int a=0;
@Override
/**
* bean 代表Spring容器创建对象
* beanName 代表配置对象对应 id属性
*/

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (beanName.equals("lifeCycleBean")) {
System.out.println("后处理器 初始化后执行...");
}
return bean;
}

@Override
public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
// 针对bean id 为 lifeCycleBean的对象 进行代理，配置文件中bean的id为lifeCycleBean就做一下处理
if (beanName.equals("lifeCycleBean")) {
System.out.println("后处理器 初始化前执行...");
/*给传进来的bean对象做一个动态代理.bean.getClass().getClassLoader表示要被执行代理的类，也就是我们的IOC容器创建的bean对象。
bean.getClass().getInterfaces()表示我们的要代理的类所实现
的所有的而接口，我们最后new出来的代理类会按照这个参数实现这些所有的接口。这也是为什么动态代理模式必须要用接口的原因了。
new InvocationHandler() {}表示真正要执行的方法。
最后用的是return 就是把生成出来的的代理类返回了。所以执行好这个方法后其实的返回的是new 出来的的代理类，而不是之前的bean对象了。（这句话非常重要）
*/
return Proxy.newProxyInstance(bean.getClass().getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//模拟代理方法（额外要执行的方法）
System.out.println("执行代理.....");

//执行要真正的方法
return method.invoke(bean, args);

}
});
}
return bean;
}

}

再给出Spring的配置文件（applicationContext.xml）

<bean id="lifeCycleBean" class="cn.itcast.spring.d_lifecycle.LifeCycleBean"
init-method="setup" destroy-method="teardown" />

最后给出Junit的测试代码

package cn.itcast.spring.d_lifecycle;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class LifeCycleTest {
@Test
public void testInitDestroy() {
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
IHello lifeCycleBean = (IHello) applicationContext.getBean("lifeCycleBean");
System.out.println(lifeCycleBean);
lifeCycleBean.sayHello();

// 必须手动调用 容器销毁的方法 --- web服务器tomcat，自动调用容器销毁
applicationContext.close();
}
}

对上面代码的分析：经过public class MyBeanPostProcessor implements BeanPostProcessor里面的postProcessBeforeInitialization方法后，就是给IOC创建的bean对象进行了动态代理，在Junit的测试代码中。我们执行了 lifeCycleBean.sayHello();就会被动态代理给拦截，执行 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {......}里面的方法.这里的lifeCycleBean已经不是lifeCycleBean.class类型了，而是com.sun.proxy.$Proxy4类型了，要验证这个观点很简单，只要在public class LifeCycleTest 方法中的 lifeCycleBean.sayHello();之前加一句System.out.println(lifeCycleBean);就可以得到验证。

最后给出上述代码的是运行结果：

后处理器 初始化前执行...
执行代理.....
被代理的方法是public abstract void cn.itcast.spring.d_lifecycle.IHello.setup()a的值是1aaaaacn.itcast.spring.d_lifecycle.LifeCycleBeanLifeCycleBean 初始化...
后处理器 初始化后执行...
执行代理.....
被代理的方法是public java.lang.String java.lang.Object.toString()

aaaaacn.itcast.spring.d_lifecycle.LifeCycleBeancn.itcast.spring.d_lifecycle.LifeCycleBean@a0430b6
测试方法中lifeCycleBean的真相是com.sun.proxy.$Proxy4执行代理.....

被代理的方法是public abstract void cn.itcast.spring.d_lifecycle.IHello.sayHello()a的值是3aaaaacn.itcast.spring.d_lifecycle.LifeCycleBeanhello ,itcast...

这里很奇怪，为什么执行了这么多的“执行代理” 原因很简单，因为setup()和 System.out.println(lifeCycleBean)和 lifeCycleBean.sayHello();每一次执行方法时都会被动态代理所拦截，从而执行了三次动态代理。