spring之扩展点

上篇文章，介绍了spring中bean的生命周期，并且在文章末尾提到，spring使用BeanPostProcessor接口来处理生命周期的回调。我们可以在初始化函数（init()）中定制化一些逻辑。上述BeanPostProcessor就是spring扩展点（extension points）。Spring及其灵活，一般情况下我们并不需要去继承ApplicationContext 去扩展功能，只需要使用spring提供的扩展接口，就可以刻spring无缝集成。

Spring主要提供了两类扩展点BeanPostProcessor和BeanFactoryPostProcessor。前者是操作bean的实例，后者使对bean的元数据定义进行扩展。

BeanPostProcessor

接口说明

BeanPostProcessor提供对bean实例的操作扩展，在spring容器对bean实例化和设置依赖之后，其回调开始执行。BeanPostProcessor接口定义的两个方法，分别在bean的初始化方法（InitializingBean接口，或者init-method定义）执行的前后执行：

public interface BeanPostProcessor{      /**       * 在bean的初始化方法执行后执行       */      public Object postProcessAfterInitialization(Object arg0, String arg1)            throws BeansException ;      /**       * 在bean的初始化方法执行前执行       */      public Object postProcessBeforeInitialization(Object arg0, String arg1)            throws BeansException ;           }

以上两个方法的参数列表中分别是spring容器创建的对象和beanName，返回值是经过定制化的对象。

BeanPostProcessor对bean实例进行操作，其在bean被实例化和后开始被执行相关回调。它是与容器相关的，它只对其所在容器中的bean有影响，对其父容器没有影响。

BeanPostProcessor也是一个bean，只不过它对其它bean进行后续的扩展处理。Spring容器可以自动的发现实现这个接口的bean。所以如果我们要使我们自定义的BeanPostProcessor起作用，可以像配置其他bean一样在配置文件中进行配置（当然也可以编码实现，向容器注册一个）。Spring容器对BeanPostProcessor类型的bean专门处理，所有的BeanPostProcessor及其引用的依赖在spring容器启动的时候实例化，作为spring容器启动的一个阶段。

Spring容器中内置很多BeanPostProcessor的实现，如上篇文章中使用JSR注解@PostConstruct，对它的处理就是使用BeanPostProcessor。它的另外一哥较常见的作用是spring-aop动态代理。

另外我们可以定义多个BeanPostProcessor，他们执行的顺序可以通过实现Ordered接口来控制。

一个示例

代码说明

这个示例演示有两个点：

1.     BeanPostProcessor的在bean的生命周期中执行时机。

2.     模拟实现一个aop的事务处理代理。

这个示例使用的代码基本上还是上篇文章的代码，增加了一个BeanPostProcessor的一个实现类、一个自定义的注解等在UserService的方法上添加事务的功能，其基本结构如下：

代码和注释

首先我们创建一个注解来标识某个方法，说明其需要事务处理，如下所示：

/** *一个标志的注解，只有被这个注解标识的方法才需要增加事务。 * */@Retention(RetentionPolicy.RUNTIME)@Target(value={ElementType.METHOD})public @interface MyTransaction { }

然后采用在采用JDK动态代理的机制创建代理前，我们需要一个自定义的InvocationHandler，它对仅对上述注解标识的方法进行事务处理，其代码和注释如下：

package com.test; import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method; /** * 自定义代理，JDK动态代理 * */public class MyCustomProxy implements InvocationHandler{    private Object target;         public MyCustomProxy(Object target) {      super();      this.target = target;   }    @Override   public Object invoke(Object proxy, Method method, Object[] args)         throws Throwable {      if (isNeed(method)) {//只有被@MyTransaction注解标识的方法才执行开启事务操作。         beginTransaction(proxy);      }      Object res = method.invoke(target, args);           if (isNeed(method)) {         endTransaction();      }      return res;   }     /**    *模拟开启事务，假如通用点，就很类似AOP中的 Before advice    */   private void beginTransaction(Object o){      System.out.println("-----开始事务--------");   }     /**    *模拟结束事务，假如通用点，就很类似AOP中的 After advice    */   private void endTransaction(){      System.out.println("-----结束事务--------");   }     /**    * 这个实现也可以更加的通用，基于不同的对象不同方法不同的规则    */   private boolean isNeed(Method method){      if (method.getAnnotation(MyTransaction.class) != null) {         return true;      }           return false;   } }

接下来我们需要在合适的时机创建JDK动态代理，以下代码仅对UserService创建代理，当然这里可以更加通用一些，如对某些包的某些类、被某个注解标识等。下面的代码是自定义的BeanPostProcessor，我们在postProcessAfterInitialization方法中创建代理对象并返回给Spring容器：

package com.test; import java.lang.reflect.Proxy; import org.springframework.beans.BeansException;import org.springframework.beans.factory.config.BeanPostProcessor; import com.test.service.UserService; /** * 注意打印的文字，观察其生命周期 * 这里只对UserService创建代理 * */public class MyCustomPostProcessor implements BeanPostProcessor {    @Override   public Object postProcessAfterInitialization(Object arg0, String arg1)         throws BeansException {      if (arg0 instanceof UserService) {//为UserService创建代理，实现事务，如果这里的可以是基于某种规则，如@ASPECTJ的规则         System.out                .println(" i am postProcessAfterInitialization beanname :"                      + arg1 + " BEAN type:" + arg0);                 System.out.println("创建代理，实现事务");         //创建代理，这里可以通过一个代理工厂，根据不同的规则采用不同的InvokeHandler         Object res = Proxy.newProxyInstance(getClass().getClassLoader(), arg0.getClass().getInterfaces(), new MyCustomProxy(arg0));         return res;      }      return arg0;   }    @Override   public Object postProcessBeforeInitialization(Object arg0, String arg1)         throws BeansException {      if (arg0 instanceof UserService) {         System.out                .println(" i am postProcessBeforeInitialization beanname :"                      + arg1 + " BEAN type:" + arg0);      }      return arg0;   } } 

最后我们需要上述的BeanPostProcessor生效，为此我们在xml配置文件中增加如下代码：

<bean class="com.test.MyCustomPostProcessor"/>

然后测试代码如下，和之前一样采用main方法模拟：

 UserService userService0 = context.getBean("user0", UserService.class);      System.out.println(userService0.getUser());

程序运行结果，从以下程序运行结果可以看出我们提出的两点：

1.                 BeanPostProcessor的两个回调一个在依赖注入和初始化函数执行前执行，一个在初始化函数执行后执行。

2.                 我们模拟AOP事务处理的代码成功执行。实际上Spring中AOP自动代理就是使用BeanPostProcessor实现的。

BeanFactoryPostProcessor

接口说明

这是Spring容器的另外一个扩展点，和BeanPostProcessor不同的地方在于，它是对beanDefiniton进行操作。

其接口定义如下所示：

public interface BeanFactoryPostProcessor {       /**       * Modify the application context's internal bean factory after its standard       * initialization. All bean definitions will have been loaded, but no beans       * will have been instantiated yet. This allows for overriding or adding       * properties even to eager-initializing beans.       * @param beanFactory the bean factory used by the application context       * @throws org.springframework.beans.BeansException in case of errors       */      void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;   }

实现该接口，可以在spring的bean创建之前，修改bean的定义属性。也就是说，Spring允许BeanFactoryPostProcessor在容器实例化任何其它bean之前读取配置元数据，并可以根据需要进行修改，例如可以把bean的scope从singleton改为prototype，也可以把property的值给修改掉。可以同时配置多个BeanFactoryPostProcessor，并通过设置'order'属性或实现order接口来控制各个BeanFactoryPostProcessor的执行次序，这些和BeanPostProcessor很类似，并且其启用方式和容器相关性也与之一致。

注意：BeanFactoryPostProcessor是在spring容器加载了bean的定义文件之后，在bean实例化之前执行的。接口方法的入参是ConfigurrableListableBeanFactory，使用该参数，可以获取到相关bean的定义信息：

 BeanDefinition obj = arg0.getBeanDefinition("sumBean");

Spring内置实现了很多的BeanFactoryPostProcessor实现，例如：

常用的有：

• org.springframework.beans.factory.config.PropertyPlaceholderConfigurer
• org.springframework.beans.factory.config.PropertyOverrideConfigurer
• org.springframework.beans.factory.config.CustomEditorConfigurer：用来注册自定义的属性编辑器。

一个示例

这个示例我们来演示下BeanFactoryPostProcessor的简单用法，我们在UserServiceIml.Java中新增加一个field 名字是testValue（假设这是个String类型的），但是不设置初值，然后我们在BeanFactoryPostProcessor中进行设置。

我们自定义的BeanFactoryPostProcessor如下：

public class MyCostumFactoryProcessor implements BeanFactoryPostProcessor{    @Override   public void postProcessBeanFactory(ConfigurableListableBeanFactory arg0)         throws BeansException {      BeanDefinition obj = arg0.getBeanDefinition("user0");      MutablePropertyValues pv = obj.getPropertyValues();      pv.add("testValue", "这是新增加的测试值");   }  }

最后在配置文件中注册它：

<bean class="com.test.MyCostumFactoryProcessor"/>

结束语

Spring扩展点在Spring核心中是很重要的概念，spring本身就内置了很多实现。如果我们需要扩展Spring的功能，他们是很好的方式。并且它们可以像插件一样很好的工作。本篇演示完整代码见底下评论。