Spring提供了很多扩展接口,BeanPostProcessor接口和InstantiationAwareBeanPostProcessor接口就是其中两个。
(实现对于所有Bean在初始化前后的自定义方法)
BeanPostProcessor
BeanPostProcessor接口作用是:如果我们需要在Spring容器完成Bean的实例化、配置和其他的初始化前后添加一些自己的逻辑处理,我们就可以定义一个或者多个BeanPostProcessor接口的实现,然后注册到容器中。
Spring中Bean的实例化过程图示:
由上图可以看到,Spring中的BeanPostProcessor在实例化过程处于的位置,BeanPostProcessor接口有两个方法需要实现:postProcessBeforeInitialization和postProcessAfterInitialization,
- 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接口定义如下:
- 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接口中定义了注册方法:
- /**
- * 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得方法的使用情况。
- 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;
- }
- }
- 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