关于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 编译期/运行期织入。 

原因基本分析明白了： 

是否能应用增强的判断代码如下（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注解事务的特殊情况： 

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

是的。 

这个只看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使用）： 

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

引用spring文档 

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

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


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

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