v一、前言
本文章所讲并没有基于aspectj，而是直接通过cglib以及proxyfactory bean 去创建代理bean。通过下面的例子，可以看出cglib方式创建的代理bean和proxyfactorybean创建的代理bean的区别。
v二、基本测试代码
测试实体类，在bpp中创建bpptestdepbean类型的代理bean。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
@component public static class bpptestbean { @autowired private bpptestdepbean depbean;
public void test1() { depbean.testdep(); }
public void test2() { depbean.testdep(); }
@testmethod public void test3() { depbean.testdep(); } }
@component public static class bpptestdepbean { public void testdep() { system.out.println( "hehe" ); } }
@target (elementtype.method) @retention (retentionpolicy.runtime) @documented public @interface testmethod { } |
测试类
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
@runwith ( spring runner. class ) @springboottest public class bpptest {
@autowired private bpptestbean bpptestbean;
@test public void test() { bpptestbean.test1(); bpptestbean.test2(); bpptestbean.test3(); } } |
v三、使用cglib创建代理bean
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
public class proxybpp1 implements beanpostprocessor { private static final logger logger = loggerfactory.getlogger(proxybpp1. class );
@override public object postprocessbeforeinitialization(object bean, string beanname) throws beansexception { if (bean instanceof bpptestbean) { enhancer enhancer = new enhancer(); enhancer.setsuperclass(bean.getclass()); //标识spring-generated proxies enhancer.setinterfaces( new class []{springproxy. class }); //设置增强 enhancer.setcallback((methodinterceptor) (target, method, args, methodproxy) -> { if ( "test1" .equals(method.getname())) { logger.info( "proxybpp1 开始执行..." ); object result = methodproxy.invokesuper(target, args); logger.info( "proxybpp1 结束执行..." ); return result; } return method.invoke(target, args); });
return enhancer.create(); } return bean; } } |
主要是代理 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 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
public class proxybpp2 implements beanpostprocessor { private static final logger logger = loggerfactory.getlogger(proxybpp2. class );
@override public object postprocessbeforeinitialization(object bean, string beanname) throws beansexception { if (bean instanceof bpptestbean) { proxyfactorybean pfb = new proxyfactorybean(); pfb.settarget(bean); pfb.setautodetectinterfaces( false ); namematchmethodpointcutadvisor advisor = new namematchmethodpointcutadvisor(); advisor.addmethodname( "test1" ); advisor.setadvice((methodinterceptor) invocation -> { logger.info( "proxybpp2 开始执行..." ); object result = invocation.getmethod().invoke(invocation.getthis(), invocation.getarguments()); logger.info( "proxybpp2 结束执行..." ); return result; }); pfb.addadvisor(advisor);
return pfb.getobject(); } return bean; } } |
使用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 2 3 4 5 6 |
@nullable default propertyvalues postprocessproperties(propertyvalues pvs, object bean, string beanname) throws beansexception {
return null ; } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
@override public propertyvalues postprocessproperties(propertyvalues pvs, object bean, string beanname) { injectionmetadata metadata = findautowiringmetadata(beanname, bean.getclass(), pvs); try { metadata.inject(bean, beanname, pvs); } catch (beancreationexception ex) { throw ex; } catch (throwable ex) { throw new beancreationexception(beanname, "injection of autowired dependencies failed" , ex); } return pvs; } |
instantiationawarebeanpostprocessor的postprocessproperties方法实在spring abstractautowirecapablebeanfactory的populatebean方法中被调用。在abstractautowirecapablebeanfactory的docreateban中有如下代码。
|
1 2 3 4 5 6 |
// initialize the bean instance. object exposedobject = bean;# try { populatebean(beanname, mbd, instancewrapper); exposedobject = initializebean(beanname, exposedobject, mbd); } |
也就是先进行了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 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
public <t> t postprocess(t object) { if (object == null ) { return null ; } t result; try { // 使用容器autowirebeanfactory标准依赖注入方法autowirebean()处理 object对象的依赖注入 this .autowirebeanfactory.autowirebean(object); // 使用容器autowirebeanfactory标准初始化方法initializebean()初始化对象 object result = (t) this .autowirebeanfactory.initializebean(object, object.tostring()); } catch (runtimeexception e) { class <?> type = object.getclass(); throw new runtimeexception( "could not postprocess " + object + " of type " + type, e); } return result; } |
上图代码，可以帮组我们实现非spring容器bean自动注入和初始化的功能。使用过spring security同学都知道，内部也是用了这个方式解决对象中的属性注入问题。如果你阅读了spring security的源码，你会发现很多对象，比如websecurity、providermanager、各个安全filter等，这些对象的创建并不是通过bean定义的形式被容器发现和注册进入spring容器的，而是直接new出来的。spring security提供的autowirebeanfactoryobjectpostprocessor这个工具类可以使这些对象具有容器bean同样的生命周期，也能注入相应的依赖，从而进入准备好被使用的状态。
使用cglib在instantiationawarebeanpostprocessor 中创建动态代理bean。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
public class proxybpp3 implements instantiationawarebeanpostprocessor { private static final logger logger = loggerfactory.getlogger(proxybpp3. class );
private final autowirecapablebeanfactory autowirebeanfactory;
proxybpp3(autowirecapablebeanfactory autowirebeanfactory) { this .autowirebeanfactory = autowirebeanfactory; }
@override public object postprocessbeforeinstantiation( class <?> beanclass, string beanname) throws beansexception { if (beanclass.equals(bppconfig.bpptestbean. class )) { enhancer enhancer = new enhancer(); enhancer.setsuperclass(beanclass); //标识spring-generated proxies enhancer.setinterfaces( new class []{springproxy. class }); //设置增强 enhancer.setcallback((methodinterceptor) (target, method, args, methodproxy) -> { if ( "test1" .equals(method.getname())) { logger.info( "proxybpp3 开始执行..." ); object result = methodproxy.invokesuper(target, args); logger.info( "proxybpp3 结束执行..." ); return result; } return methodproxy.invokesuper(target, args); });
return this .postprocess(enhancer.create()); } return null ; }
... } |
使用proxyfactorybean在instantiationawarebeanpostprocessor 中创建动态代理bean。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
public class proxybpp4 implements instantiationawarebeanpostprocessor { private static final logger logger = loggerfactory.getlogger(proxybpp4. class );
private final autowirecapablebeanfactory autowirebeanfactory;
proxybpp4(autowirecapablebeanfactory autowirebeanfactory) { this .autowirebeanfactory = autowirebeanfactory; }
@override public object postprocessbeforeinstantiation( class <?> beanclass, string beanname) throws beansexception { if (beanclass.equals(bppconfig.bpptestbean. class )) { proxyfactorybean pfb = new proxyfactorybean(); pfb.settarget( this .postprocess(beanutils.instantiateclass(beanclass))); pfb.setautodetectinterfaces( false ); namematchmethodpointcutadvisor advisor = new namematchmethodpointcutadvisor(); advisor.addmethodname( "test1" ); advisor.setadvice((methodinterceptor) invocation -> { logger.info( "proxybpp4 开始执行..." ); object result = invocation.getmethod().invoke(invocation.getthis(), invocation.getarguments()); logger.info( "proxybpp4 结束执行..." ); return result; }); pfb.addadvisor(advisor);
return pfb.getobject(); } return null ; } ... } |
上述向两种方式，注意，实例化bean后主动通过postprocess方法借助abstractautowirecapablebeanfactory完成对象相关属性的注入以及对象的初始化流程。
v七、源码分享
点我查看源码 ，如果有任何疑问请关注公众号后进行咨询。
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对的支持。
原文链接：https://HdhCmsTestcnblogs测试数据/hujunzheng/p/10463798.html
查看更多关于Spring BPP中如何优雅的创建动态代理Bean详解的详细内容...