spring aop之对象内部方法间的嵌套失效

最新推荐文章于 2023-10-10 11:28:52 发布
最新推荐文章于 2023-10-10 11:28:52 发布
阅读量603 收藏
点赞数
分类专栏： Java 文章标签： Spring AOP 对象 aop java


先看一下spring 代理原理：
*       spring代理嵌套方法调用不生效
 * 
 *       Spring AOP defaults to using standard JDK dynamic proxies for AOP
 *       proxies. This enables any interface (or set of interfaces) to be
 *       proxied.
 * 
 *       Spring AOP can also use CGLIB proxies. This is necessary to proxy
 *       classes rather than interfaces. CGLIB is used by default if a business
 *       object does not implement an interface. As it is good practice to
 *       program to interfaces rather than classes; business classes normally
 *       will implement one or more business interfaces. It is possible to force
 *       the use of CGLIB, in those (hopefully rare) cases where you need to
 *       advise a method that is not declared on an interface, or where you need
 *       to pass a proxied object to a method as a concrete type.
 * 
 *       It is important to grasp the fact that Spring AOP is proxy-based. See
 *       Section 11.6.1, “Understanding AOP proxies” for a thorough examination
 *       of exactly what this implementation detail actually means.
 * 
 * 
 * 
 *       通过配置 <aop:aspectj-autoproxy proxy-target-class="true" />可以统一用CGLIB
 *       proxies。
 * 

实际上注入到spring容器的类实例是代理类，自然我们调用类的方法都能被aop拦截，但是类中内部方法的调用即this.metho(...),
这里的this，并不是spirng生成的代理类实例，而是实际产生的原对象，自然，aop就不会拦截这样的方法调用。

写个简短的程序验证一下spring代理嵌套方法调用不生效。
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.doctor.aop.demo;  
  2.   
  3. import org.springframework.stereotype.Component;  
  4.   
  5. /** 
  6.  * @description  
  7.  * 
  8.  * @author sdcuike 
  9.  * 
  10.  * @date 2016年6月24日 下午6:44:32 
  11.  */  
  12. @Component  
  13. public class Demo {  
  14.     public void test01() {  
  15.         System.out.println("test1");  
  16.         System.out.println("this对象指的不是代理类对象，而是原对象" + this.getClass());  
  17.         test02("hello nest ");  
  18.     }  
  19.       
  20.     public String test02(String name) {  
  21.         return name;  
  22.     }  
  23. }  
package com.doctor.aop.demo;

import org.springframework.stereotype.Component;

/**
 * @description 
 *
 * @author sdcuike
 *
 * @date 2016年6月24日 下午6:44:32
 */
@Component
public class Demo {
	public void test01() {
		System.out.println("test1");
		System.out.println("this对象指的不是代理类对象，而是原对象" + this.getClass());
		test02("hello nest ");
	}
	
	public String test02(String name) {
		return name;
	}
}

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.doctor.aop.demo;  
  2.   
  3. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  4.   
  5. /** 
  6.  * @description 
  7.  * 
  8.  * @author sdcuike 
  9.  * 
  10.  * @date 2016年6月24日 下午6:44:12 
  11.  *  
  12.  *       spring代理嵌套方法调用不生效 
  13.  *  
  14.  *       Spring AOP defaults to using standard JDK dynamic proxies for AOP 
  15.  *       proxies. This enables any interface (or set of interfaces) to be 
  16.  *       proxied. 
  17.  *  
  18.  *       Spring AOP can also use CGLIB proxies. This is necessary to proxy 
  19.  *       classes rather than interfaces. CGLIB is used by default if a business 
  20.  *       object does not implement an interface. As it is good practice to 
  21.  *       program to interfaces rather than classes; business classes normally 
  22.  *       will implement one or more business interfaces. It is possible to force 
  23.  *       the use of CGLIB, in those (hopefully rare) cases where you need to 
  24.  *       advise a method that is not declared on an interface, or where you need 
  25.  *       to pass a proxied object to a method as a concrete type. 
  26.  *  
  27.  *       It is important to grasp the fact that Spring AOP is proxy-based. See 
  28.  *       Section 11.6.1, “Understanding AOP proxies” for a thorough examination 
  29.  *       of exactly what this implementation detail actually means. 
  30.  *  
  31.  *  
  32.  *  
  33.  *       通过配置 <aop:aspectj-autoproxy proxy-target-class="true" />可以统一用CGLIB 
  34.  *       proxies。 
  35.  *  
  36.  */  
  37. public class MethodInvokeTimeAspectTest {  
  38.   
  39.     public static void main(String[] args) {  
  40.         ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(  
  41.                 "classpath:/aopDemo1/spring-aop.xml");  
  42.         Demo demo = applicationContext.getBean(Demo.class);  
  43.         demo.test01();  
  44.         demo.test02("doctor who");  
  45.         System.out.println("注入到spring容器的类实例是代理类" + demo.getClass());  
  46.         // class com.doctor.aop.demo.Demo
    EnhancerBySpringCGLIB 
    e9a9050a  
  47.         // 注入到spring容器的类实例是代理类  
  48.   
  49.         InterfaceDemo interfaceDemo = applicationContext.getBean(InterfaceDemo.class);  
  50.         System.out.println("注入到spring容器的类实例是代理类" + interfaceDemo.getClass());  
  51.         interfaceDemo.testAnother();  
  52.         applicationContext.close();  
  53.     }  
  54.   
  55. }  
package com.doctor.aop.demo;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @description
 *
 * @author sdcuike
 *
 * @date 2016年6月24日 下午6:44:12
 * 
 *       spring代理嵌套方法调用不生效
 * 
 *       Spring AOP defaults to using standard JDK dynamic proxies for AOP
 *       proxies. This enables any interface (or set of interfaces) to be
 *       proxied.
 * 
 *       Spring AOP can also use CGLIB proxies. This is necessary to proxy
 *       classes rather than interfaces. CGLIB is used by default if a business
 *       object does not implement an interface. As it is good practice to
 *       program to interfaces rather than classes; business classes normally
 *       will implement one or more business interfaces. It is possible to force
 *       the use of CGLIB, in those (hopefully rare) cases where you need to
 *       advise a method that is not declared on an interface, or where you need
 *       to pass a proxied object to a method as a concrete type.
 * 
 *       It is important to grasp the fact that Spring AOP is proxy-based. See
 *       Section 11.6.1, “Understanding AOP proxies” for a thorough examination
 *       of exactly what this implementation detail actually means.
 * 
 * 
 * 
 *       通过配置 <aop:aspectj-autoproxy proxy-target-class="true" />可以统一用CGLIB
 *       proxies。
 * 
 */
public class MethodInvokeTimeAspectTest {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(
				"classpath:/aopDemo1/spring-aop.xml");
		Demo demo = applicationContext.getBean(Demo.class);
		demo.test01();
		demo.test02("doctor who");
		System.out.println("注入到spring容器的类实例是代理类" + demo.getClass());
		// class com.doctor.aop.demo.Demo$$EnhancerBySpringCGLIB$$e9a9050a
		// 注入到spring容器的类实例是代理类

		InterfaceDemo interfaceDemo = applicationContext.getBean(InterfaceDemo.class);
		System.out.println("注入到spring容器的类实例是代理类" + interfaceDemo.getClass());
		interfaceDemo.testAnother();
		applicationContext.close();
	}

}

看一下输出：
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. 07-03 11:23:57.357 main  INFO  org.springframework.context.support.ClassPathXmlApplicationContext - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@9f70c54: startup date [Sun Jul 03 11:23:57 CST 2016]; root of context hierarchy  
  2. 07-03 11:23:57.457 main  INFO  org.springframework.beans.factory.xml.XmlBeanDefinitionReader -  Loading XML bean definitions from class path resource [aopDemo1/spring-aop.xml]  
  3. AspectAopDemo===before  execution(void com.doctor.aop.demo.Demo.test01())  
  4. test1  
  5. this对象指的不是代理类对象，而是原对象class com.doctor.aop.demo.Demo  
  6. AspectAopDemo===before  execution(String com.doctor.aop.demo.Demo.test02(String))  
  7. AspectAopDemo===after   execution(String com.doctor.aop.demo.Demo.test02(String))  
  8. AspectAopDemo===after   execution(void com.doctor.aop.demo.Demo.test01())  
  9. 07-03 11:23:59.108 main  INFO  com.doctor.aop.demo.MethodInvokeTimeAspect - [execution(void com.doctor.aop.demo.Demo.test01())],[],[null], [20]   
  10. AspectAopDemo===before  execution(String com.doctor.aop.demo.Demo.test02(String))  
  11. AspectAopDemo===after   execution(String com.doctor.aop.demo.Demo.test02(String))  
  12. 07-03 11:23:59.108 main  INFO  com.doctor.aop.demo.MethodInvokeTimeAspect - [execution(String com.doctor.aop.demo.Demo.test02(String))],[doctor who],[doctor who], [0]   
  13. 注入到spring容器的类实例是代理类class com.doctor.aop.demo.Demo
    EnhancerBySpringCGLIB 
    595bc0d7  
  14. 注入到spring容器的类实例是代理类class com.sun.proxy.$Proxy7  
  15. 07-03 11:23:59.108 main  INFO  org.springframework.context.support.ClassPathXmlApplicationContext - Closing org.springframework.context.support.ClassPathXmlApplicationContext@9f70c54: startup date [Sun Jul 03 11:23:57 CST 2016]; root of context hierarchy  
07-03 11:23:57.357 main  INFO  org.springframework.context.support.ClassPathXmlApplicationContext -	Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@9f70c54: startup date [Sun Jul 03 11:23:57 CST 2016]; root of context hierarchy
07-03 11:23:57.457 main  INFO  org.springframework.beans.factory.xml.XmlBeanDefinitionReader -	Loading XML bean definitions from class path resource [aopDemo1/spring-aop.xml]
AspectAopDemo===before  execution(void com.doctor.aop.demo.Demo.test01())
test1
this对象指的不是代理类对象，而是原对象class com.doctor.aop.demo.Demo
AspectAopDemo===before  execution(String com.doctor.aop.demo.Demo.test02(String))
AspectAopDemo===after   execution(String com.doctor.aop.demo.Demo.test02(String))
AspectAopDemo===after   execution(void com.doctor.aop.demo.Demo.test01())
07-03 11:23:59.108 main  INFO  com.doctor.aop.demo.MethodInvokeTimeAspect -	[execution(void com.doctor.aop.demo.Demo.test01())],[],[null], [20] 
AspectAopDemo===before  execution(String com.doctor.aop.demo.Demo.test02(String))
AspectAopDemo===after   execution(String com.doctor.aop.demo.Demo.test02(String))
07-03 11:23:59.108 main  INFO  com.doctor.aop.demo.MethodInvokeTimeAspect -	[execution(String com.doctor.aop.demo.Demo.test02(String))],[doctor who],[doctor who], [0] 
注入到spring容器的类实例是代理类class com.doctor.aop.demo.Demo$$EnhancerBySpringCGLIB$$595bc0d7
注入到spring容器的类实例是代理类class com.sun.proxy.$Proxy7
07-03 11:23:59.108 main  INFO  org.springframework.context.support.ClassPathXmlApplicationContext -	Closing org.springframework.context.support.ClassPathXmlApplicationContext@9f70c54: startup date [Sun Jul 03 11:23:57 CST 2016]; root of context hierarchy

日志结果：注入到spring容器内的类实例是代理类实例，非原实例，而类内方法之间调用的时候，this指向的是原实例，非代理类。

由spring代理是动态的，运行时织入，固类内部方法之间调用的时候，不可能让this指向代理类。


如何解决

 动态代理不行，我们基于字节码的支持编译期间进行织入(weaving)，还是编译后(post-compile)的AspectJ。

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.doctor.aop.aspect.demo;  
  2.   
  3. /** 
  4.  * @description  
  5.  * 
  6.  * @author sdcuike 
  7.  * 
  8.  * @date 2016年6月27日 下午1:51:14 
  9.  */  
  10. public aspect AspectAopDemo {  
  11. pointcut demo() : execution(* com.doctor.aop.demo.Demo.* (..));  
  12.   
  13. before() : demo() {  
  14.     System.out.println("AspectAopDemo===before  " + thisJoinPoint);  
  15. }  
  16.   
  17. after() : demo() {  
  18.     System.out.println("AspectAopDemo===after   " + thisJoinPoint);  
  19.  }  
  20. }  
package com.doctor.aop.aspect.demo;

/**
 * @description 
 *
 * @author sdcuike
 *
 * @date 2016年6月27日 下午1:51:14
 */
public aspect AspectAopDemo {
pointcut demo() : execution(* com.doctor.aop.demo.Demo.* (..));

before() : demo() {
	System.out.println("AspectAopDemo===before  " + thisJoinPoint);
}

after() : demo() {
	System.out.println("AspectAopDemo===after   " + thisJoinPoint);
 }
}

[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.doctor.aop.demo;  
  2.   
  3. import org.springframework.stereotype.Component;  
  4.   
  5. /**  
  6.  * @description   
  7.  *  
  8.  * @author sdcuike  
  9.  *  
  10.  * @date 2016年6月24日 下午6:44:32  
  11.  */  
  12. @Component  
  13. public class Demo {  
  14.     public void test01() {  
  15.         System.out.println("test1");  
  16.         System.out.println("this对象指的不是代理类对象，而是原对象" + this.getClass());  
  17.         test02("hello nest ");  
  18.     }  
  19.       
  20.     public String test02(String name) {  
  21.         return name;  
  22.     }  
  23. }  
package com.doctor.aop.demo;

import org.springframework.stereotype.Component;

/**
 * @description 
 *
 * @author sdcuike
 *
 * @date 2016年6月24日 下午6:44:32
 */
@Component
public class Demo {
	public void test01() {
		System.out.println("test1");
		System.out.println("this对象指的不是代理类对象，而是原对象" + this.getClass());
		test02("hello nest ");
	}
	
	public String test02(String name) {
		return name;
	}
}



看一下结果：eclipse IDE中把项目转变成AspectJ项目。

运行下面程序：（AspectJ/java application）

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.doctor.aop.aspect.demo;  
  2.   
  3. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  4.   
  5. import com.doctor.aop.demo.Demo;  
  6.   
  7. /** 
  8.  * @description 
  9.  * 
  10.  * @author sdcuike 
  11.  * 
  12.  * @date 2016年6月27日 下午2:16:57 
  13.  *  
  14.  *       aspect 编译时候注入，克服动态代理方法嵌套调用失效问题. 
  15.  *  
  16.  *       运行方法：把项目转换成AspectJ工程，运行的时候选择：Run As-> AspectJ/Java Application 
  17.  */  
  18. class AspectAopDemoTest {  
  19.   
  20.     public static void main(String[] args) {  
  21.         ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(  
  22.                 "classpath:/aopDemo1/spring-aop2.xml");  
  23.         Demo demo = applicationContext.getBean(Demo.class);  
  24.         demo.test01();  
  25.         demo.test02("doctor who");  
  26.         System.out.println("注入到spring容器的类实例是代理类" + demo.getClass());  
  27.         // class com.doctor.aop.demo.Demo
    EnhancerBySpringCGLIB 
    e9a9050a  
  28.         // 注入到spring容器的类实例是代理类  
  29.   
  30.         applicationContext.close();  
  31.     }  
  32.   
  33. }  
package com.doctor.aop.aspect.demo;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.doctor.aop.demo.Demo;

/**
 * @description
 *
 * @author sdcuike
 *
 * @date 2016年6月27日 下午2:16:57
 * 
 *       aspect 编译时候注入，克服动态代理方法嵌套调用失效问题.
 * 
 *       运行方法：把项目转换成AspectJ工程，运行的时候选择：Run As-> AspectJ/Java Application
 */
class AspectAopDemoTest {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(
				"classpath:/aopDemo1/spring-aop2.xml");
		Demo demo = applicationContext.getBean(Demo.class);
		demo.test01();
		demo.test02("doctor who");
		System.out.println("注入到spring容器的类实例是代理类" + demo.getClass());
		// class com.doctor.aop.demo.Demo$$EnhancerBySpringCGLIB$$e9a9050a
		// 注入到spring容器的类实例是代理类

		applicationContext.close();
	}

}


输出结果：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. 07-03 12:04:48.375 main  INFO  org.springframework.context.support.ClassPathXmlApplicationContext - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@13c78c0b: startup date [Sun Jul 03 12:04:48 CST 2016]; root of context hierarchy  
  2. 07-03 12:04:48.421 main  INFO  org.springframework.beans.factory.xml.XmlBeanDefinitionReader -  Loading XML bean definitions from class path resource [aopDemo1/spring-aop2.xml]  
  3. AspectAopDemo===before  execution(void com.doctor.aop.demo.Demo.test01())  
  4. test1  
  5. this对象指的不是代理类对象，而是原对象class com.doctor.aop.demo.Demo  
  6. AspectAopDemo===before  execution(String com.doctor.aop.demo.Demo.test02(String))  
  7. AspectAopDemo===after   execution(String com.doctor.aop.demo.Demo.test02(String))  
  8. AspectAopDemo===after   execution(void com.doctor.aop.demo.Demo.test01())  
  9. AspectAopDemo===before  execution(String com.doctor.aop.demo.Demo.test02(String))  
  10. AspectAopDemo===after   execution(String com.doctor.aop.demo.Demo.test02(String))  
  11. 注入到spring容器的类实例是代理类class com.doctor.aop.demo.Demo  
  12. 07-03 12:04:48.794 main  INFO  org.springframework.context.support.ClassPathXmlApplicationContext - Closing org.springframework.context.support.ClassPathXmlApplicationContext@13c78c0b: startup date [Sun Jul 03 12:04:48 CST 2016]; root of context hierarchy  
07-03 12:04:48.375 main  INFO  org.springframework.context.support.ClassPathXmlApplicationContext -	Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@13c78c0b: startup date [Sun Jul 03 12:04:48 CST 2016]; root of context hierarchy
07-03 12:04:48.421 main  INFO  org.springframework.beans.factory.xml.XmlBeanDefinitionReader -	Loading XML bean definitions from class path resource [aopDemo1/spring-aop2.xml]
AspectAopDemo===before  execution(void com.doctor.aop.demo.Demo.test01())
test1
this对象指的不是代理类对象，而是原对象class com.doctor.aop.demo.Demo
AspectAopDemo===before  execution(String com.doctor.aop.demo.Demo.test02(String))
AspectAopDemo===after   execution(String com.doctor.aop.demo.Demo.test02(String))
AspectAopDemo===after   execution(void com.doctor.aop.demo.Demo.test01())
AspectAopDemo===before  execution(String com.doctor.aop.demo.Demo.test02(String))
AspectAopDemo===after   execution(String com.doctor.aop.demo.Demo.test02(String))
注入到spring容器的类实例是代理类class com.doctor.aop.demo.Demo
07-03 12:04:48.794 main  INFO  org.springframework.context.support.ClassPathXmlApplicationContext -	Closing org.springframework.context.support.ClassPathXmlApplicationContext@13c78c0b: startup date [Sun Jul 03 12:04:48 CST 2016]; root of context hierarchy

test02方法确实被调用了4次。

使用AspectJ的一个间接局限是，因为AspectJ通知可以应用于POJO之上，它有可能将通知应用于一个已配置的通知之上。对于一个你没有注意到这方面问题的大范围应用的通知，这有可能导致一个无限循环。


Footloose_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Spring注解驱动开发】困扰了我很久的AOP嵌套调用终于解决了
m0_67595943的博客
05-10 291
Spring AOP在同一个类里自身方法相互调用时无法拦截。比如下面的代码: public class SomeServiceImpl implements SomeService { public void someMethod() { someInnerMethod(); } public void someInnerMethod(){ } } 两个方法经过AOP代理,执行时都实现系统日志记录。单独使用someInnerMethod时，没有任何问题。但someMethod就有问题了。someMeth
Spring AOP对嵌套方法不起作用
bobozai86的博客
12-25 2367
今天在调研系统操作记录日志时，好多教程都是借助于Spring AOP机制来实现。于是也采用这种方法来实现。在Service中的删除日志方法上注解自定义的切点，但是执行没有生效。代码如下： //尝试删除溢出日志 public synchronized void tryDelOverflowLog() { logNum++; if (logNum - LogC
spring aop 无法在内部嵌套的方法上生效
冲吧，不要停！
08-01 1799
1，问题例子：public void method1(){ ......... method2(); ........... } public void method2(){ ............... ............... }结果：当你调用method1，并且在method1方法里面调用method2方法时，设置在method2上的“拦截/代理”是无效的。
Spring 嵌套方法AOP不生效问题
weixin_30536513的博客
08-09 271
问题描述, 如下Abc定义为一个Bean, b()方法添加@TargetDatasource，定义切面DynamicDataSourceAspect，期望：调用a()方法，b()方法上的AOP拦截能生效。实际不生效。 @Service public class Abc { public void a(){ b();}@TargetDatasource(value=abc) ...
Spring aop失效的几种解决方案
08-19
Spring AOP失效的几种解决方案是指在使用Spring框架时，Aspect Oriented Programming（面向方面编程）机制出现故障或不生效的解决方法。AOP是一种编程范式，它可以让开发人员将业务逻辑和非业务逻辑（如日志记录、...
Spring Aop之AspectJ注解配置实现日志管理的方法
08-28
Spring Aop之AspectJ注解配置实现日志管理的方法 Spring Aop是基于AspectJ实现的面向切面编程（AOP），它提供了一个灵活的方式来实现日志管理。通过使用AspectJ注解，可以轻松地实现日志记录、性能监控、安全检查...
Java利用spring aop进行监测方法执行耗时
05-25
使用 Spring AOP 进行方法耗时监测的好处有以下几点： 1. 代码实现简单，易于维护：使用 Spring AOP 可以将耗时监测的逻辑与业务逻辑进行解耦，避免业务逻辑代码的冗余和代码维护难度的提高。 2. 安全性高：使用 ...
Spring AOP中使用args表达式的方法示例
08-25
Spring AOP中使用args表达式的方法示例 Spring AOP（Aspect-Oriented Programming）是一种面向切面编程的技术， args表达式是AOP中的一种表达式，它可以用来指定目标方法的参数类型和数量。下面我们将详细介绍...
Spring AOP访问目标方法的参数操作示例
08-25
Spring AOP访问目标方法的参数操作示例 Spring AOP访问目标方法的参数操作示例是Spring框架中的一种面向切面编程（Aspect-Oriented Programming，AOP）技术的应用。AOP是软件开发中的一个重要概念，它可以将系统中...
Spring AOP 嵌套AOP
八角塘塘主的博客
12-04 1147
在写代码的时候碰到这样一个问题，就是在一个被Aop拦截的方法中，又调用了一个Aop拦截的方法，但是在调用的过程中，发现和实际想要走的流程不一致，调用方法如下： Warehouse newWh = this.getWhByCodeAndType(warehouse.getCode(),warehouse.getType());百度一下： 实际上注入到spring容器的类实例是代理类，自然我们调用类
Spring AOP嵌套调用
圈儿的专栏
12-10 2592
在做日志的时候，我通常是用aop的方式，以降低耦合性，保证业务代码的干净。 之前一直使用的挺好。今天开发反映在嵌套调用的时候日志没有起作用。 场景如下： A调用B.a方法，B.a上的拦截是有用的。B.a里调用了B.b，在B.b上也同样有拦截注解，但是没有起作用。 其实这个没起作用是很正常的，因为Spring aop是基于bean的，而B.a里调用B.b，其中这个B已经不是spring中的代
spring嵌套使用aop
最新发布
newbrid007的博客
10-10 146
使用AopContext.currentProxy() 包装一下。
SpringAOP嵌套调用的解决办法
热门推荐
hupoling的专栏
01-19 9万+
Spring AOP在同一个类里自身方法相互调用时无法拦截。比如下面的代码:  Java代码   public class SomeServiceImpl implements SomeService   {          public void someMethod()       {           someInnerMethod();       
SpringAop、嵌套调用失效、解决办法
jumper的博客
06-05 402
一、加入注解 @EnableAspectJAutoProxy(proxyTargetClass = true, exposeProxy = true) 二、获取当前代理的接口 public interface ICurrentAopProxyService<T> { T getCurrentProxyService(); } 三、需要嵌套调用的Service实现它 @Override public SysMerchantVersionService getCurre
spring aop 方法嵌套调用 问题解决
ytsydmx的博客
08-13 813
1 问题出现 //t1 调用t3 方法 public void t1(String name){ System.out.println("t1你好！"+name); // 调用方法t3 t3(name); } public void t3(String name){ System.out.println("t3你好！"+name); } 拦截器 // 拦截t1 @Before("e2()") public void a5(Joi
Spring AOP动态代理失效的解决方法@Transactional为何会失效
asoklove的专栏
06-04 1148
环境：springboot2.3.10 演示类 JavaBean public class User { private Integer id ; private String name ; public User(Integer id, String name) { this.id = id; this.name = name; } } DAO接口 public interface UserDAO { User save(User user) ;
spring之aop方法内部调用问题
nieyanshun_me的专栏
07-09 8613
现象描述：假设有一个service，其中有A B 两个方法，A B都被aop托管，且A中调用了B方法，这时请求方法A的时候只会触发A的aop逻辑而不会触发B的aop逻辑。public interface UserService { void test(); } public class UserServiceImpl implements UserService { @Overri
spring aop失效原因
09-01
2. 目标方法没有被代理：Spring AOP 使用动态代理来实现切面，在运行时生成代理对象，并将切面应用于代理对象上的目标方法。如果目标方法没有被代理，切面将无法生效。 3. 目标方法被直接调用而不是通过代理调用：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值