Spring后处理Bean（BeanPostProcessor 接口）Bean增强

后处理Bean也称之为Bean的后处理器，作用是：在Bean初始化的前后，对Bean对象进行增强。它既可以增强一个指定的Bean，也可以增强所有的Bean，底层很多功能（如AOP等）的实现都是基于它的，Spring可以在容器中直接识别调用。

 

【示例】

要对“所有”的bean的初始化的时候进行增强（打印一句话）

第一步：创建MyBeanPostProcessor类，实现接口BeanPostProcessor

 

//后处理bean，：用来对bean进行功能增强，可以实现，对所有，或某个bean的初始化进行增强

public class MyBeanPostProcessor implements BeanPostProcessor{

 

    //初始化时（之前）调用的

    //参数1：bean对象，参数2，bean的名字，id、name

    public Object postProcessBeforeInitialization(Object bean, String beanName)

           throws BeansException {

//     System.out.println(beanName+"在初始化前开始增强了");

       //如何只增强一个bean

       if(beanName.equals("lifeCycleBean")){

           System.out.println(beanName+"在初始化前开始增强了");

       }

       return bean;//放行

    }

 

    //初始化时（之后）调用

    public Object postProcessAfterInitialization(Object bean, String beanName)

           throws BeansException {

//     System.out.println(beanName+"在初始化后开始增强了");

       if(beanName.equals("lifeCycleBean")){

           System.out.println(beanName+"在初始化后开始增强了");

       }

       return bean;

    }

 

}

第二步：定义applicationContext.xml文件

<!-- 后处理bean：spring在初始化MyBeanPostProcessor的时候，判断是否实现了BeanPostProcessor，如果实现了，就采用动态代理的方式，对所有的bean对象增强 -->

    <bean class="com.igeek.xmllifecycle.MyBeanPostProcessor"/>

 

执行任意bean操作的测试，控制台输出：

注意调用顺序。

BeanPostProcessor接口，提供增强途径，在不修改原来代码情况下，增添新的功能！

 

==========================================代码示例===============================================

 bean1

public class Bean1 {
	
	public Bean1() {
		System.out.println("Bean1-无参数的构造方法");
	}

	public void method() {
		System.out.println("bean1 - method");
	}
	
	/**
	 * 初始化方法， 方法名无所谓是什么
	 * 主要用于初始化相关数据
	 */
	public void init() {
		System.out.println("初始化Bean1");
	}
	/**
	 * 销毁Bean的方法，方法名无所谓
	 * 主要用于释放资源
	 */
	public void destroy() {
		System.out.println("销毁方法，释放资源");
	}
}

bean2

public class Bean2 {
	
	public Bean2() {
		System.out.println("Bean2-无参数的构造方法");
	}

	public void method() {
		System.out.println("bean2 - method");
	}
	
	/**
	 * 初始化方法， 方法名无所谓是什么
	 * 主要用于初始化相关数据
	 */
	public void init() {
		System.out.println("初始化Bean2");
	}
	/**
	 * 销毁Bean的方法，方法名无所谓
	 * 主要用于释放资源
	 */
	public void destroy() {
		System.out.println("bean2销毁方法，释放资源");
	}
}

MyBeanPostProcessor 实现接口：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
/**
 * Bean的后处理器
 * @author Administrator
 *
 */
public class MyBeanPostProcessor implements BeanPostProcessor {

	/**
	 * bean对象被初始化之前执行的方法
	 * @param bean 要处理的bean的对象
	 * @param beanName 要处理的bean的名称或者ID
	 */
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println(beanName+"初始化之前增强");
		return bean;
	}

	/**
	 * bean对象被初始化之后执行的方法
	 * @param bean 要处理的bean的对象
	 * @param beanName 要处理的bean的名称或者ID
	 */
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println(beanName+"初始化之后增强");
		return 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的生命周期 -->
<!-- 
过 init-method属性 指定初始化后的调用方法
通过 destroy-method属性 指定销毁对象前的方法 
 -->
<bean id="bean1" class="com.igeek.Bean1" scope="singleton" init-method="init" destroy-method="destroy"/>
<bean id="bean2" class="com.igeek.Bean2" scope="singleton" init-method="init" destroy-method="destroy"/>

<!-- 配置后置处理Bean -->
<bean class="com.igeek.MyBeanPostProcessor"/>

</beans>

test测试：

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

public class BeanTest {
	
	ClassPathXmlApplicationContext context = null;
	@Before
	public void befor() {
		 context = new ClassPathXmlApplicationContext("applicationContext.xml");
	}
	
	@Test
	public void getBean1() {
		Bean1 bean1 = context.getBean(Bean1.class);
		bean1.method();
		bean1 = context.getBean(Bean1.class);
		bean1.method();
		bean1 = context.getBean(Bean1.class);
		bean1.method();
		bean1 = context.getBean(Bean1.class);
		bean1.method();
		//销毁容器的时候，会执行bean的destroy方法。
		context.close();
	}
}