Spring-AOP-基于注解的AOP通知执行顺序

最新推荐文章于 2025-06-10 12:09:47 发布
最新推荐文章于 2025-06-10 12:09:47 发布
阅读量1k 收藏 4
点赞数
CC 4.0 BY-SA版权
文章标签： spring java 后端
原文链接：https://www.cnblogs.com/orzjiangxiaoyu/p/13869747.html

通知的选取规则

五大通知类型中，环绕通知功能最为强大，因为环绕通知，可以控制目标方法是否执行。

如果需要记录异常信息，使用异常通知。

其他通知，只能做记录工作，不能做处理，所以执行顺序其实对整个程序影响不大，没有必要太深究。

Spring版本不一样，通知执行顺序可能也会存在差异

下面以Spring4.0版本、Spring5.28版本进行测试

一、单个切面类

（1）@Before、@After、@AfterReturning、@AfterThrowing执行顺序

　　①Spring4.0

　　正常情况：@Before=====目标方法=====@After=====@AfterReturning

　　 异常情况：@Before=====目标方法=====@After=====@AfterThrowing

　　②Spring5.28

　　正常情况：@Before=====目标方法=====@AfterReturning=====@After

　　 异常情况：@Before=====目标方法=====@AfterThrowing=====@After

@Service
public class BookService {

    public int add(int i,int j)
    {
        int result=i+j;
        System.out.println("目标方法执行");
        //System.out.println(1/0);
        return result;
    }
}


@Aspect
@Component
public class BookServiceProxy {

    @Pointcut(value = "execution(* com.orz.spring.aop.BookService.add(..))")
    public void myPointCut(){}

    @Before(value = "myPointCut()")
    public void before()
    {
        System.out.println("@Before");
    }

    @After(value = "myPointCut()")
    public void after()
    {
        System.out.println("@After");
    }
    @AfterReturning(value = "myPointCut()")
    public void afterReturning()
    {
        System.out.println("@AfterReturning");
    }
    @AfterThrowing(value = "myPointCut()")
    public void afterThrowing()
    {
        System.out.println("@AfterThrowing");
    }
}


@Test
public void test2()
{
    ApplicationContext applicationContext=new ClassPathXmlApplicationContext("bean2.xml");
    BookService bookService = applicationContext.getBean("bookService", BookService.class);
    bookService.add(1,2);
}



Spring4.0

正常情况
@Before
目标方法执行
@After
@AfterReturning

异常情况
@Before
目标方法执行
@After
@AfterThrowing



Spring5.28

正常情况
@Before
目标方法执行
@AfterReturning
@After

异常情况
@Before
目标方法执行
@AfterThrowing
@After

（2）@Around的执行顺序

@Around(value = "myPointCut()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint)
    {
        Object[] args = proceedingJoinPoint.getArgs();
        Object result=null;
        try {
            //前置通知@Before
            System.out.println("环绕前置通知");
            //目标方法执行
            result = proceedingJoinPoint.proceed(args);
            //环绕返回通知@AfterReturning
            System.out.println("环绕返回通知");
        } catch (Throwable throwable) {
            //环绕异常通知@AfterThrowing
            System.out.println("环绕异常通知");
            throw new RuntimeException(throwable);
        } finally {
            //最终通知@After
            System.out.println("环绕最终通知");
        }
        return result;
    }

　　①Spring4.0

　　　　正常情况：环绕前置=====目标方法执行=====环绕返回=====环绕最终

　　　　异常情况：环绕前置=====目标方法执行=====环绕异常=====环绕最终

　　②Spring5.28

　　　　正常情况：环绕前置=====目标方法执行=====环绕返回=====环绕最终

　　　　异常情况：环绕前置=====目标方法执行=====环绕异常=====环绕最终

@Service
public class BookService {

    public int add(int i,int j)
    {
        int result=i+j;
        System.out.println("目标方法执行");
        return result;
    }
}

@Aspect
@Component
public class BookServiceProxy {

    @Pointcut(value = "execution(* com.orz.spring.aop.BookService.add(..))")
    public void myPointCut(){}

    @Around(value = "myPointCut()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint)
    {
        Object[] args = proceedingJoinPoint.getArgs();
        Object result=null;
        try {
            //前置通知@Before
            System.out.println("环绕前置通知");
            //目标方法执行
            result = proceedingJoinPoint.proceed(args);
            //环绕返回通知@AfterReturning
            System.out.println("环绕返回通知");
        } catch (Throwable throwable) {
            //环绕异常通知@AfterThrowing
            System.out.println("环绕异常通知");
            throw new RuntimeException(throwable);
        } finally {
            //最终通知@After
            System.out.println("环绕最终通知");
        }
        return result;
    }
}

@Test
public void test2()
{
    ApplicationContext applicationContext=new ClassPathXmlApplicationContext("bean2.xml");
    BookService bookService = applicationContext.getBean("bookService", BookService.class);
    bookService.add(1,2);
}


Spring4.0

环绕前置通知
目标方法执行
环绕返回通知
环绕最终通知

异常情况
环绕前置通知
目标方法执行
环绕异常通知
环绕最终通知


Spring5.28

正常情况
环绕前置通知
目标方法执行
环绕返回通知
环绕最终通知

异常情况
环绕前置通知
目标方法执行
环绕异常通知
环绕最终通知

（3）五大通知执行顺序

　　①Spring4.0

　　　　正常情况：环绕前置=====@Before======目标方法执行=====环绕返回=====环绕最终=====@After=====@AfterReturning

　　　　异常情况：环绕前置=====@Before======目标方法执行=====环绕异常=====环绕最终=====@After=====@AfterThrowing

　　②Spring5.28

　　　　正常情况：环绕前置=====@Before=====目标方法执行=====@AfterReturning=====@After=====环绕返回=====环绕最终

　　　　异常情况：环绕前置=====@Before=====目标方法执行=====@AfterThrowing=====@After=====环绕异常=====环绕最终

@Service
public class BookService {

    public int add(int i,int j)
    {
        int result=i+j;
        System.out.println("目标方法执行");
        //System.out.println(1/0);
        return result;
    }
}

@Aspect
@Component
public class BookServiceProxy {

    @Pointcut(value = "execution(* com.orz.spring.aop.BookService.add(..))")
    public void myPointCut(){}

    @Before(value = "myPointCut()")
    public void before()
    {
        System.out.println("@Before");
    }

    @After(value = "myPointCut()")
    public void after()
    {
        System.out.println("@After");
    }
    @AfterReturning(value = "myPointCut()")
    public void afterReturning()
    {
        System.out.println("@AfterReturning");
    }
    @AfterThrowing(value = "myPointCut()")
    public void afterThrowing()
    {
        System.out.println("@AfterThrowing");
    }

    @Around(value = "myPointCut()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint)
    {
        Object[] args = proceedingJoinPoint.getArgs();
        Object result=null;
        try {
            //前置通知@Before
            System.out.println("环绕前置通知");
            //目标方法执行
            result = proceedingJoinPoint.proceed(args);
            //环绕返回通知@AfterReturning
            System.out.println("环绕返回通知");
        } catch (Throwable throwable) {
            //环绕异常通知@AfterThrowing
            System.out.println("环绕异常通知");
            throw new RuntimeException(throwable);
        } finally {
            //最终通知@After
            System.out.println("环绕最终通知");
        }
        return result;
    }
}

@Test
public void test2()
{
    ApplicationContext applicationContext=new ClassPathXmlApplicationContext("bean2.xml");
    BookService bookService = applicationContext.getBean("bookService", BookService.class);
    bookService.add(1,2);
}


Spring4.0

正常情况
环绕前置通知
@Before
目标方法执行
环绕返回通知
环绕最终通知
@After
@AfterReturning

异常情况
环绕前置通知
@Before
目标方法执行
环绕异常通知
环绕最终通知
@After
@AfterThrowing



Spring5.28
正常情况
环绕前置通知
@Before
目标方法执行
@AfterReturning
@After
环绕返回通知
环绕最终通知

异常情况
环绕前置通知
@Before
目标方法执行
@AfterThrowing
@After
环绕异常通知
环绕最终通知

二、多个切面

 　　①Spring4.0

　　　　正常情况：切面1环绕前置===切面1@Before===切面2环绕前置===切面2@Before===目标方法执行===切面2环绕返回===切面2环绕最终===切面2@After===切面2@AfterReturning===切面1环绕返回===切面1环绕最终===切面1@After===切面1@AfterThrowing

　　　　异常情况：切面1环绕前置===切面1@Before===切面2环绕前置===切面2@Before===目标方法执行===切面2环绕异常===切面2环绕最终===切面2@After===切面2@AfteThrowing===切面1环绕异常===切面1环绕最终===切面1@After===切面1@AfterThrowing

　　②Spring5.28

　　　　正常情况：切面1环绕前置===切面1@Before===切面2环绕前置===切面2@Before===目标方法执行===切面2@AfterReturning===切面2@After===切面2环绕返回===切面2环绕最终===切面1@AfterReturning===切面1@After===切面1环绕返回===切面1环绕最终

　　　　异常情况：切面1环绕前置===切面1@Before===切面2环绕前置===切面2@Before===目标方法执行===切面2@AfterThrowing===切面2@After===切面2环绕异常===切面2环绕最终===切面1@AfterThrowing===切面1@After===切面1环绕异常===切面1环绕最终

@Service
public class BookService {

    public int add(int i,int j)
    {
        int result=i+j;
        System.out.println("目标方法执行");
        //System.out.println(1/0);
        return result;
    }
}

@Aspect
@Component
public class BookServiceProxy {

    @Pointcut(value = "execution(* com.orz.spring.aop.BookService.add(..))")
    public void myPointCut(){}

    @Before(value = "myPointCut()")
    public void before()
    {
        System.out.println("切面一：@Before");
    }

    @After(value = "myPointCut()")
    public void after()
    {
        System.out.println("切面一：@After");
    }
    @AfterReturning(value = "myPointCut()")
    public void afterReturning()
    {
        System.out.println("切面一：@AfterReturning");
    }
    @AfterThrowing(value = "myPointCut()")
    public void afterThrowing()
    {
        System.out.println("切面一：@AfterThrowing");
    }

    @Around(value = "myPointCut()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint)
    {
        Object[] args = proceedingJoinPoint.getArgs();
        Object result=null;
        try {
            //前置通知@Before
            System.out.println("切面一：环绕前置通知");
            //目标方法执行
            result = proceedingJoinPoint.proceed(args);
            //环绕返回通知@AfterReturning
            System.out.println("切面一：环绕返回通知");
        } catch (Throwable throwable) {
            //环绕异常通知@AfterThrowing
            System.out.println("切面一：环绕异常通知");
            throw new RuntimeException(throwable);
        } finally {
            //最终通知@After
            System.out.println("切面一：环绕最终通知");
        }
        return result;
    }
}

@Test
public void test2()
{
    ApplicationContext applicationContext=new ClassPathXmlApplicationContext("bean2.xml");
    BookService bookService = applicationContext.getBean("bookService", BookService.class);
    bookService.add(1,2);
}

Spring4.0
正常情况
切面一：环绕前置通知
切面一：@Before
切面二：环绕前置通知
切面二：@Before
目标方法执行
切面二：环绕返回通知
切面二：环绕最终通知
切面二：@After
切面二：@AfterReturning
切面一：环绕返回通知
切面一：环绕最终通知
切面一：@After
切面一：@AfterReturning

异常情况
切面一：环绕前置通知
切面一：@Before
切面二：环绕前置通知
切面二：@Before
目标方法执行
切面二：环绕异常通知
切面二：环绕最终通知
切面二：@After
切面二：@AfterThrowing
切面一：环绕异常通知
切面一：环绕最终通知
切面一：@After
切面一：@AfterThrowing


Spring5.28
正常情况
切面一：环绕前置通知
切面一：@Before
切面二：环绕前置通知
切面二：@Before
目标方法执行
切面二：@AfterReturning
切面二：@After
切面二：环绕返回通知
切面二：环绕最终通知
切面一：@AfterReturning
切面一：@After
切面一：环绕返回通知
切面一：环绕最终通知

异常情况
切面一：环绕前置通知
切面一：@Before
切面二：环绕前置通知
切面二：@Before
目标方法执行
切面二：@AfterThrowing
切面二：@After
切面二：环绕异常通知
切面二：环绕最终通知
切面一：@AfterThrowing
切面一：@After
切面一：环绕异常通知
切面一：环绕最终通知

三、可以使用@Order注解指定先后顺序，数字越小，优先级越高，先进后出

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

可以使用@Order注解指定先后顺序，数字越小，优先级越高，先进后出

@Order(value = 1)

@Aspect

@Component

public class BookServiceProxy {}

@Order(value = 0)

@Aspect

@Component

public class BookServiceProxy2 {}

切面二：环绕前置通知

切面二：@Before

切面一：环绕前置通知

切面一：@Before

目标方法执行

切面一：@AfterReturning

切面一：@After

切面一：环绕返回通知

切面一：环绕最终通知

切面二：@AfterReturning

切面二：@After

切面二：环绕返回通知

切面二：环绕最终通知

转自：https://www.cnblogs.com/orzjiangxiaoyu/p/13869747.html

Java道哥
关注
Spring AOP 通知的执行顺序
Mr_Richard的博客
07-08 1063
Around通知导致异常被捕获了，没有触发 @AfterThrowing 通知，反而触发了 @AfterReturning 通知方法的执行；触发 了@AfterThrowing 通知。当spring-aop版本为。当spring-aop版本为。目标方法异常执行，可以看到。
spring-aop-jar
12-14
"spring-aop-jar"这个主题涉及到Spring框架中的核心组件之一——Spring AOP。这里我们将深入探讨Spring AOP、相关jar文件以及它们在实际开发中的作用。 首先，我们来看一下提供的文件： 1. aopalliance.jar：这是一...
Spring：AOP通知执行顺序
Eternal_Summer
03-14 1056
Spring：AOP通知执行顺序 1. AOP的通知 Before、After、AfterReturning、AfterThrowing、Around 2. AOP通知的执行顺序 切面代码： package com.itlearn.aspect; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; public class AccountAspect { public
Spring-AOP通知和执行顺序？
最新发布
java1234的博客
06-10 969
Spring-AOP通知和执行顺序？
Spring系列26：Spring AOP 通知与顺序详解
kongxubihai的博客
03-21 562
本文内容 如何声明通知 如何传递参数到通知方法中 多种通知多个切面的通知顺序 多个切面通知的顺序源码分析与图解 声明通知 Spring中有5种通知，通过对应的注解来声明： @BeforeBefore 通知，用于方法执行前增强 @AfterReturning ：After Returning 通知，方法正常执行返回后增强 @AfterThrowing：After Throwing 通知，方法执行通过抛出异常退出时 @After：After (Finally) 通知，方法执行退出时执行增强，不管是正常返回
spring （四）AOP源码分析 五种通知的执行顺序
Ethan_199402的博客
11-05 3397
之前面的时候被问到有没有了解AOP的增强，当时我一脸懵逼 ，什么是增强？后来查了下，增强也就时通知。 通知的执行顺序 1、首先是目标方法没有异常的情况： 环绕通知、前置通知、目标方法、环绕通知，后置通知、返回通知 2、目标方法有异常的顺序： 环绕通知、前置通知、目标方法、后置通知、异常通知 所以各通知执行时机为 @Around：环绕通知：前置通知之前执行proceed方法之前的部分 @Before：前置通知，目标方法之前执行 @Around：环绕通知：目标方法执行之后执行proceed方法之后的部分 @Af
Spring AOP 通知执行顺序
Solitary_Han的博客
11-23 1156
1）当多个切面的通知切入到同一个切入点时，他们的执行顺序是什么样的？可以调整顺序吗？ 2）当一个切面的多个不同类型通知切入到同一切入点时，他的执行顺序是什么样的？ 3）当一个切面的多个相同类型通知切入到同一切入点时，他的执行顺序是什么样的？ 首先： Spring官网文档中关于 AOP的执行顺序描述已经很详细【Version 5.3.6】：Core Technologies 来，练练英语： Advice Ordering What happens when multipl...
spring-aop
03-17
在实际使用Spring AOP时，可以通过注解或XML配置来定义切面。例如，我们可以使用`@Aspect`注解来声明一个类作为切面，使用`@Before`、`@After`等注解来定义通知，使用`@Pointcut`来定义切入点表达式。 以下是一些...
2024-spring-aop学习项目
01-26
1. 配置切面：在Spring配置文件中声明切面，定义切入点表达式，指定何时何地执行通知。 2. 定义通知：编写包含业务逻辑的通知方法，并通过注解@Before、@After、@Around、@AfterThrowing、@AfterReturning来标记执行...
commons-logging-1.1.3,spring-test-4.0.0.RELEASE,spring-aop-4.0.0.RELEASE
06-14
commons-logging-1.1.3,spring-test-4.0.0.RELEASE,spring-aop-4.0.0.RELEASE,spring-aspects-4.0.0.RELEASE
spring-boot aop
01-23
默认情况下，Spring使用基于Java的代理，但对于需要在静态方法或非Spring管理对象上应用AOP的情况，可能需要使用CGLIB或AspectJ字节码代理。 5. **理解代理行为**：理解Spring AOP代理的工作方式很重要，因为这可能...
Spring AOP执行先后顺序实例详解
08-25
主要介绍了Spring AOP执行先后顺序实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
AOP通知执行顺序
weixin_43278612的博客
04-02 235
AOP各通知执行顺序
Spring——AOP中五大通知功能的执行顺序（完全注解开发）
贝尔摩德苦艾酒
06-25 6736
Spring AOP中五大通知功能的执行顺序（完全注解开发）
[Spring] Aop 注解执行顺序
qq_40155680的博客
03-31 952
验证 @Around、@Before、@After、@AfterReturning、@AfterThrowing 执行顺序。
Spring Aop的使用和通知注解的执行顺序
JemeryShen的专栏
05-14 3518
AOP通知注解执行顺序
Spring之AOP通知顺序
weixin_42972832的博客
02-05 607
一、面试题： 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 常见注解和执行顺序
Java知音
02-16 490
点击关注公众号，实用技术文章及时了解来源：juejin.cn/post/7062506923194581029Spring 一开始最强大的就是 IOC / AOP 两大核心功能，我们今天一...
Spring AOP - 通知方法的执行顺序
paralysed的博客
09-26 1198
前言 我们知道可以通过注解的方式来定义通知方法，如 @Before，@After 等，那么当执行连接点方法的时候这些通知方法的执行的执行顺序是什么呢？本篇文章就是探讨这个问题的，关于 advisor, pointCut,切面等定义以及生成 advisor 的时间点前面文章都已经介绍过，所以本篇只讨论 advisor 数组排序相关的内容。 第一次排序，遍历切面方法时排序 我们知道，生成 advisor 实例首先要解析切面类，更准确的说是解析通知方法上的注解，根据不同的注解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值