Spring AOP中expose-proxy介绍

梦里梦外; 2021-06-11 15:13 636阅读 0赞

https://www.cnblogs.com/chihirotan/p/7356683.html

写在前面

　　expose-proxy。为是否暴露当前代理对象为ThreadLocal模式。

　　SpringAOP对于最外层的函数只拦截public方法，不拦截protected和private方法（后续讲解），另外不会对最外层的public方法内部调用的其他方法也进行拦截，即只停留于代理对象所调用的方法。

案例分析

复制代码

  1. public class AServiceImpl implements AService{
  2.     @Override
  3.     public void barA() {
  4.         System.out.println("AServiceImpl.barA()");  
  5.         barB();
  6.     }
  7.     @Override
  8.     public void barB() {
  9.          System.out.println("AServiceImpl.barB()");  
  10.     }
  11. }

复制代码

控制台的输出结果：

  1. run my before advice
  2. AServiceImpl.barA()
  3. AServiceImpl.barB()

分析：

　　发现aop并没有对barB方法进行增强，只是增强了barA方法。

　　判断上述this.barB()方法是否被拦截的最本质的东西是看this到底是谁？有如下对象B类的对象b,和cglib生成的代理对象bProxy，代理对象bProxy内部拥有b。如果调用b对象的任何方法，肯定不会发生任何拦截，当调用bProxy的方法则都会进入拦截函数。

　　当我们调用bProxy对象的barA()方法时，先执行cglib之前设置的callback对象的intercept拦截函数，如下： （之前的文章已经分析过代码）

复制代码

  1. public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
  2.             Object oldProxy = null;
  3.             boolean setProxyContext = false;
  4.             Class<?> targetClass = null;
  5.             Object target = null;
  6.             try {
  7.                 if (this.advised.exposeProxy) {
  8.                     oldProxy = AopContext.setCurrentProxy(proxy);
  9.                     setProxyContext = true;
  10.                 }
  11.                 target = getTarget();
  12.                 if (target != null) {
  13.                     targetClass = target.getClass();
  14.                 }
  15.                 List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
  16.                 Object retVal;
  17.                 if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
  18.                     retVal = methodProxy.invoke(target, args);
  19.                 }
  20.                 else {
  21.                     retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
  22.                 }
  23.                 retVal = processReturnType(proxy, target, method, retVal);
  24.                 return retVal;
  25.             }
  26.             finally {
  27.                 if (target != null) {
  28.                     releaseTarget(target);
  29.                 }
  30.                 if (setProxyContext) {
  31.                     AopContext.setCurrentProxy(oldProxy);
  32.                 }
  33.             }
  34.         }

复制代码

　　这个过程之前的文章已经分析过，这里就是首先取出拦截器链List chain，当barA方法不符合我们所配置的pointcut时，拦截器链必然为空,然后就是直接执行目标对象的方法。
当barA方法符合所配置的pointcut时，拦截器链不为空，执行相应的通知advice，currentInterceptorIndex 从-1开始，如下（之前的文章已经分析过代码）

复制代码

  1. public Object proceed() throws Throwable {
  2.         if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
  3.             return invokeJoinpoint();
  4.         }
  5.         Object interceptorOrInterceptionAdvice =
  6.                 this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
  7.         if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
  8.             InterceptorAndDynamicMethodMatcher dm =
  9.                     (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
  10.             if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
  11.                 return dm.interceptor.invoke(this);
  12.             }
  13.             else {
  14.                 return proceed();
  15.             }
  16.         }
  17.         else {
  18.             return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
  19.         }
  20.     }

复制代码

　　随着通知不断的传递执行，最终this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1将会满足条件，将会来到执行目标对象的方法invokeJoinpoint()：

复制代码

  1. protected Object invokeJoinpoint() throws Throwable {
  2.             if (this.publicMethod) {
  3.                 return this.methodProxy.invoke(this.target, this.arguments);
  4.             }
  5.             else {
  6.                 return super.invokeJoinpoint();
  7.             }
  8.         }

复制代码

　　在这里不管要拦截的目标方法是不是public方法，最终所传递的对象都是this.target，他是目标对象而不是代理对象，即执行上述barA()函数的对象是目标对象而不是代理对象，所以它内部所调用的this.barB()也是目标对象,因此不会发生拦截，如果是执行的是代理对象.barB（）则必然会进入intercept拦截过程。所以上述调用barA函数，其内部调用的barB函数是不会发生拦截的，因为this指的是目标对象，不是代理对象。

实现BarB拦截

　　如果你想实现barA调用时内部的BarB也进行拦截，就必须把this换成代理对象。这时就要用到了，xml配置中的expose-proxy=”true”,即暴露出代理对象，它使用的是ThreadLocal设计模式，我们可以这样获取代理对象,AopContext.currentProxy()就是代理对象，然后转换成目标对象或者目标接口，执行相应的方法：

复制代码

  1. public class AServiceImpl implements AService{
  2.     @Override
  3.     public void barA() {
  4.         System.out.println("AServiceImpl.barA()");  
  5.         AService proxy=(AService) AopContext.currentProxy();
  6.         proxy.barB();
  7.     }
  8.     @Override
  9.     public void barB() {
  10.          System.out.println("AServiceImpl.barB()");  
  11.     }
  12. }

复制代码

复制代码

  1. <bean id="aServiceImplProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  2.         <property name="exposeProxy">
  3.             <value>true</value>
  4.         </property>
  5.         <property name="interfaces" value="com.xxx.plus.aop.demo.AService"/>
  6.         <property name="target">
  7.             <ref bean="aServiceImpl"/>
  8.         </property>
  9.          <property name="interceptorNames">  
  10.             <list>  
  11.                 <value>myBeforAdvice</value>  
  12.             </list>  
  13.         </property>  
  14.     </bean>

复制代码

执行结果：

  1. run my before advice
  2. AServiceImpl.barA()
  3. run my before advice
  4. AServiceImpl.barB()

分析：

　　barA()和barB都被aop拦截实现了增强

最后再给出Spring的文档说明：

　　Due to the proxy-based nature of Spring’s AOP framework, protected methods are by definition not intercepted, neither for JDK proxies (where this isn’t applicable) nor for CGLIB proxies (where this is technically possible but not recommendable for AOP purposes). As a consequence, any given pointcut will be matched against public methods only!
　　If your interception needs include protected/private methods or even constructors, consider the use of Spring-driven native AspectJ weaving instead of Spring’s proxy-based AOP framework. This constitutes a different mode of AOP usage with different characteristics, so be sure to make yourself familiar with weaving first before making a decision.

发表评论

表情：
评论列表 （有 0 条评论，636人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Spring AOP基本介绍

    AOP是Spring框架除了IOC之外的另一个核心概念。 我们知道Java是面向对象编程（OOP）的语言，也就是将所有的一切都看成对象，通过对象与对象之间相互作用来解决问题

    绝地灬酷狼绝地灬酷狼/ 0 赞/ 86 阅读

    相关 Spring AOP介绍

    1、简介 spring提供了两个核心功能，一个是IoC(控制反转)，另外一个便是Aop(面向切面编程)，IoC有助于应用对象之间的解耦，AOP则可以实现横切关注点（如日志、

    ゞ 浴缸里的玫瑰ゞ 浴缸里的玫瑰/ 0 赞/ 294 阅读

    相关 java_spring_AOP介绍

    Aspect oriented programming 面向切面编程，对某一类对象编程。 1. 简介     面向切面编程（AOP）通过提供另外一种思考程序结构的途经来弥

    冷不防冷不防/ 0 赞/ 297 阅读

    相关 Spring AOP详细介绍

    AOP称为面向切面编程，在程序开发中主要用来解决一些系统层面上的问题，比如日志，事务，权限等待，Struts2的拦截器设计就是基于AOP的思想，是个比较经典的例子。 一 AO

    浅浅的花香味﹌浅浅的花香味﹌/ 0 赞/ 300 阅读

    相关 Spring AOP介绍

    什么是AOP 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维

    缺乏、安全感缺乏、安全感/ 0 赞/ 294 阅读