获取目标方法的信息

    访问目标方法最简单的做法是定义增强处理方法时，将第一个参数定义为JoinPoint类型，当该增强处理方法被调用时，该JoinPoint参数就代表了织入增强处理的连接点。JoinPoint里包含了如下几个常用的方法：

• Object[] getArgs：返回目标方法的参数

• Signature getSignature：返回目标方法的签名

• Object getTarget：返回被织入增强处理的目标对象

• Object getThis：返回AOP框架为目标对象生成的代理对象

    注意：当使用@Around处理时，我们需要将第一个参数定义为ProceedingJoinPoint类型，该类是JoinPoint的子类。

    下面的切面类（依然放在com.abc.advice包中）中定义了Before、Around、AfterReturning和After 4中增强处理，并分别在4种增强处理中访问被织入增强处理的目标方法、目标方法的参数和被织入增强处理的目标对象等：

package com.abc.advice;import java.util.Arrays;import org.aspectj.lang.JoinPoint;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.After;import org.aspectj.lang.annotation.AfterReturning;import org.aspectj.lang.annotation.Around;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;@Aspectpublic class AdviceTest {    @Around("execution(* com.abc.service.*.many*(..))")    public Object process(ProceedingJoinPoint point) throws Throwable {        System.out.println("@Around：执行目标方法之前...");        //访问目标方法的参数：        Object[] args = point.getArgs();        if (args != null && args.length > 0 && args[0].getClass() == String.class) {            args[0] = "改变后的参数1";        }        //用改变后的参数执行目标方法        Object returnValue = point.proceed(args);        System.out.println("@Around：执行目标方法之后...");        System.out.println("@Around：被织入的目标对象为：" + point.getTarget());        return "原返回值：" + returnValue + "，这是返回结果的后缀";    }        @Before("execution(* com.abc.service.*.many*(..))")    public void permissionCheck(JoinPoint point) {        System.out.println("@Before：模拟权限检查...");        System.out.println("@Before：目标方法为：" +                 point.getSignature().getDeclaringTypeName() +                 "." + point.getSignature().getName());        System.out.println("@Before：参数为：" + Arrays.toString(point.getArgs()));        System.out.println("@Before：被织入的目标对象为：" + point.getTarget());    }        @AfterReturning(pointcut="execution(* com.abc.service.*.many*(..))",         returning="returnValue")    public void log(JoinPoint point, Object returnValue) {        System.out.println("@AfterReturning：模拟日志记录功能...");        System.out.println("@AfterReturning：目标方法为：" +                 point.getSignature().getDeclaringTypeName() +                 "." + point.getSignature().getName());        System.out.println("@AfterReturning：参数为：" +                 Arrays.toString(point.getArgs()));        System.out.println("@AfterReturning：返回值为：" + returnValue);        System.out.println("@AfterReturning：被织入的目标对象为：" + point.getTarget());            }        @After("execution(* com.abc.service.*.many*(..))")    public void releaseResource(JoinPoint point) {        System.out.println("@After：模拟释放资源...");        System.out.println("@After：目标方法为：" +                 point.getSignature().getDeclaringTypeName() +                 "." + point.getSignature().getName());        System.out.println("@After：参数为：" + Arrays.toString(point.getArgs()));        System.out.println("@After：被织入的目标对象为：" + point.getTarget());    }}

    在AdviceManager类中增加以下内容：

//将被AdviceTest的各种方法匹配public String manyAdvices(String param1, String param2) {    System.out.println("方法：manyAdvices");    return param1 + " 、" + param2;}

    在com.abc.main.AOPTest中加入方法的调用，触发切点：

String result = manager.manyAdvices("aa", "bb");System.out.println("Test方法中调用切点方法的返回值：" + result);

    下面是执行结果：

@Around：执行目标方法之前...@Before：模拟权限检查...@Before：目标方法为：com.abc.service.AdviceManager.manyAdvices@Before：参数为：[改变后的参数1, bb]@Before：被织入的目标对象为：com.abc.service.AdviceManager@1dfc617e方法：manyAdvices@Around：执行目标方法之后...@Around：被织入的目标对象为：com.abc.service.AdviceManager@1dfc617e@After：模拟释放资源...@After：目标方法为：com.abc.service.AdviceManager.manyAdvices@After：参数为：[改变后的参数1, bb]@After：被织入的目标对象为：com.abc.service.AdviceManager@1dfc617e@AfterReturning：模拟日志记录功能...@AfterReturning：目标方法为：com.abc.service.AdviceManager.manyAdvices@AfterReturning：参数为：[改变后的参数1, bb]@AfterReturning：返回值为：原返回值：改变后的参数1 、 bb，这是返回结果的后缀@AfterReturning：被织入的目标对象为：com.abc.service.AdviceManager@1dfc617eTest方法中调用切点方法的返回值：原返回值：改变后的参数1 、bb，这是返回结果的后缀

    从结果中可以看出：在任何一个织入的增强处理中，都可以获取目标方法的信息。另外，Spring AOP采用和AspectJ一样的有限顺序来织入增强处理：在“进入”连接点时，最高优先级的增强处理将先被织入（所以给定的两个Before增强处理中，优先级高的那个会先执行）；在“退出”连接点时，最高优先级的增强处理会最后被织入（所以给定的两个After增强处理中，优先级高的那个会后执行）。当不同的切面中的多个增强处理需要在同一个连接点被织入时，Spring AOP将以随机的顺序来织入这些增强处理。如果应用需要指定不同切面类里的增强处理的优先级，Spring提供了如下两种解决方案：

• 让切面类实现org.springframework.core.Ordered接口：实现该接口只需要实现一个int getOrder()方法，该方法返回值越小，优先级越高

• 直接使用@Order注解来修饰一个切面类：使用这个注解时可以配置一个int类型的value属性，该属性值越小，优先级越高

    优先级高的切面类里的增强处理的优先级总是比优先级低的切面类中的增强处理的优先级高。例如：优先级为1的切面类Bean1包含了@Before，优先级为2的切面类Bean2包含了@Around，虽然@Around优先级高于@Before，但由于Bean1的优先级高于Bean2的优先级，因此Bean1中的@Before先被织入。

    同一个切面类里的两个相同类型的增强处理在同一个连接点被织入时，Spring AOP将以随机的顺序来织入这两个增强处理，没有办法指定它们的织入顺序。如果确实需要保证它们以固有的顺序被织入，则可以考虑将多个增强处理压缩为一个增强处理；或者将不同增强处理重构到不同切面中，通过在切面级别上定义顺序。

    如果只要访问目标方法的参数，Spring还提供了一种更加简洁的方法：我们可以在程序中使用args来绑定目标方法的参数。如果在一个args表达式中指定了一个或多个参数，该切入点将只匹配具有对应形参的方法，且目标方法的参数值将被传入增强处理方法。下面辅以例子说明：

package com.abc.advice;import java.util.Date;import org.aspectj.lang.annotation.AfterReturning;import org.aspectj.lang.annotation.Aspect;@Aspectpublic class AccessArgAdviceTest {    @AfterReturning(            pointcut="execution(* com.abc.service.*.access*(..)) && args(time, name)",            returning="returnValue")    public void access(Date time, Object returnValue, String name) {        System.out.println("目标方法中的参数String = " + name);        System.out.println("目标方法中的参数Date = " + time);        System.out.println("目标方法的返回结果returnValue = " + returnValue);    }}

    上面的程序中，定义pointcut时，表达式中增加了args(time, name)部分，意味着可以在增强处理方法（access方法）中定义time和name两个属性——这两个形参的类型可以随意指定，但一旦指定了这两个参数的类型，则这两个形参类型将用于限制该切入点只匹配第一个参数类型为Date，第二个参数类型为name的方法（方法参数个数和类型若有不同均不匹配）。

    注意，在定义returning的时候，这个值（即上面的returning="returnValue"中的returnValue）作为增强处理方法的形参时，位置可以随意，即：如果上面access方法的签名可以为

public void access(Date time, Object returnValue, String name)

    也可以为

public void access(Object returnValue, Date time, String name)

    还可以为

public void access(Date time, String name, Object returnValue)

    只需要满足另外的参数名的顺序和pointcut中args(param1, param2)的顺序相同即可。我们在AdviceManager中定义一个方法，该方法的第一个参数为Date类型，第二个参数为String类型，该方法的执行将触发上面的access方法，如下：

//将被AccessArgAdviceTest的access方法匹配public String accessAdvice(Date d, String n) {    System.out.println("方法：accessAdvice");    return "aa";}

    在AOPTest中增加调用这个accessAdvice方法并执行，下面是输出结果：

    从执行结果可以看出，使用args表达式有如下两个作用：

• 提供了一种简单的方式来访问目标方法的参数

• 可用于对切入点表达式作额外的限制

    除此之外，使用args表达式时，还可以使用如下形式：args(param1, param2, ..)，注意args参数中后面的两个点，它表示可以匹配更多参数。在例子args(param1, param2, ..)中，表示目标方法只需匹配前面param1和param2的类型即可。

    《Spring中的AOP系列三、四、五》的代码在这里：点击下载，欢迎留言提意见。

[java] view plain copy

 

 

1. package com.jay.demo3.aop1.myannotation;  
2.   
3. import java.lang.annotation.Documented;  
4. import java.lang.annotation.ElementType;  
5. import java.lang.annotation.Retention;  
6. import java.lang.annotation.RetentionPolicy;  
7. import java.lang.annotation.Target;  
8.   
9. //业务注释类  -- 定义 ： 运行期间基于方法的注解    参考http://my.oschina.net/yangzg/blog/343945  
10. /* 
11.  * 常用注解说明：  
12.  * 1. RetentionPolicy(保留策略)是一个enum类型，有三个值  
13.  * SOURCE        --  这个Annotation类型的信息只会保留在程序源码里，源码如果经过了编译后，Annotation的数据就会消失，并不会保留在编译好的.class文件里 
14.  * CLASS         --  这个Annotation类型的信息保留在程序源码中，同时也会保留在编译好的.class文件里面,在执行的时候，并不会把这一些信息加载到虚拟 机(JVM)中去.注意一下，当你没有设定一个Annotation类型的Retention值时，系统默认值是CLASS。 
15.  * RUNTIME       --  在源码、编译好的.class文件中保留信息，在执行的时候会把这一些信息加载到JVM中去的。 
16.  *  
17.  * 2.ElementType @Target中的ElementType用来指定Annotation类型可以用在哪些元素上 
18.  * TYPE(类型)    -- 在Class，Interface，Enum和Annotation类型上 
19.  * FIELD        -- 属性上 
20.  * METHOD       -- 方法上 
21.  * PARAMETER    -- 参数上 
22.  * CONSTRUCTOR  -- 构造函数上 
23.  * LOCAL_VARIABLE -- 局部变量 
24.  * ANNOTATION_TYPE   -- Annotation类型上 
25.  * PACKAGE           -- 包上 
26.  *  
27.  * 3.Documented    -- 让这个Annotation类型的信息能够显示在API说明文档上；没有添加的话，使用javadoc生成的API文件找不到这个类型生成的信息 
28.  */  
29. @Retention(RetentionPolicy.RUNTIME)  
30. @Target({ElementType.METHOD})  
31. @Documented  
32. public @interface BussAnnotation {  
33.     //模块名  
34.     String moduleName() default "";  
35.     //操作内容  
36.     String option() default "";  
37. }  

[java] view plain copy

 

 

1. public interface UserManagerApplogic {  
2.     public void addUser(String name);  
3.     public void addOne(int type,int parentid);  
4. }  

[java] view plain copy

 

 

1. package com.jay.demo3.aop1.impl;  
2.   
3. import org.springframework.stereotype.Component;  
4.   
5. import com.jay.demo3.aop1.UserManagerApplogic;  
6. import com.jay.demo3.aop1.myannotation.BussAnnotation;  
7. //用户管理业务逻辑实现类     
8. @Component("userManager")  
9. public class UserManagerApplogicImpl implements UserManagerApplogic {  
10.   
11.     @BussAnnotation(moduleName="人员管理",option="添加用户")  
12.     @Override  
13.     public void addUser(String name) {  
14.         System.out.println("add a User name is "+name);  
15.     }  
16.   
17.     @BussAnnotation(moduleName="人员管理",option="添加新人")  
18.     @Override  
19.     public void addOne(int type, int parentid) {  
20.         System.out.println("add a new one type : "+type+" \t perentid : "+parentid);  
21.     }  
22.   
23. }  

[java] view plain copy

 

 

1. package com.jay.demo3.aop1.interceptor;  
2.   
3.   
4. import java.lang.reflect.Method;  
5.   
6.   
7. import org.aspectj.lang.ProceedingJoinPoint;  
8. import org.aspectj.lang.annotation.Around;  
9. import org.aspectj.lang.annotation.Aspect;  
10. import org.aspectj.lang.annotation.Pointcut;  
11. import org.springframework.stereotype.Component;  
12.   
13.   
14. import com.jay.demo3.aop1.myannotation.BussAnnotation;  
15.   
16.   
17. //切面类  http://my.oschina.net/yangzg/blog/343945  
18. /* 
19.  * 特别注意： Spring的配置文件中添加：   
20.  *  
21.  * <aop:aspectj-autoproxy /> 
22.  * spring-mvc-dispatcher.xml中天机 
23.  * <!--通知spring使用cglib而不是jdk的来生成代理方法 AOP可以拦截到Controller-->   
24.  * <aop:aspectj-autoproxy proxy-target-class="true"/> 
25.  * 
26.  * <aop:config>节点中proxy-target-class="true"不为true时。 
27.  * 当登录的时候会报这个异常java.lang.NoSuchMethodException: $Proxy54.login()， 
28.  */  
29.   
30.   
31. @Aspect  
32. @Component  
33. public class LogInterceptor {  
34.   
35.   
36.     // 定义切入点  @Pointcut("execution(public * com.jay..*.*(..))")  -- 表示对com.jay 包下的所有方法都可添加切入点  
37.     @Pointcut("execution(public * com.jay..*.addUser(..))")  
38.     public void aApplogic() {  
39.     }  
40.       
41.     //定义切入点  -- 拦截指定的方法  这里拦截 com.jay.demo3.aop1.impl.UserManagerApplogicImpl 的addOne()方法  
42.     @Pointcut("execution(public * com.jay..*.addOne(..))")  
43.     public void joinPointForAddOne(){  
44.           
45.     }  
46.       
47.     /** 
48.      * 环绕通知 用于拦截指定内容，记录用户的操作 
49.      */  
50.     @Around(value = "aApplogic() && @annotation(annotation) &&args(object,..) ", argNames = "annotation,object")  
51.     public Object interceptorApplogic(ProceedingJoinPoint pj,  
52.             BussAnnotation annotation, Object object) throws Throwable {  
53.         System.out.println("moduleName:" + annotation.moduleName());  
54.         System.out.println("option:" + annotation.option());  
55.         pj.proceed();  
56.         System.out.println(pj.getSignature().getName());  
57.         for(Object obj : pj.getArgs()){  
58.             System.out.println(obj.toString());  
59.         }  
60.         return object;  
61.     }  
62.       
63.     /** 
64.      * 环绕通知   拦截指定的切点，这里拦截joinPointForAddOne切入点所指定的addOne()方法 
65.      *  
66.      */  
67.     @Around("joinPointForAddOne()")  
68.     public Object interceptorAddOne(ProceedingJoinPoint joinPoint) throws Throwable {  
69.         System.out.println("Aop start");  
70.         String methodRemark = getMthodRemark(joinPoint);  
71.         Object result = null;  
72.         try {    
73.             // 记录操作日志...谁..在什么时间..做了什么事情..    
74.             result = joinPoint.proceed();    
75.         } catch (Exception e) {    
76.             // 异常处理记录日志..log.error(e);    
77.             throw e;    
78.         }    
79.         System.out.println(methodRemark);  
80.         System.out.println("Aop end");  
81.         return result;  
82.     }  
83.   
84.   
85.      // 获取方法的中文备注____用于记录用户的操作日志描述    
86.     public static String getMthodRemark(ProceedingJoinPoint joinPoint)    
87.             throws Exception {    
88.         String targetName = joinPoint.getTarget().getClass().getName();    
89.         String methodName = joinPoint.getSignature().getName();    
90.         System. out.println("====调用" +methodName+"方法-开始！");  
91.         Object[] arguments = joinPoint.getArgs();   //获得参数列表  
92.         System.out.println("打印出方法调用时传入的参数，可以在这里通过添加参数的类型，进行一些简易逻辑处理和判断");  
93.         if(arguments.length<=0){  
94.             System.out.println("=== "+methodName+" 方法没有参数");  
95.         }else{  
96.         for(int i=0;i<arguments.length;i++){  
97.             System.out.println("==== 参数   "+(i+1)+" : "+arguments[i]);  
98.         }  
99.         }  
100.     
101.         Class targetClass = Class.forName(targetName);    
102.         Method[] method = targetClass.getMethods();    
103.         String methode = "";    
104.         for (Method m : method) {    
105.             if (m.getName().equals(methodName)) {    
106.                 Class[] tmpCs = m.getParameterTypes();    
107.                 if (tmpCs.length == arguments.length) {    
108.                     BussAnnotation methodCache = m.getAnnotation(BussAnnotation.class);    
109.                     methode = methodCache.moduleName();    
110.                     break;    
111.                 }    
112.             }    
113.         }    
114.         return methode;    
115.     }    
116. }  

[java] view plain copy

 

 

1. package com.jay.demo3.aop1.test;  
2.   
3. import org.junit.Test;  
4. import org.junit.runner.RunWith;  
5. import org.springframework.beans.factory.annotation.Autowired;  
6. import org.springframework.test.context.ContextConfiguration;  
7. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
8.   
9. import com.jay.demo3.aop1.UserManagerApplogic;  
10.   
11. @RunWith(SpringJUnit4ClassRunner.class)  
12. @ContextConfiguration(locations = "classpath:*.xml")  
13. public class AopTest1 {  
14.     @Autowired  
15.     private UserManagerApplogic userManager;  
16.       
17.     @Test  
18.     public void testAopAddUser(){  
19.         userManager.addUser("You you ");  
20.     }  
21.   
22.     @Test  
23.     public void testAopAddOne(){  
24.         userManager.addOne(1, 1);  
25.     }  
26.       
27. }  

[html] view plain copy

 

 

1. <context:annotation-config/>    
2. <aop:aspectj-autoproxy />  
3. <context:component-scan base-package="com.jay" />