Spring Aop实例@Aspect、@Before、@AfterReturning@Around 注解方式配置

心已赠人 2021-12-11 04:39 407阅读 1赞

用过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() {
     
        }
    }

*  package test; import org.aspectj.lang.annotation.Pointcut; public class PointCuts \{ @Pointcut(value = "within(test.\*)") public void aopDemo() \{ \} \}

**添加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");
        }
    }

**添加测试用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;
            }
        }
    }

**测试 正常情况**

在浏览器直接输入以下的URL，回车：

[http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=false][http_192.168.142.8_7070_aoptest_v1_aop_test_throwException_false]

我们会看到输出的结果是：

[Aspect1] around advise 1
    [Aspect1] before advise
    test OK
    [Aspect1] around advise2
    [Aspect1] after advise
    [Aspect1] afterReturning advise

**测试 异常情况**

在浏览器中直接输入以下的URL，回车：

[http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=true][http_192.168.142.8_7070_aoptest_v1_aop_test_throwException_true]

我们会看到输出的结果是：

[Aspect1] around advise 1
    [Aspect1] before advise
    throw an exception
    [Aspect1] after advise
    [Aspect1] afterThrowing advise

**结论**

在一个方法只被一个aspect类拦截时，aspect类内部的 advice 将按照以下的顺序进行执行：

**正常情况：**

![20160811192425854][]

--------------------

**异常情况：**

![20160811192446479][]

### 情况二: 同一个方法被多个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");
        }
    }

**测试用Controller也不变**

还是使用上面的那个Controller。但是现在 aspect1 和 aspect2 都会拦截该controller中的方法。

下面继续进行测试！

**测试 正常情况**

在浏览器直接输入以下的URL，回车：

[http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=false][http_192.168.142.8_7070_aoptest_v1_aop_test_throwException_false]

我们会看到输出的结果是：

[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

但是这个时候，我不能下定论说 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

也就是说，这种情况下， aspect1 和 aspect2 的执行顺序是未知的。那怎么解决呢？不急，下面会给出解决方案。

**测试 异常情况**

在浏览器中直接输入以下的URL，回车：

[http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=true][http_192.168.142.8_7070_aoptest_v1_aop_test_throwException_true]

我们会看到输出的结果是：

[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

同样地，如果把服务器重启，然后再测试的话，就可能会看到如下的结果：

[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

也就是说，同样地，异常情况下， 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 {
        // ...
    }

这样修改之后，可保证不管在任何情况下， aspect1 中的 advice 总是比 aspect2 中的 advice 先执行。如下图所示：

![20160811193349342][]

### 注意点 ###

*  如果在同一个 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

从结果可以发现， Controller 中的 接口 未被执行，aspect1 中的 **@Before** advice 也未被执行。

### 参考资料 ###

*  Spring 4.3.2.RELEASE 官方资料：[http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/][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][http_docs.spring.io_spring_docs_current_spring-framework-reference_htmlsingle_aop-ataspectj-advice-ordering]

[http_192.168.142.8_7070_aoptest_v1_aop_test_throwException_false]: http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=false
[http_192.168.142.8_7070_aoptest_v1_aop_test_throwException_true]: http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=true
[20160811192425854]: /images/20211211/893d87a32f854b04a76870a457239eea.png
[20160811192446479]: /images/20211211/326b25620f4942dab26532a88428e61c.png
[20160811193349342]: /images/20211211/6555159175374dc5beaf1a299c6d1ad2.png
[http_docs.spring.io_spring_docs_current_spring-framework-reference_htmlsingle]: http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/
[http_docs.spring.io_spring_docs_current_spring-framework-reference_htmlsingle_aop-ataspectj-advice-ordering]: http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#aop-ataspectj-advice-ordering