Spring(三)-AOP

1、名词理解

• 切面(Aspect)：
  
  
  
  • 含有前置通知，后置通知，返回通知，异常抛出通知，环绕通知等方法的类；
    
  
  
• 通知(Advice)：
  
  
  
  • 对原方法进行添加处理(如日志等)的方法；
    
  
  
• 切入点(PointCute)：
  
  
  
  • 通知需要在哪些方法上执行的表达式；(可以唯一匹配或模糊匹配)；
    
  
  
• 连接点(JoinPoint)：
  
  
  
  • 与切入点匹配的具体执行的方法；
    
  
  
• 目标(Target)：
  
  
  
  • 原业务类(主要 是核心代码)；
    
  
  
• 代理(Proxy)：
  
  
  
  • 生成的代理类(包含原业务类的 核心代码 和 通知里面的代码);
    
  
  

2、前置通知

2.1 jar

1. <properties>
2.         <spring.version>4.3.18.RELEASE</spring.version>
3. </properties>
5. <dependencies>
6.    
7.     <dependency>
8.         <groupId>org.springframework</groupId>
9.         <artifactId>spring-beans</artifactId>
10.         <version>${spring.version}</version>
11.     </dependency>
12.    
14.    
15.     <dependency>
16.         <groupId>org.springframework</groupId>
17.         <artifactId>spring-core</artifactId>
18.         <version>${spring.version}</version>
19.     </dependency>
20.    
22.    
23.     <dependency>
24.         <groupId>org.springframework</groupId>
25.         <artifactId>spring-context</artifactId>
26.         <version>${spring.version}</version>
27.     </dependency>
28.    
30.    
31.     <dependency>
32.         <groupId>org.springframework</groupId>
33.         <artifactId>spring-expression</artifactId>
34.         <version>${spring.version}</version>
35.     </dependency>
36.    
38.    
39.    
40.     <dependency>
41.         <groupId>org.springframework</groupId>
42.         <artifactId>spring-aspects</artifactId>
43.         <version>${spring.version}</version>
44.     </dependency>
45.    
47. </dependencies>

复制代码

2.2 切入点

通知需要在哪些方法上执行的表达式；(可以唯一匹配或模糊匹配)；
2.2.1 唯一匹配

1. execution(public int com.kgc.spring.aspectj.ArithmeticCalculator.add(int ,int ))

复制代码

execution(修饰符  返回值类型   方法全类名)
2.2.2 模糊匹配

1. execution(* com.kgc.spring.aspectj.*.*(..)

复制代码

通用切入点表达式含义：

• 第一个*：代表任意的修饰符，任意的返回值类型;
  
• 第二个*：代表任意的类;
  
• 第三个*：代表任意的方法;
  
• . .           ：代表任意的类型和个数的形参;
  

2.2.3 可重用切入点表达式

其他地方直接应用此方法即可；

1. //重用切入点表达式
2. @Pointcut( "execution(* com.kgc.spring.aspectj.*.*(..))")
3. public void joinPointcut(){}
5. //同一个类中引用
6. @Before("joinPointcut()")
7. @After("joinPointcut()")
9. //其他类中引用(方法全类名)
10. @Before("com.kgc.spring.aspectj.LogAspect.joinPointcut()")

复制代码

2.3  JoinPoint 和 ProceedingJoinPoint

2.3.1 JoinPoint 对象

JoinPoint对象封装了SpringAop中切面方法的信息,在切面方法中添加JoinPoint参数,就可以获取到封装了该方法信息的JoinPoint对象。
常用api:
方法名功能Signature getSignature();获取封装了署名信息的对象,在该对象中可以获取到目标方法名,所属类的Class等信息Object[] getArgs();获取传入目标方法的参数对象Object getTarget();获取被代理的对象Object getThis();获取代理对象2.3.2 ProceedingJoinPoint对象

ProceedingJoinPoint对象是JoinPoint的子接口,该对象只用在@Around的切面方法中 添加了 两个方法.
方法名功能Object proceed() throws Throwable执行目标方法Object proceed(Object[] var1) throws Throwable传入的新的参数去执行目标方法2.4  @Before

2.4.1 接口

ArithmeticCalculator

1. public interface ArithmeticCalculator {
3.     //加
4.     int add(int m,int n);
6.     //减
7.     int sub(int m,int n);
9.     //乘
10.     int nul(int m,int n);
12.     //除
13.     int div(int m,int n);
15. }

复制代码

2.4.2 实现类

ArithmeticCalculatorImpl

1. @Service("arithmeticCalculator")  
2. //起别名，方便单元测试，根据别名，从容器中获取
3. public class ArithmeticCalculatorImpl implements ArithmeticCalculator {
4.     @Override
5.     public int add(int m, int n) {
6.         return m + n;
7.     }
9.     @Override
10.     public int sub(int m, int n) {
11.         return m - n;
12.     }
14.     @Override
15.     public int nul(int m, int n) {
16.         return m*n;
17.     }
19.     @Override
20.     public int div(int m, int n) {
21.         System.out.println("====== 执行 div 方法 ======");
22.         return m/n;
23.     }
25. }

复制代码

2.4.3 @Before 前置通知

在目标方法执行前，自动执行此方法(通过代理实现);

1. @Component //声明为一个普通的组件，放入spring的容器中，才可以生效
2. @Aspect  //声明当前类是 一个切面
3. public class LogAspect {
5.     //重用切入点表达式
6.     @Pointcut( "execution(* com.kgc.spring.aspectj.*.*(..))")
7.     public void joinPointcut(){}
9.     //前置通知 @Before
10.     @Before("joinPointcut()")
11.     public void  logBeforeMethod(JoinPoint joinPoint){
13.         //获取通知作用的目标方法名
14.         String methodName = joinPoint.getSignature().getName();
16.         //获取通知作用的目标方法入参，返回的是参数值数组
17.         Object[] methodParams = joinPoint.getArgs();
19.         System.out.println("------ LogAspect "+methodName+" 方法，入参："+ Arrays.toString(methodParams) +" ------");
20.         }
21.    
22. }

复制代码

2.5 配置文件

spring-aop.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.        xmlns:context="http://www.springframework.org/schema/context"
5.        xmlns:aop="http://www.springframework.org/schema/aop"
6.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
8.        
9.         <context:component-scan base-package="com.kgc.spring.aspectj"></context:component-scan>
11.    
12.    
13.         <aop:aspectj-autoproxy ></aop:aspectj-autoproxy>
14.    
16. </beans>

复制代码

2.6测试

1. public  void  testSpringAopAspectj(){
2.     //从容器中获取计算器的实例对象
3.     ArithmeticCalculator arithmeticCalculator = context.getBean("arithmeticCalculator", ArithmeticCalculator.class);
5.     System.out.println(arithmeticCalculator.getClass());
7.     //调用切面作用的目标方法，执行操作,
8.     int result = arithmeticCalculator.div(20, 10);
10.     System.out.println("****** 通过单元测试，计算结果："+result +" ******");
12. }

复制代码

测试结果

1. class com.sun.proxy.$Proxy15
2.    
3. ------ LogAspect div 方法，入参：[20, 10] ------
4.    
5. ====== 执行 div 方法 ======
6.    
7. ****** 通过单元测试，计算结果：2 ******   

复制代码

3、后置通知

3.1 @After

目标方法发执行之后，自动执行；
特点：

• 后置通知无法获取目标方法的返回值;
  
• 它的执行跟目标方法是否抛出异常无关，不影响此方法的执行;
  

1. @After("joinPointcut()")
2. public void  logAfterMethod(JoinPoint joinPoint){
3.     //获取通知作用的目标方法名
4.     String methodName = joinPoint.getSignature().getName();
6.     //获取通知作用的目标方法入参，返回的是参数值数组
7.     Object[] methodParams = joinPoint.getArgs();
9.     System.out.println("------ LogAspect "+methodName+" 方法执行结束 ------");
10. }

复制代码

3.2  测试

3.2.1 无异常

1. @Test
2. public  void  testSpringAopAspectj(){
3.     //从容器中获取计算器的实例对象
4.     ArithmeticCalculator arithmeticCalculator = context.getBean("arithmeticCalculator", ArithmeticCalculator.class);
6.     //调用切面作用的目标方法，执行操作,
7.     int result = arithmeticCalculator.div(20, 10);
9.     System.out.println("****** 通过单元测试，计算结果："+result +" ******");
11. }

复制代码

测试结果

1. ====== 执行 div 方法 ======
2.    
3. ------ LogAspect div 方法执行结束 ------
4.    
5. ****** 通过单元测试，计算结果：2 ******

复制代码

3.2.2 有异常

1. @Test
2. public  void  testSpringAopAspectj(){
3.     //从容器中获取计算器的实例对象
4.     ArithmeticCalculator arithmeticCalculator = context.getBean("arithmeticCalculator", ArithmeticCalculator.class);
6.     //调用切面作用的目标方法，执行操作,
7.     int result = arithmeticCalculator.div(20, 0);
9.     System.out.println("****** 通过单元测试，计算结果："+result +" ******");
11. }

复制代码

测试结果

1. ====== 执行 div 方法 ======
2.    
3. ------ LogAspect div 方法执行结束 ------ //有异常也会执行后置通知
5. java.lang.ArithmeticException: / by zero

复制代码

4、返回通知

4.1 @AfterReturning

• 目标方法返回结果后自动执行，可以获取目标方法的返回值;
  
• 但是要求@AfterReturning必须增加属性returning，指定一个参数名;
  
• 且此参数名必须跟通知方法的一个形参名一致，用于接收返回值;
  

1. @AfterReturning(value = "joinPointcut()",returning = "result")
2. public void  afterReturningMethod(JoinPoint joinPoint,Object result){
4.     //获取通知作用的目标方法名
5.     String methodName = joinPoint.getSignature().getName();
7.     System.out.println("------ LogAspect "+methodName+" 方法，执行结果："+ result +" ------");
9. }

复制代码

4.2 测试

测试结果

1. ====== 执行 div 方法 ======
2.    
3. ------ LogAspect div 方法，返回结果：2 ------
4.    
5. ****** 通过单元测试，计算结果：2 ******

复制代码

5、异常抛出通知

5.1 @AfterThrowing

• 异常抛出通知 @AfterThrowing ，在目标方法抛出异常后，可以获取目标方法发生异常后抛出的异常信息;
  
• 但是要求 @AfterThrowing 必须增加属性 throwing，指定一个参数名;
  
• 且此参数名必须跟通知方法的一个形参名一致，用于接收异常;
  

1. @AfterThrowing(value = "joinPointcut()",throwing = "ex")
2. public void logAfterThrowingMethod(JoinPoint joinPoint,Exception ex){
4.     //获取通知作用的目标方法名
5.     String methodName = joinPoint.getSignature().getName();
7.     System.out.println("------ LogAspect "+methodName+" 方法，执行异常信息："+ ex.getMessage() +" ------");
9. }

复制代码

5.2 测试

1. @Test
2. public  void  testSpringAopAspectj(){
3.     //从容器中获取计算器的实例对象
4.     ArithmeticCalculator arithmeticCalculator = context.getBean("arithmeticCalculator", ArithmeticCalculator.class);
6.     System.out.println(arithmeticCalculator.getClass());
8.     //调用切面作用的目标方法，执行操作,
9.     int result = arithmeticCalculator.div(20, 0);
11.     System.out.println("****** 通过单元测试，计算结果："+result +" ******");
13. }

复制代码

测试结果

1. ====== 执行 div 方法 ======
3. ------ LogAspect div 方法，执行异常信息：/ by zero ------
5. java.lang.ArithmeticException: / by zero

复制代码

6、环绕通知

6.1 @Around

• 环绕通知 @Around,可以看作是上面四种通知的结合体，一般不建议跟单个的通知共用(防止冲突失效)；
  
• 作用：可以让开发人员在环绕通知的处理方法中根据不同也业务逻辑，决定是否发起对目标方法的调用;
  

1. @Around(value = "joinPointcut()")
2. public Object logAroundMethod(ProceedingJoinPoint joinPoint){
4.     //获取通知作用的目标方法名
5.     String methodName = joinPoint.getSignature().getName();
7.     //定义获取目标方法的返回值变量
8.     Object result = null;
10.     try{
11.         //实现前置通知功能
12.         System.out.println("------ LogAspect "+methodName+" 方法 Around通知，入参："+ Arrays.toString(joinPoint.getArgs()) +" ------");
14.         //手动调用原目标方法(业务中决定，是否对核心方法方法发起调用)
15.         result  = joinPoint.proceed();
16.     }catch (Throwable tx){
17.         //实现异常抛出通知功能
18.         System.out.println("------ LogAspect "+methodName+" 方法 Around通知，执行异常信息："+ tx.getMessage() +" ------");
20.     }finally {
21.         //实现后置通知功能
22.         System.out.println("------ LogAspect "+methodName+" 方法 Around通知，执行结束 ------");
23.     }
25.     //实现返回通知功能
26.     System.out.println("------ LogAspect "+methodName+" 方法 Around通知，执行结果："+ result +" ------");
28.     return result;
29. }

复制代码

6.2 测试

6.2.1 测试结果,无异常

1. //调用切面作用的目标方法，执行操作,
2. int result = arithmeticCalculator.div(20, 10);

复制代码

1. class com.sun.proxy.$Proxy13
2.    
3. ------ LogAspect div 方法 Around通知，入参：[20, 10] ------
4.    
5. ====== 执行 div 方法 ======
6.    
7. ------ LogAspect div 方法 Around通知，执行结束 ------
8.    
9. ------ LogAspect div 方法 Around通知，返回结果：2 ------
10.    
11. ****** 通过单元测试，计算结果：2 ******

复制代码

6.2.2 测试结果，有异常

1. //调用切面作用的目标方法，执行操作,
2. int result = arithmeticCalculator.div(20, 0);

复制代码

1. class com.sun.proxy.$Proxy13
2.    
3. ------ LogAspect div 方法 Around通知，入参：[20, 0] ------
4.    
5. ====== 执行 div 方法 ======
6.    
7. ------ LogAspect div 方法 Around通知，执行异常信息：/ by zero ------
8.    
9. ------ LogAspect div 方法 Around通知，执行结束 ------
10.    
11. ------ LogAspect div 方法 Around通知，返回结果：null ------

复制代码

6.2.3 测试结果 不调用 原方法

1. //调用切面作用的目标方法，执行操作,
2. int result = arithmeticCalculator.div(20, 0);//(业务中决定，是否对核心方法发起调用)//不调用核心方法//result  = joinPoint.proceed();

复制代码

1. ------ LogAspect div 方法 Around通知，入参：[20, 10] ------
2.    
3. ------ LogAspect div 方法 Around通知，执行结束 ------
4.    
5. ------ LogAspect div 方法 Around通知，返回结果：null ------

复制代码

7、切入点优先级

当有多个前置通知时，我们想自定义前置通知顺序：使用@Order(int)
指定切面优先级，一般都是int型整数，值越小，优先级越高**（默认值 2^31 - 1 最低优先级）;
7.1 多个前置通知

logBeforeMethod

1. @Before("joinPointcut()")
2. public void  logBeforeMethod(JoinPoint joinPoint){
4.     //获取通知作用的目标方法名
5.     String methodName = joinPoint.getSignature().getName();
7.     //获取通知作用的目标方法入参，返回的是参数值数组
8.     Object[] methodParams = joinPoint.getArgs();
10.     System.out.println("------ LogAspectBeforeMethod "+methodName+" 方法，入参："+ Arrays.toString(methodParams) +" ------");
12. }

复制代码

verifyBeforeMethod

1. @Component
2. @Aspect
3. public class VerifyParamAspect {
4.     @Before("com.kgc.spring.aspectj.LogAspect.joinPointcut()")
5.     public void  verifyBeforeMethod( JoinPoint joinPoint){
6.         //获取通知作用的目标方法名
7.         String methodName = joinPoint.getSignature().getName();
9.         //获取通知作用的目标方法入参，返回的是参数值数组
10.         Object[] methodParams = joinPoint.getArgs();
12.         System.out.println("------ verifyBeforeMethod "+methodName+" 方法，入参："+ Arrays.toString(methodParams) +" ------");
14.     }
16. }

复制代码

7.2 测试(默认)

1. @Test
2. public   void testVerifyParamAspect(){
4.     //从容器中获取计算器的实例对象
5.     ArithmeticCalculator arithmeticCalculator = context.getBean("arithmeticCalculator", ArithmeticCalculator.class);
7.     System.out.println(arithmeticCalculator.getClass());
9.     //调用切面作用的目标方法，执行操作,
10.     int result = arithmeticCalculator.div(20, 10);
12.     System.out.println("****** 通过单元测试，计算结果："+result +" ******");
14. }

复制代码

测试结果

1. ------ LogAspectBeforeMethod div 方法，入参：[20, 10] ------  //LogAspectBeforeMethod 先执行
2.    
3. ------ verifyBeforeMethod div 方法，入参：[20, 10] ------
4.    
5. ====== 执行 div 方法 ======
6.    
7. ****** 通过单元测试，计算结果：2 ******

复制代码

7.3 测试(自定义优先级)

1. @Component
2. @Aspect
3. @Order(1) //指定切面优先级，一般都是int型整数，值越小，优先级越高（默认值 2^31 - 1）
4. public class VerifyParamAspect {
5.     @Before("com.kgc.spring.aspectj.LogAspect.joinPointcut()")
6.     public void  verifyBeforeMethod( JoinPoint joinPoint){
7.         //获取通知作用的目标方法名
8.         String methodName = joinPoint.getSignature().getName();
10.         //获取通知作用的目标方法入参，返回的是参数值数组
11.         Object[] methodParams = joinPoint.getArgs();
13.         System.out.println("------ verifyBeforeMethod "+methodName+" 方法，入参："+ Arrays.toString(methodParams) +" ------");
15.     }
17. }

复制代码

测试结果

1. ------ verifyBeforeMethod div 方法，入参：[20, 10] ------ //优先级高的切面中的verifyBeforeMethod，先执行
2.    
3. ------ LogAspectBeforeMethod div 方法，入参：[20, 10] ------
4.    
5. ====== 执行 div 方法 ======
6.    
7. ****** 通过单元测试，计算结果：2 ******

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！