对于Spring-AOP使用不同层级多个切点表达式，但是切入同一个方法的切入顺序探讨

秒速五厘米 2022-12-13 04:22 55阅读 0赞

博主脑子短路的操作

今天在研究aop的时候发现了一种神奇的情况：

首先，包结构如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center]  
包结构下有com.yankaizhang.aoptest.controller.Test.show()方法

## 情况1 ##

想要分别在三个不同层级下，对show方法进行切入操作，三个层次的切面表达式如下：

1.  com.yankaizhang.aoptest.controller.Test1.\*
2.  com.yankaizhang.aoptest.controller.\*.\*
3.  com.yankaizhang.aoptest.\*.\*.\*

于是我写了一个切点类：

@Aspect
    @Component
    public class LogAspect {
        
    
        @Before("execution(* com.yankaizhang.aoptest.controller.Test1.*(..))")
        public void before1(){
        
            System.out.println("before1");
        }
    
        @Before("execution(* com.yankaizhang.aoptest.controller.*.*(..))")
        public void before2(){
        
            System.out.println("before2");
        }
    
        @Before("execution(* com.yankaizhang.aoptest.*.*.*(..))")
        public void before3(){
        
            System.out.println("before3");
        }
    
        @AfterReturning("execution(* com.yankaizhang.aoptest.controller.Test1.*(..))")
        public void after1(){
        
            System.out.println("after1");
        }
    
        @AfterReturning("execution(* com.yankaizhang.aoptest.controller.*.*(..))")
        public void after2(){
        
            System.out.println("after2");
        }
    
        @AfterReturning("execution(* com.yankaizhang.aoptest.*.*.*(..))")
        public void after3(){
        
            System.out.println("after3");
        }
    }

运行程序，得到结果如下：

before1
    before2
    before3
    Test1 ==> show
    after3
    after2
    after1

**可以看到，切入点层级是包结构上最外层级的通知，按照顺序竟然是最内侧的切面**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 1]  
这个结论是有点意外的，如果在一个@Aspect里面定义不同层级的切面表达式，而这些层级恰好是嵌套的，那么他们之间的执行顺序是**先执行包结构最里面的通知，然后由里到外，再由外到里**，让人挺秃然的。

这样环状的切面倒是符合了AOP的环切顺序，网上文章很多  
[https://www.cnblogs.com/fanguangdexiaoyuer/p/10562069.html][https_www.cnblogs.com_fanguangdexiaoyuer_p_10562069.html]

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

## 情况2 ##

紧接着，我又做了个骚操作，又写了这样一个切面类：

@Aspect
    @Component
    public class LogAspect2 {
        
    
        @Before("execution(* com.yankaizhang.aoptest.controller.Test1.*(..))")
        public void before1(){
        
            System.out.println("before1");
        }
    
        @Before("execution(* com.yankaizhang.aoptest.controller.Test1.*(..))")
        public void before2(){
        
            System.out.println("before2");
        }
    }

可以看到，我只加了2个前置通知方法，不过这次，是在同一层上加入的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 2]

问题来了：这次的执行顺序是什么呢？此时我开始有点迷茫了，因为在同一层有两个方法

执行结果如下：

before1
    before2
    Test1 ==> show

可以看到，before1先执行了，是按照方法顺序定义的原因吗？

我把两个方法交换了位置，但是输出照旧；我又尝试使用了@Order注解来强制改变顺序，显然并没有什么作用

最后，我把两个方法名字颠倒了，因为猜测spring在遍历方法的时候是按照字典序遍历的

@Before("execution(* com.yankaizhang.aoptest.controller.Test1.*(..))")
    public void before2(){
        	// 我是before1
        System.out.println("before1");
    }
    
    @Before("execution(* com.yankaizhang.aoptest.controller.Test1.*(..))")
    public void before1(){
        	// 我是before2
        System.out.println("before2");
    }

输出结果：

before2
    before1
    Test1 ==> show

这次竟然成功了。。为了验证到底是不是字典序，我又把方法改名称为bbb和aaa，结果永远是aaa方法先执行，确实是按照**字典序**来排列顺序的

紧接着，我又试了试后置方法在这一情况下的顺序，非常简单，把@Before换成@AfterReturning就行

@Aspect
    @Component
    public class LogAspect2 {
        
    
        @AfterReturning("execution(* com.yankaizhang.aoptest.controller.Test1.*(..))")
        public void before1(){
        
            System.out.println("before1");
        }
    
        @AfterReturning("execution(* com.yankaizhang.aoptest.controller.Test1.*(..))")
        public void before2(){
        
            System.out.println("before2");
        }
    }

输出结果如下：

Test1 ==> show
    before2
    before1

到这里，可以大胆猜测，after类型在同一层次上对同一方法的通知执行顺序应该是**字典序倒序**

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

## 情况3 ##

现在我有了个要求，想要在不改变程序名字的情况下，强制修改情况2里面的执行顺序，要怎么办？

我尝试了各种方法和@Order注解，发现没有作用，解决不了这个问题，后来仔细一想其实是自己完全把整个事情搞复杂了

在一个切面类里面对同一切点执行2次前置通知，而且还要保持顺序是很奇葩的一件事，为什么不定义1个前置通知，然后分别调用2个private函数呢。。。

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

## 正确做法 ##

**情况1**：如果想要控制执行顺序的话，最好的方法是横向把1个切面类按照层次分为3个切面类，在每个切面类上面使用@Order注解控制切入顺序

这样无论什么层次，在order的控制下可以按照规定的执行顺序执行通知方法

代码大致如下：

@Aspect
    @Component
    @Order(1)	// 1表示最高优先级
    public class LogAspect1 {
        
    
        @Pointcut("execution(* com.yankaizhang.aoptest.controller.Test1.*(..))")
        public void pointCut(){
        
    
        }
    
        @Before("pointCut()")
        public void before1(){
        
            System.out.println("before1");
        }
    
        @AfterReturning("pointCut()")
        public void after1(){
        
            System.out.println("after1");
        }
    }
    
    @Aspect
    @Component
    @Order(3)	// 故意让这个层次切面最后执行
    public class LogAspect2 {
        
    
        @Pointcut("execution(* com.yankaizhang.aoptest.controller.*.*(..))")
        public void pointCut(){
        
    
        }
    
        @Before("pointCut()")
        public void before2(){
        
            System.out.println("before2");
        }
    
        @AfterReturning("pointCut()")
        public void after2(){
        
            System.out.println("after2");
        }
    }
    
    
    @Aspect
    @Component
    @Order(2)	// 第二位执行
    public class LogAspect3 {
        
    
        @Pointcut("execution(* com.yankaizhang.aoptest.*.*.*(..))")
        public void pointCut(){
        
    
        }
    
        @Before("pointCut()")
        public void before3(){
        
            System.out.println("before3");
        }
    
        @AfterReturning("pointCut()")
        public void after3(){
        
            System.out.println("after3");
        }
    }

此时，又来了一些没遇到的疑问，如果@Order大家都**没有注明优先级**，都是同一个优先级怎么办？（你为什么写@Order不加优先级数字啊！！！）

因为此时已经有3个切面类了，那么切面类之间的顺序如何控制呢？

答案还是按照**字典序顺序**，别问，问就是实践出真知（）

肯定是跟spring扫描包的时候的载入顺序有关~，具体涉及到源码，暂时打住

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

**情况2**：刚才已经提到了情况2的处理方式，首先是在一个切面类里面避免对同一个切入点执行多次同一个通知，而是在一个通知下调用多个私有方法进行

@Aspect
    @Component
    public class LogAspect5 {
        
    
        @Pointcut("execution(* com.yankaizhang.aoptest.controller.Test1.*(..))")
        public void pointCut(){
        
    
        }
    
        @Before("pointCut()")
        public void before1(){
        
            step1();
            step2();
        }
    
        private void step2(){
        
            System.out.println("第二步");
        }
    
        private void step1(){
        
            System.out.println("第一步");
        }
    
    }

这样的代码看上去才正常啊。。。刚才那个明显是为了探讨特殊情况而有意为之的

本次的脑袋短路之旅就进行到这里吧。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/d4b7e66bf84541deb42a676ef7ba7dea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/90a850460a56438c92aad64c46f8352d.png
[https_www.cnblogs.com_fanguangdexiaoyuer_p_10562069.html]: https://www.cnblogs.com/fanguangdexiaoyuer/p/10562069.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNjI0Mg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/ff188a02338242659595b7fa99ee42d7.png