Spring AOP执行先后顺序实例详解

更新时间：2020年01月22日 15:20:53 作者：panchanggui

这篇文章主要介绍了Spring AOP执行先后顺序实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

众所周知，spring声明式事务是基于AOP实现的，那么，如果我们在同一个方法自定义多个AOP，我们如何指定他们的执行顺序呢？

网上很多答案都是指定order，order越小越是最先执行，这种也不能算是错，但有些片面。

配置AOP执行顺序的三种方式：

通过实现org.springframework.core.Ordered接口

@Component 
@Aspect 
@Slf4j 
public class MessageQueueAopAspect1 implements Ordered{@Override 
  public int getOrder() { 
    // TODO Auto-generated method stub 
    return 2; 
  } 
   
}

通过注解

@Component 
@Aspect 
@Slf4j 
@Order(1) 
public class MessageQueueAopAspect1{ 
   
  ... 
}

通过配置文件配置

<aop:config expose-proxy="true"> 
  <aop:aspect ref="aopBean" order="0">  
    <aop:pointcut id="testPointcut" expression="@annotation(xxx.xxx.xxx.annotation.xxx)"/>  
    <aop:around pointcut-ref="testPointcut" method="doAround" />  
    </aop:aspect>  
</aop:config>

我们在同一个方法上加以下两个AOP，看看究竟。

@Component 
@Aspect 
@Slf4j 
public class MessageQueueAopAspect1 implements Ordered{ 
   
  @Resource(name="actionMessageProducer") 
  private IProducer<MessageQueueInfo> actionProducer;   
   
  @Pointcut("@annotation(com.xxx.annotation.MessageQueueRequire1)") 
  private void pointCutMethod() { 
  } 
   
  //声明前置通知 
  @Before("pointCutMethod()") 
  public void doBefore(JoinPoint point) { 
    log.info("MessageQueueAopAspect1:doBefore"); 
    return; 
  } 
 
  //声明后置通知 
  @AfterReturning(pointcut = "pointCutMethod()", returning = "returnValue") 
  public void doAfterReturning(JoinPoint point,Object returnValue) { 
    log.info("MessageQueueAopAspect1:doAfterReturning"); 
  } 
 
  //声明例外通知 
  @AfterThrowing(pointcut = "pointCutMethod()", throwing = "e") 
  public void doAfterThrowing(Exception e) { 
    log.info("MessageQueueAopAspect1:doAfterThrowing"); 
  } 
 
  //声明最终通知 
  @After("pointCutMethod()") 
  public void doAfter() { 
    log.info("MessageQueueAopAspect1:doAfter"); 
  } 
 
  //声明环绕通知 
  @Around("pointCutMethod()") 
  public Object doAround(ProceedingJoinPoint pjp) throws Throwable { 
    log.info("MessageQueueAopAspect1:doAround-1"); 
    Object obj = pjp.proceed(); 
    log.info("MessageQueueAopAspect1:doAround-2"); 
    return obj; 
  } 
   
  @Override 
  public int getOrder() { 
    return 1001; 
  } 
}

@Component 
@Aspect 
@Slf4j 
public class MessageQueueAopAspect2 implements Ordered{ 
   
  @Resource(name="actionMessageProducer") 
  private IProducer<MessageQueueInfo> actionProducer;   
   
  @Pointcut("@annotation(com.xxx.annotation.MessageQueueRequire2)") 
  private void pointCutMethod() { 
  } 
   
   
  //声明前置通知 
  @Before("pointCutMethod()") 
  public void doBefore(JoinPoint point) { 
    log.info("MessageQueueAopAspect2:doBefore"); 
    return; 
  } 
 
  //声明后置通知 
  @AfterReturning(pointcut = "pointCutMethod()", returning = "returnValue") 
  public void doAfterReturning(JoinPoint point,Object returnValue) { 
    log.info("MessageQueueAopAspect2:doAfterReturning"); 
  } 
 
  //声明例外通知 
  @AfterThrowing(pointcut = "pointCutMethod()", throwing = "e") 
  public void doAfterThrowing(Exception e) { 
    log.info("MessageQueueAopAspect2:doAfterThrowing"); 
  } 
 
  //声明最终通知 
  @After("pointCutMethod()") 
  public void doAfter() { 
    log.info("MessageQueueAopAspect2:doAfter"); 
  } 
 
  //声明环绕通知 
  @Around("pointCutMethod()") 
  public Object doAround(ProceedingJoinPoint pjp) throws Throwable { 
    log.info("MessageQueueAopAspect2:doAround-1"); 
    Object obj = pjp.proceed(); 
    log.info("MessageQueueAopAspect2:doAround-2"); 
    return obj; 
  } 
   
  @Override 
  public int getOrder() { 
    return 1002; 
  } 
}

@Transactional(propagation=Propagation.REQUIRES_NEW) 
@MessageQueueRequire1 
@MessageQueueRequire2 
public PnrPaymentErrCode bidLoan(String id){ 
       ... 
    }

看看执行结果：

从上面的测试我们看到，确实是order越小越是最先执行，但更重要的是最先执行的最后结束。

这个不难理解，Spring AOP就是面向切面编程，什么是切面，画一个图来理解下：

由此得出：spring aop就是一个同心圆，要执行的方法为圆心，最外层的order最小。从最外层按照AOP1、AOP2的顺序依次执行doAround方法，doBefore方法。然后执行method方法，最后按照AOP2、AOP1的顺序依次执行doAfter、doAfterReturn方法。也就是说对多个AOP来说，先before的，一定后after。

如果我们要在同一个方法事务提交后执行自己的AOP，那么把事务的AOP order设置为2，自己的AOP order设置为1，然后在doAfterReturn里边处理自己的业务逻辑。

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

您可能感兴趣的文章:

Java SPI模块化解耦的技术指南
Java 的 Service Provider Interface (SPI) 是一种提供模块化和扩展性的方法,使得程序能够通过动态加载服务实现类来实现解耦,本文将详细介绍 Java SPI 的机制、应用场景及实现步骤,并通过示例代码展示如何使用 SPI,需要的朋友可以参考下
2025-03-03
详解Java中finally和return的执行顺序
try-catch-finally是一种针对程序运行时出错的响应手段,对于一些可以预料到的出错类型,在发生时对其进行报告和补救,这篇文章主要介绍了Java中finally和return的执行顺序,需要的朋友可以参考下
2024-01-01
Spring @Bean注解的使用场景与案例实现
随着SpringBoot的流行，我们现在更多采用基于注解式的配置从而替换掉了基于XML的配置，所以本篇文章我们主要探讨基于注解的@Bean以及和其他注解的使用
2023-03-03
Java中的5种同步辅助类介绍
你提交了一些任务，但你想等它们都完成了再做另外一些事情；你提交了一些任务，但是不想让它们立刻执行，等你喊123开始的时候，它们才开始执行；等等这些场景，线程之间需要相互配合，或者等待某一个条件成熟执行。这些场景想你就需要用到同步辅助类
2014-04-04
MyBatis-Plus如何通过注解使用TypeHandler
这篇文章主要介绍了MyBatis-Plus如何通过注解使用TypeHandler，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-01-01
MyBatis-Plus中实现自定义复杂排序逻辑的详细步骤
这篇文章主要介绍了MyBatis-Plus中实现自定义复杂排序逻辑,通过使用MyBatis-Plus的QueryWrapper和SQL原始片段,我们可以灵活地实现复杂的数据排序逻辑,这种方法尤其适用于需要对数据进行特定规则排序的场景,需要的朋友可以参考下
2024-07-07
Java的List集合框架之ArrayList详解
这篇文章主要介绍了Java的List集合框架之ArrayList详解,ArrayList默认容量为10(构造方法未指定初始容量为0),扩容是利用位运算(右移一位)和直接相加进行1.5倍扩容,需要的朋友可以参考下
2023-11-11
在controller中如何设置接收参数的默认值
这篇文章主要介绍了在controller中如何设置接收参数的默认值，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-03-03
Java编程实现NBA赛事接口调用实例代码
这篇文章主要介绍了Java编程实现NBA赛事接口调用实例代码，具有一定参考价值，需要的朋友可以了解下。
2017-11-11
Java注解简介和使用详细讲解
Java 语言中的类、构造器、方法、成员变量、参数等都可以被注解进行标注，这篇文章主要介绍了Java注解的介绍和使用详细讲解,需要的朋友可以参考下
2023-02-02

Spring AOP执行先后顺序实例详解

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具