aop - smile0821/learngit GitHub Wiki

用过spring框架进行开发的人，多多少少会使用过它的AOP功能，都知道有@Before、@Around和@After等advice。最近，为了实现项目中的输出日志和权限控制这两个需求，我也使用到了AOP功能。我使用到了@Before、@Around这两个advice。但在，使用过程中，却对它们的执行顺序并不清楚。为了弄清楚在不同情况下，这些advice到底是以怎么样的一个顺序进行执行的，我作了个测试，在此将其记录下来，以供以后查看。

前提对于AOP相关类(aspect、pointcut等)的概念，本文不作说明。对于如何让spring框架扫描到AOP，本文也不作说明。情况一: 一个方法只被一个Aspect类拦截当一个方法只被一个Aspect拦截时，这个Aspect中的不同advice是按照怎样的顺序进行执行的呢？请看:

添加 PointCut类该pointcut用来拦截test包下的所有类中的所有方法。

package test;

import org.aspectj.lang.annotation.Pointcut;

public class PointCuts { @Pointcut(value = "within(test.*)") public void aopDemo() {

} 1 2 3 4 5 6 7 8 9 10 添加Aspect类该类中的advice将会用到上面的pointcut，使用方法请看各个advice的value属性。

package test;

import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component;

@Component @Aspect public class Aspect1 {

@Before(value = "test.PointCuts.aopDemo()")
public void before(JoinPoint joinPoint) {
    System.out.println("[Aspect1] before advise");
}

@Around(value = "test.PointCuts.aopDemo()")
public void around(ProceedingJoinPoint pjp) throws  Throwable{
    System.out.println("[Aspect1] around advise 1");
    pjp.proceed();
    System.out.println("[Aspect1] around advise2");
}

@AfterReturning(value = "test.PointCuts.aopDemo()")
public void afterReturning(JoinPoint joinPoint) {
    System.out.println("[Aspect1] afterReturning advise");
}

@AfterThrowing(value = "test.PointCuts.aopDemo()")
public void afterThrowing(JoinPoint joinPoint) {
    System.out.println("[Aspect1] afterThrowing advise");
}

@After(value = "test.PointCuts.aopDemo()")
public void after(JoinPoint joinPoint) {
    System.out.println("[Aspect1] after advise");
}

} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 添加测试用Controller 添加一个用于测试的controller，这个controller中只有一个方法，但是它会根据参数值的不同，会作出不同的处理：一种是正常返回一个对象，一种是抛出异常(因为我们要测试@AfterThrowing这个advice)

package test;

import test.exception.TestException; import org.springframework.http.HttpStatus; import org.springframework.web.bind.annotation.*;

@RestController @RequestMapping(value = "/aop") public class AopTestController {

@ResponseStatus(HttpStatus.OK)
@RequestMapping(value = "/test", method = RequestMethod.GET)
public Result test(@RequestParam boolean throwException) {
    // case 1
    if (throwException) {
        System.out.println("throw an exception");
        throw new TestException("mock a server exception");
    }

    // case 2
    System.out.println("test OK");
    return new Result() {{
        this.setId(111);
        this.setName("mock a Result");
    }};
}

public static class Result {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 测试正常情况在浏览器直接输入以下的URL，回车：

http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=false 1 我们会看到输出的结果是：

[Aspect1] around advise 1 [Aspect1] before advise test OK [Aspect1] around advise2 [Aspect1] after advise [Aspect1] afterReturning advise 1 2 3 4 5 6 测试异常情况在浏览器中直接输入以下的URL，回车：

http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=true 1 我们会看到输出的结果是：

[Aspect1] around advise 1 [Aspect1] before advise throw an exception [Aspect1] after advise [Aspect1] afterThrowing advise 1 2 3 4 5 结论在一个方法只被一个aspect类拦截时，aspect类内部的 advice 将按照以下的顺序进行执行：

正常情况：

异常情况：

情况二: 同一个方法被多个Aspect类拦截此处举例为被两个aspect类拦截。有些情况下，对于两个不同的aspect类，不管它们的advice使用的是同一个pointcut，还是不同的pointcut，都有可能导致同一个方法被多个aspect类拦截。那么，在这种情况下，这多个Aspect类中的advice又是按照怎样的顺序进行执行的呢？请看:

pointcut类保持不变添加一个新的aspect类 package test;

import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component;

@Component @Aspect public class Aspect2 {

@Before(value = "test.PointCuts.aopDemo()")
public void before(JoinPoint joinPoint) {
    System.out.println("[Aspect2] before advise");
}

@Around(value = "test.PointCuts.aopDemo()")
public void around(ProceedingJoinPoint pjp) throws Throwable{
    System.out.println("[Aspect2] around advise 1");
    pjp.proceed();
    System.out.println("[Aspect2] around advise2");
}

@AfterReturning(value = "test.PointCuts.aopDemo()")
public void afterReturning(JoinPoint joinPoint) {
    System.out.println("[Aspect2] afterReturning advise");
}

@AfterThrowing(value = "test.PointCuts.aopDemo()")
public void afterThrowing(JoinPoint joinPoint) {
    System.out.println("[Aspect2] afterThrowing advise");
}

@After(value = "test.PointCuts.aopDemo()")
public void after(JoinPoint joinPoint) {
    System.out.println("[Aspect2] after advise");
}

} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 测试用Controller也不变还是使用上面的那个Controller。但是现在 aspect1 和 aspect2 都会拦截该controller中的方法。

下面继续进行测试！

测试正常情况在浏览器直接输入以下的URL，回车：

http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=false 1 我们会看到输出的结果是：

[Aspect2] around advise 1 [Aspect2] before advise [Aspect1] around advise 1 [Aspect1] before advise test OK [Aspect1] around advise2 [Aspect1] after advise [Aspect1] afterReturning advise [Aspect2] around advise2 [Aspect2] after advise [Aspect2] afterReturning advise 1 2 3 4 5 6 7 8 9 10 11 但是这个时候，我不能下定论说 aspect2 肯定就比 aspect1 先执行。不信？你把服务务器重新启动一下，再试试，说不定你就会看到如下的执行结果：

[Aspect1] around advise 1 [Aspect1] before advise [Aspect2] around advise 1 [Aspect2] before advise test OK [Aspect2] around advise2 [Aspect2] after advise [Aspect2] afterReturning advise [Aspect1] around advise2 [Aspect1] after advise [Aspect1] afterReturning advise 1 2 3 4 5 6 7 8 9 10 11 也就是说，这种情况下， aspect1 和 aspect2 的执行顺序是未知的。那怎么解决呢？不急，下面会给出解决方案。

测试异常情况在浏览器中直接输入以下的URL，回车：

http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=true 1 我们会看到输出的结果是：

[Aspect2] around advise 1 [Aspect2] before advise [Aspect1] around advise 1 [Aspect1] before advise throw an exception [Aspect1] after advise [Aspect1] afterThrowing advise [Aspect2] after advise [Aspect2] afterThrowing advise 1 2 3 4 5 6 7 8 9 同样地，如果把服务器重启，然后再测试的话，就可能会看到如下的结果：

[Aspect1] around advise 1 [Aspect1] before advise [Aspect2] around advise 1 [Aspect2] before advise throw an exception [Aspect2] after advise [Aspect2] afterThrowing advise [Aspect1] after advise [Aspect1] afterThrowing advise 1 2 3 4 5 6 7 8 9 也就是说，同样地，异常情况下， aspect1 和 aspect2 的执行顺序也是未定的。

那么在情况二下，如何指定每个 aspect 的执行顺序呢？方法有两种：

实现org.springframework.core.Ordered接口，实现它的getOrder()方法给aspect添加@Order注解，该注解全称为：org.springframework.core.annotation.Order 不管采用上面的哪种方法，都是值越小的 aspect 越先执行。比如，我们为 apsect1 和 aspect2 分别添加 @Order 注解，如下：

@Order(5) @Component @Aspect public class Aspect1 { // ... }

@Order(6) @Component @Aspect public class Aspect2 { // ... } 1 2 3 4 5 6 7 8 9 10 11 12 13 这样修改之后，可保证不管在任何情况下， aspect1 中的 advice 总是比 aspect2 中的 advice 先执行。如下图所示：

注意点如果在同一个 aspect 类中，针对同一个 pointcut，定义了两个相同的 advice(比如，定义了两个 @Before)，那么这两个 advice 的执行顺序是无法确定的，哪怕你给这两个 advice 添加了 @Order 这个注解，也不行。这点切记。

对于@Around这个advice，不管它有没有返回值，但是必须要方法内部，调用一下 pjp.proceed();否则，Controller 中的接口将没有机会被执行，从而也导致了 @Before这个advice不会被触发。比如，我们假设正常情况下，执行顺序为”aspect2 -> apsect1 -> controller”，如果，我们把 aspect1中的@Around中的 pjp.proceed();给删掉，那么，我们看到的输出结果将是：

[Aspect2] around advise 1 [Aspect2] before advise [Aspect1] around advise 1 [Aspect1] around advise2 [Aspect1] after advise [Aspect1] afterReturning advise [Aspect2] around advise2 [Aspect2] after advise [Aspect2] afterReturning advise 1 2 3 4 5 6 7 8 9 从结果可以发现， Controller 中的接口未被执行，aspect1 中的 @Before advice 也未被执行。

参考资料 Spring 4.3.2.RELEASE 官方资料：http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/ 其中，AOP的执行顺序章节为：http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#aop-ataspectj-advice-ordering Advice ordering

What happens when multiple pieces of advice all want to run at the same join point? Spring AOP follows the same precedence rules as AspectJ to determine the order of advice execution. The highest precedence advice runs first "on the way in" (so given two pieces of before advice, the one with highest precedence runs first). "On the way out" from a join point, the highest precedence advice runs last (so given two pieces of after advice, the one with the highest precedence will run second).

When two pieces of advice defined in different aspects both need to run at the same join point, unless you specify otherwise the order of execution is undefined. You can control the order of execution by specifying precedence. This is done in the normal Spring way by either implementing the org.springframework.core.Ordered interface in the aspect class or annotating it with the Order annotation. Given two aspects, the aspect returning the lower value from Ordered.getValue() (or the annotation value) has the higher precedence.

When two pieces of advice defined in the same aspect both need to run at the same join point, the ordering is undefined (since there is no way to retrieve the declaration order via reflection for javac-compiled classes). Consider collapsing such advice methods into one advice method per join point in each aspect class, or refactor the pieces of advice into separate aspect classes - which can be ordered at the aspect le