spring aop中各个advice顺序

最新推荐文章于 2024-05-15 09:41:25 发布
最新推荐文章于 2024-05-15 09:41:25 发布
阅读量833 收藏
点赞数 1
分类专栏： java 文章标签： aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24912789/article/details/81606928
版权

背景

      项目中需要用到aop切面，但是切点方法上有@Transaction，我自定义了注解切面，但是不知道切点上两个注解切面，哪个先执行，哪个后执行。所以本文就通过实验测试各个aop切面的顺序。

 

测试DEMO

1.同一个aspect的不同advice

测试代码：

//spring aspect
@Aspect
@Component
public class BroundAspect {

    private  Logger logger = LoggerFactory.getLogger(BroundAspect.class);


    @Pointcut("@annotation(cn.wh.test.annotation.PostAction)")
    public void around() {

    }


    @Pointcut("@annotation(cn.wh.test.annotation.PostAction)")
    public void after() {

    }

    @Pointcut("@annotation(cn.wh.test.annotation.PostAction)")
    public void before() {

    }

    @Before("before()")
    public void beforeInterceptor1(JoinPoint joinPoint) {
        logger.info("beforeInterceptor1: 1-before");
    }

    @After("after()")
    public void afterInterceptor1(JoinPoint jp) {
        logger.info("afterInterceptor1: 1-after start.");
    }

    @AfterReturning("after()")
    public void afterReturningInterceptor1(JoinPoint jp) {
        logger.info("afterReturningInterceptor1: 1-afterReturning start.");
    }

    @AfterThrowing("after()")
    public void afterThrowing(JoinPoint joinPoint) {
        logger.info("afterThrowing1: 1-afterThrowing start.");
    }

    @Around("around()")
    public void aroundInterceptor1(ProceedingJoinPoint joinPoint) {

        logger.info("AroundAspect.aroundInterceptor1: 1-around start!!!");

        try {

            Object proceed = joinPoint.proceed();
        } catch (Throwable e) {
            logger.error("AroundAspect.interceptor1: 1-around error:msg={},e={}.", e.getMessage(), e);
            throw new RuntimeException(e);
        }

        logger.info("AroundAspect.aroundInterceptor1: 1-arount end!!!");

        return;
    }
}


//切点方法：
@Service
public class AspectService {

    private Logger logger = LoggerFactory.getLogger(AspectService.class);

    @PostAction("wh")
    public void testAspect() {
        logger.info("AspectService.testAspect: method body!!!");
        return;
    }
}

//测试代码:
@RunWith(SpringJUnit4ClassRunner.class)
@ComponentScan(basePackages = "cn.wh.test")
@EnableAspectJAutoProxy
public class AspectOrderTest {
    
    @Resource
    private AspectService aspectService;

    @Test
    public void testAspect() {
        try {
            aspectService.testAspect();
        } catch (Throwable t) {
            System.out.println("t= " + t);
        }

        System.out.println("over!!!");
    }
}

测试结果：

//正常执行:
15:56:33.308 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor1: 1-around start!!!
15:56:33.308 [main] INFO cn.wh.test.aspect.BroundAspect - beforeInterceptor1: 1-before
15:56:33.327 [main] INFO cn.wh.test.AspectService - AspectService.testAspect: method body!!!
15:56:33.327 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor1: 1-arount end!!!
15:56:33.327 [main] INFO cn.wh.test.aspect.BroundAspect - afterInterceptor1: 1-after start.
15:56:33.327 [main] INFO cn.wh.test.aspect.BroundAspect - afterReturningInterceptor1: 1-afterReturning start.
over!!!

//执行异常:
//在切点方法中抛runtimeException，afterThrowing会执行，如果异常不消耗则继续抛出
15:58:21.445 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor1: 1-around start!!!
15:58:21.445 [main] INFO cn.wh.test.aspect.BroundAspect - beforeInterceptor1: 1-before
15:58:21.459 [main] INFO cn.wh.test.AspectService - AspectService.testAspect: method body!!!
15:58:21.463 [main] INFO cn.wh.test.aspect.BroundAspect - afterInterceptor1: 1-after start.
15:58:21.463 [main] INFO cn.wh.test.aspect.BroundAspect - afterThrowing1: 1-afterThrowing start.
t= java.lang.RuntimeException: java.lang.RuntimeException: test exception.
over!!!

总结：

同一个aspect的各个advice执行顺序：

正常情况：around--->before--->目标方法--->around (end)--->after--->after returning

异常情况：around--->before--->目标方法--->around (end)--->after--->after throwing

2.同一个aspect的相同类型advice

在上面的aspect类中增加一个around方法

//第二个环绕通知
@Around("around()")
public void aroundInterceptor2(ProceedingJoinPoint joinPoint) {
    logger.info("AroundAspect.aroundInterceptor2: 2-around start!!!");
    try {
        Object proceed = joinPoint.proceed();
    } catch (Throwable e) {
        logger.error("AroundAspect.interceptor2: 2-around error:msg={},e={}.", e.getMessage(), e);
    }
    logger.info("AroundAspect.aroundInterceptor2: 2-arount end!!!");
    return;
}

测试结果：

16:09:38.342 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor1: 1-around start!!!
16:09:38.342 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor2: 2-around start!!!
16:09:38.342 [main] INFO cn.wh.test.aspect.BroundAspect - beforeInterceptor1: 1-before
16:09:38.355 [main] INFO cn.wh.test.AspectService - AspectService.testAspect: method body!!!
16:09:38.355 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor2: 2-arount end!!!
16:09:38.355 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor1: 1-arount end!!!
16:09:38.355 [main] INFO cn.wh.test.aspect.BroundAspect - afterInterceptor1: 1-after start.
16:09:38.355 [main] INFO cn.wh.test.aspect.BroundAspect - afterReturningInterceptor1: 1-afterReturning start.
over!!!

此时各个advice的order是相同的，将aroundInterceptor2---->aroundInterceptor：

//第二个环绕通知
@Around("around()")
public void aroundInterceptor(ProceedingJoinPoint joinPoint) {
    logger.info("AroundAspect.aroundInterceptor2: 2-around start!!!");
    try {
        Object proceed = joinPoint.proceed();
    } catch (Throwable e) {
        logger.error("AroundAspect.interceptor2: 2-around error:msg={},e={}.", e.getMessage(), e);
    }
    logger.info("AroundAspect.aroundInterceptor2: 2-arount end!!!");
    return;
}

16:12:50.827 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor2: 2-around start!!!
16:12:50.827 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor1: 1-around start!!!
16:12:50.827 [main] INFO cn.wh.test.aspect.BroundAspect - beforeInterceptor1: 1-before
16:12:50.843 [main] INFO cn.wh.test.AspectService - AspectService.testAspect: method body!!!
16:12:50.843 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor1: 1-arount end!!!
16:12:50.843 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor2: 2-arount end!!!
16:12:50.843 [main] INFO cn.wh.test.aspect.BroundAspect - afterInterceptor1: 1-after start.
16:12:50.843 [main] INFO cn.wh.test.aspect.BroundAspect - afterReturningInterceptor1: 1-afterReturning start.

结论：

order和aspect名字相同时，会比较intercept方法名，字母越小越在外层，但是advice的相对位置不会改变，比如before和around2

3.同一aspect，多组相同的advice

在上面aspect类中新增：

    //第2个环绕通知
    @Around("around()")
    public void aroundInterceptor3(ProceedingJoinPoint joinPoint) {
        logger.info("AroundAspect.aroundInterceptor3: 3-around start!!!");
        try {

            Object proceed = joinPoint.proceed();
        } catch (Throwable e) {
            logger.error("AroundAspect.interceptor3: 3-around error:msg={},e={}.", e.getMessage(), e);
        }
        logger.info("AroundAspect.aroundInterceptor3: 3-arount end!!!");
        return;
    }

    //第2个前置通知
    @Before("before()")
    public void beforeInterceptor3(JoinPoint joinPoint) {
        logger.info("beforeInterceptor3: 3-before");
    }

    //第2个后置通知
    @After("after()")
    public void afterInterceptor3(JoinPoint jp) {
        logger.info("afterInterceptor3: 3-after start.");
    }

    //第2个后置返回通知
    @AfterReturning("after()")
    public void afterReturningInterceptor3(JoinPoint jp) {
        logger.info("afterReturningInterceptor3: 3-afterReturning start.");
    }

    //第2个后置异常通知
    @AfterThrowing("after()")
    public void afterThrowing3(JoinPoint joinPoint) {
        logger.info("afterThrowing3: 3-afterThrowing start.");
    }

测试结果：

16:44:36.891 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor1: 1-around start!!!
16:44:36.891 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor3: 3-around start!!!
16:44:36.891 [main] INFO cn.wh.test.aspect.BroundAspect - beforeInterceptor1: 1-before
16:44:36.892 [main] INFO cn.wh.test.aspect.BroundAspect - beforeInterceptor3: 3-before
16:44:36.910 [main] INFO cn.wh.test.AspectService - AspectService.testAspect: method body!!!
16:44:36.911 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor3: 3-arount end!!!
16:44:36.911 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor1: 1-arount end!!!
16:44:36.911 [main] INFO cn.wh.test.aspect.BroundAspect - afterInterceptor1: 1-after start.
16:44:36.911 [main] INFO cn.wh.test.aspect.BroundAspect - afterInterceptor3: 3-after start.
16:44:36.911 [main] INFO cn.wh.test.aspect.BroundAspect - afterReturningInterceptor1: 1-afterReturning start.
16:44:36.911 [main] INFO cn.wh.test.aspect.BroundAspect - afterReturningInterceptor3: 3-afterReturning start.
over!!!

结论：

同一个aspect相同advice会根据intecept名字排序，字母越小越靠外，但是不同advice的相对位置不变

 

4.不同aspect类

删除上面aspect中的around2方法，增加一个新的aspect类：

@Aspect
@Component
public class AroundAspect2 {

    private Logger logger = LoggerFactory.getLogger(AroundAspect2.class);

    @Pointcut("@annotation(cn.wh.test.annotation.PostAction)")
    public void Around2(){

    }

    @Pointcut("@annotation(cn.wh.test.annotation.PostAction)")
    public void before2(){

    }

    @Pointcut("@annotation(cn.wh.test.annotation.PostAction)")
    public void after2() {

    }

    @Before("before2()")
    public void beforeInterceptor2(JoinPoint jp) {
        logger.info("beforeInterceptor2: 2-before start.");
    }

    @After("after2()")
    public void afterInterceptor2(JoinPoint joinPoint) {
        logger.info("afterInterceptor2: 2-after start.");
    }

    @AfterReturning("after2()")
    public void afterReturningInterceptor2(JoinPoint jp) {
        logger.info("afterReturningInterceptor2: 2-afterReturning start.");
    }

    @AfterThrowing("after2()")
    public void afterThrowing2(JoinPoint joinPoint) {
        logger.info("afterThrowing2: 2-afterThrowing start.");
    }

    @Around("Around2()")
    public void aroundInterceptor2(ProceedingJoinPoint joinPoint) {

        logger.info("aroundInterceptor2: 2-around start.");
        try {
            joinPoint.proceed();
        } catch (Throwable t) {
            logger.info("aroundInterceptor2: 2-t={}.", t);
        }
        logger.info("aroundInterceptor2: 2-around end.");
    }
}

bspect和aspect2都是默认的order，执行结果：

16:20:05.680 [main] INFO cn.wh.test.aspect.AroundAspect2 - aroundInterceptor2: 2-around start.
16:20:05.680 [main] INFO cn.wh.test.aspect.AroundAspect2 - beforeInterceptor2: 2-before start.
16:20:05.681 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Returning cached instance of singleton bean 'broundAspect'
16:20:05.681 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor1: 1-around start!!!
16:20:05.681 [main] INFO cn.wh.test.aspect.BroundAspect - beforeInterceptor1: 1-before
16:20:05.701 [main] INFO cn.wh.test.AspectService - AspectService.testAspect: method body!!!
16:20:05.701 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor1: 1-arount end!!!
16:20:05.701 [main] INFO cn.wh.test.aspect.BroundAspect - afterInterceptor1: 1-after start.
16:20:05.701 [main] INFO cn.wh.test.aspect.BroundAspect - afterReturningInterceptor1: 1-afterReturning start.
16:20:05.701 [main] INFO cn.wh.test.aspect.AroundAspect2 - aroundInterceptor2: 2-around end.
16:20:05.701 [main] INFO cn.wh.test.aspect.AroundAspect2 - afterInterceptor2: 2-after start.
16:20:05.701 [main] INFO cn.wh.test.aspect.AroundAspect2 - afterReturningInterceptor2: 2-afterReturning start.
over!!!

修改aspect2的order：

bspect实现ordered接口
@Override
public int getOrder() {
    return 1;
}



aspect2实现ordered接口
@Override
public int getOrder() {
    return 2;
}
16:34:27.669 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor1: 1-around start!!!
16:34:27.669 [main] INFO cn.wh.test.aspect.BroundAspect - beforeInterceptor1: 1-before
16:34:27.669 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Returning cached instance of singleton bean 'aroundAspect2'
16:34:27.670 [main] INFO cn.wh.test.aspect.AroundAspect2 - aroundInterceptor2: 2-around start.
16:34:27.670 [main] INFO cn.wh.test.aspect.AroundAspect2 - beforeInterceptor2: 2-before start.
16:34:27.686 [main] INFO cn.wh.test.AspectService - AspectService.testAspect: method body!!!
16:34:27.686 [main] INFO cn.wh.test.aspect.AroundAspect2 - aroundInterceptor2: 2-around end.
16:34:27.686 [main] INFO cn.wh.test.aspect.AroundAspect2 - afterInterceptor2: 2-after start.
16:34:27.686 [main] INFO cn.wh.test.aspect.AroundAspect2 - afterReturningInterceptor2: 2-afterReturning start.
16:34:27.686 [main] INFO cn.wh.test.aspect.BroundAspect - AroundAspect.aroundInterceptor1: 1-arount end!!!
16:34:27.686 [main] INFO cn.wh.test.aspect.BroundAspect - afterInterceptor1: 1-after start.
16:34:27.686 [main] INFO cn.wh.test.aspect.BroundAspect - afterReturningInterceptor1: 1-afterReturning start.
over!!!

结论：

order越小，越靠外层

 

 

结论

相同aspect：

order和aspect类名字相同，会根据intecept名排优先级，intecept名字字母越小越靠外层，不同advice的相对位置不变，例如:around在before之前

 

不同aspect：

首先根据order排优先级，order越小越靠外层，越大越靠内层;

order相同，比较aspect类名，越小越靠外层.

 

 

 

wanghao2349
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring aop 拦截业务方法，实现权限控制示例
08-31
Spring AOP（面向切面编程）是Spring框架中的一个重要组件，它允许我们在不修改业务代码的情况下，通过代理机制对特定的“切点”（方法、类等）进行增强，实现如日志记录、事务管理、权限控制等功能。在这个示例中，...
AOP切面中通知的执行顺序
weixin_43873239的博客
01-24 569
在面向切面编程（AOP）中，切面（Aspect）的执行顺序是指不同切面或通知（Advice）在目标方法执行过程中的调用顺序。了解和控制这个顺序是非常重要的，特别是当你的应用程序中有多个切面都应用于同一个连接点（如同一个方法）时。
Spring AOP：搞清楚advice的执行顺序
MayMatrix 的博客
09-11 699
文章目录 目录 AOP的核心概念 模拟aspect advice的执行过程 同一aspect，不同advice的执行顺序 不同aspect，advice的执行顺序 同一aspect，相同advice的执行顺序 Transactional Aspect的优先级 AOP的核心概念 要完全理解Spring AOP首先要理解AOP的核心概念和术语，这些术语并不是Spring指定的，而且很不幸，这些术语并不能直观理解，但是，如果Spring使用自己的术语，那将更加令人困惑。 A.
【Spring】AOP中的核心概念：通知(Advice)和切点(Pointcut)
最新发布
m0_65277261的博客
05-15 843
通知(Advice)：在切面的某个特定的连接点上执行的动作。通知有多种类型，包括“around”，“before” 和“after”等等。通知的类型将在后面详细了解。许多AOP框架，包括Spring在内，都是以拦截器做通知模型的，并维护着一个以连接点为中心的拦截器链。 用来放增强的代码的那个方法 环绕通知@Around：可以把代码增强在目标方法的任意地方，更通用 前置通知@Before：目标方法之前执行 后置通知@After：目标方法之后执行 异常通知@AfterThrowing：目标方法出现了异常执行
Spring的AOP执行顺序
liangsheng_g的专栏
01-26 3220
Spring中的Advisors的执行顺序
Spring关于AOP中关于advice的执行顺序
迷雾总会解
03-02 663
AOP的核心概念      要完全理解Spring AOP首先要理解AOP的核心概念和术语，这些术语并不是Spring指定的，而且很不幸，这些术语并不能直观理解，但是，如果Spring使用自己的术语，那将更加令人困惑。       Aspect：切面，由一系列切点、增强和引入组成的模块对象，可...
SpringBoot之AOP
Shy的博客
11-26 549
一、AOP简介（摘抄） aop 全称 Aspect Oriented Programming ，面向切面，AOP主要实现的目的是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。其与设计模式完成的任务差不多，是提供另一种角度来思考程序的结构，来弥补面向对象编程的不足。 二、搭建aop，通过自定义注解实现日志插入 1、依赖 &l...
Spring AOP切面解决数据库读写分离实例详解
10-19
在Spring AOP中，切面（Aspect）是关注点的一个模块化，它封装了横切关注点，比如日志记录、事务管理或权限检查，这里我们关注的是数据源的选择。Spring AOP通过切面拦截方法调用，根据方法名来判断是读操作还是写...
SpringBoot项目中使用AOP的方法
08-27
Pointcut用于定义哪个方法会被拦截，例如execution(* cn.springcamp.springaop.service.*.*(..))。Advice是拦截到方法后要执行的动作。Aspect是将Pointcut和Advice组合在一起形成一个切面。Join Point是在执行时...
Spring-Reference_zh_CN（Spring中文参考手册）
06-06
6.4.2. Spring AOP中使用@AspectJ还是XML？ 6.5. 混合切面类型 6.6. 代理机制 6.7. 编程方式创建@AspectJ代理 6.8. 在Spring应用中使用AspectJ 6.8.1. 在Spring中使用AspectJ来为domain object进行依赖注入 6.8.1.1....
SpringBean 调用 事务 AOP
05-27
在Spring框架中，事务管理和AOP（面向切面编程）是两个核心概念，它们相互结合以提供高效且灵活的应用程序开发。本篇文章将深入探讨如何在Spring中通过Bean调用来应用事务AOP，并通过示例代码详细解释其配置和工作...
Spring AOP之坑：完全搞清楚advice的执行顺序
热门推荐
洛丹伦的夏天
06-06 3万+
要完全理解Spring AOP首先要理解AOP的核心概念和术语，这些术语并不是Spring指定的，而且很不幸，这些术语并不能直观理解，但是，如果Spring使用自己的术语，那将更加令人困惑。
Spring自定义@Aspect与TransactionInterceptor先后执行问题
xiaozuzonguu的博客
02-04 1117
自定义@Aspect分析返回结果，并保存到数据库中，所以希望在事务结束前处理。 对应方法： 1.自定义@Aspect中增加order，数值定为10。 2.事务的@Aspect中，返回值Advisor设置order为5。 事务拦截的类中直接设置order不起作用，因为@Configuration+@Bean与xml同样作用，要写在新归Advisor处，才相当于 <aop:advisor adv...
xml中 aop:aspect aop:advisor如何配置
yangsnow_rain_wind的专栏
05-09 2886
我们知道Spring-AOP的核心执行流程是这样的. 1. Spring Ioc初始化所有Bean. 如果初始化Bean的时候发现改Bean满足pointcut中SpEl表达式, 则将该Bean做动态代理. 2. 在Bean的方法执行时,判断该Bean是否为代理对象,若是代理对象的话, 判断当前Method是否满足aop表达式, 3. 如果满足表达式,则按照顺序通知Aop配置的各通知(前,后...
跟着小马哥学系列之 Spring AOP（ Advice 组件详解）
qq_42419406的博客
05-17 1655
跟着小马哥学系列之 Spring AOP（ Advice 组件详解）简介 学好路更宽，钱多少加班。 ——小马哥 简介 大家好，我是小马哥成千上万粉丝中的一员！2019年8月有幸在叩丁狼教育举办的猿圈活动中知道有这么一位大咖，从此结下了不解之缘！此系列在多次学习极客时间《小马哥讲Spring AOP 编程思想》基础上形成的个人一些总结。希望能帮助各位小伙伴， 祝小伙伴早日学有所成。 ...
spring aop——advice注解
麻雀之梦想
12-05 414
@Before 前置通知 @After 后置通知，方法执行完后 @AfterReturning 返回通知，成功执行后 @AfterThrowing  异常通知，抛出异常后 @Around  环绕通知 @Before("matchAnno()") @After("matchAnno())") //相当于finally @AfterReturning("matchException()"...
AOP切面的优先级Order属性
qq_38409944的博客
09-14 8179
如果有两个切面，那么谁先谁后怎么判断？ 那如果我们要指定切面的执行顺序呢？ 可以使用@Order注解指定切面的优先级，值越小优先级越高： 举例： 两个切面类： @Order(2) @Aspect @Component public class MyAspect { @Before(&amp;quot;execution(public * calculator.CalculatorImpl.*(....
spring AspectJ order(顺序)
学而不思则罔 思而不学则殆
06-29 8981
@Aspect @Order(2) public class HelloWorldAspectAnnotation { /** * JoinPoint接口 * @param joinPoint */ /*public interface JoinPoint { String toString(); //连接点所在位置的相关信息 String to
SPring AOP介绍
09-13
Spring AOP supports several types of advice, such as before advice, which is executed before a method is called, and after advice, which is executed after a method has returned. Spring AOP also ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值