BeanPostProcessor使用心得

来源：互联网发布：上海太平洋保险java 编辑：程序博客网时间：2024/04/29 06:40

最近想对项目中的所有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);  
    }  
  
}  

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

有时候，我们希望在Spring IoC容器初始化受管Bean之前、属性设置之后对该Bean先做一些预处理，或者在容器销毁受管Bean之前自己释放资源。那么该如何实现呢？Spring IoC为我们提供了多种方法来实现受管Bean的预处理和后处理。
在Spring中定义了BeanPostProcessors接口，代码如下：

Java代码  
package org.springframework.beans.factory.config;  
  
import org.springframework.beans.BeansException;  
  
public interface BeanPostProcessor {  
  
Object postProcessBeforeInitialization(Object bean,String BeanName)throws BeansException;  
  
Object postProcessAfterInitialization(Object bean,String BeanName)throws BeansException;   
}  

如果这个接口的某个实现类被注册到某个容器，那么该容器的每个受管Bean在调用初始化方法之前，都会获得该接口实现类的一个回调。容器调用接口定义的方法时会将该受管Bean的实例和名字通过参数传入方法，进过处理后通过方法的返回值返回给容器。根据这个原理，我们就可以很轻松的自定义受管Bean。

上面提到过，要使用BeanPostProcessor回调，就必须先在容器中注册实现该接口的类，那么如何注册呢？BeanFactory和ApplicationContext容器的注册方式不大一样：若使用BeanFactory，则必须要显示的调用其addBeanPostProcessor()方法进行注册，参数为BeanPostProcessor实现类的实例；如果是使用ApplicationContext，那么容器会在配置文件在中自动寻找实现了BeanPostProcessor接口的Bean，然后自动注册，我们要做的只是配置一个BeanPostProcessor实现类的Bean就可以了。

注意，假如我们使用了多个的BeanPostProcessor的实现类，那么如何确定处理顺序呢？其实只要实现Ordered接口，设置order属性就可以很轻松的确定不同实现类的处理顺序了。

例程3.5展示了如何使用BeanPostProcessor回调接口。创建Java工程，为其添加Spring开发能力后，创建ioc.test包。再创建一个名字为Animal的Bean，添加name、age成员和speak()方法。代码如下：

Java代码  
package ioc.test;  
  
public class Animal {  
  
private String name;  
  
private int age;  
  
public String speak(){  
return "我的名字是："+this.name+"，年龄是："+this.age+"!\n";  
}  
//Geter和Seter省略  
}  

创建一个BeanPost类，实现BeanPostProcessor接口。在其postProcessAfterInitialization()方法中修改通过参数传入的受管Bean，然后返回。由于它处理容器中的每一个Bean，因此在修改前，应判断Bean是否为我们要处理的Bean。可以通过传入Bean的类型判定，也可以通过传入Bean的名字判定。代码如下：

Java代码  
package ioc.test;  
  
//Import省略  
  
public class BeanPost implements BeanPostProcessor {  
  
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {  
  
System.out.println("BeanPostProcessor.postProcessAfterInitialization 正在预处理！");  
  
if ((bean instanceof Animal)) {  
  
Animal animal = (Animal) bean;  
  
animal.setAge(50);  
  
animal.setName("猴子");  
  
return bean;  
  
}  
  
return bean;  
}  
  
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {  
  
System.out.println("BeanPostProcessor.postProcessBeforeInitialization 正在预处理！");  
  
return bean;  
  
}  
}

定义好Animal Bean，为其属性随便注入一个值，再定义一个Bean，class为BeanPost类。代码如下：

Java代码  
<?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-2.5.xsd">  
<bean id="animal" class="ioc.test.Animal">  
<property name="age"  value="5"></property>  
<property name="name" value="猪"></property>  
</bean>  
<bean id="beanPost" class="ioc.test.BeanPost"></bean>  
</beans>  

最后创建TestMain类输出结果，代码如下：

Java代码  
package ioc.test;  
  
//Import省略  
  
public class TestMain {  
  
public static void main(String[] args) {  
  
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");  
Animal animal = (Animal)ac.getBean("animal");  
System.out.println(animal.speak());      
  
}  
}  

运行后输出结果如下：

运行结果

可以看到，输出结果并不是我们在配置文件中注入的值，这说明BeanPost已经成功的修改了目标Bean。