经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Spring » 查看文章
Spring BPP中如何优雅的创建动态代理Bean详解
来源：jb51　　时间：2019/3/4 8:39:59　　对本文有异议

v一、前言

本文章所讲并没有基于Aspectj，而是直接通过Cglib以及ProxyFactoryBean去创建代理Bean。通过下面的例子，可以看出Cglib方式创建的代理Bean和ProxyFactoryBean创建的代理Bean的区别。

v二、基本测试代码

测试实体类，在BPP中创建BppTestDepBean类型的代理Bean。

  1. @Component
  2. public static class BppTestBean {
  3.  @Autowired
  4.  private BppTestDepBean depBean;
  5.  
  6.  public void test1() {
  7.   depBean.testDep();
  8.  }
  9.  
  10.  public void test2() {
  11.   depBean.testDep();
  12.  }
  13.  
  14.  @TestMethod
  15.  public void test3() {
  16.   depBean.testDep();
  17.  }
  18. }
  19.  
  20. @Component
  21. public static class BppTestDepBean {
  22.  public void testDep() {
  23.   System.out.println("HEHE");
  24.  }
  25. }
  26.  
  27. @Target(ElementType.METHOD)
  28. @Retention(RetentionPolicy.RUNTIME)
  29. @Documented
  30. public @interface TestMethod {
  31. }

测试类

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class BppTest {
  4.  
  5.  @Autowired
  6.  private BppTestBean bppTestBean;
  7.  
  8.  @Test
  9.  public void test() {
  10.   bppTestBean.test1();
  11.   bppTestBean.test2();
  12.   bppTestBean.test3();
  13.  }
  14. }

v三、使用Cglib创建代理Bean

  1. public class ProxyBpp1 implements BeanPostProcessor {
  2.  private static final Logger LOGGER = LoggerFactory.getLogger(ProxyBpp1.class);
  3.  
  4.  @Override
  5.  public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  6.   if (bean instanceof BppTestBean) {
  7.    Enhancer enhancer = new Enhancer();
  8.    enhancer.setSuperclass(bean.getClass());
  9.    //标识Spring-generated proxies
  10.    enhancer.setInterfaces(new Class[]{SpringProxy.class});
  11.    //设置增强
  12.    enhancer.setCallback((MethodInterceptor) (target, method, args, methodProxy) -> {
  13.     if ("test1".equals(method.getName())) {
  14.      LOGGER.info("ProxyBpp1 开始执行...");
  15.      Object result = methodProxy.invokeSuper(target, args);
  16.      LOGGER.info("ProxyBpp1 结束执行...");
  17.      return result;
  18.     }
  19.     return method.invoke(target, args);
  20.    });
  21.  
  22.    return enhancer.create();
  23.   }
  24.   return bean;
  25.  }
  26. }

主要是代理 BppTestBean的test1方法。其实这种方式创建的代理Bean使用问题的，@Autowired字段没有注入进来，所以会有出现NPE。methodProxy.invokeSuper(target, args) ，这一行代码是有问题的，targe是代理类对象，而真实的对象是postProcessBeforeInitialization(Object bean, String beanName) 中的bean对象，此时bean对象@Autowired字段已经注入了。所以可以将methodProxy.invokeSuper(target, args) 修改为method.invoke(bean, args)解决无法注入@Autowired字段的问题。

v四、使用ProxyFactoryBean创建代理Bean

  1. public class ProxyBpp2 implements BeanPostProcessor {
  2.  private static final Logger LOGGER = LoggerFactory.getLogger(ProxyBpp2.class);
  3.  
  4.  @Override
  5.  public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  6.   if (bean instanceof BppTestBean) {
  7.    ProxyFactoryBean pfb = new ProxyFactoryBean();
  8.    pfb.setTarget(bean);
  9.    pfb.setAutodetectInterfaces(false);
  10.    NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor();
  11.    advisor.addMethodName("test1");
  12.    advisor.setAdvice((MethodInterceptor) invocation -> {
  13.     LOGGER.info("ProxyBpp2 开始执行...");
  14.     Object result = invocation.getMethod().invoke(invocation.getThis(), invocation.getArguments());
  15.     LOGGER.info("ProxyBpp2 结束执行...");
  16.     return result;
  17.    });
  18.    pfb.addAdvisor(advisor);
  19.  
  20.    return pfb.getObject();
  21.   }
  22.   return bean;
  23.  }
  24. }

使用ProxyFactoryBean创建代理Bean的时候，一定要一个targe对象的。Advisor在切入的时候，会逐个执行Advice。invocation.getThis()就是在通过ProxyFactoryBean创建代理Bean的时候传入的target对象。由于target对象就是postProcessBeforeInitialization(Object bean, String beanName) 中的bean对象，所以@Autowired字段也已经注入进来了。

v五、@Autowired注解何时被处理

想必大家都知道@Autowired字段的处理也是通过一个BPP，不过这个BPP比我们平常使用的要高级一些，它就是InstantiationAwareBeanPostProcessor。这个BPP可以实现Bean的创建、属性的注入和解析（比如@Autowired、@Value、@Resource等等），大家可以参考一下CommonAnnotationBeanPostProcessor（处理JSR-250相关注解），AutowiredAnnotationBeanPostProcessor（处理@Autowired、@Value、@Inject相关注解）。

InstantiationAwareBeanPostProcessor中有一个如下的方法，AutowiredAnnotationBeanPostProcessor就是覆盖这个方法实现了带有相关注解属性的自动注入。

  1. @Nullable
  2. default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
  3.   throws BeansException {
  4.  
  5.  return null;
  6. }
  1. @Override
  2. public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
  3.  InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
  4.  try {
  5.   metadata.inject(bean, beanName, pvs);
  6.  }
  7.  catch (BeanCreationException ex) {
  8.   throw ex;
  9.  }
  10.  catch (Throwable ex) {
  11.   throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
  12.  }
  13.  return pvs;
  14. }

InstantiationAwareBeanPostProcessor的postProcessProperties方法实在Spring AbstractAutowireCapableBeanFactory的populateBean方法中被调用。在AbstractAutowireCapableBeanFactory的doCreateBan中有如下代码。

  1. // Initialize the bean instance.
  2. Object exposedObject = bean;#
  3. try {
  4.  populateBean(beanName, mbd, instanceWrapper);
  5.  exposedObject = initializeBean(beanName, exposedObject, mbd);
  6. }

也就是先进行了Bean的属性填充，然后进行Bean的初始化工作。initializeBean方法中主要做了四件事。

　　1、invokeAwareMethods

　　2、applyBeanPostProcessorsBeforeInitialization

　　3、invokeInitMethods

　　4、applyBeanPostProcessorsAfterInitialization

其中2和4就是分别调用的普通的BPP中的postProcessBeforeInitialization方法和postProcessAfterInitialization方法。

这就是为什么在BPP中创建代理Bean的时候，对应的目标Bean相关的@Autowired字段已经注入的原因了。

v六、InstantiationAwareBeanPostProcessor方式创建动态代理Bean

InstantiationAwareBeanPostProcessor接口中有个postProcessBeforeInstantiation方法，可以让我们自己去实例化Bean。通过查看AbstractAutowireCapableBeanFactory，方法调用：createBean方法 -> resolveBeforeInstantiation方法 -> applyBeanPostProcessorsBeforeInstantiation方法 ->InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation方法，如果最终返回一个非null的实例，那么就不会再执行doCreateBean方法。这就意味着不会有Bean属性的填充和初始化的流程了，但是可以借助AbstractAutowireCapableBeanFactory帮助我们实现。

  1. public <T> T postProcess(T object) {
  2.  if (object == null) {
  3.   return null;
  4.  }
  5.  T result;
  6.  try {
  7.   // 使用容器autowireBeanFactory标准依赖注入方法autowireBean()处理 object对象的依赖注入
  8.   this.autowireBeanFactory.autowireBean(object);
  9.   // 使用容器autowireBeanFactory标准初始化方法initializeBean()初始化对象 object
  10.   result = (T) this.autowireBeanFactory.initializeBean(object,
  11.     object.toString());
  12.  } catch (RuntimeException e) {
  13.   Class<?> type = object.getClass();
  14.   throw new RuntimeException(
  15.     "Could not postProcess " + object + " of type " + type, e);
  16.  }
  17.  return result;
  18. }

上图代码，可以帮组我们实现非Spring容器Bean自动注入和初始化的功能。使用过Spring security同学都知道，内部也是用了这个方式解决对象中的属性注入问题。如果你阅读了Spring security的源码，你会发现很多对象，比如WebSecurity、ProviderManager、各个安全Filter等，这些对象的创建并不是通过bean定义的形式被容器发现和注册进入spring容器的，而是直接new出来的。Spring security提供的AutowireBeanFactoryObjectPostProcessor这个工具类可以使这些对象具有容器bean同样的生命周期，也能注入相应的依赖，从而进入准备好被使用的状态。

使用Cglib在InstantiationAwareBeanPostProcessor 中创建动态代理Bean。

  1. public class ProxyBpp3 implements InstantiationAwareBeanPostProcessor {
  2.  private static final Logger LOGGER = LoggerFactory.getLogger(ProxyBpp3.class);
  3.  
  4.  private final AutowireCapableBeanFactory autowireBeanFactory;
  5.  
  6.  ProxyBpp3(AutowireCapableBeanFactory autowireBeanFactory) {
  7.   this.autowireBeanFactory = autowireBeanFactory;
  8.  }
  9.  
  10.  @Override
  11.  public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
  12.   if (beanClass.equals(BppConfig.BppTestBean.class)) {
  13.    Enhancer enhancer = new Enhancer();
  14.    enhancer.setSuperclass(beanClass);
  15.    //标识Spring-generated proxies
  16.    enhancer.setInterfaces(new Class[]{SpringProxy.class});
  17.    //设置增强
  18.    enhancer.setCallback((MethodInterceptor) (target, method, args, methodProxy) -> {
  19.     if ("test1".equals(method.getName())) {
  20.      LOGGER.info("ProxyBpp3 开始执行...");
  21.      Object result = methodProxy.invokeSuper(target, args);
  22.      LOGGER.info("ProxyBpp3 结束执行...");
  23.      return result;
  24.     }
  25.     return methodProxy.invokeSuper(target, args);
  26.    });
  27.  
  28.    return this.postProcess(enhancer.create());
  29.   }
  30.   return null;
  31.  }
  32.  
  33.  ...
  34. }

使用ProxyFactoryBean在InstantiationAwareBeanPostProcessor 中创建动态代理Bean。

  1. public class ProxyBpp4 implements InstantiationAwareBeanPostProcessor {
  2.  private static final Logger LOGGER = LoggerFactory.getLogger(ProxyBpp4.class);
  3.  
  4.  private final AutowireCapableBeanFactory autowireBeanFactory;
  5.  
  6.  ProxyBpp4(AutowireCapableBeanFactory autowireBeanFactory) {
  7.   this.autowireBeanFactory = autowireBeanFactory;
  8.  }
  9.  
  10.  @Override
  11.  public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
  12.   if (beanClass.equals(BppConfig.BppTestBean.class)) {
  13.    ProxyFactoryBean pfb = new ProxyFactoryBean();
  14.    pfb.setTarget(this.postProcess(BeanUtils.instantiateClass(beanClass)));
  15.    pfb.setAutodetectInterfaces(false);
  16.    NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor();
  17.    advisor.addMethodName("test1");
  18.    advisor.setAdvice((MethodInterceptor) invocation -> {
  19.     LOGGER.info("ProxyBpp4 开始执行...");
  20.     Object result = invocation.getMethod().invoke(invocation.getThis(), invocation.getArguments());
  21.     LOGGER.info("ProxyBpp4 结束执行...");
  22.     return result;
  23.    });
  24.    pfb.addAdvisor(advisor);
  25.  
  26.    return pfb.getObject();
  27.   }
  28.   return null;
  29.  }
  30.  ...
  31. }

上述向两种方式，注意，实例化bean后主动通过postProcess方法借助AbstractAutowireCapableBeanFactory完成对象相关属性的注入以及对象的初始化流程。

v七、源码分享

点我查看源码，如果有任何疑问请关注公众号后进行咨询。

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对w3xue的支持。

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Spring热门文章

  • 解决springboot+activemq启动报注解错误的问题
  • Springboot整合Rabbitmq之Confirm和Return机制
  • SpringBoot SpringEL表达式的使用
  • SpringBoot自动配置原理,你真的懂吗?(简单易懂)
  • Spring源码：Bean生命周期（终章）
  • Springboot-Management的项目实践
  • 解决springboot 启动找不到主类的问题
  • Spring5路径匹配器PathPattern解析
  • SpringAOP如何获取方法参数上的注解
  • java与es8实战之五：SpringBoot应用中操作es8(带安全检查：https、账号密码、API Key)

    • Spring推荐文章

  • SpringBoot Session共享，配置不生效问题排查 → 你竟然在代码里下毒！
  • 【Spring源码分析】Spring Scope功能中的动态代理 - Scoped Proxy
  • Spring AOP概念及原理
  • SpringBoot2.7还是任性的，就是不支持Logback1.3，你能奈他何
  • SpringBoot+ Sharding Sphere 轻松实现数据库字段加解密
  • Spring MVC 中视图的实现原理，在Spring MVC 中实现重定向和转发，以及访问静态资源 - Rainbow-Sea
  • Spring MVC 中 HttpMessageConverter 转换器 - Rainbow-Sea
  • SpringBoot+mail 轻松实现各类邮件自动推送
  • Spring MVC 获取三个域(request请求域，session 会话域，application 应用域)对象的方式 - Rainbow-Sea
  • SpringBoot3整合SpringDoc实现在线接口文档

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号