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

最新推荐文章于 2026-03-22 22:06:22 发布
转载 最新推荐文章于 2026-03-22 22:06:22 发布 · 1.2k 阅读 · 4 ·
CC 4.0 BY-SA版权
原文链接：https://www.cnblogs.com/orzjiangxiaoyu/p/13869747.html
文章标签：

#spring #java #后端

通知的选取规则

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

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

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

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执行顺序
liangsheng_g的专栏
01-26 4272
Spring中的Advisors的执行顺序
Spring AOP 通知的执行顺序
Mr_Richard的博客
07-08 1227
Around通知导致异常被捕获了，没有触发 @AfterThrowing 通知，反而触发了 @AfterReturning 通知方法的执行；触发 了@AfterThrowing 通知。当spring-aop版本为。当spring-aop版本为。目标方法异常执行，可以看到。
Java高频面试题：Spring-AOP通知和执行顺序？
最新发布
java1234的博客
03-22 302
Spring AOP提供了五种通知类型：前置通知（Before）、后置通知（AfterReturning）、异常通知（AfterThrowing）、最终通知（After）和环绕通知（Around）。执行顺序为：环绕通知前半部分→前置通知→目标方法→环绕通知后半部分→后置通知（正常情况）或异常通知（异常情况）→最终通知。环绕通知可控制目标方法执行，异常情况下后置通知不执行。多个通知的执行顺序可通过@Order注解控制，数值越小优先级越高。
深入解析Spring AOP切面优先级与执行顺序
不会说话の猴子的博客
02-14 1585
在Spring AOP（面向切面编程）中，切面（Aspect）是用于在方法执行前后插入额外逻辑的机制。当多个切面作用于同一个方法时，它们的执行顺序由切面的优先级决定。本文将从一个具体的场景出发，探讨当两个切面（Aspect A和Aspect B）同时作用于同一个方法时，它们的执行顺序以及背后的原理。我们将结合JDK 相关源码，深入分析Spring AOP的实现机制。
Spring Aop的使用和通知注解的执行顺序
JemeryShen的专栏
05-14 3644
AOP通知注解执行顺序
Spring中AOP的通知类型和执行顺序
weixin_46665411的博客
07-23 1495
@Around：环绕通知，此注解标注的通知方法在目标方法前、后都被执行 @Before：前置通知，此注解标注的通知方法在目标方法前被执行 @After ：后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行 @AfterReturning ： 返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行 @AfterThrowing ： 异常后通知，此注解标注的通知方法发生异常后执行
面试官：Spring AOP的通知注解有哪些？它们的执行顺序是什么？
Like0703的博客
02-18 1477
Aspect@ComponentSystem.out.println("@Around开始");System.out.println("@Around结束");通知类型：5种注解覆盖方法执行全生命周期。执行顺序@Around包裹所有通知，@After类似finally始终执行。源码逻辑：通过拦截器链按顺序触发通知。
Spring中AOP注解的使用说明及通知的执行顺序问题
Java全栈领域/离线地图/微服务
01-16 7898
步骤： 1.环境搭建：项目结构 com |_ xiaozhang |_ service ...
Spring 基于注解的AOP配置注意事项:通知类方法的执行顺序
banmingi的博客
05-30 1229
Spring 基于注解的AOP配置注意事项 通知类方法的执行顺序 基于XML: 前置通知(Before) → 后置通知(AfterRunning)/异常通知(AfterThrowing) → 最终通知(After) 基于注解 前置通知(Before) → 最终通知(After) → 后置通知(AfterRunning)/异常通知(AfterThrowing) 所以,基于注解的AOP配置通知类的方法...
spring aop通知类型注解方法执行顺序
yngzh的博客
01-02 484
【代码】spring aop通知类型注解方法执行顺序。
AOP切面执行顺序
zijikanwa
05-07 8827
文章目录一. 概述二. 讲述1. 单切面中各通知方法的执行顺序2. 多切面中各通知方法的执行顺序3. 多切面的通知方法中抛出异常参考资料 一. 概述 本文主要讲述以下几点 单AOP切面时，各通知方法的执行顺序。 多AOP切面时，多切面的执行顺序和各通知方法的执行顺序。 二. 讲述 1. 单切面中各通知方法的执行顺序 单切面中各通知方法执行顺序·总结 spring aop就是一个同心圆，以要执行的方法为圆心。从最外层按照依次执行切面的@Around方法，@Before方法。然后执行method
spring （四）AOP源码分析 五种通知的执行顺序
Ethan_199402的博客
11-05 3667
之前面的时候被问到有没有了解AOP的增强，当时我一脸懵逼 ，什么是增强？后来查了下，增强也就时通知。 通知的执行顺序 1、首先是目标方法没有异常的情况： 环绕通知、前置通知、目标方法、环绕通知，后置通知、返回通知 2、目标方法有异常的顺序： 环绕通知、前置通知、目标方法、后置通知、异常通知 所以各通知执行时机为 @Around：环绕通知：前置通知之前执行proceed方法之前的部分 @Before：前置通知，目标方法之前执行 @Around：环绕通知：目标方法执行之后执行proceed方法之后的部分 @Af
面试官常问：Spring AOP有哪些通知类型，它们的执行顺序是怎样的？
Java后端架构V
05-28 456
在基于Spring AOP编程的过程中，基于AspectJ框架标准，spring中定义了五种类型的通知，它们分别是：前置通知 (@Before)。返回通知 (@AfterReturning)。异常通知 (@AfterThrowing)。后置通知 (@After)。环绕通知 (@Around) :（优先级最高）通知执行顺序将上面的所有通知类型写入同一个切面中，它的执行顺序为：需要获取以下这些面试题答案以及学习资料得话麻烦关注+好评之后直接点击此链接→即可免费获取哦~~
Spring aop通知代码执行顺序
Yk6247650的博客
02-20 342
Spring aop通知代码执行顺序
AOP的通知类型及其执行顺序
weixin_70001451的博客
12-01 808
AOP的通知类型和执行顺序
AOP切面中通知的执行顺序
weixin_43873239的博客
01-24 984
在面向切面编程（AOP）中，切面（Aspect）的执行顺序是指不同切面或通知（Advice）在目标方法执行过程中的调用顺序。了解和控制这个顺序是非常重要的，特别是当你的应用程序中有多个切面都应用于同一个连接点（如同一个方法）时。
Spring的AOP
weixin_30682415的博客
06-13 204
AOP面向切面编程Spring是基于Aspectj的AOP开发 AOP的底层原理就是动态代理 动态代理分两种JDK动态代理：只能对实现了接口的类产生代理Cglib动态代理：第三方代理技术，对没有实现接口的类产生代理对象，生成子类对象，可以动态添加类的属性和方法 Spring会根据是否有接口自动选择相应的代理 术语：连接点：可以被拦截的点切入点：真正被拦截的点通知：增强方法...
AOP（面向切面编程）的执行顺序
qq_41748678的博客
01-14 1182
AOP（面向切面编程）的执行顺序是先执行代理对象动态绑定到目标对象，然后在目标对象方法执行前执行前置通知，接着执行目标对象的方法，最后在目标对象方法执行后执行后置通知。所以正确的执行顺序是：代理对象动态绑定到目标对象 -> 前置通知 -> 目标对象方法 -> 后置通知。
没有异常情况下的Spring AOP通知的执行顺序
学亮编程手记
11-22 710
如果没有异常抛出，在正常情况下，通知的执行顺序是前置通知 → 环绕通知（前置部分）→ 目标方法执行 → 环绕通知（后置部分）→ 返回通知 → 后置通知。需要注意的是，环绕通知可以完全控制目标方法的执行，包括是否执行目标方法以及在何时执行。因此，环绕通知可以在前置通知和后置通知之间包含目标方法的执行。在目标方法执行之前和之后，环绕通知都可以执行自定义的逻辑。后置通知在目标方法执行之后（无论是否发生异常）执行。返回通知在目标方法成功执行并返回结果后执行。前置通知在目标方法执行之前执行。
spring多个AOP执行先后顺序记录
前端kk的博客
08-15 6087
spring多个AOP执行先后顺序记录 order越小越是最先执行，最先执行的最后结束。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值