Spring AOP：隐秘的秘密

Spring AOP 在大家日常开发设计中饰演了一个十分关键的人物角色，针对怎么使用 AOP 坚信很多人早已不生疏，但在其中有一些点却非常容易被大家忽略，这节大家融合一些“不以常知”的难题深入探讨。

同一个 AOP 类中好多个横切面注释的实行次序

先得出结果：@Around [joinPoint.proceed()前] —> @Before —> @Around [joinPoint.proceed()及其以后] —> @After —> @AfterReturning(如果有出现异常则@AfterThrowing) 。

话不多说，我这们立即上编码：

@Aspect
public class AopClass {

    @Pointcut(value = "execution(* io.alan.*.Klass.*dong(..))")
    public void point() {

    }

    @Before(value = "point()")
    public void before() {
        System.out.println("========>begin klass dong... //2");
    }

    @Around("point()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("========>around begin klass dong //1");
        joinPoint.proceed();
        System.out.println("========>around after klass dong //3");
    }
    @After(value = "point()")
    public void after() {
        System.out.println("========>after klass dong... //4");
    }
    @AfterReturning(value = "point()")
    public void afterReturning() {
        System.out.println("========>after klass dong... //5");
    }

}

查询运用打印出的日志，以下：

不一样 AOP 类横切面的实行次序

如果我们对同一个方式界定好几个 AOP，它的实行次序是哪些的呢？

配备 AOP 实行次序的三种方法

方法1：完成 org.springframework.core.Ordered 插口

@Aspect
public class AopClass implements Ordered {

    @Override
    public int getOrder() {
        return 2;
    }

}

方法2：应用注释 @Order

@Aspect
@Order(2)
public class AopClass {

}

方法3：应用环境变量

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

编码检测

下边大家演试在同一份编码上再加上2个 AOP，随后观查日志。

@Aspect
@Order(2)
public class Aop2 {

    @Pointcut(value = "execution(* io.kimmking.*.Klass.*dong(..))")
    public void point() {

    }

    @Before(value = "point()")
    public void before() {
        System.out.println("    Aop2========>before klass dong... //2");
    }

    @AfterReturning(value = "point()")
    public void afterReturning() {
        System.out.println("    Aop2========>afterReturning klass dong... //5");
    }

    @After(value = "point()")
    public void after() {
        System.out.println("    Aop2========>after klass dong... //4");
    }

    @Around("point()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("    Aop2========>around before klass dong //1");
        joinPoint.proceed();
        System.out.println("    Aop2========>around after klass dong //3");

    }

}

@Aspect
@Order(3)
public class Aop3 {

    @Pointcut(value = "execution(* io.kimmking.*.Klass.*dong(..))")
    public void point() {

    }

    @Before(value = "point()")
    public void before() {
        System.out.println("    Aop3========>before klass dong... //2");
    }

    @AfterReturning(value = "point()")
    public void afterReturning() {
        System.out.println("    Aop3========>afterReturning klass dong... //5");
    }

    @After(value = "point()")
    public void after() {
        System.out.println("    Aop3========>after klass dong... //4");
    }

    @Around("point()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("    Aop3========>around before klass dong //1");
        joinPoint.proceed();
        System.out.println("    Aop3========>around after klass dong //3");

    }

}

打印出的日志以下：

从日志中我们可以见到，order 越小的 AOP 类越先实行，但也有一点必须 大家留意：便是最开始实行的 AOP 最终才实行完毕（如上图所述中的 AOP2）。

大家根据下边的这张平面图就可以了解了。

总结一下：我们可以将 Spring AOP 作为一个内切圆，要实行的方式为圆心点，最表层的 order 最少。从最表层依照 AOP1、AOP2 的次序先后实行 Around 方式，Before 方式。随后实行 method 方式，最终依照 AOP2、AOP1 （次序相反了）的次序先后实行 After、AfterReturn 方式。

因此对好几个AOP而言，先实行 before 的，一定后实行 after。

比如，假如我们要在同一个方式事务管理递交后实行自身的 AOP ，那麼能够 把事务管理的 AOP order 设定为2，自身的 AOP order 设定为1，随后在 AfterReturn 里面解决自身的领域模型。

参照连接

• https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#spring-core
• https://blog.csdn.net/rainbow702/article/details/52185827