Spring AOP 通知的执行顺序

于 2024-07-08 20:45:41 发布
阅读量164 收藏 4
点赞数 3
分类专栏： spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_Richard/article/details/140277845
版权

1. 结论

官方文档：Spring AOP Advice

故各种通知的执行顺序：

  • Spring版本5.2.7以后：
    • @Around环绕通知前置操作
    • @Before前置通知
    • 目标方法
    • @After后置通知
    • @AfterReturnin返回通知或@AfterThrowing异常通知
    • @Around环绕通知后置操作
  • Spring版本5.2.7一千：
    • @Around环绕通知前置操作
    • @Before前置通知
    • 目标方法
    • @Around环绕通知后置操作
    • @After后置通知
    • @AfterReturnin返回通知或@AfterThrowing异常通知

2. 示例

/**
 * 接口类
 */
public interface CalculatorService {
    
    int add(int i, int j);
    
    int sub(int i, int j);
    
    int mul(int i, int j);
    
    int div(int i, int j);
    
}

import com.example.aop.service.CalculatorService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * 接口实现类
 */
@Slf4j
@Component
public class CalculatorServiceImpl implements CalculatorService {

    @Override
    public int add(int i, int j) {
        int result = i + j;
        log.info("方法内部 result = {}", result);
        // 为了测试效果，模拟异常信息
        // int a = 1/0;
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        log.info("方法内部 result ={} ", result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        log.info("方法内部 result ={} ", result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        log.info("方法内部 result = {}", result);
        return result;
    }


}

切面类

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * 自定义日志切面类
 *
 * @author : Sakura
 * @className : LogAspect
 * @description : 日志切面类
 */
@Component  // 交由IoC容器进行管理
@Aspect     // 声明为切面类
@Slf4j
public class LogAspect {

    // 设置切入点和通知类型

    /**
     * 前置通知：在被代理的目标方法前执行
     * 设置前置通知  @Before(value = "切入点表达式配置切入点")
     * 切入点表达式：
     * 下面切入点设置为：public int CalculatorImpl 所有方法 任意参数类型
     */
    @Before(value = "execution(public int com.example.aop.service.impl.CalculatorServiceImpl.*(..))")
    public void beforeMethod(JoinPoint joinPoint) {
        // 使用JoinPoint获取方法签名、方法参数等相关信息
        // 获取方法名
        String methodName = joinPoint.getSignature().getName();
        // 获取方法参数
        Object[] args = joinPoint.getArgs();
        log.info("Logger--@Before前置通知，方法名称：{}，方法参数：{}", methodName, Arrays.toString(args));
    }


    /**
     * 返回通知：在被代理的目标方法成功结束后执行
     * 设置返回通知：  @AfterReturning(value = "切入点表达式配置切入点", returning = "res")
     * res: 目标方法的返回结果
     */
    @AfterReturning(value = "execution(public int com.example.aop.service.impl.CalculatorServiceImpl.*(..))", returning = "result")
    public void AfterReturningMethod(JoinPoint joinPoint, Object result) {
        // 使用JoinPoint获取方法签名、方法参数等相关信息
        // 获取方法名
        String methodName = joinPoint.getSignature().getName();
        // 获取方法参数
        Object[] args = joinPoint.getArgs();
        log.info("Logger--@AfterReturning返回通知，方法名称：{}，方法参数：{}，返回结果：{}", methodName, Arrays.toString(args), result);
    }


    /**
     * 后置通知：在被代理的目标方法最终结束后执行
     * 设置前置通知：  @After(value = "切入点表达式配置切入点")
     */
    @After(value = "execution(public int com.example.aop.service.impl.CalculatorServiceImpl.*(..))")
    public void afterMethod(JoinPoint joinPoint) {
        // 使用JoinPoint获取方法签名、方法参数等相关信息
        // 获取方法名
        String methodName = joinPoint.getSignature().getName();
        // 获取方法参数
        Object[] args = joinPoint.getArgs();
        log.info("Logger--@After后置通知，方法名称：{}，方法参数：{}", methodName, Arrays.toString(args));


    }

    /**
     * 异常通知：在被代理的目标方法异常结束后执行
     * 设置异常通知：  @AfterThrowing(value = "切入点表达式配置切入点", throwing = "ex")
     * ex: 代指异常信息
     */
    @AfterThrowing(value = "execution(public int com.example.aop.service.impl.CalculatorServiceImpl.*(..))", throwing = "ex")
    public void afterThrowingMethod(JoinPoint joinPoint, Throwable ex) {
        // 使用JoinPoint获取方法签名、方法参数等相关信息
        // 获取方法名
        String methodName = joinPoint.getSignature().getName();
        log.info("Logger--@AfterThrowing异常通知，方法名称：" + methodName + ",异常信息：" + ex.getMessage());

    }

    /**
     * 环绕通知：使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置
     * 设置异常通知：  @Around(value = "切入点表达式配置切入点)
     * 注：可以使用JoinPoint的子类 ProceedingJoinPoint 调用目标方法
     */
    @Around(value = "execution(public int com.example.aop.service.impl.CalculatorServiceImpl.*(..))")
    public Object aroundMethod(ProceedingJoinPoint joinPoint) {
        // 使用JoinPoint获取方法签名、方法参数等相关信息
        // 获取方法名
        String methodName = joinPoint.getSignature().getName();
        // 获取方法参数
        Object[] args = joinPoint.getArgs();
        Object result = null;
        try {
            log.info("Logger--@Around环绕通知——目标方法执行之前");
            // 使用JoinPoint的子类 ProceedingJoinPoint 调用目标方法
            result = joinPoint.proceed();
            log.info("Logger--@Around环绕通知——目标方法执行之后");
        } catch (Throwable e) {
            e.printStackTrace();
            log.info("Logger--@Around环绕通知——目标方法出现异常执行");
        } finally {
            log.info("Logger--@Around环绕通知——目标方法执行完毕后执行");
        }
        return result;
    }

}

测试：
当spring-aop版本为5.2.7.RELEASE:
目标方法正常执行

2024-07-08 17:06:54.148  INFO 260808 --- [           main] com.example.aop.config.LogAspect         : Logger--@Around环绕通知——目标方法执行之前
2024-07-08 17:06:54.148  INFO 260808 --- [           main] com.example.aop.config.LogAspect         : Logger--@Before前置通知，方法名称：add，方法参数：[2, 3]
2024-07-08 17:06:54.154  INFO 260808 --- [           main] c.e.a.s.impl.CalculatorServiceImpl       : 方法内部 result = 5
2024-07-08 17:06:54.154  INFO 260808 --- [           main] com.example.aop.config.LogAspect         : Logger--@AfterReturning返回通知，方法名称：add，方法参数：[2, 3]，返回结果：5
2024-07-08 17:06:54.154  INFO 260808 --- [           main] com.example.aop.config.LogAspect         : Logger--@After后置通知，方法名称：add，方法参数：[2, 3]
2024-07-08 17:06:54.154  INFO 260808 --- [           main] com.example.aop.config.LogAspect         : Logger--@Around环绕通知——目标方法执行之后
2024-07-08 17:06:54.154  INFO 260808 --- [           main] com.example.aop.config.LogAspect         : Logger--@Around环绕通知——目标方法执行完毕后执行

目标方法异常执行：

2024-07-08 17:06:05.156  INFO 320568 --- [           main] com.example.aop.config.LogAspect         : Logger--@Around环绕通知——目标方法执行之前
2024-07-08 17:06:05.156  INFO 320568 --- [           main] com.example.aop.config.LogAspect         : Logger--@Before前置通知，方法名称：add，方法参数：[2, 3]
2024-07-08 17:06:05.162  INFO 320568 --- [           main] c.e.a.s.impl.CalculatorServiceImpl       : 方法内部 result = 5
2024-07-08 17:06:05.163  INFO 320568 --- [           main] com.example.aop.config.LogAspect         : Logger--@AfterThrowing异常通知，方法名称：add,异常信息：/ by zero
2024-07-08 17:06:05.163  INFO 320568 --- [           main] com.example.aop.config.LogAspect         : Logger--@After后置通知，方法名称：add，方法参数：[2, 3]
2024-07-08 17:06:05.163  INFO 320568 --- [           main] com.example.aop.config.LogAspect         : Logger--@Around环绕通知——目标方法出现异常执行
2024-07-08 17:06:05.163  INFO 320568 --- [           main] com.example.aop.config.LogAspect         : Logger--@Around环绕通知——目标方法执行完毕后执行
java.lang.ArithmeticException: / by zero
	at com.example.aop.service.impl.CalculatorServiceImpl.add(CalculatorServiceImpl.java:19)
	at com.example.aop.service.impl.CalculatorServiceImpl$$FastClassBySpringCGLIB$$a70e6bfb.invoke(<generated>)

当spring-aop版本为5.2.6.RELEASE:
目标方法正常执行

2024-07-08 17:04:28.394  INFO 330008 --- [           main] com.example.aop.config.LogAspect         : Logger--@Around环绕通知——目标方法执行之前
2024-07-08 17:04:28.394  INFO 330008 --- [           main] com.example.aop.config.LogAspect         : Logger--@Before前置通知，方法名称：add，方法参数：[2, 3]
2024-07-08 17:04:28.400  INFO 330008 --- [           main] c.e.a.s.impl.CalculatorServiceImpl       : 方法内部 result = 5
2024-07-08 17:04:28.400  INFO 330008 --- [           main] com.example.aop.config.LogAspect         : Logger--@Around环绕通知——目标方法执行之后
2024-07-08 17:04:28.400  INFO 330008 --- [           main] com.example.aop.config.LogAspect         : Logger--@Around环绕通知——目标方法执行完毕后执行
2024-07-08 17:04:28.400  INFO 330008 --- [           main] com.example.aop.config.LogAspect         : Logger--@After后置通知，方法名称：add，方法参数：[2, 3]
2024-07-08 17:04:28.401  INFO 330008 --- [           main] com.example.aop.config.LogAspect         : Logger--@AfterReturning返回通知，方法名称：add，方法参数：[2, 3]，返回结果：5

目标方法异常执行，可以看到 5.2.6.RELEASE@Around通知导致异常被捕获了，没有触发 @AfterThrowing 通知，反而触发了 @AfterReturning 通知方法的执行；而5.2.7.RELEASE触发 了@AfterThrowing 通知

2024-07-08 17:04:57.640  INFO 315420 --- [           main] com.example.aop.config.LogAspect         : Logger--@Around环绕通知——目标方法执行之前
2024-07-08 17:04:57.640  INFO 315420 --- [           main] com.example.aop.config.LogAspect         : Logger--@Before前置通知，方法名称：add，方法参数：[2, 3]
2024-07-08 17:04:57.647  INFO 315420 --- [           main] c.e.a.s.impl.CalculatorServiceImpl       : 方法内部 result = 5
2024-07-08 17:04:57.647  INFO 315420 --- [           main] com.example.aop.config.LogAspect         : Logger--@Around环绕通知——目标方法出现异常执行
2024-07-08 17:04:57.648  INFO 315420 --- [           main] com.example.aop.config.LogAspect         : Logger--@Around环绕通知——目标方法执行完毕后执行
2024-07-08 17:04:57.648  INFO 315420 --- [           main] com.example.aop.config.LogAspect         : Logger--@After后置通知，方法名称：add，方法参数：[2, 3]
2024-07-08 17:04:57.648  INFO 315420 --- [           main] com.example.aop.config.LogAspect         : Logger--@AfterReturning返回通知，方法名称：add，方法参数：[2, 3]，返回结果：null
java.lang.ArithmeticException: / by zero
	at com.example.aop.service.impl.CalculatorServiceImpl.add(CalculatorServiceImpl.java:19)
	at com.example.aop.service.impl.CalculatorServiceImpl$$FastClassBySpringCGLIB$$a70e6bfb.invoke(<generated>)
Mr_Richard
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring aop两种配置方式
09-03
3. 在Spring的配置文件中，使用<aop:config>元素声明切面，使用<aop:advisor>元素定义通知。例如，创建一个名为myAspect的切面，定义一个切入点表达式，并添加前置通知： ```xml <aop:config> <aop:aspect id=...
一步一步手绘spring AOP时序图.rar
05-17
时序图会展示在调用目标方法前、后以及可能出现的异常处理时，各个通知如何按照顺序执行。这种图形化的方式有助于开发者更好地理解和设计AOP应用场景。 总结来说，Spring AOP是Spring框架中用于解决横切关注点的...
Spring AOP 通知执行顺序
Solitary_Han的博客
11-23 1021
1）当多个切面的通知切入到同一个切入点时，他们的执行顺序是什么样的？可以调整顺序吗？ 2）当一个切面的多个不同类型通知切入到同一切入点时，他的执行顺序是什么样的？ 3）当一个切面的多个相同类型通知切入到同一切入点时，他的执行顺序是什么样的？ 首先： Spring官网文档中关于 AOP的执行顺序描述已经很详细【Version 5.3.6】：Core Technologies 来，练练英语： Advice Ordering What happens when multipl...
Spring aop通知代码执行顺序
Yk6247650的博客
02-20 221
Spring aop通知代码执行顺序
Spring AOP - 通知方法的执行顺序
paralysed的博客
09-26 979
前言 我们知道可以通过注解的方式来定义通知方法，如 @Before，@After 等，那么当执行连接点方法的时候这些通知方法的执行的执行顺序是什么呢？本篇文章就是探讨这个问题的，关于 advisor, pointCut,切面等定义以及生成 advisor 的时间点前面文章都已经介绍过，所以本篇只讨论 advisor 数组排序相关的内容。 第一次排序，遍历切面方法时排序 我们知道，生成 advisor 实例首先要解析切面类，更准确的说是解析通知方法上的注解，根据不同的注解...
Spring之AOP通知顺序
weixin_42972832的博客
02-05 506
一、面试题： 1、Aop 的全部通知顺序 以及Springboot 或 Springboot2 对 Aop 的执行顺序影响 2、说说你使用 Aop 中碰到的坑 二、Spring4,5与SpringBoot1,2的关联以及对通知的影响 一、前置代码准备 1、service层 接口： public interface CalcService { public int div(int x, int y); } 实现类： @Service public class CalcServiceIm
Spring-AOP通知和执行顺序？
越努力越幸运。
01-04 484
1、正常执行：前置--->方法---->返回--->后置。2、异常执行：前置--->方法---->异常--->后置。
Spring Aop通知注解的执行顺序
weixin_57869541的博客
10-04 298
Spring Aop通知注解的执行顺序
Spring AOP 的执行顺序详解
公众号：Java后端
03-28 952
本文内容重点：问题描述Spring AOP执行顺序探究顺序错误的真相代码验证结论问题描述公司新项目需要搭建一个新的前后分离HTTP服务，我选择了目前比较熟悉的SpringBoot Web...
Spring AOP 通知执行顺序《三》不同切面相同类型通知顺序
灵颖桥人的博客
05-17 1096
同一切面中的同一类型通知的执行顺序 Spring 官方文档中是这样描述的：当在不同切面定义的两条相同类型通知都需要在同一连接点上运行时，除非另行指定，否则执行顺序是不确定的。 您可以通过指定优先级来控制执行顺序。 通过在切面类中实现 org.springframework.core.Ordered 接口或使用 @Order 注解对其进行注解。 给定两个切面，从 Ordered.getValue()（或 @Order 注解值）返回较低值的切面具有较高的优先级。 @Order 注...
Spring系列：Spring AOP 通知与顺序详解
HongYu012的博客
03-22 289
本文内容 如何声明通知 如何传递参数到通知方法中 多种通知多个切面的通知顺序 多个切面通知的顺序源码分析与图解 声明通知 Spring中有5种通知，通过对应的注解来声明： @BeforeBefore 通知，用于方法执行前增强 @AfterReturning：After Returning 通知，方法正常执行返回后增强 @AfterThrowing：After Throwing 通知，方法执行通过抛出异常退出时 @After：After (Finally) 通知，方法执行退出时执行增...
Spring——AOP中五大通知功能的执行顺序（完全注解开发）
胜天半子祁同伟
06-25 6387
Spring AOP中五大通知功能的执行顺序（完全注解开发）
spring 应用aop 实例
07-10
切入点则是定义一组连接点的表达式，决定哪些连接点会被通知执行。织入是指将切面应用到目标对象，创建代理的过程，这可以在编译时、类加载时或运行时完成。 在Spring中实现AOP，我们需要做以下几步： 1. **配置...
Java进阶之SpringAOP应用共16页.pdf.zi
11-20
本资料"Java进阶之SpringAOP应用共16页.pdf"深入探讨了Spring AOP在实际开发中的应用和实现原理，旨在提升Java开发者的技能水平。 首先，理解AOP的基本概念至关重要。AOP是一种编程范式，它将关注点分离为不同的...
Spring Boot如何使用AOP实例解析
08-19
在使用AOP时，我们需要注意的是，AOP的执行顺序是按照定义的顺序执行的。例如，如果我们定义了多个前置通知，那么它们将按照定义的顺序执行。 在本文中，我们通过示例代码详细地介绍了如何在Spring Boot中使用AOP...
SpringBoot 如何处理跨域请求？你说的出几种方法？
2401_84419325的博客
07-02 896
1）什么是跨域请求？跨域请求（Cross-Origin Request）指的是在浏览器环境下，前端代码发起的请求与当前页面的域名（或端口、协议）不同。浏览器的同源策略（Same-Origin Policy）限制了从一个源（域名、协议、端口组成的组合）加载的文档或脚本如何与来自另一个源的资源进行交互。具体来说，如果一个页面加载自 http://domain1.com，则它的同源策略默认限制了对 http://domain2.com 发起的请求。2）为什么会出现跨域问题？
SpringBoot AOP切入点表达式
最新发布
生产队的驴
07-05 183
在AOP中可以通过@Around注解来定义 切入点表达式来控制被监控的方法。匹配 com.example.service 包中的任何类的 save 方法，且方法参数为 java.lang.String 类型。
学习springMVC
weixin_45621552的博客
07-03 495
JSR全称为 Java Specification Requests，表示 Java 规范提案。JSR-303是 Java 为 Java Bean 数据合法性校验提供的标准框架，它定义了一套可标注在成员变量，属性方法上的校验注解。Hibernate Validatior提供了这套标准的实现。-- 最新7.0.1.Final --> </ dependency >-- 最新7.0.1.Final --> </ dependency ></
基于Java+SpringMvc+Vue技术智慧校园系统设计与实现--60页及以上论文参考
mr_lili_111的博客
07-05 656
Java是一种面向对象的编程语言，目前由美国Oracle公司开发。自1995年上线以来，已经广泛应用于Web开发、桌面应用开发等多个领域。Java语言的特点包括：1、面向对象：Java提供了类、接口和继承等面向对象的特性，支持单继承和多接口继承，以及动态绑定。2、分布式：Java支持Internet应用的开发，提供了网络应用编程接口(java.net)，支持RMI(远程方法激活)机制，适合开发分布式应用。3、健壮性：Java的强类型机制、异常处理、垃圾自动收集等特性保证了程序的健壮性。
spring aop 事物执行顺序
04-16
在Spring AOP中，事务的执行顺序可以通过以下步骤来理解： 1. 首先，Spring会检查是否存在与事务相关的注解（如`@Transactional`），如果存在，则会启动事务管理器。 2. 接下来，Spring会在方法执行之前创建一个事务，并将其绑定到当前线程上。 3. 在方法执行之前，Spring会检查是否存在与事务相关的通知（如`@Before`），并在方法执行之前执行这些通知。 4. 然后，方法会被执行，包括其中的业务逻辑。 5. 如果方法执行成功，Spring会提交事务，并将其从当前线程上解绑。 6. 如果方法执行过程中发生异常，Spring会回滚事务，并将其从当前线程上解绑。 7. 最后，Spring会检查是否存在与事务相关的通知（如`@After`或`@AfterReturning`），并在方法执行之后执行这些通知。 总结起来，Spring AOP中事务的执行顺序为：事务创建 -> 前置通知 -> 方法执行 -> 后置通知/返回通知 -> 提交事务/回滚事务。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值