Spring之后处理器

Spring的后处理器，除了可以与各种第三方框架良好整合外，其IoC容器也允许开发者进行扩展，这种扩展甚至无须实现BeanFactory或ApplicationContext接口，而是允许通过两个后处理器对IoC容器进行扩展。Spring提供了两种常用的后处理器。

1) Bean后处理器:这种后处理器会对容器中的Bean进行后处理，对Bean进行额外加强。

2) 容器后处理器：这种后处理器对Ioc容器进行处理，用于增强容器功能。

1. Bean后处理器

Bean后处理器会在Bean实例创建成功后，对Bean实例进行进一步的增强处理。使用Bean后处理器必须实现BeanPostProcessor接口，BeanPostProcessor接口包含如下两个方法：

1) ObjectpostProcessBeforeInitialization(Object bean,String name)throws BeansException:该方法的第一个参数是系统即将进行后处理的Bean实例，第二个参数是该Bean的配置id。

2) ObjectpostProcessAfterInitialization(Object bean, String name) throws BeansException:该方法的第一个参数是系统即将进行后处理的Bean实例，第二个参数是该Bean的配置id。

下面定义一个简单的Bean后处理器对容器中其他Bean进行后处理。

public class MyBeanPostProcessorimplements BeanPostProcessor
{/*** 对容器中的Bean实例进行后处理* @param bean 需要进行后处理的原Bean实例* @param beanName 需要进行后处理的Bean的配置id* @return 返回后处理完成后的Bean*/public Object postProcessBeforeInitialization(Object bean , String beanName){System.out.println("Bean后处理器在初始化之前对"+ beanName + "进行增强处理...");// 返回的处理后的Bean实例，该实例就是容器中实际使用的Bean// 该Bean实例甚至可与原Bean截然不同return bean;}public Object postProcessAfterInitialization(Object bean , String beanName){System.out.println("Bean后处理器在初始化之后对"+ beanName + "进行增强处理...");// 如果该Bean是Chinese类的实例if (bean instanceof Chinese){// 修改其name成员变量Chinese c = (Chinese)bean;c.setName("Spring4");}return bean;}
}

当Spring容器实例化Bean实例之后，就会依次调用Bean后处理器的两个方法对Bean实例进行增强处理。

下面我们提供一个ChineseBean类，用于实现Bean的实例的生命周期。

 public class Chineseimplements Person,InitializingBean
{private Axe axe;private String name;public Chinese(){System.out.println("Spring实例化主调bean：Chinese实例...");}public void setAxe(Axe axe){this.axe = axe;}public void setName(String name){System.out.println("Spring执行setName()方法注入依赖关系...");this.name = name;}public void useAxe(){System.out.println(name + axe.chop());}// 下面是两个生命周期方法public void init(){System.out.println("正在执行初始化方法 init...");}public void afterPropertiesSet() throws Exception{System.out.println("正在执行初始化方法 afterPropertiesSet...");}
}

接下来，我们来配置Spring的Bean文件。

<?xml version="1.0" encoding="GBK"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns="http://www.springframework.org/schema/beans"xmlns:p="http://www.springframework.org/schema/p"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.0.xsd"><!-- 配置2个普通Bean实例 --><bean id="steelAxe" class="com.owen.app.service.impl.SteelAxe"/><bean id="chinese" class="com.owen.app.service.impl.Chinese"init-method="init" p:axe-ref="steelAxe" p:name="依赖注入的值"/><!-- 配置Bean后处理器，可以无需指定id属性 --><bean id="bp" class="com.owen.app.util.MyBeanPostProcessor"/>
</beans>

如果使用BeanFactory作为Spring容器，则Bean需要配置id属性，而如果使用ApplicationContext作为Spring容器，则可以不配置id属性。因为，ApplicationContext可以自动处理，而BeanFactory需要手动处理。下面我们也配置了id属性。同时，实现了两种的方式。

1) 使用ApplicationContext调用。

public class BeanTest
{public static void main(String[] args)throws Exception{// 以类加载路径下的beans.xml文件来创建Spring容器ApplicationContext ctx = newClassPathXmlApplicationContext("beans.xml");Person p = (Person)ctx.getBean("chinese");p.useAxe();}
}

2) 使用BeanFactory调用。

 public class BeanTest
{public static void main(String[] args)throws Exception{// 搜索类加载路径下的beans.xml文件创建Resource对象Resource isr = new ClassPathResource("beans.xml");// 创建默认的BeanFactory容器DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();// 让默认的BeanFactory容器加载isr对应的XML配置文件new XmlBeanDefinitionReader(beanFactory).loadBeanDefinitions(isr);// 获取容器中的Bean后处理器BeanPostProcessor bp = (BeanPostProcessor)beanFactory.getBean("bp");// 注册Bean后处理器beanFactory.addBeanPostProcessor(bp);Person p = (Person)beanFactory.getBean("chinese");p.useAxe();
}
}

运行的结果如下：

Bean后处理在初始化之前对chinese进行增强处理….

正在执行初始化方法afterPropertiesSet….

正在执行初始化方法 inti….

Bean后处理器在初始化之后对chinese进行增强处理….

2. 容器后处理器

容器后处理器必须实现BeanFactoryPostProcessor接口。实现该接口必须实现方法：

postProcessBeanFactory(ConfigurabloeListableBeanFactorybeanFactory).实现该方法体就是对Spring容器进行的处理，这种处理可以对Spring容器进行自定义扩展，当然也可对Spring容器不进行任何处理。

下面定义了一个容器后处理。

public class MyBeanFactoryPostProcessorimplements BeanFactoryPostProcessor
{/*** 重写该方法，对Spring进行后处理。* @param beanFactory Spring容器本身*/public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)throws BeansException{System.out.println("程序对Spring所做的BeanFactory的初始化没有改变...");System.out.println("Spring容器是：" + beanFactory);}
}

将容器后处理作为普通Bean部署在容器中，如果使用ApplicationContext作为容器，容器会自动调用BeanFactoryPostProcessor来处理Spring容器。但如果使用BeanFactory作为Spring容器，则必须手动调用容器来处理Spring容器。

<?xml version="1.0" encoding="GBK"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns="http://www.springframework.org/schema/beans"xmlns:p="http://www.springframework.org/schema/p"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.0.xsd"><!-- 配置两个简单Bean实例 --><bean id="steelAxe" class="com.owen.app.service.impl.SteelAxe"/><bean id="chinese" class=" com.owen.app.service.impl.Chinese"init-method="init" p:name="孙悟空" p:axe-ref="steelAxe"/><!-- 配置容器后处理器 --><bean id="beanFactoryPostProcessor" class=" com.owen.app.util.MyBeanFactoryPostProcessor"/>
</beans>

3. 总结

Spring的后处理总的有两种，对于Bean后处理来说，是很好的对IoC容器进行扩展，而容器后处理只是对容器本身进行处理，不对容器中的Bean进行处理。