AOP & 拦截器

 

https://www.cnblogs.com/boywwj/p/7502185.html

 

spring aop中@after-returning和@after，@afterThrowing，@Around，@Before注解执行顺序
try{
try{
//@Around
//@Before
method.invoke(..);
//@Around
}catch(){
throw.....;
}finally{
//@After
}
//@AfterReturning
}catch(){
//@AfterThrowing
}

正常情况 @Around @Before 目标方法 @Around @After @AfterReturning;
异常情况 @Around @Before 目标方法 @After @AfterThrowing;

 


____________________________________________________________________________________________________________
 

 

　　一：AOP的背景

　　面试的时候面试官让我解释一下什么是AOP，当时不懂，在路上就查了，AOP：面向切面的编程技术，困惑了，JAVA是OOP：面向对象的编程技术。那么自己就立刻查了几个为题：1、什么是面向切面的编程技术；2、为什么要面向切面的编程技术；3、与OOP是什么关系？

首先解释第二个问题：在我们平时的开发过程中，你肯定会遇到下面几个面：1）权限校验；2）业务的核心代码；3）记录日志。那么在@Service层采用代码累加的方法，那么结构就会如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Service
public class myService{
 
@Resource
private CoreService coreService;
 
@Resource
private LogService logService;
@Resource
private PropertyService propertyService;
  
// 权限校验代码
 
//核心业务层代码
 
//记录日志的代码  <br><br>// 异常的处理<br>
}

从上面的代码结构中我们可以看出以下几个问题：

1.1、代码混乱：核心业务模块与其他非核心的代码交织在一起，大大影响了代码的模块独立性能，不利于代码的维护，而且分工不明确造成代码混乱。

1.2、冗余代码：其实权限的校验，异常的处理，日志的记录可以独立在一个模块给所有的服务公用，写在一起导致代码的分散和冗余。

因此面向切面的编程技术应运而生。

解释第一个问题：什么是面向切面的编程技术。切面与切点是几何上面的术语，用在这里可以这样理解：将核心业务代码过程比作一个柱体，其他的日志记录，权限校验等就像是横切核心业务的面，这些面需要完成一些非核心的业务。如下图：

                 

从图中可以看出我们定义了多个切面，每个切面都完成各自的非核心的业务，一个切面上还可以完成多个非核心的业务。 

1.3、第三个问题：与OOP是什么关系？

AOP的实现技术有多种，其中与Java无缝对接的是一种称为AspectJ的技术，Spring AOP 与AspectJ 实现原理上并不完全一致，但功能上是相似的。AOP的出现确实解决外围业务代码与核心业务代码分离的问题，但它并不会替代OOP，如果说OOP的出现是把编码问题进行模块化，那么AOP就是把涉及到众多模块的某一类问题进行统一管理（参考：关于 Spring AOP (AspectJ) 你该知晓的一切；其实我也想到了他们的关系，但是感觉没有这篇博客总结的很好）

 二：AOP的核心概念

从上右图可以可以很好看到切面（Aspect）包含了切点(PointCut)、连接点（JoinPoint）;额外还有通知（Advice）,织入（Weaving）,引入（Introduce）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
package springMVCmybatis.com.my.aop;
import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Around; 
import org.aspectj.lang.annotation.Before; 
import org.aspectj.lang.annotation.Pointcut; 
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.AfterThrowing; 
import org.springframework.core.annotation.Order;
@Aspect
// 切面执行顺序
@Order(3)
public class MyAopTest {
      @Pointcut("execution(* springMVCmybatis..addController.addEmp(..))") 
        private void pointCutMethod() { 
        } 
       
      @Pointcut("execution(* springMVCmybatis.com.my.aop.UserServiceImp.*(..))") 
        private void testAOP() { 
        }
      /*
       *  声明前置通知 ，JoinPont是srpring提供的静态变量，
       *  通过joinPoint参数可以获得目标方法的类名，方法参数，方法名等信息，这个参数可有可无。
       */
        
        @Before("pointCutMethod() || testAOP()") 
        public void doBefore(JoinPoint joinPoint) { 
            System.out.println("@Before:开始添加--order=3"); 
        } 
       
        //声明后置通知 ，如果result的类型与proceed执行的方法返回的参数类型不匹配那么就不会执行这个方法
        @AfterReturning(pointcut = "pointCutMethod()  || testAOP()", returning = "result") 
        public void doAfterReturning(String result) { 
            System.out.println("@AfterReturning:后置通知--order=3"); 
            System.out.println("---" + result + "---"); 
        } 
       
        //声明例外通知 
        @AfterThrowing(pointcut = "pointCutMethod() || testAOP()", throwing = "e") 
        public void doAfterThrowing(Exception e) { 
            System.out.println("@AfterThrowing:例外通知--order=3"); 
            System.out.println(e.getMessage()); 
        } 
       
        //声明最终通知 
        @After("pointCutMethod() || testAOP()") 
        public void doAfter() { 
            System.out.println("@After:最终通知--order=3"); 
        } 
      /*
       * 声明环绕通知
       * 参数必须是ProceedingJoinPoint，通过该对象的proceed()方法来执行目标函数，
       * proceed()的返回值就是环绕通知的返回值，proceedingJoinPoint是个接口，
       * implement JoinPoint,所以也可以获得目标函数的类名，方法名等参数。
       */
         
        @Around("pointCutMethod() || testAOP()") 
        public Object doAround(ProceedingJoinPoint pjp) throws Throwable { 
            System.out.println("@Around:进入方法---环绕通知--order=3"); 
            Object o = pjp.proceed(); 
            System.out.println("@Around:退出方法---环绕通知--order=3"); 
            return o; 
        }
 
        
}

　　

　上面是我写的一个例子，结合例子我们来看看这些核心的概念：

2.1、切面(Aspect)：是一个类，里面定义了通知与切点。

2.2、切点(PointCut)：表达式。就是告诉程序要在执行哪些核心业务的时候，执行非核心的业务。

2.3、通知（advice）:五种通知方式：

  • @Before：前置通知，在调用目标方法之前执行通知定义的任务
  • @After：后置通知，在目标方法执行结束后，无论执行结果如何都执行通知定义的任务
  • @After-returning：后置通知，在目标方法执行结束后，如果执行成功，则执行通知定义的任务
  • @After-throwing：异常通知，如果目标方法执行过程中抛出异常，则执行通知定义的任务
  • @Around：环绕通知，在目标方法执行前和执行后，都需要执行通知定义的任务。

五种通知方式的执行顺序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
正常情况下的执行顺序：<br><br>@Around:进入方法---环绕通知--order=3
@Before:开始添加--order=3
============执行业务方法findUser,查找的用户是：张三=============
@Around:退出方法---环绕通知--order=3
@After:最终通知--order=3
@AfterReturning:后置通知--order=3
---张三---
<br>异常情况下的执行顺序：
 
@Around:进入方法---环绕通知--order=3
@Before:开始添加--order=3
============执行业务方法addUser=============
@After:最终通知--order=3
@AfterThrowing:例外通知--order=3
null

三：切点表达式。

这个表达式有很多种，如方法签名表达式，类型签名表达式，还有其他的表达式，我只用过前面两个，其他的没用过，也不做介绍，如果这两种表达式不能解决问题的可以参考我参考的博客。

3.1：方法签名表达式
 
1
2
execution(<修饰符模式>?<返回类型模式><方法所在类的完全限定名称模式>(<参数模式>)<异常模式>?)
execution(modifiers-pattern? ret-type-pattern fully-qualified-class-name (param-pattern) throws-pattern?)  　
 
其实如果单纯的给定这个表达式还是不容易记忆，下面对比方法的定义来记忆，一个java方法的全部定义方式可以表示成下面的方式：
　　　　
1
2
public String springMVCmybatic.com.my.aop.UserServiceImp(String a, int b) throw Exception{
}
  • modifier-pattern?：表示方法的修饰符，可有可无；对应的就是 public
  • ret-type-pattern：表示方法的返回值；对应的就是 String
  • fully-qualified-class-name  方法所在类的完全限定名称；对应的就是 springMVCmybatic.com.my.aop.UserServiceImp
  • param-pattern：表示方法的参数；对应的就是 String a, int b
  • throws-pattern：表示方法抛出的异常，可有可无；对应的就是 throw Exception

3.2：&&，||，！

1
2
3
4
5
6
7
@Around("pointCutMethod() || testAOP()") 
      public Object doAround(ProceedingJoinPoint pjp) throws Throwable { 
          System.out.println("@Around:进入方法---环绕通知"); 
          Object o = pjp.proceed(); 
          System.out.println("@Around:退出方法---环绕通知"); 
          return o; 
      }

表达式之间可以采用与，或，非的方式来过滤。

四：多个切点的执行顺序

　上面的例子中，定义了order=3，重新创建一个切面，定义order=6，执行的结果是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
@Around:进入方法---环绕通知--order=3
@Before:开始添加--order=3
@Around:进入方法---环绕通知--order=6
@Before:开始添加--order=6
============执行业务方法findUser,查找的用户是：张三=============
@Around:退出方法---环绕通知--order=6
@After:最终通知--order=6
@AfterReturning:后置通知--order=6
---张三---
@Around:退出方法---环绕通知--order=3
@After:最终通知--order=3
@AfterReturning:后置通知--order=3
---张三---
 
 
@Around:进入方法---环绕通知--order=3
@Before:开始添加--order=3
@Around:进入方法---环绕通知--order=6
@Before:开始添加--order=6
============执行业务方法addUser=============
@After:最终通知--order=6
@AfterThrowing:例外通知--order=6
null
@After:最终通知--order=3
@AfterThrowing:例外通知--order=3
null

　从结果中可以看出order越小越先执行，执行完了之后就order越小就越后推出。总结为下面的图：

 

【参考博客】

1、http://blog.csdn.net/javazejian/article/details/56267036/

2、http://blog.csdn.net/qqxhwwqwq/article/details/51678595

 

————————————————————————————————————————————————————————

https://blog.csdn.net/u011974797/article/details/80591986

 

@Around是可以同时在所拦截方法的前后执行一段逻辑。

@Before是在所拦截方法执行之前执行一段逻辑。

@After 是在所拦截方法执行之后执行一段逻辑。

注意：不能拦截静态(static)方法

示例：

  1.  package com.abc.advice;
  2.   
  3. import java.util.Arrays;
  4.   
  5.  import org.aspectj.lang.JoinPoint;
  6.  import org.aspectj.lang.ProceedingJoinPoint;
  7.  import org.aspectj.lang.annotation.After;
  8.  import org.aspectj.lang.annotation.AfterReturning;
  9.  import org.aspectj.lang.annotation.Around;
  10.  import org.aspectj.lang.annotation.Aspect;
  11.  import org.aspectj.lang.annotation.Before;
  12.  
     
  13.  @Aspect
  14.  public class AdviceTest {
  15.  @Around("execution(* com.abc.service.*.many*(..))")
  16.  public Object process(ProceedingJoinPoint point) throws Throwable {
  17.  System.out.println("@Around：执行目标方法之前...");
  18.  //访问目标方法的参数：
  19.  Object[] args = point.getArgs();
  20.  if (args != null && args.length > 0 && args[0].getClass() == String.class) {
  21.  args[0] = "改变后的参数1";
  22.  }
  23.  //用改变后的参数执行目标方法
  24.  Object returnValue = point.proceed(args);
  25.  System.out.println("@Around：执行目标方法之后...");
  26.  System.out.println("@Around：被织入的目标对象为：" + point.getTarget());
  27.  return "原返回值：" + returnValue + "，这是返回结果的后缀";
  28.  }
  29.  
     
  30.  @Before("execution(* com.abc.service.*.many*(..))")
  31.  public void permissionCheck(JoinPoint point) {
  32.  System.out.println("@Before：模拟权限检查...");
  33.  System.out.println("@Before：目标方法为：" +
  34.  point.getSignature().getDeclaringTypeName() +
  35.  "." + point.getSignature().getName());
  36.  System.out.println("@Before：参数为：" + Arrays.toString(point.getArgs()));
  37.  System.out.println("@Before：被织入的目标对象为：" + point.getTarget());
  38.  }
  39.   
  40.  @AfterReturning(pointcut="execution(* com.abc.service.*.many*(..))",
  41.  returning="returnValue")
  42.  public void log(JoinPoint point, Object returnValue) {
  43.  System.out.println("@AfterReturning：模拟日志记录功能...");
  44.  System.out.println("@AfterReturning：目标方法为：" +
  45.  point.getSignature().getDeclaringTypeName() +
  46.  "." + point.getSignature().getName());
  47.  System.out.println("@AfterReturning：参数为：" +
  48.  Arrays.toString(point.getArgs()));
  49.  System.out.println("@AfterReturning：返回值为：" + returnValue);
  50.  System.out.println("@AfterReturning：被织入的目标对象为：" + point.getTarget());
  51.  
  52. }
  53.   
  54.  @After("execution(* com.abc.service.*.many*(..))")
  55.  public void releaseResource(JoinPoint point) {
  56.  System.out.println("@After：模拟释放资源...");
  57.  System.out.println("@After：目标方法为：" +
  58.  point.getSignature().getDeclaringTypeName() +
  59.  "." + point.getSignature().getName());
  60.  System.out.println("@After：参数为：" + Arrays.toString(point.getArgs()));
  61.  System.out.println("@After：被织入的目标对象为：" + point.getTarget());
  62.  }
  63.  
    }

被拦截的方法

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

运行方法

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

结果

  1.  @Around：执行目标方法之前...
  2.  @Before：模拟权限检查...
  3.  @Before：目标方法为：com.abc.service.AdviceManager.manyAdvices
  4.  @Before：参数为：[改变后的参数1, bb]
  5.  @Before：被织入的目标对象为：com.abc.service.AdviceManager@1dfc617e
  6.  方法：manyAdvices
  7.  @Around：执行目标方法之后...
  8.  @Around：被织入的目标对象为：com.abc.service.AdviceManager@1dfc617e
  9.  @After：模拟释放资源...
  10.  @After：目标方法为：com.abc.service.AdviceManager.manyAdvices
  11.  @After：参数为：[改变后的参数1, bb]
  12.  @After：被织入的目标对象为：com.abc.service.AdviceManager@1dfc617e
  13.  @AfterReturning：模拟日志记录功能...
  14.  @AfterReturning：目标方法为：com.abc.service.AdviceManager.manyAdvices
  15.  @AfterReturning：参数为：[改变后的参数1, bb]
  16.  @AfterReturning：返回值为：原返回值：改变后的参数1 、 bb，这是返回结果的后缀
  17.  @AfterReturning：被织入的目标对象为：com.abc.service.AdviceManager@1dfc617e
  18.  Test方法中调用切点方法的返回值：原返回值：改变后的参数1 、bb，这是返回结果的后缀

 ___________________________________________________________________________________________________________

 

 

AspectJ 切面注解中五种通知注解：@Before、@After、@AfterRunning、@AfterThrowing、@Around

2017-12-16 23:52:27  阅读数 27383更多
分类专栏： spring
 
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010502101/article/details/78823056

要在 Spring 中声明 AspectJ 切面, 只需要在 IOC 容器中将切面声明为 Bean 实例. 当在 Spring IOC 容器中初始化 AspectJ 切面之后, Spring IOC 容器就会为那些与 AspectJ 切面相匹配的 Bean 创建代理。
在切面类中需要定义切面方法用于响应响应的目标方法，切面方法即为通知方法，通知方法需要用注解标识，AspectJ 支持 5 种类型的通知注解:

  • @Before: 前置通知, 在方法执行之前执行
  • @After: 后置通知, 在方法执行之后执行 。
  • @AfterRunning: 返回通知, 在方法返回结果之后执行
  • @AfterThrowing: 异常通知, 在方法抛出异常之后
  • @Around: 环绕通知, 围绕着方法执行

下面分别举例5中通知方法的使用

首先建立一个目标接口ArithmeticCalculator：

package lzj.com.spring.aop;

public interface ArithmeticCalculator {
    int add(int i, int j);
    int div(int i, int j);
}

 

然后创建接口的实现类ArithmeticCalculatorIml ：

package lzj.com.spring.aop;
import org.springframework.stereotype.Component;

@Component("arithmeticCalculator")
public class ArithmeticCalculatorIml implements ArithmeticCalculator {

    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("add->result:" + result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        System.out.println("div->result:" + result);
        return result;
    }

}

 

配置文件bean-aop.xml：

<context:component-scan base-package="lzj.com.spring.aop"></context:component-scan>

 

创建测试类：

package lzj.com.spring.aop;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("bean-aop.xml");
        ArithmeticCalculator arithmetic = (ArithmeticCalculator) ctx.getBean("arithmeticCalculator");
        arithmetic.add(3, 2);
        arithmetic.div(4, 2);

    }

}

 

运行结果：

add->result:5
div->result:2

 

上面的例子把目标类注入到IOC容器中，执行时从容器中获取目标类的bean，然后调用目标方法。
下面要在目标方法的前后等执行其它操作，打印日志，不需要改变任何目标方法，只需要增加切面类，新建切面类LogProxy，把切面类注入到IOC中，然后在切面类中定义要执行的切面方法即可。

在执行下面切面方法之前，需要先启动五种注解，配置文件中定义如下：

<context:component-scan base-package="lzj.com.spring.aop"></context:component-scan>
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

 

一、@Before前置通知

用@Before标识的方法为前置方法，在目标方法的执行之前执行，即在连接点之前进行执行。
示例如下：

package lzj.com.spring.aop;
import java.util.Arrays;
import java.util.List;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LogProxy {

    @Before("execution(public int lzj.com.spring.aop.ArithmeticCalculator.*(int, int))")
    public void beforMethod(JoinPoint point){
        String methodName = point.getSignature().getName();
        List<Object> args = Arrays.asList(point.getArgs());
        System.out.println("调用前连接点方法为：" + methodName + ",参数为：" + args);
    }

}

 

执行测试类，输出结果如下：

调用前连接点方法为：add,参数为：[3, 2]
add->result:5
调用前连接点方法为：div,参数为：[4, 2]
div->result:2

 

在目标方法add和div之前分别执行了前置通知方法。

二、@After后置通知方法

后置方法在连接点方法完成之后执行，无论连接点方法执行成功还是出现异常，都将执行后置方法。示例如下：

@Aspect
@Component
public class LogProxy {

    @After(("execution(public int lzj.com.spring.aop.ArithmeticCalculator.*(int, int))"))
    public void afterMethod(JoinPoint point){
        String methodName = point.getSignature().getName();
        List<Object> args = Arrays.asList(point.getArgs());
        System.out.println("调用后连接点方法为：" + methodName + ",参数为：" + args);
    }
}

 

执行测试类，输出结果如下：

add->result:5
调用后连接点方法为：add,参数为：[3, 2]
div->result:2
调用后连接点方法为：div,参数为：[4, 2]

 

发现add和div两个连接点方法执行之后都调用了后置方法。如果目标连接点方法出现异常时，也会执行后置通知方法。把测试方法改成如下：

public class Main {

    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("bean-aop.xml");
        ArithmeticCalculator arithmetic = (ArithmeticCalculator) ctx.getBean("arithmeticCalculator");
        arithmetic.add(3, 2);
        /*被除数为0,会抛出异常*/
        arithmetic.div(4, 0);   
    }

执行测试方法，输出结果如下：

add->result:5
调用后连接点方法为：add,参数为：[3, 2]
调用后连接点方法为：div,参数为：[4, 0]
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at lzj.com.spring.aop.ArithmeticCalculatorIml.div(ArithmeticCalculatorIml.java:17)
    ……

 

从输出结果中可以看出，即使目标方法出现异常，后置通知方法依然执行。但后置通知拿不到目标方法执行后的结果，因为目标方法有可能出现异常。如果要拿目标方法的执行结果，要用下面的通知方法。

三、@AfterRunning返回通知方法

当连接点方法成功执行后，返回通知方法才会执行，如果连接点方法出现异常，则返回通知方法不执行。返回通知方法在目标方法执行成功后才会执行，所以，返回通知方法可以拿到目标方法(连接点方法)执行后的结果。切面类中定义返回通知方法，示例如下：

@Aspect
@Component
public class LogProxy {

    /*通过returning属性指定连接点方法返回的结果放置在result变量中，在返回通知方法中可以从result变量中获取连接点方法的返回结果了。*/
    @AfterReturning(value="execution(public int lzj.com.spring.aop.ArithmeticCalculator.*(int, int))",
            returning="result")
    public void afterReturning(JoinPoint point, Object result){
        String methodName = point.getSignature().getName();
        List<Object> args = Arrays.asList(point.getArgs());
        System.out.println("连接点方法为：" + methodName + ",参数为：" + args + ",目标方法执行结果为：" + result);
    }
}

 

运行测试方法，输出结果如下：

add->result:5
连接点方法为：add,参数为：[3, 2],目标方法执行结果为：5
div->result:2
连接点方法为：div,参数为：[4, 2],目标方法执行结果为：2

 

当连接点方法出现异常时，不执行返回通知方法，把测试方法该为如下：

public class Main {

    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("bean-aop.xml");
        ArithmeticCalculator arithmetic = (ArithmeticCalculator) ctx.getBean("arithmeticCalculator");
        arithmetic.add(3, 2);
        arithmetic.div(4, 0);

    }

}

 

运行测试方法，输出结果如下：

add->result:5
连接点方法为：add,参数为：[3, 2],目标方法执行结果为：5
Exception in thread "main" java.lang.ArithmeticException: / by zero
……

 

从输出结果可以看出，div(4,0)出现异常，因此该连接点对应的返回通知方法也不执行。

四、@AfterThrowing异常通知

异常通知方法只在连接点方法出现异常后才会执行，否则不执行。在异常通知方法中可以获取连接点方法出现的异常。在切面类中异常通知方法，示例如下：

/*通过throwing属性指定连接点方法出现异常信息存储在ex变量中，在异常通知方法中就可以从ex变量中获取异常信息了*/
@AfterThrowing(value="execution(public int lzj.com.spring.aop.ArithmeticCalculator.*(int, int))",
            throwing="ex")
    public void afterReturning(JoinPoint point, Exception ex){
        String methodName = point.getSignature().getName();
        List<Object> args = Arrays.asList(point.getArgs());
        System.out.println("连接点方法为：" + methodName + ",参数为：" + args + ",异常为：" + ex);
    }

 

测试方法为：

public class Main {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("bean-aop.xml");
        ArithmeticCalculator arithmetic = (ArithmeticCalculator) ctx.getBean("arithmeticCalculator");
        arithmetic.add(3, 2);
        arithmetic.div(4, 0);       
    }
}

 

执行测试方法，输出结果如下：

add->result:5
连接点方法为：div,参数为：[4, 0],异常为：java.lang.ArithmeticException: / by zero
Exception in thread "main" java.lang.ArithmeticException: / by zero

 

从输出结果中可以看出，add方法没有异常，因此不执行异常通知方法，div方法出现异常，执行科异常通知方法。
上面的例子中，异常类型设置的是Exception，表示捕获连接点方法的所有异常信息，也可以指定捕获指定类型的信息，例如

@AfterThrowing(value="execution(public int lzj.com.spring.aop.ArithmeticCalculator.*(int, int))",
            throwing="ex")
    /*只捕获连接点方法中的NullPointerException 类型的异常信息*/
    public void afterReturning(JoinPoint point, NullPointerException ex){
        String methodName = point.getSignature().getName();
        List<Object> args = Arrays.asList(point.getArgs());
        System.out.println("连接点方法为：" + methodName + ",参数为：" + args + ",异常为：" + ex);
    }

五、@Around环绕通知

环绕通知方法可以包含上面四种通知方法，环绕通知的功能最全面。环绕通知需要携带 ProceedingJoinPoint 类型的参数，且环绕通知必须有返回值, 返回值即为目标方法的返回值。在切面类中创建环绕通知方法，示例如下：

@Around("execution(public int lzj.com.spring.aop.ArithmeticCalculator.*(int, int))")
    public Object aroundMethod(ProceedingJoinPoint pdj){
        /*result为连接点的放回结果*/
        Object result = null;
        String methodName = pdj.getSignature().getName();

        /*前置通知方法*/
        System.out.println("前置通知方法>目标方法名：" + methodName + ",参数为：" + Arrays.asList(pdj.getArgs()));

        /*执行目标方法*/
        try {
            result = pdj.proceed();

            /*返回通知方法*/
            System.out.println("返回通知方法>目标方法名" + methodName + ",返回结果为：" + result);
        } catch (Throwable e) {
            /*异常通知方法*/
            System.out.println("异常通知方法>目标方法名" + methodName + ",异常为：" + e);
        }

        /*后置通知*/
        System.out.println("后置通知方法>目标方法名" + methodName);

        return result;
    }
}

 

测试方法为：

public class Main {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("bean-aop.xml");
        ArithmeticCalculator arithmetic = (ArithmeticCalculator) ctx.getBean("arithmeticCalculator");
        arithmetic.add(3, 2);
        arithmetic.div(4, 0);       
    }
}

 

运行测试方法：

public class Main {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("bean-aop.xml");
        ArithmeticCalculator arithmetic = (ArithmeticCalculator) ctx.getBean("arithmeticCalculator");
        arithmetic.add(3, 2);
        arithmetic.div(4, 0);       
    }
}

运行测试方法，输出结果：

前置通知方法>目标方法名：add,参数为：[3, 2]
add->result:5
返回通知方法>目标方法名add,返回结果为：5
后置通知方法>目标方法名add
前置通知方法>目标方法名：div,参数为：[4, 0]
异常通知方法>目标方法名div,异常为：java.lang.ArithmeticException: / by zero
后置通知方法>目标方法名div
Exception in thread "main" org.springframework.aop.AopInvocationException: Null return value from advice does not match primitive return type for: public abstract int lzj.com.spring.aop.ArithmeticCalculator.div(int,int)
    at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:219)
    at com.sun.proxy.$Proxy7.div(Unknown Source)
    at lzj.com.spring.aop.Main.main(Main.java:12)

 

从输出结果中可以看出，环绕通知实现了上面几种通知的结合。
当div目标方法出现异常时，在环绕通知方法中已经用try…catch方法进行捕捉了，为什么最后输出结果中还出现了一个返回类型不匹配的错误：

Exception in thread "main" org.springframework.aop.AopInvocationException: Null return value from advice does not match primitive return type for: public abstract int lzj.com.spring.aop.ArithmeticCalculator.div(int,int)
    at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:219)
    at com.sun.proxy.$Proxy7.div(Unknown Source)
    at lzj.com.spring.aop.Main.main(Main.java:12)

 

 

那是因为在环绕通知方法中开始就定义了目标方法的返回结果
Object result = null。当目标方法出现异常时，result = pdj.proceed();执行时出现异常，此时result中还是null，所以在环绕通知方法最后return result;时，返回的result就是null，但是环绕通知的返回类型我们定义的是Object类型的，null不能转化为Object类型，所以抛出了个类型转换的错误。我们可以在环绕通知方法中把异常抛出去，即为：

@Around("execution(public int lzj.com.spring.aop.ArithmeticCalculator.*(int, int))")
    public Object aroundMethod(ProceedingJoinPoint pdj){
        /*result为连接点的放回结果*/
        Object result = null;
        String methodName = pdj.getSignature().getName();

        /*前置通知方法*/
        System.out.println("前置通知方法>目标方法名：" + methodName + ",参数为：" + Arrays.asList(pdj.getArgs()));

        /*执行目标方法*/
        try {
            result = pdj.proceed();

            /*返回通知方法*/
            System.out.println("返回通知方法>目标方法名" + methodName + ",返回结果为：" + result);
        } catch (Throwable e) {
            /*异常通知方法*/
            System.out.println("异常通知方法>目标方法名" + methodName + ",异常为：" + e);
            /*当环绕通知方法本身还有其它异常时，非连接点方法出现的异常，此时抛出来*/
            throw new RuntimeException();
        }

        /*后置通知*/
        System.out.println("后置通知方法>目标方法名" + methodName);

        return result;
    }
}

 

在输出结果中会抛出一个运行时异常java.lang.RuntimeException

插曲：不可以在执行目标方法时在定义result变量：

        ……
        /*执行目标方法*/
        try {
            Object result = pdj.proceed();
            ……
        } catch (Throwable e) {
            ……
        }
        ……
        return result;

这种方法是行不通的，在Object result = pdj.proceed();中，如果pdj.proceed()执行失败，就会被try …catch捕获到异常，而不会就不会执行定义result变量那一步了，即Object result不会执行，所以在return result;就会出现错误。

posted @ 2019-08-15 15:25  kelelipeng  阅读(873)  评论(0)  编辑  收藏  举报