BeanPostProcessor

来源：互联网发布：mac键盘大小写灯不亮编辑：程序博客网时间：2024/05/09 01:45

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

(实现对于所有Bean在初始化前后的自定义方法)

BeanPostProcessor

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

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

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

Java代码  
import org.springframework.beans.factory.config.BeanPostProcessor;  
   
public class MyBeanPostProcessor implements BeanPostProcessor {  
   
     public MyBeanPostProcessor() {  
        super();  
        System.out.println("这是BeanPostProcessor实现类构造器！！");          
     }  
   
     @Override  
     public Object postProcessAfterInitialization(Object bean, String arg1)  
             throws BeansException {  
         System.out.println("bean处理器：bean创建之后..");  
         return bean;  
     }  
   
     @Override  
     public Object postProcessBeforeInitialization(Object bean, String arg1)  
             throws BeansException {  
         System.out.println("bean处理器：bean创建之前..");  
       
         return bean;  
     }  
 }  

BeanPostProcessor接口定义如下：

Java代码  
public interface BeanPostProcessor {  
  
    /** 
     * Apply this BeanPostProcessor to the given new bean instance <i>before</i> any bean 
     * initialization callbacks (like InitializingBean's {@code afterPropertiesSet} 
     * or a custom init-method). The bean will already be populated with property values.    
     */  
//实例化、依赖注入完毕，在调用显示的初始化之前完成一些定制的初始化任务  
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;  
  
      
    /** 
     * Apply this BeanPostProcessor to the given new bean instance <i>after</i> any bean 
     * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}   
     * or a custom init-method). The bean will already be populated with property values.       
     */  
//实例化、依赖注入、初始化完毕时执行  
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;  
  
}  

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

注意：

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

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

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

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

=========================================================================================

最近想对项目中的所有bean进行一个代理。然后监控bean得方法的使用情况。

刚开始想的方法是：重写项目的beanFactory，然后再getBean的使用，对结果object进行一个代理，达到我的目的。但是发现重写getBean的方法，无法对bean中的依赖注入的bean（set进来的bean）进行代理。

正好看到了beanPostProcessor的使用方法。可以在spring的xml的配置一个BeanPostProcessor，然后对所有的bean进行一个代理处理，正好可以满足我的需求！

BeanPostProcessor代码如下：

Java代码  
import java.lang.reflect.Proxy;  
import java.util.Map;  
import java.util.concurrent.ConcurrentHashMap;  
  
import org.springframework.beans.BeansException;  
import org.springframework.beans.factory.config.BeanPostProcessor;  
  
import com.alibaba.common.logging.Logger;  
import com.alibaba.common.logging.LoggerFactory;  
  
public class MyBeanPostProcesser implements BeanPostProcessor {  
    private Map map = new ConcurrentHashMap(100);  
    private static final Logger log = LoggerFactory.getLogger("myBeanPostProcesser");  
  
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {  
        MyProxy proxy = new MyProxy();  
  
        if (beanName.contains("DB")) {  
            return bean;  
        }  
  
        if (bean.toString().contains("Proxy")) {  
            log.info(beanName + "为代理类,不进行再次代理!");  
            return bean;  
        }  
        if (beanName.contains("TransactionTemplate")) {  
            log.info(beanName + "为TransactionTemplate类,不进行再次代理!该类为:" + bean);  
            return bean;  
        }  
  
        if (map.get(beanName) != null) {  
            log.info(beanName + "已经代理过,不进行再次代理!");  
            return map.get(beanName);  
        }  
        proxy.setObj(bean);  
        proxy.setName(beanName);  
        Class[] iterClass = bean.getClass().getInterfaces();  
        if (iterClass.length > 0) {  
            Object proxyO = Proxy.newProxyInstance(bean.getClass().getClassLoader(), iterClass, proxy);  
            map.put(beanName, proxyO);  
            return proxyO;  
        } else {  
            log.info(beanName + "么有接口不进行代理!");  
            return bean;  
        }  
    }  
  
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {  
        return bean;  
    }  
  
}  

代理类Proxy代码如下：

Java代码  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
  
import com.alibaba.common.logging.Logger;  
import com.alibaba.common.logging.LoggerFactory;  
  
import sun.reflect.Reflection;  
  
public class MyProxy implements InvocationHandler {  
    private static final Logger log = LoggerFactory.getLogger("myself");  
  
    private Object obj;  
  
    private String name;  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public Object getObj() {  
        return obj;  
    }  
  
    public void setObj(Object obj) {  
        this.obj = obj;  
    }  
  
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
        System.out.println("begin================" + "bean 名称为【" + name + "】方法为【" + method.getName() + "】========="  
                + obj.getClass());  
        log.error("begin================" + "bean 名称为【" + name + "】方法为【" + method.getName() + "】========="  
                + obj.getClass());  
        return method.invoke(obj, args);  
    }  
  
    public void printDetail(String detail) {  
        log.error(detail);  
    }  
  
}  

感觉还是比较好使的！记录一下。以后再有监控的需求，可以考虑使用这种方式了！

转自：http://guoliangqi.iteye.com/blog/635826

0 0