浅谈spring aop的五种通知类型

 更新时间:2017年12月05日 11:19:04   作者:C__joy  
这篇文章主要介绍了浅谈spring aop的五种通知类型,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧

Java技术迷

spring aop通知(advice)分成五类: 

前置通知[Before advice]:在连接点前面执行,前置通知不会影响连接点的执行,除非此处抛出异常。 

正常返回通知[After returning advice]:在连接点正常执行完成后执行,如果连接点抛出异常,则不会执行。 

异常返回通知[After throwing advice]:在连接点抛出异常后执行。 

返回通知[After (finally) advice]:在连接点执行完成后执行,不管是正常执行完成,还是抛出异常,都会执行返回通知中的内容。 

环绕通知[Around advice]:环绕通知围绕在连接点前后,比如一个方法调用的前后。这是最强大的通知类型,能在方法调用前后自定义一些操作。

环绕通知还需要负责决定是继续处理join point(调用ProceedingJoinPoint的proceed方法)还是中断执行。 
接下来通过编写示例程序来测试一下五种通知类型:

定义接口

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.chenqa.springaop.example.service;
 
public interface BankService {
 
  /**
   * 模拟的银行转账
   * @param from 出账人
   * @param to 入账人
   * @param account 转账金额
   * @return
   */
  public boolean transfer(String form, String to, double account);
}

编写实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.chenqa.springaop.example.service.impl;
 
import com.chenqa.springaop.example.service.BankService;
 
public class BCMBankServiceImpl implements BankService {
 
  public boolean transfer(String form, String to, double account) {
    if(account<100) {
      throw new IllegalArgumentException("最低转账金额不能低于100元");
    }
    System.out.println(form+"向"+to+"交行账户转账"+account+"元");
    return false;
  }
 
}

修改spring配置文件,添加以下内容:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!-- bankService bean --> 
  <bean id="bankService" class="com.chenqa.springaop.example.service.impl.BCMBankServiceImpl"/>
  <!-- 切面 -->
  <bean id="myAspect" class="com.chenqa.springaop.example.aspect.MyAspect"/>
  <!-- aop配置 -->
  <aop:config>
    <aop:aspect ref="myAspect">
      <aop:pointcut expression="execution(* com.chenqa.springaop.example.service.impl.*.*(..))" id="pointcut"/>
      <aop:before method="before" pointcut-ref="pointcut"/>
      <aop:after method="after" pointcut-ref="pointcut"/>
      <aop:after-returning method="afterReturning" pointcut-ref="pointcut"/>
      <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut"/>
      <aop:around method="around" pointcut-ref="pointcut"/>
    </aop:aspect>
  </aop:config>

编写测试程序

1
2
3
ApplicationContext context = new ClassPathXmlApplicationContext("spring-aop.xml");
    BankService bankService = context.getBean("bankService", BankService.class);
    bankService.transfer("张三", "李四", 200);

执行后输出: 

这里写图片描述 

将测试程序中的200改成50,再执行后输出: 

这里写图片描述 

通过测试结果可以看出,五种通知的执行顺序为:

前置通知→环绕通知→正常返回通知/异常返回通知→返回通知,可以多次执行来查看。

情况一: 一个方法只被一个Aspect类拦截

当一个方法只被一个Aspect拦截时,这个Aspect中的不同advice是按照怎样的顺序进行执行的呢?请看:

添加 PointCut类

该pointcut用来拦截test包下的所有类中的所有方法。

1
2
3
4
5
6
7
8
9
10
package test;
 
import org.aspectj.lang.annotation.Pointcut;
 
public class PointCuts {
  @Pointcut(value = "within(test.*)")
  public void aopDemo() {
 
  }
}

添加Aspect类

该类中的advice将会用到上面的pointcut,使用方法请看各个advice的value属性。

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
package test;
 
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
 
@Component
@Aspect
public class Aspect1 {
 
  @Before(value = "test.PointCuts.aopDemo()")
  public void before(JoinPoint joinPoint) {
    System.out.println("[Aspect1] before advise");
  }
 
  @Around(value = "test.PointCuts.aopDemo()")
  public void around(ProceedingJoinPoint pjp) throws Throwable{
    System.out.println("[Aspect1] around advise 1");
    pjp.proceed();
    System.out.println("[Aspect1] around advise2");
  }
 
  @AfterReturning(value = "test.PointCuts.aopDemo()")
  public void afterReturning(JoinPoint joinPoint) {
    System.out.println("[Aspect1] afterReturning advise");
  }
 
  @AfterThrowing(value = "test.PointCuts.aopDemo()")
  public void afterThrowing(JoinPoint joinPoint) {
    System.out.println("[Aspect1] afterThrowing advise");
  }
 
  @After(value = "test.PointCuts.aopDemo()")
  public void after(JoinPoint joinPoint) {
    System.out.println("[Aspect1] after advise");
  }
}

添加测试用Controller

添加一个用于测试的controller,这个controller中只有一个方法,但是它会根据参数值的不同,会作出不同的处理:一种是正常返回一个对象,一种是抛出异常(因为我们要测试@AfterThrowing这个advice)

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
package test;
 
import test.exception.TestException;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
 
@RestController
@RequestMapping(value = "/aop")
public class AopTestController {
 
  @ResponseStatus(HttpStatus.OK)
  @RequestMapping(value = "/test", method = RequestMethod.GET)
  public Result test(@RequestParam boolean throwException) {
    // case 1
    if (throwException) {
      System.out.println("throw an exception");
      throw new TestException("mock a server exception");
    }
 
    // case 2
    System.out.println("test OK");
    return new Result() {{
      this.setId(111);
      this.setName("mock a Result");
    }};
  }
 
  public static class Result {
    private int id;
    private String name;
 
    public int getId() {
      return id;
    }
 
    public void setId(int id) {
      this.id = id;
    }
 
    public String getName() {
      return name;
    }
 
    public void setName(String name) {
      this.name = name;
    }
  }
}

测试 正常情况

在浏览器直接输入以下的URL,回车:http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=false1

我们会看到输出的结果是:

1
2
3
4
5
6
[Aspect1] around advise 1
[Aspect1] before advise
test OK
[Aspect1] around advise2
[Aspect1] after advise
[Aspect1] afterReturning advise

测试 异常情况

在浏览器中直接输入以下的URL,回车:http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=true1

我们会看到输出的结果是:

1
2
3
4
5
[Aspect1] around advise 1
[Aspect1] before advise
throw an exception
[Aspect1] after advise
[Aspect1] afterThrowing advise

结论

在一个方法只被一个aspect类拦截时,aspect类内部的 advice 将按照以下的顺序进行执行:

正常情况: 

one-ok

异常情况: 

one-exception

情况二: 同一个方法被多个Aspect类拦截

此处举例为被两个aspect类拦截。 

有些情况下,对于两个不同的aspect类,不管它们的advice使用的是同一个pointcut,还是不同的pointcut,都有可能导致同一个方法被多个aspect类拦截。那么,在这种情况下,这多个Aspect类中的advice又是按照怎样的顺序进行执行的呢?请看:

pointcut类保持不变

添加一个新的aspect类

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
package test;
 
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
 
@Component
@Aspect
public class Aspect2 {
 
  @Before(value = "test.PointCuts.aopDemo()")
  public void before(JoinPoint joinPoint) {
    System.out.println("[Aspect2] before advise");
  }
 
  @Around(value = "test.PointCuts.aopDemo()")
  public void around(ProceedingJoinPoint pjp) throws Throwable{
    System.out.println("[Aspect2] around advise 1");
    pjp.proceed();
    System.out.println("[Aspect2] around advise2");
  }
 
  @AfterReturning(value = "test.PointCuts.aopDemo()")
  public void afterReturning(JoinPoint joinPoint) {
    System.out.println("[Aspect2] afterReturning advise");
  }
 
  @AfterThrowing(value = "test.PointCuts.aopDemo()")
  public void afterThrowing(JoinPoint joinPoint) {
    System.out.println("[Aspect2] afterThrowing advise");
  }
 
  @After(value = "test.PointCuts.aopDemo()")
  public void after(JoinPoint joinPoint) {
    System.out.println("[Aspect2] after advise");
  }
}

测试用Controller也不变

还是使用上面的那个Controller。但是现在 aspect1 和 aspect2 都会拦截该controller中的方法。

下面继续进行测试!

测试 正常情况

在浏览器直接输入以下的URL,回车:http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=false1

我们会看到输出的结果是:

1
2
3
4
5
6
7
8
9
10
11
[Aspect2] around advise 1
[Aspect2] before advise
[Aspect1] around advise 1
[Aspect1] before advise
test OK
[Aspect1] around advise2
[Aspect1] after advise
[Aspect1] afterReturning advise
[Aspect2] around advise2
[Aspect2] after advise
[Aspect2] afterReturning advise

但是这个时候,我不能下定论说 aspect2 肯定就比 aspect1 先执行。 

不信?你把服务务器重新启动一下,再试试,说不定你就会看到如下的执行结果:

1
2
3
4
5
6
7
8
9
10
11
[Aspect1] around advise 1
[Aspect1] before advise
[Aspect2] around advise 1
[Aspect2] before advise
test OK
[Aspect2] around advise2
[Aspect2] after advise
[Aspect2] afterReturning advise
[Aspect1] around advise2
[Aspect1] after advise
[Aspect1] afterReturning advise

也就是说,这种情况下, aspect1 和 aspect2 的执行顺序是未知的。那怎么解决呢?不急,下面会给出解决方案。

测试 异常情况

在浏览器中直接输入以下的URL,回车:http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=true1

我们会看到输出的结果是:

1
2
3
4
5
6
7
8
9
[Aspect2] around advise 1
[Aspect2] before advise
[Aspect1] around advise 1
[Aspect1] before advise
throw an exception
[Aspect1] after advise
[Aspect1] afterThrowing advise
[Aspect2] after advise
[Aspect2] afterThrowing advise

同样地,如果把服务器重启,然后再测试的话,就可能会看到如下的结果:

1
2
3
4
5
6
7
8
9
[Aspect1] around advise 1
[Aspect1] before advise
[Aspect2] around advise 1
[Aspect2] before advise
throw an exception
[Aspect2] after advise
[Aspect2] afterThrowing advise
[Aspect1] after advise
[Aspect1] afterThrowing advise

也就是说,同样地,异常情况下, aspect1 和 aspect2 的执行顺序也是未定的。

那么在 情况二 下,如何指定每个 aspect 的执行顺序呢? 

方法有两种:

  1. 实现org.springframework.core.Ordered接口,实现它的getOrder()方法
  2. 给aspect添加@Order注解,该注解全称为:org.springframework.core.annotation.Order

不管采用上面的哪种方法,都是值越小的 aspect 越先执行。 

比如,我们为 apsect1 和 aspect2 分别添加 @Order 注解,如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
@Order(5)
@Component
@Aspect
public class Aspect1 {
  // ...
}
 
@Order(6)
@Component
@Aspect
public class Aspect2 {
  // ...
}

这样修改之后,可保证不管在任何情况下, aspect1 中的 advice 总是比 aspect2 中的 advice 先执行。如下图所示: 

two-ok

注意点

如果在同一个 aspect 类中,针对同一个 pointcut,定义了两个相同的 advice(比如,定义了两个 @Before),那么这两个 advice 的执行顺序是无法确定的,哪怕你给这两个 advice 添加了 @Order 这个注解,也不行。这点切记。

对于@Around这个advice,不管它有没有返回值,但是必须要方法内部,调用一下 pjp.proceed();否则,Controller 中的接口将没有机会被执行,从而也导致了 @Before这个advice不会被触发。比如,我们假设正常情况下,执行顺序为”aspect2 -> apsect1 -> controller”,如果,我们把 aspect1中的@Around中的 pjp.proceed();给删掉,那么,我们看到的输出结果将是:

1
2
3
4
5
6
7
8
9
[Aspect2] around advise 1
[Aspect2] before advise
[Aspect1] around advise 1
[Aspect1] around advise2
[Aspect1] after advise
[Aspect1] afterReturning advise
[Aspect2] around advise2
[Aspect2] after advise
[Aspect2] afterReturning advise

从结果可以发现, Controller 中的 接口 未被执行,aspect1 中的 @Before advice 也未被执行。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

蓄力AI

微信公众号搜索 “ 脚本之家 ” ,选择关注

程序猿的那些事、送书等活动等着你

原文链接:http://blog.csdn.net/qq_35873847/article/details/78624941

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。
如若内容造成侵权/违法违规/事实不符,请将相关资料发送至 reterry123@163.com 进行投诉反馈,一经查实,立即处理!

相关文章

  • 详解基于MybatisPlus两步实现多租户方案

    详解基于MybatisPlus两步实现多租户方案

    这篇文章主要介绍了详解基于MybatisPlus两步实现多租户方案,本文分两步,通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2021-04-04
  • list转tree和list中查找某节点下的所有数据操作

    list转tree和list中查找某节点下的所有数据操作

    这篇文章主要介绍了list转tree和list中查找某节点下的所有数据操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2020-09-09
  • java多线程加锁以及Condition类的使用实例解析

    java多线程加锁以及Condition类的使用实例解析

    这篇文章主要介绍了java多线程加锁以及Condition类的使用实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2019-11-11
  • JavaFX桌面应用未响应问题解决方案

    JavaFX桌面应用未响应问题解决方案

    这篇文章主要介绍了JavaFX桌面应用未响应问题解决方案,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-07-07
  • Java协程编程之Loom项目实战记录

    Java协程编程之Loom项目实战记录

    这篇文章主要介绍了Java协程编程之Loom项目尝鲜,如果用尝鲜的角度去使用Loom项目,可以提前窥探JVM开发者们是如何基于协程这个重大特性进行开发的,这对于提高学习JDK内核代码的兴趣有不少帮助,需要的朋友可以参考下
    2021-08-08
  • springmvc实现导出数据信息为excle表格示例代码

    springmvc实现导出数据信息为excle表格示例代码

    本篇文章主要介绍了springmvc实现导出数据信息为excle表格,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧。
    2017-01-01
  • Java基础总结之Thymeleaf详解

    Java基础总结之Thymeleaf详解

    Thymeleaf是一种现代的基于服务器端的Java模板引擎技术,也是一个优秀的面向Java的XML、XHTML、HTML5页面模板,它具有丰富的标签语言、函数和表达式,在使用Spring Boot框架进行页面设计时,一般会选择Thymeleaf模板,需要的朋友可以参考下
    2021-05-05
  • 解决Spring配置文件中bean的property属性中的name出错问题

    解决Spring配置文件中bean的property属性中的name出错问题

    这篇文章主要介绍了解决Spring配置文件中bean的property属性中的name出错问题,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2021-07-07
  • SpringBoot中使用Ehcache的详细教程

    SpringBoot中使用Ehcache的详细教程

    EhCache 是一个纯 Java 的进程内缓存框架,具有快速、精干等特点,是 Hibernate 中默认的 CacheProvider。这篇文章主要介绍了SpringBoot中使用Ehcache的相关知识,需要的朋友可以参考下
    2020-08-08
  • 浅谈java中的访问修饰符

    浅谈java中的访问修饰符

    这篇文章介绍了java中的访问修饰符,有需要的朋友可以参考一下
    2013-10-10

最新评论