Spring中BeanPostProcessor

http://uule.iteye.com/blog/2094549

Spring提供了很多扩展接口，BeanPostProcessor接口和InstantiationAwareBeanPostProcessor接口就是其中两个。

 

BeanPostProcessor

BeanPostProcessor接口作用是：如果我们需要在Spring容器完成Bean的实例化、配置和其他的初始化前后添加一些自己的逻辑处理，我们就可以定义一个或者多个BeanPostProcessor接口的实现，然后注册到容器中。

Spring中Bean的实例化过程图示：

由上图可以看到，Spring中的BeanPostProcessor在实例化过程处于的位置，BeanPostProcessor接口有两个方法需要实现：postProcessBeforeInitialization和postProcessAfterInitialization，

Java代码  

1. import org.springframework.beans.factory.config.BeanPostProcessor;  
2.    
3. public class MyBeanPostProcessor implements BeanPostProcessor {  
4.    
5.      public MyBeanPostProcessor() {  
6.         super();  
7.         System.out.println("这是BeanPostProcessor实现类构造器！！");          
8.      }  
9.    
10.      @Override  
11.      public Object postProcessAfterInitialization(Object bean, String arg1)  
12.              throws BeansException {  
13.          System.out.println("bean处理器：bean创建之后..");  
14.          return bean;  
15.      }  
16.    
17.      @Override  
18.      public Object postProcessBeforeInitialization(Object bean, String arg1)  
19.              throws BeansException {  
20.          System.out.println("bean处理器：bean创建之前..");  
21.        
22.          return bean;  
23.      }  
24.  }  

 

BeanPostProcessor接口定义如下：

Java代码  

1. public interface BeanPostProcessor {  
2.   
3.     /** 
4.      * Apply this BeanPostProcessor to the given new bean instance <i>before</i> any bean 
5.      * initialization callbacks (like InitializingBean's {@code afterPropertiesSet} 
6.      * or a custom init-method). The bean will already be populated with property values.    
7.      */  
8. //实例化、依赖注入完毕，在调用显示的初始化之前完成一些定制的初始化任务  
9.     Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;  
10.   
11.       
12.     /** 
13.      * Apply this BeanPostProcessor to the given new bean instance <i>after</i> any bean 
14.      * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}   
15.      * or a custom init-method). The bean will already be populated with property values.       
16.      */  
17. //实例化、依赖注入、初始化完毕时执行  
18.     Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;  
19.   
20. }  

 

 

由方法名字也可以看出，前者在实例化及依赖注入完成后、在任何初始化代码（比如配置文件中的init-method）调用之前调用；后者在初始化代码调用之后调用。

注意：

1、接口中的两个方法都要将传入的bean返回，而不能返回null，如果返回的是null那么我们通过getBean方法将得不到目标。

 

2、BeanFactory和ApplicationContext对待bean后置处理器稍有不同。ApplicationContext会自动检测在配置文件中实现了BeanPostProcessor接口的所有bean，并把它们注册为后置处理器，然后在容器创建bean的适当时候调用它，因此部署一个后置处理器同部署其他的bean并没有什么区别。而使用BeanFactory实现的时候，bean 后置处理器必须通过代码显式地去注册，在IoC容器继承体系中的ConfigurableBeanFactory接口中定义了注册方法：

 

Java代码  

1. /**  
2.  * Add a new BeanPostProcessor that will get applied to beans created  
3.  * by this factory. To be invoked during factory configuration.  
4.  * <p>Note: Post-processors submitted here will be applied in the order of  
5.  * registration; any ordering semantics expressed through implementing the  
6.  * {@link org.springframework.core.Ordered} interface will be ignored. Note  
7.  * that autodetected post-processors (e.g. as beans in an ApplicationContext)  
8.  * will always be applied after programmatically registered ones.  
9.  * @param beanPostProcessor the post-processor to register  
10.  */    
11. void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);   

 

 

另外，不要将BeanPostProcessor标记为延迟初始化。因为如果这样做，Spring容器将不会注册它们，自定义逻辑也就无法得到应用。假如你在<beans />元素的定义中使用了'default-lazy-init'属性，请确信你的各个BeanPostProcessor标记为'lazy-init="false"'。

 

InstantiationAwareBeanPostProcessor

InstantiationAwareBeanPostProcessor是BeanPostProcessor的子接口，可以在Bean生命周期的另外两个时期提供扩展的回调接口，即实例化Bean之前（调用postProcessBeforeInstantiation方法）和实例化Bean之后（调用postProcessAfterInstantiation方法），该接口定义如下：

Java代码  

1. package org.springframework.beans.factory.config;    
2.     
3. import java.beans.PropertyDescriptor;    
4.     
5. import org.springframework.beans.BeansException;    
6. import org.springframework.beans.PropertyValues;    
7.     
8. public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {    
9.     
10.     Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException;    
11.     
12.     boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException;    
13.     
14.     PropertyValues postProcessPropertyValues(    
15.             PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)    
16.             throws BeansException;    
17.     
18. }  

 其使用方法与上面介绍的BeanPostProcessor接口类似，只时回调时机不同。

 

如果是使用ApplicationContext来生成并管理Bean的话则稍有不同，使用ApplicationContext来生成及管理Bean实例的话，在执行BeanFactoryAware的setBeanFactory()阶段后，若Bean类上有实现org.springframework.context.ApplicationContextAware接口，则执行其setApplicationContext()方法，接着才执行BeanPostProcessors的ProcessBeforeInitialization()及之后的流程。

应用实例：把spring 配置为service（@Service ）的bean导出来hession服务：

step1:服务使用

@Service("ExampleServiceeb")
@HessianService
public class ExampleServiceImpl  implements ExampleService {

}

step2:把带有@HessianService和@Service("ExampleService") 导出为hession服务

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Service;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.core.Ordered;
import org.springframework.core.PriorityOrdered;
import org.springframework.remoting.caucho.HessianServiceExporter;


/**
 * HessianService处理器，定义为@HessianService的类将被自动加载为Hessian服务
 *
 */
public class HessianBeanPostProcessor implements BeanPostProcessor, PriorityOrdered, ApplicationContextAware{
private ApplicationContext ctx;
protected Log logger = LogFactory.getLog(getClass());


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


if(bean.getClass().isAnnotationPresent(HessianService.class)){
Service svc = bean.getClass().getAnnotation(Service.class);
if(svc.value() == null || svc.value().trim().equals("")){
throw new RuntimeException(bean.getClass().getName() + "被申明为HessianService，则必须指定@Service的值");
}
if(bean.getClass().getInterfaces().length > 1 || bean.getClass().getInterfaces().length == 0){
throw new RuntimeException(bean.getClass().getName() + "被申明为HessianService，则必须指定一个且仅一个Interface");
}
DefaultListableBeanFactory factory = (DefaultListableBeanFactory)ctx.getAutowireCapableBeanFactory();
BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(HessianServiceExporter.class);
builder.addPropertyReference("service", svc.value());
builder.addPropertyValue("serviceInterface", bean.getClass().getInterfaces()[0].getName());
factory.registerBeanDefinition("/" + svc.value(), builder.getBeanDefinition()); 
if(logger.isDebugEnabled()){
logger.debug("HessianBeanPostProcessor装载Hessian服务" + svc.value() + "成功!");
}
}
return bean;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Override
public int getOrder() {
        return Ordered.LOWEST_PRECEDENCE;
}
@Override
public void setApplicationContext(ApplicationContext ctx) throws BeansException {
this.ctx = ctx;
}
}