Spring切面通知执行的顺序（Advice Order）

最新推荐文章于 2024-03-18 14:15:07 发布
最新推荐文章于 2024-03-18 14:15:07 发布
阅读量741 收藏 1
点赞数 1
文章标签： java
原文链接：http://www.cnblogs.com/shugen/p/6863008.html
版权

问题描述

如果在Spring的程序中同时定义了环绕通知（Around）和前置通知（Before）。.那么，有以下问题：
1.怎么让两个切面通知都起作用
2.或者让两者切面按自己指定的顺序进行执行？
3.环绕通知和前置后置通知的区别

引用知乎上的回答

如果在同一接入点（join point) 有多个通知（advice），Spring AOP 采用和 AspectJ 类似的优先级来指定通知的执行顺序，目标执行前（进入时），优先级高的通知先执行，目标执行后（出来时），优先级高的通知后执行。

如果两个通知分别定义在各自的 Aspect 内，可以通过如下两种方式控制 Aspect 的施加顺序：
Aspect 类添加注解：org.springframework.core.annotation.Order
顺序值：使用注解属性指定
Aspect 类实现接口：org.springframework.core.Ordered
顺序值：实现 Ordered 接口的 getOrder() 方法即可
如果两个 advice 位于同一 aspect 内，且执行顺序有先后，通过 advice 的声明顺序是无法确定其执行顺序的，因为 advice 方法的声明顺序无法通过反射获取，只能采取如下变通方式，二选一：
将两个 advice 合并为一个 advice，那么执行顺序就可以通过代码控制了
将两个 advice 分别抽离到各自的 aspect 内，然后为 aspect 指定执行顺序
作者：Night Silent
链接：http://www.zhihu.com/question/32326290/answer/55572235
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

问题回答

1. 怎么让两个切面通知都起作用

将需要被执行的通知的实现类，在Sping中进行注册或者全部采用注解的方式和配置扫描包
如果编写的环绕通知和前置后置通知没有问题，那么，通知就可以在切点出被调用。

<bean id="aroundAudience"
      class="com.springinaction.springidol.AroundAudience">
</bean>
<bean id="audience" 
      class="com.springinaction.springidol.Audience" />

2. 或者让两者切面按自己指定的顺序进行执行？

你在Spring的配置文件中声明环绕通知和前置后置通知的顺序就是他们执行的先后顺序。由配置顺序决定执行先后顺序，本身没有优先级。

3.环绕通知和前置后置通知的区别

参考文档文档
下面的地址是Spring官方给出的AOP切面的文档

http://docs.spring.io/spring/docs/2.5.x/reference/aop.html#aop-ataspectj-advice-ordering
使用Spring进行面向切面编程（AOP).
http://www.blogjava.net/supercrsky/articles/174368.html
跟我学SPring3.x之切面执行顺序
http://jinnianshilongnian.iteye.com/blog/1423489

下面用一个实例来说明如何执行多个通知，实例采用Maven进行依赖管理，通知采用注解形式的配置

先上Spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!--<start id="preamble" />--> 
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
     http://www.springframework.org/schema/beans/spring-beans.xsd
     http://www.springframework.org/schema/aop
     http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--<end id="preamble" />-->

  <bean id="eddie"
      class="com.springinaction.springidol.Instrumentalist">
    <property name="instrument">
      <bean class="com.springinaction.springidol.Guitar" />
    </property>
  </bean>
<bean id="aroundAudience"
      class="com.springinaction.springidol.AroundAudience">

</bean>
  <!--<start id="audience_bean" />--> 
  <bean id="audience" 
      class="com.springinaction.springidol.Audience" />
  <!--<end id="audience_bean" />-->

  <!--<start id="contestant_introducer" />--> 
  <bean class="com.springinaction.springidol.ContestantIntroducer" />
  <!--<end id="contestant_introducer" />-->

  <!--<start id="aspectj_autoproxy" />--> 
    <aop:aspectj-autoproxy />
  <!--<end id="aspectj_autoproxy" />-->

</beans>

Instrument接口

package com.springinaction.springidol;

public interface Instrument {
  public void play();
}

Instrument实现类

package com.springinaction.springidol;

public class Guitar implements Instrument {
  public void play() {
    System.out.println("Strum strum strum");
  }
}

AroundAudience类（定义环绕通知的类）

package com.springinaction.springidol;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class AroundAudience {

  @Pointcut("execution(* com.springinaction.springidol.Performer.perform(..))")
  public void performance() {

  }
  //<start id="audience_around_bean" /> 
  @Around("performance()")
  public void watchPerformance(ProceedingJoinPoint joinpoint) {
    try {
      System.out.println("The audience is taking their seats.");
      System.out.println("The audience is turning off their cellphones");

      long start = System.currentTimeMillis();
      joinpoint.proceed();
      long end = System.currentTimeMillis();

      System.out.println("CLAP CLAP CLAP CLAP CLAP");

      System.out.println("The performance took " + (end - start)
          + " milliseconds.");
    } catch (Throwable t) {
      System.out.println("Boo! We want our money back!");
    }
  }
  //<end id="audience_around_bean" />
}

Audience定义前置通知

package com.springinaction.springidol;

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class Audience {
  @Pointcut(
        "execution(* com.springinaction.springidol.Performer.perform(..))")
  public void performance() { //<co id="co_definePointcut"/>
    System.out.println("fuck fuck fuck me ");
  }

  @Before("performance()")
  public void takeSeats() { //<co id="co_takeSeatsBefore"/>
    System.out.println("2222The audience is taking their seats.");
  }

  @Before("performance()")
  public void turnOffCellPhones() { //<co id="co_turnOffCellPhonesBefore"/>
    System.out.println("The audience is turning off their cellphones");
  }

  @AfterReturning("performance()")
  public void applaud() { //<co id="co_applaudAfter"/>
    System.out.println("CLAP CLAP CLAP CLAP CLAP");
  }

  @AfterThrowing("performance()")
  public void demandRefund() { //<co id="co_demandRefundAfterException"/>
    System.out.println("Boo! We want our money back!");
  }
}

Performer(被织入实现类的接口)

package com.springinaction.springidol;

public interface Performer {
  void perform() throws PerformanceException;
}

PerformanceException

package com.springinaction.springidol;

public class PerformanceException extends Exception {
  private static final long serialVersionUID = 1L;

}

Instrumentalist(被织入实现类的接口)

package com.springinaction.springidol;

public class Instrumentalist implements Performer {
  public void perform() throws PerformanceException {
    instrument.play();
  }

  private Instrument instrument;

  public void setInstrument(Instrument instrument) {
    this.instrument = instrument;
  }

  public Instrument getInstrument() {
    return instrument;
  }
}

测试类

package com.springinaction.springidol;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("spring-idol.xml")
public class AspectTest {
  @Autowired
  ApplicationContext context;

  @Test
  public void audienceShouldApplaud() throws Exception {
    Performer eddie = (Performer) context.getBean("eddie");
    eddie.perform();
  }

  @Test
  public void eddieShouldBeAContestant() {
    Contestant eddie = (Contestant) context.getBean("eddie");
    eddie.receiveAward();
  }
}

Maven的依赖

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.frank</groupId>
  <artifactId>springinaction</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>springinaction Maven Webapp</name>
  <url>http://maven.apache.org</url>


  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <springversion>3.1.1.RELEASE</springversion>
    <junitversion>3.8.1</junitversion>
  </properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-asm</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${springversion}</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.8.2</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.2</version>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jms</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-oxm</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${springversion}</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>

    <dependency>
      <groupId>commons-collections</groupId>
      <artifactId>commons-collections</artifactId>
      <version>3.1</version>
    </dependency>

    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.1</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>RELEASE</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

运行的结果

这里写图片描述

转载于:https://www.cnblogs.com/shugen/p/6863008.html

weixin_30477293
关注
Spring AOP切面解决数据库读写分离实例详解
01-20
切面通过切点（Pointcut）来定位需要增强的方法，然后应用通知（Advice）来执行特定的行为。在这里，我们可以创建一个切面类，如`ReadWriteInterceptor`，并定义两个列表，分别存储读操作和写操作的方法名前缀。 在...
spring AspectJ order(顺序)
学而不思则罔 思而不学则殆
06-29 9024
@Aspect @Order(2) public class HelloWorldAspectAnnotation { /** * JoinPoint接口 * @param joinPoint */ /*public interface JoinPoint { String toString(); //连接点所在位置的相关信息 String to
Spring Aop切面类优先级@Order()
MrCollins的博客
10-13 1548
相同目标方法上同时存在多个切面时，切面的优先级控制切面的内外嵌套顺序。注：@Order默认值为int类型的最大值。@Order(较小的数)：优先级高。@Order(较大的数)：优先级低。优先级高的切面：外面。优先级低的切面：里面。
spring应用手册-AOP(注解)-(25)-切面发布-通知顺序-@Order
10-18 958
戴着假发的程序员出品 抖音ID：戴着假发的程序员 欢迎关注 切面发布-通知顺序-@Order spring应用手册（第三部分） 有时我们可能在我们的业务上会增加多个相同类型的切面。这时就会有一个先后顺序问题。那么spring如何解决顺序问题呢？ 在使用注解方式的环境下，我们可以通过@Order注解给切面排序，当然在没有@Order注解的情况下，多个切面本身是无顺序的（也就是按照默认顺序执
java 程序中try catch / throw / 函数名上throws 具体执行顺序和扔异常捕获异常的概念模型
水墨江南
02-17 3109
1. code 如下： throws： public Object aroundMethod(ProceedingJoinPoint pjd) throws Throwable{ Object result = null; String methodName = pjd.getSignature().getName(); Object[] args = pjd.getArg
spring-环绕通知 @Around 注解
Little_Arya的博客
02-27 3316
该增强方法实际是拦截了目标方法的执行。
Spring AOP面向切面三种实现
04-19
当有多个切面涉及到同一个方法时，Spring会根据切面的优先级（@Order注解）或源代码的顺序决定执行顺序。 - **代理模式的局限性** 虽然代理模式简单易用，但它无法处理静态方法或无接口的类。这时，AspectJ或注解...
Aop记录执行时间.pdf
11-15
8. Order接口：通过实现Spring的Ordered接口，可以控制多个切面的执行顺序。在本例中，通过getOrder()方法返回的整数值越小，对应的切面优先级越高。 9. 使用Spring AOP的场景：在本例中，AOP被用来记录HTTP请求的...
spring使用动态代理面向切面编程(AOP) xml
04-22
但如果有特殊需求，可以通过`<aop:aspect-order>`或`<aop:declare-parents>`来调整切面的执行顺序。 四、例子解析 文件名`spring_1600_AOP_xml`可能是指Spring AOP的示例代码，可能包含了如何在XML配置中定义和使用...
详解Spring Aop实例@Around、@Before、@After、@AfterReturning 、@AfterThrowing注解方式配置以及注意事项
huluwa10526的博客
12-01 2522
用过spring框架进行开发的人，多多少少会使用过它的AOP功能，都知道有@Before、@Around和@After等advice。最近，为了实现项目中的输出日志和权限控制这两个需求，我也使用到了AOP功能。我使用到了@Before、@Around这两个advice。但在，使用过程中，却对它们的执行顺序并不清楚。为了弄清楚在不同情况下，这些advice到底是以怎么样的一个顺序进行执行的，我作了个测试，在此将其记录下来，以供以后查看。 前提 对于AOP相关类(aspect、pointcut等)的概念，
切面执行顺序@order
zqj1172102457的博客
07-23 2433
切面执行顺序@order 参考链接 https://www.cnblogs.com/softidea/p/6123307.html
切面aop编程的执行顺序，通过@Order注解来指定
m0_68292446的博客
03-14 819
指定切面的执行顺序
Spring Core-AOP原理与实践
陈海龙的格物之路
07-18 378
介绍springcore中的AOP，阐述通过源码了解的原理，列举AOP的使用方式。
Spring 存在多个AOP切面时，执行顺序问题
最新发布
qq_40419080的博客
03-18 1945
切面的配置顺序决定了切面的执行顺序，多个切面执行的过程，类似于方法调用的过程，在环绕通知的proceed()执行时，去执行下一个切面或如果没有下一个切面执行目标方法，从而达成了如下的执行过程：（目标方法只会执行一次）责任链设计模式：为解除请求的发送者和接收者之间的耦合，而使多个对象都有机会处理这个请求。spring项目中可能会用aop来完成日志、事务等功能，当存在多个aop切面时，这些切面的执行顺序是怎么样的？注解的value属性指定各个切面的执行顺序，value值默认为Integer的最大值，
Spring @Aspect、@Before、@After 注解实现 AOP 切面功能
热门推荐
蚩尤后裔-汪茂雄
08-22 6万+
Spring AOP 注解概述 1、Spring 的 AOP 功能除了在配置文件中配置一大堆的配置，比如切入点、表达式、通知等等以外，使用注解的方式更为方便快捷，特别是 Spring boot 出现以后，基本不再使用原先的 beans.xml 等配置文件了，而都推荐注解编程。 @Aspect 切面声明，标注在类、接口（包括注解类型）或枚举上。 @Pointcut 切入点声明，即切入到哪些目标类的目标方法。 value 属性指定切入点表达式，默认为 ""，用于被通知注解引用
Spring应用 -- AOP基础
知识点滴
06-23 316
一：戏谑前言 删删改改写了很多次，懒得再折腾什么没有狗屁意义的概念。AOP的概念晦涩难懂，根本就不属于人类理解的范畴。这篇文章就说Spring AOP的大概实现原理，面试应该怎么去说，工作中怎么用。其余的仁者见仁智者见智，有更好描述的朋友欢迎补充探讨。一上来看那些见鬼的概念然后纠结不清的都是ZZ 将依赖放在最显眼的位置，它是最靓的一个仔。还有朋友喜欢引用aspectjweaver这个包，但是as...
【无标题】
qq_42282792的博客
12-18 357
springboot 多个切面的执行顺序分析
调整多个ControllerAdvice的执行顺序
felixu的博客
04-18 1万+
有时候在项目里面会有多个 @ControllerAdvice 或者 @RestControllerAdvice 的情况，这时候，可能就会出现一个特定的异常被其他的处理掉，从而出现一些奇怪的问题。
spring aop 环绕通知 基于@aspectJ
prefer_n的专栏
06-01 1634
<br />前言：<br />     Spring 的环绕通知和前置通知，后置通知有着很大的区别，主要有两个重要的区别：<br />1） 目标方法的调用由环绕通知决定，即你可以决定是否调用目标方法，而前置和后置通知   是不能决定的，他们只是在方法的调用前后执行通知而已，即目标方法肯定是要执行的。<br />2）  环绕通知可以控制返回对象，即你可以返回一个与目标对象完全不同的返回值，虽然这很危险，但是你却可以办到。而后置方法是无法办到的，因为他是在目标方法返回值后调用<br />   这里是经过我自己测
Spring AOP：如何管理多个切面的执行顺序
需要注意的是，如果两个切面的`getOrder()`返回值相同或者`@Order`注解的值相等，Spring将会使用类名的字典顺序来决定执行顺序，这通常不是我们期望的行为，因此尽量避免这种情况。 通过以上两种方式，我们可以有效...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值