`
jinnianshilongnian
  • 浏览: 21499485 次
  • 性别: Icon_minigender_1
博客专栏
5c8dac6a-21dc-3466-8abb-057664ab39c7
跟我学spring3
浏览量:2417778
D659df3e-4ad7-3b12-8b9a-1e94abd75ac3
Spring杂谈
浏览量:3008091
43989fe4-8b6b-3109-aaec-379d27dd4090
跟开涛学SpringMVC...
浏览量:5638961
1df97887-a9e1-3328-b6da-091f51f886a1
Servlet3.1规范翻...
浏览量:259809
4f347843-a078-36c1-977f-797c7fc123fc
springmvc杂谈
浏览量:1597051
22722232-95c1-34f2-b8e1-d059493d3d98
hibernate杂谈
浏览量:250119
45b32b6f-7468-3077-be40-00a5853c9a48
跟我学Shiro
浏览量:5858161
Group-logo
跟我学Nginx+Lua开...
浏览量:701791
5041f67a-12b2-30ba-814d-b55f466529d5
亿级流量网站架构核心技术
浏览量:784902
社区版块
存档分类
最新评论

关于spring的aop拦截的问题 protected方法代理问题

 
阅读更多

之前一论坛朋友问的,复制保存下。原文地址。

 

问题

貌似不能拦截私有方法? 
试了很多次,都失败了,是不是不行啊? 

我想了一下,因为aop底层是代理, 
jdk是代理接口,私有方法必然不会存在在接口里,所以就不会被拦截到; 
cglib是子类,private的方法照样不会出现在子类里,也不能被拦截。 

我不是类内部直接调用方法,而是通过维护一个自身实例的代理 

execution(* test.aop.ServiceA.*(..)) 

Java代码  收藏代码
  1. public class ServiceA {  
  2.   
  3.     private ServiceA  self;  
  4.   
  5.     public void setSelf(ServiceA self) {  
  6.         this.self = self;  
  7.     }  
  8.   
  9.     public String methodA(String str) {  
  10.         System.out.println("methodA: args=" + str);  
  11.         self.methodB("b");  
  12.         return "12345" + str;  
  13.     }  
  14.   
  15.     private String methodB(String str) {  
  16.         System.out.println("methodB: args=" + str);  
  17.         self.methodC("c");  
  18.         return "12345" + str;  
  19.     }  
  20.   
  21.     public String methodC(String str) {  
  22.         System.out.println("methodC: args=" + str);  
  23.         return "12345" + str;  
  24.     }  
  25. }  



如果外部调用methodA,那么methodA和methodC会被拦截到,methodB不行 

是不是这么回事? 
但是stackoverflow上,有人说 it works fine 
http://stackoverflow.com/questions/4402009/aspectj-and-catching-private-or-inner-methods 

execution(public * test.aop.ServiceA.*(..)) 
还有个奇怪的现象,execution里如果不写权限,那么public protected package的方法都能被拦截到 
如果写了public,那就只拦截public方法这个没问题, 
如果写了protected,他就什么事情都不做,连protected的方法也不拦截。

 

分析

private方法 在Spring使用纯Spring AOP(只能拦截public/protected/包)都是无法被拦截的 因为子类无法覆盖;包级别能被拦截的原因是,如果子类和父类在同一个包中是能覆盖的。 

在cglib代理情况下, execution(* *(..)) 可以拦截 public/protected/包级别方法(即这些方法都是能代理的)。 

Java代码  收藏代码
  1. private static boolean isOverridable(Method method, Class targetClass) {  
  2.         if (Modifier.isPrivate(method.getModifiers())) {  
  3.             return false;  
  4.         }  
  5.         if (Modifier.isPublic(method.getModifiers()) || Modifier.isProtected(method.getModifiers())) {  
  6.             return true;  
  7.         }  
  8.         return getPackageName(method.getDeclaringClass()).equals(getPackageName(targetClass));  
  9.     }  




如果想要实现拦截private方法的 可以使用 原生 AspectJ 编译期/运行期织入。 


引用
如果写了protected,他就什么事情都不做,连protected的方法也不拦截;这个应该不会


原因基本分析明白了: 

是否能应用增强的判断代码如下(org.springframework.aop.support.AopUtils): 

Java代码  收藏代码
  1. public static boolean canApply(Pointcut pc, Class targetClass, boolean hasIntroductions) {  
  2.     if (!pc.getClassFilter().matches(targetClass)) {  
  3.         return false;  
  4.     }  
  5.   
  6.     MethodMatcher methodMatcher = pc.getMethodMatcher();  
  7.     IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;  
  8.     if (methodMatcher instanceof IntroductionAwareMethodMatcher) {  
  9.         introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;  
  10.     }  
  11.   
  12.     Set classes = new HashSet(ClassUtils.getAllInterfacesForClassAsSet(targetClass));  
  13.     classes.add(targetClass);  
  14.     for (Iterator it = classes.iterator(); it.hasNext();) {  
  15.         Class clazz = (Class) it.next();  
  16.         Method[] methods = clazz.getMethods();  
  17.         for (int j = 0; j < methods.length; j++) {  
  18.             if ((introductionAwareMethodMatcher != null &&  
  19.                     introductionAwareMethodMatcher.matches(methods[j], targetClass, hasIntroductions)) ||  
  20.                     methodMatcher.matches(methods[j], targetClass)) {  
  21.                 return true;  
  22.             }  
  23.         }  
  24.     }  
  25.   
  26.     return false;  
  27. }  



此处Method[] methods = clazz.getMethods();只能拿到public方法。。 

场景1:execution(* *(..)) 

Java代码  收藏代码
  1. public class Impl2  {  
  2.       
  3.     protected/public String testAop2() {  
  4.         System.out.println("234");  
  5.         return "1233";  
  6.     }  
  7. }  


因为切入点没有访问修饰符,即可以是任意,因此canApply方法能拿到如wait这种public方法,即可以实施代理。 

场景2:execution(public * *(..)) 

Java代码  收藏代码
  1. public class Impl2  {  
  2.       
  3.     public String testAop2() {  
  4.         System.out.println("234");  
  5.         return "1233";  
  6.     }  
  7. }  


因为拦截public的,因此canApply方法能拿到如wait这种public方法,即可以实施代理。 


场景3:execution(protected * *(..)) 

Java代码  收藏代码
  1. public class Impl2  {  
  2.       
  3.     protected String testAop2() {  
  4.         System.out.println("234");  
  5.         return "1233";  
  6.     }  
  7. }  


还记得之前说过,在canApply方法中 的 Method[] methods = clazz.getMethods();只能拿到public方法的,因此跟protected访问修饰符是无法匹配的,所以如果“execution(protected * *(..))” 是 无法代理的。 

这就是为什么execution(protected * *(..))在纯Spring AOP环境下不行的原因。 

注,@Transactional注解事务的特殊情况: 

引用
方法的可见度和 @Transactional 
在使用代理的时候,@Transactional 注解应该只被应用到 public 可见度的方法上。 如果你在 protected、private 或者 package-visible 的方法上使用 @Transactional 注解,系统也不会报错, 但是这个被注解的方法将不会执行已配置的事务设置。如果你非要注解非公共方法的话,请参考使用AspectJ 



关于spring切入点语法可以参考我的博客 【http://jinnianshilongnian.iteye.com/blog/1420691

 

 

wangyu1221 写道

 

非常感谢您的回帖~canApply方法是不是用于判断某个切点能否应用于某个类上,只要这个类里面有一个方法能够和切点匹配,就返回true,从整个逻辑来看,就是这个类可以/需要被代理。 

实际运行时在方法拦截的时候,如果某个类不需要被代理,就直接调用这个类实例的方法,而不是这个类的代理的方法, 
如果需要代理,再匹配方法名和修饰符? 

对于上面这个帖子里,之所以protected方法能被无访问修修饰符的execution拦截,是因为这个类里面其他public方法被execution匹配了,导致spring认为这个类可以被代理,而不是protected的方法本身被execution匹配?



引用

 

canApply方法是不是用于判断某个切点能否应用于某个类上,只要这个类里面有一个方法能够和切点匹配,就返回true,从整个逻辑来看,就是这个类可以/需要被代理。


是的。 

引用

 

实际运行时在方法拦截的时候,如果某个类不需要被代理,就直接调用这个类实例的方法,而不是这个类的代理的方法, 
如果需要代理,再匹配方法名和修饰符?



这个只看Cglib2AopProxy吧: 

Java代码  收藏代码
  1. public int accept(Method method) {  
  2.             if (AopUtils.isFinalizeMethod(method)) {  
  3.                 logger.debug("Found finalize() method - using NO_OVERRIDE");  
  4.                 return NO_OVERRIDE;  
  5.             }  
  6.             if (!this.advised.isOpaque() && method.getDeclaringClass().isInterface() &&  
  7.                     method.getDeclaringClass().isAssignableFrom(Advised.class)) {  
  8.                 if (logger.isDebugEnabled()) {  
  9.                     logger.debug("Method is declared on Advised interface: " + method);  
  10.                 }  
  11.                 return DISPATCH_ADVISED;  
  12.             }  
  13.             // We must always proxy equals, to direct calls to this.  
  14.             if (AopUtils.isEqualsMethod(method)) {  
  15.                 logger.debug("Found 'equals' method: " + method);  
  16.                 return INVOKE_EQUALS;  
  17.             }  
  18.             // We must always calculate hashCode based on the proxy.  
  19.             if (AopUtils.isHashCodeMethod(method)) {  
  20.                 logger.debug("Found 'hashCode' method: " + method);  
  21.                 return INVOKE_HASHCODE;  
  22.             }  
  23.             Class targetClass = this.advised.getTargetClass();  
  24.             // Proxy is not yet available, but that shouldn't matter.  
  25.             List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);  
  26.             boolean haveAdvice = !chain.isEmpty();  
  27.             boolean exposeProxy = this.advised.isExposeProxy();  
  28.             boolean isStatic = this.advised.getTargetSource().isStatic();  
  29.             boolean isFrozen = this.advised.isFrozen();  
  30.             if (haveAdvice || !isFrozen) {  
  31.                 // If exposing the proxy, then AOP_PROXY must be used.  
  32.                 if (exposeProxy) {  
  33.                     if (logger.isDebugEnabled()) {  
  34.                         logger.debug("Must expose proxy on advised method: " + method);  
  35.                     }  
  36.                     return AOP_PROXY;  
  37.                 }  
  38.                 String key = method.toString();  
  39.                 // Check to see if we have fixed interceptor to serve this method.  
  40.                 // Else use the AOP_PROXY.  
  41.                 if (isStatic && isFrozen && this.fixedInterceptorMap.containsKey(key)) {  
  42.                     if (logger.isDebugEnabled()) {  
  43.                         logger.debug("Method has advice and optimisations are enabled: " + method);  
  44.                     }  
  45.                     // We know that we are optimising so we can use the  
  46.                     // FixedStaticChainInterceptors.  
  47.                     int index = ((Integer) this.fixedInterceptorMap.get(key)).intValue();  
  48.                     return (index + this.fixedInterceptorOffset);  
  49.                 }  
  50.                 else {  
  51.                     if (logger.isDebugEnabled()) {  
  52.                         logger.debug("Unable to apply any optimisations to advised method: " + method);  
  53.                     }  
  54.                     return AOP_PROXY;  
  55.                 }  
  56.             }  
  57.             else {  
  58.                 // See if the return type of the method is outside the class hierarchy  
  59.                 // of the target type. If so we know it never needs to have return type  
  60.                 // massage and can use a dispatcher.  
  61.                 // If the proxy is being exposed, then must use the interceptor the  
  62.                 // correct one is already configured. If the target is not static cannot  
  63.                 // use a Dispatcher because the target can not then be released.  
  64.                 if (exposeProxy || !isStatic) {  
  65.                     return INVOKE_TARGET;  
  66.                 }  
  67.                 Class returnType = method.getReturnType();  
  68.                 if (targetClass == returnType) {  
  69.                     if (logger.isDebugEnabled()) {  
  70.                         logger.debug("Method " + method +  
  71.                                 "has return type same as target type (may return this) - using INVOKE_TARGET");  
  72.                     }  
  73.                     return INVOKE_TARGET;  
  74.                 }  
  75.                 else if (returnType.isPrimitive() || !returnType.isAssignableFrom(targetClass)) {  
  76.                     if (logger.isDebugEnabled()) {  
  77.                         logger.debug("Method " + method +  
  78.                                 " has return type that ensures this cannot be returned- using DISPATCH_TARGET");  
  79.                     }  
  80.                     return DISPATCH_TARGET;  
  81.                 }  
  82.                 else {  
  83.                     if (logger.isDebugEnabled()) {  
  84.                         logger.debug("Method " + method +  
  85.                                 "has return type that is assignable from the target type (may return this) - " +  
  86.                                 "using INVOKE_TARGET");  
  87.                     }  
  88.                     return INVOKE_TARGET;  
  89.                 }  
  90.             }  
  91.         }  


List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); 
即如果此方法有对应的advice就走代理。 

//getInterceptorsAndDynamicInterceptionAdvice代码如下所示: 

Java代码  收藏代码
  1. public List getInterceptorsAndDynamicInterceptionAdvice(Method method, Class targetClass) {  
  2.     MethodCacheKey cacheKey = new MethodCacheKey(method);  
  3.     List cached = (List) this.methodCache.get(cacheKey);  
  4.     if (cached == null) {  
  5.         cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(  
  6.                 this, method, targetClass); //转调DefaultAdvisorChainFactory  
  7.         this.methodCache.put(cacheKey, cached);  
  8.     }  
  9.     return cached;  
  10. }  



也就是说需要一次切入点的匹配,即如果方法有切入点就走代理方法 否则目标方法。 


再来看CglibMethodInvocation(cglib的 DynamicAdvisedInterceptor使用): 

引用

 

public Object proceed() throws Throwable { 
// We start with an index of -1 and increment early. 
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) { 
return invokeJoinpoint(); 


Object interceptorOrInterceptionAdvice = 
    this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex); 
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) { 
// Evaluate dynamic method matcher here: static part will already have 
// been evaluated and found to match. 
InterceptorAndDynamicMethodMatcher dm = 
    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice; 
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) { 
return dm.interceptor.invoke(this); 

else { 
// Dynamic matching failed. 
// Skip this interceptor and invoke the next in the chain. 
return proceed(); 


else { 
// It's an interceptor, so we just invoke it: The pointcut will have 
// been evaluated statically before this object was constructed. 
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this); 



                 /** 
* Gives a marginal performance improvement versus using reflection to 
* invoke the target when invoking public methods. 
*/ 
protected Object invokeJoinpoint() throws Throwable { 
if (this.protectedMethod) { 
return super.invokeJoinpoint(); 

else { 
return this.methodProxy.invoke(this.target, this.arguments); 




即如果有InterceptorAndDynamicMethodMatcher 这是动态切入点切入点匹配器: 

引用spring文档 

引用

 

7.2.4.2. 动态切入点 
动态切入点比起静态切入点在执行时要消耗更多的资源。它们同时计算方法参数和静态信息。 这意味着它们必须在每次方法调用时都被计算;由于参数的不同,结果不能被缓存。 
动态切入点的主要例子是控制流切入点。 


这个在spring aop中只有一种情况:PerTargetInstantiationModelPointcut 这个切入点;这个可以参考《【第六章】 AOP 之 6.8 切面实例化模型 ——跟我学spring3 》 pertarget。 

也就是说如果是 
静态切入点代理:如果有匹配的advice就走代理; 
动态切入点代理:需要在运行时进行匹配。 


综上所述: 
execution(* *(..)) 可以匹配public/protected的,因为public的有匹配的了,目标类就代理了,,,再进行切入点匹配时也是能匹配的,而且cglib方式能拿到包级别/protected方法,而且包级别/protected方法可以直接通过反射调用。 


引用

 


对于上面这个帖子里,之所以protected方法能被无访问修修饰符的execution拦截,是因为这个类里面其他public方法被execution匹配了,导致spring认为这个类可以被代理,而不是protected的方法本身被execution匹配?


这个是因为protected 修饰符的切入点 无法匹配 Method[] methods = clazz.getMethods(); 这里的任何一个,因此无法代理的。 

8
1
分享到:
评论
1 楼 anxihuixiang 2016-07-10  
讲的真好地地道道

相关推荐

    Java spring AOP源码

    Spring AOP对于最外层的函数只拦截`public`方法,不拦截`protected`和`private`方法。这意味着只有类公开的方法才会受到Spring AOP的影响。此外,Spring AOP不会对最外层的`public`方法内部调用的其他方法也进行拦截...

    spring 事务配置的五种方法

    **概念介绍:** 使用 AOP(面向切面编程)的思想,通过定义一个事务管理拦截器来拦截特定的方法调用,实现事务的自动管理。 **配置示例:** ```xml &lt;!-- 配置事务管理器 --&gt; class="org.springframework.orm....

    spring_如何管理事务的

    Spring通过AOP(面向切面编程)技术实现了声明式事务管理,可以通过XML配置或注解来实现。 ##### 1. XML配置示例 ```xml &lt;!-- 定义数据源 --&gt; &lt;!-- 配置数据源参数 --&gt; &lt;!-- 定义事务管理器 --&gt; ...

    spring-Acgei的一个小例子之一

    在Spring-Acegi中,`MethodSecurityInterceptor`是关键组件,它拦截并处理具有安全约束的方法调用。我们可以通过配置Acegi来定义哪些方法需要特定的角色或权限才能访问。以下是一个简单的例子,展示了如何使用Acegi...

    SpringBoot多数据源配置(方式三:基于AOP切面动态切换需要使用哪个数据源).docx

    - **动态代理**: 使用Spring AOP(面向切面编程)来拦截数据访问层(DAO层)的方法调用,根据一定的规则(如注解或上下文变量)选择合适的DataSource。 - **数据库路由**: 根据查询条件自动选择合适的数据源。 本篇...

    springboot集合mysql基于aop动态数据源切换

    在这个主题中,我们将深入探讨如何在Spring Boot项目中结合MySQL数据库,利用AOP(面向切面编程)实现动态数据源的切换。 首先,我们需要理解Spring Boot对数据源的支持。Spring Boot通过`@EnableJpaRepositories`...

    SpringBoot多数据源配置(方式二:在代码中动态切换需要使用哪个数据源).docx

    为了实现在代码中动态切换数据源,我们可以使用Spring AOP(面向切面编程)的方式,在需要动态切换数据源的方法上添加注解,通过AOP拦截器来实现数据源的动态切换。具体的实现步骤如下: - 创建一个`...

    揭秘Spring的魔力:Spring框架在Java开发中的核心作用

    - **面向切面编程(AOP)**:Spring的AOP支持提供了将横切关注点(如日志记录、事务管理等)与业务逻辑分离的方法,提高了代码的可读性和可维护性。 - **数据访问**:Spring简化了与数据库的交互,支持多种数据访问...

    08-Hystrix源码分析1

    它通过对方法的AOP拦截来实现熔断和降级。下面是Hystrix源码分析的主要知识点: 1. HystrixCommandAspect类 HystrixCommandAspect是Hystrix的核心类之一,负责拦截带有@HystrixCommand注解的方法。它实现了方法的...

    Spring系统多数据库动态切换,完整demo直接使用

    最后,对于Spring MVC,我们可能需要在拦截器或控制器中根据请求信息动态地切换数据源。例如,从请求头中读取数据库标识,并调用`switchDataSource`方法。 这个压缩包中的"sssp"可能是项目名称或文件夹,它可能包含...

    Spring Security学习总结

    Spring Security 通过一系列可以在 Spring 应用上下文中配置的 Bean 来实现这些功能,利用了 Spring 的 IoC 和 AOP 特性,极大地简化了安全控制相关的代码编写工作量。 **Spring Security 的核心组件:** 1. **...

    基于注解和Spring的多数据源配置和使用

    Spring框架广泛使用注解进行依赖注入、AOP(面向切面编程)以及其他功能的实现,使得代码更加简洁,更易于维护。 在Spring中,多数据源配置通常涉及以下几个关键步骤: 1. **数据源配置**:创建多个DataSource对象...

    Spring Security 3系列文章——入门篇(一)

    它通过AOP(面向切面编程)实现,可以方便地与Spring应用程序集成。 ### 2. 安装与配置 在Spring Security 3中,首先需要在项目的`pom.xml`或`build.gradle`文件中添加依赖。然后,配置Spring Security的核心组件`...

    SpringMVC学习(四)——Spring、MyBatis和SpringMVC的整合

    首先,Spring框架是一个全面的企业级应用开发框架,它提供了依赖注入(DI)和面向切面编程(AOP)等功能,使得代码更加灵活和可测试。在整合中,Spring作为核心容器,管理着所有组件的生命周期和依赖关系。 MyBatis...

    spring-security.介绍

    这个框架的主要目标是将安全逻辑从业务代码中分离出来,利用Spring的依赖注入(DI)和面向切面编程(AOP)特性,简化应用的安全管理。 Spring Security 提供了多种安全服务,包括认证和授权机制、Web资源访问控制、...

    Spring配置动态数据源实现读写分离的方法

    创建一个AOP切面,拦截需要切换数据源的方法,如`@Transactional(readOnly = true)`标记的为只读操作,自动切换到读数据源;没有这个标记的则默认使用写数据源。 ```java @Aspect @Component public class ...

    基于Spring框架的Shiro配置方法

    通过以上配置,基于Spring的Shiro框架就能有效地管理应用的访问控制,提供用户登录、权限检查等功能,同时利用Spring的IoC和AOP特性,使得集成更加方便和灵活。在实际项目中,可以根据需求调整过滤链定义、添加拦截...

    spring mvc 文档

    - 阅读官方文档,理解Spring的核心概念,如依赖注入(DI)、面向切面编程(AOP)等。 3. **工具准备**: - 准备好开发所需的数据库(如果项目中有数据库交互的需求)。 - 安装并配置Web服务器,如Tomcat。 ####...

    聊一聊过滤器与拦截器.doc

       Interceptor 基本介绍 拦截器 Interceptor 是 Spring MVC 提供的一种 AOP(面向切面编程)思想的实现,它允许我们在请求被 Controller 处理之前或之后执行自定义逻辑。与 Filter 不同,Interceptor 更专注于 ...

    阿里Java面试-69个必会问题.rar

    这些只是部分可能出现在面试中的Java知识点,实际的压缩文件可能还会包含更多关于网络编程、数据库操作、算法与数据结构等方面的问题。为了在面试中脱颖而出,应聘者需要对这些知识点有深入的理解,并能够结合实际...

Global site tag (gtag.js) - Google Analytics