Spring AOP应用指南：概念、通知与表达式分析

一.AOP的基础概念

AOP英文全称Aspect Oriented Programming（⾯向切⾯编程），是一种编程思想，就像OOP（面向对象编程）一样都是不同的编程思想。

切线这个概念我们在数学中学习过，切线指的是一条刚好触碰到曲线上某一点的直线，切线只是与圆相切，但二者并没有重合的部分也不会相互干扰。我们可以将不同的业务逻辑抽象理解为一个个的圆，而面向切面编程就是指在不干扰原有业务逻辑处理的情况下进行编码，举个例子来说，日志记录、事务管理、安全性这些非业务逻辑都是我们在开发中必须要考虑的事情，从程序的耦合度上考虑，将业务逻辑和非业务逻辑分开是更为合理的，而AOP（⾯向切⾯编程）则恰好满足了这个条件，我们将业务逻辑抽象为一个个的圆，将非业务逻辑抽象为一个个的切线，不同的圆对应着不同的切线，切线与圆之间即有一定的联系，又可以互不干扰，从而提高了代码的模块化和可维护性。

比如在进行登录校验的开发中，我们常常会用到拦截器来进行判断用户是否进行了不合理的访问，我们设置拦截器的时候都不会对原有业务逻辑代码进行修改，而是在原有方法的基础上进行增加新的逻辑，这里的拦截器其实就是AOP思想的一种具体体现。AOP思想就是对于某一类事情的集中处理，可以做到在不改动这些原始⽅法的基础上，针对特定的⽅法进⾏功能的增强。

AOP（面向切面编程）是一种独立的编程范式，它不依赖于任何特定的框架或语言。它的核心思想是将横切关注点从业务逻辑中分离出来。它的实现方法有很多，诸如Spring AOP，AspectJ、CGLIB等。

而我们今天要谈的就是Spring AOP

• 从框架的角度上说：Spring AOP是Spring框架的一个模块，它提供了对面向切面编程的支持。Spring AOP更是AOP思想在Spring框架中的具体实现，为开发者提供了一种简单而强大的方式来处理应用程序中的横切关注点。
• 从Java语言的角度上说：Spring AOP是在Java环境中实现AOP的一种方式。它主要是利用了Java的反射机制和代理模式来实现切面的功能。

二.Spring AOP的应用场景

理论逻辑再多也是空谈，先上应用，再进行理解

如果我们需要计算每一个接口的运行时间，按照一般逻辑我们就需要在每一个Controller方法的首部和尾部分别拿到当前时间，然后再进行减法运算。

但实际上方法与方法的调用关系可能很复杂，这样操作工程量很大，而且需要大量修改原本的代码，代码重复度也非常的高。如果又有了别的需求，可能又需要大动干戈的修改源码，总的来说是非常的不利于代码的可维护性。

但是通过AOP我们就可以非常轻便的完成这样一个需求，首先是引入AOP对应的依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

我们可以通过AOP来完成对每一个接口运行时间的计算统计，如下所示

@Slf4j
@Aspect
@Component
public class TimeAspect {
    /**
     * 记录⽅法耗时
     */
    @Around("execution(* com.example.demo.controller.*.*(..))")
    public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
        //记录⽅法执⾏开始时间
        long begin = System.currentTimeMillis();
        //执⾏原始⽅法
        Object result = pjp.proceed();
        //记录⽅法执⾏结束时间
        long end = System.currentTimeMillis();
        //记录⽅法执⾏耗时
        log.info(pjp.getSignature() + "执⾏耗时: {}ms", end - begin);
        return result;
    }
}

以下是对上述程序的简单介绍（后面还会详细介绍）：

1. @Aspect：标识这是⼀个切⾯类
2. @Around：环绕通知，在⽬标⽅法的前后都会被执⾏，后⾯的表达式表⽰对哪些⽅法进⾏增强
3. ProceedingJoinPoint.proceed() ：让原始⽅法执⾏

我们通过环绕通知@Around来监控com.example.demo.controller下所有的类的所有方法，即对controller层进行监控，当外界访问这些方法的时候，就回运行这段代码，首先是在运行目标方法前拿到了当前系统的时间，后运行目标方法，当目标方法运行结束后，再次拿到系统时间，并且计算这个时间差，即得到了该接口目标方法被调用的运行时间。

也就是说，我们将整个代码分为了三部分

以上便是一个SpringAOP⼊⻔程序，完成了业务接⼝执⾏耗时的统计，通过上⾯的程序，我们也可以感受到AOP⾯向切⾯编程的⼀些优势：

• 代码⽆侵⼊: 不修改原始的业务⽅法，就可以对原始的业务⽅法进⾏了功能的增强或者是功能的改变
• 减少了重复代码
• 提⾼开发效率
• 维护⽅便

在对SpringAOP有个基础的认识后，为了更好的理解代码，需要对其中的一些核心概念进行介绍

三.Spring AOP的核心概念

AOP中还有以下的核心概念，我们还是通过刚才的例子来说明

**▐ **切点(Pointcut)

切点（Pointcut）也称之为"切⼊点"，Pointcut 的作⽤就是提供⼀组规则，告诉程序对哪些⽅法来进⾏功能增强，如下图中红色圈起来的地方，表达式 execution(* com.example.demo.controller..(..)) 就是切点表达式，通过这个表达式，我们就找到了需要切入的地方，即切点。

**▐ **连接点(Join Point)

满⾜切点表达式规则的⽅法，就是连接点，也就是可以被AOP控制的⽅法。以上图举例, 所有 com.example.demo.controller 路径下的⽅法都是连接点。

切点与连接点的关系：

    连接点是满⾜切点表达式的元素，而切点可以看做是保存了众多连接点的⼀个集合。

以学校举例来说：

• 切点表达式：计算机院全体教师
• 连接点：张三、李四、王五等教师

**▐ **通知(Advice)

通知就是具体要做的⼯作，指哪些重复的逻辑，也就是共性功能(最终体现为⼀个⽅法)，⽐如上述程序中记录业务⽅法的耗时时间，就是通知

在AOP⾯向切⾯编程当中，我们把这部分重复的代码逻辑抽取出来单独定义，这部分代码就是通知的内容

**▐ **切面(Aspect)

切⾯(Aspect) = 切点(Pointcut) + 通知(Advice)

通过切⾯就能够描述当前AOP程序需要针对于哪些⽅法，在什么时候执⾏什么样的操作，切⾯既包含了通知逻辑的定义，也包括了连接点的定义

切⾯所在的类，我们⼀般称为切⾯类（被@Aspect注解标识的类）

通知类型

通知有不同的类型，分别代表的不同的通知效果，前文中的@Around 就是其中⼀种通知类型，表⽰环绕通知，Spring中AOP的通知类型有以下几种：

• @Around: 环绕通知, 此注解标注的通知⽅法在⽬标⽅法前, 后都被执⾏
• @Before: 前置通知, 此注解标注的通知⽅法在⽬标⽅法前被执⾏
• @After: 后置通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, ⽆论是否有异常都会执⾏
• @AfterReturning: 返回后通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, 有异常不会执⾏
• @AfterThrowing: 异常后通知, 此注解标注的通知⽅法发⽣异常后执⾏

@Around 标识的通知⽅法包含两部分，⼀个"前置逻辑"， ⼀个"后置逻辑"。其中"前置逻辑" 会先于 @Before 标识的通知⽅法执⾏，"后置逻辑" 会晚于 @After 标识的通知⽅法执⾏。大概是下图这样的情况。

但是当程序出现异常的情况下，@AfterReturning 标识的通知⽅法不会执⾏，@AfterThrowing 标识的通知⽅法会执行；@Around 环绕通知中原始⽅法调⽤时有异常，通知中的环绕后的代码逻辑也不会在执⾏了（因为原始⽅法调⽤出异常了）。大概是下图这样的情况。

除此之外还有部分需要注意：

• @Around 环绕通知需要调⽤ ProceedingJoinPoint.proceed() 来让原始⽅法执⾏，其他通知不需要考虑⽬标⽅法执⾏
• @Around 环绕通知⽅法的返回值, 必须指定为Object, 来接收原始⽅法的返回值，否则原始⽅法执⾏完毕，是获取不到返回值的
• ⼀个切⾯类可以有多个切点

四.@PointCut与@Order

如果不希望写大量重复的切点表达式，则可以通过Spring提供的@PointCut 注解把公共的切点表达式提取出来，需要⽤到时引⽤该切⼊点表达式即可。

@Slf4j
@Aspect
@Component
public class AspectDemo {
    //定义切点(公共的切点表达式)
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    private void pt() {
    }
    
    //前置通知
    @Before("pt()")
    public void doBefore() {
        //...代码省略
    }
    
    //后置通知
    @After("pt()")
    public void doAfter() {
        //...代码省略
    }
    
    //返回后通知
    @AfterReturning("pt()")
    public void doAfterReturning() {
        //...代码省略
    }
    
    //抛出异常后通知
    @AfterThrowing("pt()")
    public void doAfterThrowing() {
        //...代码省略
    }
    
    //添加环绕通知
    @Around("pt()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        //...代码省略
    }
}

当切点定义使⽤private修饰时仅能在当前切⾯类中使⽤，当其他切⾯类也要使⽤当前切点定义时， 就需要把private改为public，引⽤⽅式为: 全限定类名.⽅法名()

@Slf4j
@Aspect
@Component
public class AspectDemo {
    //定义切点(公共的切点表达式)
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    public void pt() {
    }
    //...代码省略
}

@Slf4j
@Aspect
@Component
public class AspectDemo2 {
    //前置通知
    @Before("com.example.demo.aspect.AspectDemo.pt()")
    public void doBefore() {
        log.info("执⾏ AspectDemo2 -> Before ⽅法");
    }
}

切面优先级

当我们在⼀个项⽬中定义了多个切⾯类，并且这些切⾯类的多个切⼊点都匹配到了同⼀个⽬标⽅法。当⽬标⽅法运⾏的时候这些切⾯类中的通知⽅法都会执⾏，那么这几个通知方法都会执行，但执行前后的顺序则收到优先级的影响，具体情况是怎样可以通过下面这个实例来证明

一共定义了三个切面类AspectDemo2、AspectDemo3和AspectDemo4，并且使这三个切面类都监视controller层下的方法

@Slf4j
@Aspect
@Component
public class AspectDemo2 {
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    private void pt() {
    }
    
    //前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执⾏ AspectDemo2 -> Before ⽅法");
    }
    
    //后置通知
    @After("pt()")
    public void doAfter() {
        log.info("执⾏ AspectDemo2 -> After ⽅法");
    }
}

@Slf4j
@Aspect
@Component
public class AspectDemo3 {
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    private void pt() {
    }
    
    //前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执⾏ AspectDemo3 -> Before ⽅法");
    }
    
    //后置通知
    @After("pt()")
    public void doAfter() {
        log.info("执⾏ AspectDemo3 -> After ⽅法");
    }
}

@Slf4j
@Aspect
@Component
public class AspectDemo4 {
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    private void pt() {
    }
    
    //前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执⾏ AspectDemo4 -> Before ⽅法");
    }
    
    //后置通知
    @After("pt()")
    public void doAfter() {
        log.info("执⾏ AspectDemo4 -> After ⽅法");
    }
}

当我们调用controller下的方法的时候，三个切面类都会触发各自的逻辑。如下图可以看见他们之间的相互顺序，这是由默认优先级来决定的，默认的优先级是按照切面类的类名顺序来排序的

存在多个切⾯类时，默认按照切⾯类的类名字⺟排序：

• @Before 通知：字⺟排名靠前的先执⾏
• @After 通知：字⺟排名靠前的后执⾏

但这种⽅式不⽅便管理，我们的类名更多还是具备⼀定含义的，为此我们可以使用Spring为我们提供的@Order注解来自定义他们的优先级

@Aspect
@Component
@Order(5)
public class AspectDemo2 {
    //...代码省略
}

@Aspect
@Component
@Order(1)
public class AspectDemo3 {
    //...代码省略
}

@Aspect
@Component
@Order(10)
public class AspectDemo4 {
    //...代码省略
}

试运行，得到结果

得到结论，@Order 注解标识的切⾯类，执⾏顺序如下:

• @Before 通知：数字越小先执⾏
• @After 通知：数字越⼤先执⾏

@Order 控制切⾯的优先级：先执⾏优先级较⾼的切⾯，再执⾏优先级较低的切⾯，最终执⾏⽬标⽅法。按照图示大概是如下的情况：

方法的执行顺序就像从上往下横穿的一条直线一样，故而如果Before的顺序是12345，那么After的顺序就是54321

五.切点表达式

上⾯的代码中我们⼀直在使⽤切点表达式来描述切点，下⾯我们来介绍⼀下切点表达式的语法，切点表达式常⻅有两种表达⽅式

• execution(...)：根据⽅法的签名来匹配
• @annotation(...) ：根据注解匹配

execution(...)表达式

execution(...)表达式是最常用的切点表达式，在上述例子中也都是用的execution(...)表达式，具体语法如下：

execution(<访问修饰符> <返回类型> <包名.类名.⽅法(⽅法参数)> <异常>)

其中访问修饰符和异常可以省略掉，上文的例子大多也都是这样的写法

对于通配符需要注意以下事项

1.** * **：匹配任意字符，只匹配⼀个元素(返回类型, 包, 类名, ⽅法或者⽅法参数)

• a. 包名使⽤ * 表⽰任意包(⼀层包使⽤⼀个*)
• b. 类名使⽤ * 表⽰任意类
• c. 返回值使⽤ * 表⽰任意返回值类型
• d. ⽅法名使⽤ * 表⽰任意⽅法
• e. 参数使⽤ * 表⽰⼀个任意类型的参数

2.** .. **：匹配多个连续的任意符号，可以通配任意层级的包，任意类型，任意个数的参数

• a. 使⽤ .. 配置包名，标识此包以及此包下的所有⼦包
• b. 可以使⽤ .. 配置参数，任意个任意类型的参数

切点表达式示例

TestController 下的 public 修饰，返回类型为String，⽅法名为t1，方法无参数传递

 execution(public String com.example.demo.controller.TestController.t1())

省略访问修饰符

execution(String com.example.demo.controller.TestController.t1())

匹配所有返回类型

execution(* com.example.demo.controller.TestController.t1())

匹配TestController下的所有无参⽅法

execution(* com.example.demo.controller.TestController.*())

匹配TestController下的所有⽅法(不管参数如何）

execution(* com.example.demo.controller.TestController.*(..))

匹配controller包下所有的类的所有⽅法

 execution(* com.example.demo.controller.*.*(..))

匹配所有包下⾯的TestController

execution(* com..TestController.*(..))

匹配com.example.demo包下，⼦孙包下的所有类的所有方法

 execution(* com.example.demo..*(..))

通过execution(...)表达式我们就可以对于特定类中的特定方法进行切入，但是如果我们需要对俩个毫无相关的类中毫无相关的方法进行切入的话，就需要写俩个execution(...)表达式了，因为一个execution(...)表达式只能限定一个群体中的类，若是俩个毫无相关的类与方法则需要分为俩个表达式，这就引出了@annotation表达式

@annotation表达式

在execution(...)表达式中我们通过全限定类名和方法名来确认切入点，对于多个无规则的方法则不能满足需求。

而@annotation则支持我们通过自定义的注解来匹配我们需要的类和方法，具体实现起来分为以下三个步骤

1. 编写⾃定义注解
2. 使⽤ @annotation 表达式来描述切点
3. 在连接点的⽅法上添加⾃定义注解

第一步：首先编写自定义注解，名字随意

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAspect {

}

@Target 标识了 Annotation 所修饰的对象范围，即该注解可以⽤在什么地⽅，常见取值:

• ElementType.TYPE: ⽤于描述类、接⼝(包括注解类型) 或enum声明
• ElementType.METHOD: 描述⽅法
• ElementType.PARAMETER: 描述参数
• ElementType.TYPE_USE: 可以标注任意类型

@Retention 指Annotation被保留的时间⻓短, 标明注解的⽣命周期，@Retention 的取值有三种:

1. RetentionPolicy.SOURCE：表⽰注解仅存在于源代码中，编译成字节码后会被丢弃。这意味着在运⾏时⽆法获取到该注解的信息，只能在编译时使⽤。⽐如 @SuppressWarnings , 以及lombok提供的注解 @Data , @Slf4j
2. RetentionPolicy.CLASS：编译时注解，表⽰注解存在于源代码和字节码中，但在运⾏时会被丢弃。这意味着在编译时和字节码中可以通过反射获取到该注解的信息，但在实际运⾏时⽆法获取，通常⽤于⼀些框架和⼯具的注解
3. RetentionPolicy.RUNTIME：运⾏时注解，表⽰注解存在于源代码、字节码和运⾏时中。这意味着在编译时，字节码中和实际运⾏时都可以通过反射获取到该注解的信息，通常⽤于⼀些需要在运⾏时处理的注解。如Spring的 @Controller @ResponseBody

第二步：完成自定义注解编写后，我们需要通过@annotation来描述定义切点，如下所示，在表达式"@annotation(com.example.demo.aspect.MyAspect)"中MyAspect就是我们刚才自定义的注解，那么当我们这样申明后，以后只要是使用了@MyAspect注解的地方，就都会进行切入操作

@Slf4j
@Component
@Aspect
class MyAspectDemo {
    //前置通知
    @Before("@annotation(com.example.demo.aspect.MyAspect)")
    public void before() {
        log.info("MyAspect -> before ...");
    }
    
    //后置通知
    @After("@annotation(com.example.demo.aspect.MyAspect)")
    public void after() {
        log.info("MyAspect -> after ...");
    }
}

第三步：我们这时就可以直接使用刚才定义的自定义注解了，如下所示，那么当外部调用了该t1方法后，就会自动调用我们的MyAspectDemo中声明的AOP逻辑（@Before、@After）

@MyAspect
@RequestMapping("/t1")
public String t1() {
    return "t1";
}

当我们运行调用该接口后，我们自定义的AOP逻辑就执行了

** 本次的分享就到此为止了，希望我的分享能给您带来帮助，创作不易也欢迎大家三连支持，你们的点赞就是博主更新最大的动力！**如有不同意见，欢迎评论区积极讨论交流，让我们一起学习进步！有相关问题也可以私信博主，评论区和私信都会认真查看的，我们下次再见