Spring AOP（1）

什么是面向特定方法编程呢？比如之前图书馆管理系统的 “登录校验”，就是一类特定问题。登录校验拦截器，就是对 “登录校验” 这类问题的统一处理。所以，拦截器也是 AOP 的一种应用。AOP 是一种思想，拦截器是 AOP 思想的一种实现。Spring 框架实现了这种思想，提供了拦截器技术的相关接口。

同样的，统一数据返回格式和统一异常处理，也是 AOP 思想的一种实现。

简单来说：AOP 是一种思想，是对某一类事情的集中处理。

什么是Spring AOP？

AOP 是一种思想，它的实现方法有很多，有Spring AOP，也有 AspectJ、CGLIB等。

Spring AOP 是其中的一种实现方式。学会了统一功能之后，是不是就学会了Spring AOP 呢？当然不是。

拦截器作用的维度是 URL（依次请求和响应），@ControllerAdvice 应用场景主要是全局异常处理（配合自定义异常效果更佳），数据绑定，数据预处理。AOP作用的维度更加细致（可以根据包、类、方法名、参数等进行拦截），能够实现更加复杂的业务逻辑。

举个例子：我们现在有一个项目，项目中开发了很多功能。如图：

现在有一些业务的执行效率比较低，耗时较长，我们需要对接口进行优化。第一步就需要定位出执行耗时比较长的业务方法，再针对该业务方法来进行优化。如何定位呢？我们就需要统计当前项目中每一个业务方法的执行耗时。

如何统计呢？可以在业务方法运行前和运行后，记录下方法的开始时间和结束时间，两者之差就是这个方法的耗时。如图：

上面这种方法是可以解决问题的，但一个项目中会包含很多业务模块，每个业务模块又有很多接口，一个接口又包含很多方法，如果我们要在每个业务方法中都记录方法的耗时，对于程序员而言，会增加很多的工作量。

而 AOP 就可以做到在不改动这些原始方法的基础上，针对特定的方法进行功能的增强（AOP的作用：程序运行期间，在不修改源代码的基础上对已有方法进行增强 ——> 无入侵性：解耦）。

二、Spring AOP 快速入门

1、引入AOP依赖

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

2、编写AOP程序

@Slf4j
@Component
@Aspect
public class TimeRecordAspect {
    /**
     * 记录耗时
     */
    @Around("execution(* com.example.books_management_system.controller.*.*(..))")
    public Object timeRecord(ProceedingJoinPoint joinPoint) throws Throwable {
        //记录开始时间
        long star = System.currentTimeMillis();
        //执行目标方法
        Object proceed = joinPoint.proceed();
        //记录结束时间
        long end = System.currentTimeMillis();
        //日志打印耗时
        log.info("耗时时间: " + (end - star) + "ms");
        return proceed;
    }
}

运行程序，观察日志：

上面的切点是：com.example.books_management_system.controller.*.* ，指的是 ...controller包下的所有类和所有方法，都要执行上面的方法（也称为通知）。

对程序进行简单的讲解：

1、@Aspect：标识这是一个切面类。

2、@Around：环绕通知，在目标方法的前后都会被执行。后面的表达式表示对哪些方法进行增强。

3、ProceedingJoinPoint.proceed()：让原始方法执行。

整个代码划分为三部分

通过上面的程序，我们可以感受到AOP面向变成的一些优势：

1、代码无侵入：不修改原始的业务方法，就可以对原始的业务方法进行了功能的增强或者是功能的改变。

2、减少了重复代码。

3、提高开发效率。

4、方便维护。

三、Spring AOP 详解

1、Spring AOP的核心概念

（1）切点（Pointcut）

也称之为 “切入点”，Pointcut 的作用就是提供一组规则（使用 AspectJ pointcut expression language 来描述），告诉程序对哪些方法来进行功能增强。

上面的表达式：execution(* com.example.books_management_system.controller.*.*(..)) ，就是切点表达式。

（2）连接点（Join Point）

满足切点表达式规则的方法，就是连接点。也就是可以被AOP控制的方法。

以入门程序举例，所有 com.example.books_management_system.controller 路径下的方法，都是连接点。

（3）通知（Advice）

通知就是具体要做的工作，指哪些重复的逻辑，也就是共性功能（最终体现为一个方法），比如上述程序中记录业务方法的耗时时间，就是通知。

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

（4）切面（Aspect）

切面（Aspect）= 切点（Pointcut） + 通知（Advice）。

通过切面就能够描述当前AOP程序需要针对于哪些方法，在什么时候执行什么样的操作。

切面所在的类，我们一般称为切面类（被@Aspect注解表示的类）。

（5）总结

切点就是一规则，连接点就是符合这个规则的对象，通知就是对象做的事情，切面就是符合规则的所有对象做事。

举个栗子：报名蓝桥杯的学生在 2024-04-13 参比赛。

切点：报名蓝桥杯的学生。

连接点：这些学生具体的每一个人。

通知：在 2024-04-13 参加比赛。

切面：报名蓝桥杯的学生在 2024-04-13 参比赛。

2、通知类型

上面我们讲了什么是通知，接下来学习通知的类型。@Around 就是其中一种通知类型，表示环绕通知。Spring 中 AOP 的通知类型有以下几种：

@Around：环绕通知，此注解标注的通知方法在目标方法前、后都被执行。

@Before：前置通知，此注解标注的通知方法在目标方法前被执行。

@After：后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行

@AfterReturning：返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行。

@AfterThrowing：异常后通知，此注解标注的通知方法发生异常后执行。

接下来测试这些通知类型，代码如下：

@Slf4j
@Aspect
@Component
public class AspectDemo {
    //前置通知
    @Before("execution(* com.example.springaop.controller.*.*(..))")
    public void doBefore() {
        log.info("do before");
    }
    //后置通知
    @After("execution(* com.example.springaop.controller.*.*(..))")
    public void doAfter() {
        log.info("do after");
    }
    //添加环绕通知
    @Around("execution(* com.example.springaop.controller.*.*(..))")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("do around before");
        Object result = joinPoint.proceed();
        log.info("do around after");
        return result;
    }
    //返回后通知
    @AfterReturning("execution(* com.example.springaop.controller.*.*(..))")
    public void doAfterReturning() {
        log.info("do after returning");
    }
    //抛出异常后通知
    @AfterThrowing("execution(* com.example.springaop.controller.*.*(..))")
    public void doAfterThrowing() {
        log.info("do after throwing");
    }
}

测试接口：

@Slf4j
@RequestMapping("/test")
@RestController
public class TestController {
    @RequestMapping("/t1")
    public String t1() {
        log.info("执行t1方法...");
        return "t1";
    }
    @RequestMapping("/t2")
    public Boolean t2() {
        int a = 10 / 0;
        return true;
    }
}

（1）正常运行的情况

接口：http://127.0.0.1:8080/test/t1 ，测试结果如下：

执行的顺序是 Around Before -> Before -> AfterReturning -> After -> Around After，如图：

程序正常运行的情况下，AfterThrowing 标识的通知方法不会执行。

（2）运行失败的情况

接口：http://127.0.0.1:8080/test/t2 ，测试结果如下：

执行顺序：Around Before -> Before -> AfterThrowing-> After，如图：

可以看到，因为有异常，所以会执行 AfterThrowing，没有执行 AfterReturning，改成了 AfterThrowing。而 After 无论是否有异常都会执行。因为有异常，所以执行完目标方法后，就不会执行 AroundAfter 了。

（3）@Around 通知类型

其中单独测试一下 @Around 通知类型，有返回Object类型和没有返回Object类型的区别，代码如下：

无返回Object类型：

    @Around("execution(* com.example.springaop.controller.*.*(..))")
    public void doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("do around before");
        log.info("do around after");
    }

又返回Object类型：

    @Around("execution(* com.example.springaop.controller.*.*(..))")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("do around before");
        Object result = joinPoint.proceed();
        log.info("do around after");
        return result;
    }

无返回类型和有返回类型的区别图：

所以，@Around 环绕通知方法的返回值，必须指定为 Object 类型。

（4）注意事项

1、@Around 环绕通知需要调用 ProceedingJoinPoint.proceed() 来让原始方法执行，其他通知不需要考虑目标方法执行。

2、@Around 环绕通知方法的返回值，必须指定为Object 类型，来接收原始方法的返回值，否则原始方法执行完毕，使获取不到返回值的。

3、一个切面类可以有多个切点。

3、@PointCut

上面代码存在一个问题，就是存在大量重复的切点表达式：

execution(* com.example.springaop.controller.*.*(..))，Spring 提供了 @PointCut 注解，把公共的切点表达式提取出来，需要用到时引入该切入点表达式即可。

上面代码就可以修改为：

@Slf4j
@Aspect
@Component
public class AspectDemo {
    @Pointcut("execution(* com.example.springaop.controller.*.*(..))")
    private void pt(){}
    //public void pt(){} 其他类要使用pt()时，使用public修饰
    //前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("do before");
    }
    //后置通知
    @After("pt()")
    public void doAfter() {
        log.info("do after");
    }
    //添加环绕通知
    @Around("pt()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("do around before");
        Object result = joinPoint.proceed();
        log.info("do around after");
        return result;
    }
    //返回后通知
    @AfterReturning("pt()")
    public void doAfterReturning() {
        log.info("do after returning");
    }
    //抛出异常后通知
    @AfterThrowing("pt()")
    public void doAfterThrowing() {
        log.info("do after throwing");
    }
}

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

当其他切面类使用上面这个PointCut时，代码如下：

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

测试接口：http://127.0.0.1:8080/test/t1，日志如下：

4、切面优先级 @Order

当我们在一个项目中，定义了多个切面类时，并且这些切面类的多个切入点都匹配到了同一个目标方法。当目标方法运行的时候，这些切面类中的通知方法都会执行，那么这几个通知方法的执行顺序是什么样的呢？

那么不同类的通知运行的顺序是怎么样的呢？现在切面类有下面几个：

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

    @After("com.example.springaop.aspect.AspectDemo.pt()")
    public void doAfter() {
        log.info("执⾏ AspectDemo2 -> After ⽅法");
    }
}

@Slf4j
@Aspect
@Component
public class AspectDemo3 {
    @Before("com.example.springaop.aspect.AspectDemo.pt()")
    public void doBefore() {
        log.info("执⾏ AspectDemo3 -> Before ⽅法");
    }

    @After("com.example.springaop.aspect.AspectDemo.pt()")
    public void doAfter() {
        log.info("执⾏ AspectDemo3 -> After ⽅法");
    }
}

@Slf4j
@Aspect
@Component
public class AspectDemo4 {
    @Before("com.example.springaop.aspect.AspectDemo.pt()")
    public void doBefore() {
        log.info("执⾏ AspectDemo4 -> Before ⽅法");
    }

    @After("com.example.springaop.aspect.AspectDemo.pt()")
    public void doAfter() {
        log.info("执⾏ AspectDemo4 -> After ⽅法");
    }
}

测试顺序如下：

可以看到默认给我们的排序是按切面类名大小进行排序的。存在多个切面类时，默认按照切面类的类名字母排序：

@Before 通知：字母排名靠前的先执行。

@After 通知：字母排名靠前的后执行。

那如果我们不想按这个顺序，按照自定义顺序行不行？当然可以了，下面是@Order注解的使用（@Order注解的括号里面放数字）

@Slf4j
@Aspect
@Order(3)
@Component
public class AspectDemo2 {
    @Before("com.example.springaop.aspect.AspectDemo.pt()")
    public void doBefore() {
        log.info("执⾏ AspectDemo2 -> Before ⽅法");
    }

    @After("com.example.springaop.aspect.AspectDemo.pt()")
    public void doAfter() {
        log.info("执⾏ AspectDemo2 -> After ⽅法");
    }
}

@Slf4j
@Aspect
@Order(2)
@Component
public class AspectDemo3 {
    @Before("com.example.springaop.aspect.AspectDemo.pt()")
    public void doBefore() {
        log.info("执⾏ AspectDemo3 -> Before ⽅法");
    }

    @After("com.example.springaop.aspect.AspectDemo.pt()")
    public void doAfter() {
        log.info("执⾏ AspectDemo3 -> After ⽅法");
    }
}

@Slf4j
@Aspect
@Order(1)
@Component
public class AspectDemo4 {
    @Before("com.example.springaop.aspect.AspectDemo.pt()")
    public void doBefore() {
        log.info("执⾏ AspectDemo4 -> Before ⽅法");
    }

    @After("com.example.springaop.aspect.AspectDemo.pt()")
    public void doAfter() {
        log.info("执⾏ AspectDemo4 -> After ⽅法");
    }
}

运行观察日志，如图：

通过上述程序的运行结果，得出结论，@Order 注解标识的切面类，执行顺序如下：

@Before 通知：数字小的先执行。

@After 通知：数字大的先执行。

@Order 控制切面的优先级，先执行优先级较高的切面，再执行优先级较低的切面，最终执行目标方法。如图：

5、切点表达式

上面的代码中，我们一直在使用切点表达式来描述切点，下面进行介绍切点表达式的语法，切点表达式常见有两种表达方式：

1、execution(......)：根据方法的签名来匹配。

2、@annotation(......)：根据注解匹配。

（1）execution 表达式

execution() 是最常用的切点表达式，用来匹配方法，语法为：

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

上面的切点表达式意思是：任意的返回类型，在....controller包下的任意类方法(任意方法参数都行)

其中：访问修饰符和异常可以省略。

切点表达式支持通配符：

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..*(..))

（2）@annotation

execution 表达式更适用有规则的，如果我们要匹配多个无规则的方法呢？比如：TestController 中的 t1() 和 UserController 中的 u1() 这两个方法。

这个时候我们使用 execution 这种切点表达式来描述就很不方便了。

这时我们就可以借助自定义注解的方式以及另一种切点表达式 @annotation 来描述这一类的切点。

实现步骤：

1、编写自定义注解。

2、使用 @annotation 表达式来描述切点。

3、在连接点的方法上添加自定义注解。

准备测试代码：

@Slf4j
@RequestMapping("/test")
@RestController
public class TestController {
    @RequestMapping("/t1")
    public String t1() {
        log.info("执行t1方法...");
        return "t1";
    }
    @RequestMapping("/t2")
    public Boolean t2() {
        log.info("执行t2方法...");
        return true;
    }
}

@Slf4j
@RequestMapping("/user")
@RestController
public class UserController {

    @RequestMapping("/u1")
    public String u1() {
        log.info("执行u1方法...");
        return "u1";
    }

    @RequestMapping("/u2")
    public String u2() {
        log.info("执行u2方法...");
        return "u2";
    }
}

① 自定义注解 @MyAspect

创建一个注解类（和创建 Class 文件一样的流程，选择 Annotation 就可以了）

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 {
}

代码的简单说明：

1、@Target 标识了 Annotation 所修饰的对象范围，即该注解可以用在什么地方。

常用取值：

        ElementType.TYPE：用于描述类、接口(包括注解类型) 或 enum声明。
        ElementType.METHOD：描述方法。

        ElementType.PARAMETER：描述参数。

        ElementType.TYPE_USE：可以标注任意类型。
2、@Retention 指 Annotation 被保留的时间长短，标明注解的生命周期。

①RentionPolicy.SOURCE：表示注解仅存在于源代码中，编译成字节码后会被丢弃。这意味着在运⾏时⽆法获取到该注解的信息，只能在编译时使用。比如@SuppressWarnings ，以及lombok提供的注解 @Data ，@Slf4j。

②RetentionPolicy.CLASS：编译时注解。表示注解存在于源代码和字节码中，但在运⾏时会被丢弃。这意味着在编译时和字节码中可以通过反射获取到该注解的信息，但在实际运行时⽆法获取。通常⽤于⼀些框架和⼯具的注解。

③RetentionPolicy.RUNTIME：运⾏时注解。表示注解存在于源代码，字节码和运⾏时中。这意味着在编译时，字节码中和实际运⾏时都可以通过反射获取到该注解的信息。通常用于⼀些需要在运⾏时处理的注解，如Spring的 @Controller @ResponseBody。

② 切面类

使用 @annotation 切点表达式定义切点，只对 @MyAspect生效，代码如下：

@Slf4j
@Component
@Aspect
public class MyAspectDemo {
    @Around("@annotation(com.example.springaop.config.MyAspect)")
    public Object doAround(ProceedingJoinPoint joinPoint) {
        log.info("do around before");
        Object o = null;
        try {
            o = joinPoint.proceed();
        } catch (Throwable e) {
            log.error("发生异常, e:" + e);
        }
        log.info("do around after");
        return o;
    }
}

上面的通知类型使用 @annotation注解后，注解括号里的 MyAspect，表示谁使用 @MyAspect注解，就会执行下面代码。

③ 添加自定义注解

在 TestController 中的 t1() 和 UserController 中的 u1 这两个方法上添加自定义注解 @MyAspect，其他方法不添加。（已把之前的AspectDemo的@Comment注解给注释掉了）

@Slf4j
@RequestMapping("/user")
@RestController
public class UserController {
    @MyAspect
    @RequestMapping("/u1")
    public String u1() {
        log.info("执行u1方法...");
        return "u1";
    }
}
@Slf4j
@RequestMapping("/test")
@RestController
public class TestController {
    @MyAspect
    @RequestMapping("/t1")
    public String t1() {
        log.info("执行t1方法...");
        return "t1";
    }
}

运行程序，测试接口：

127.0.0.1:8080/test/t1

控制台日志如下：

127.0.0.1:8080/user/u1

可以看到，通过自定义注解的方式，就可以匹配多个无规则的方法。

6、Spring AOP 的实现方式（常见面试题）

（1）基于注解 @Aspect （参考上述）

（2）基于自定义注解（参考自定义注解 @annotation 部分的内容）

（3）基于 Spring API（通过 xml 配置的方式，自从SpringBoot 广泛使用之后，这种方法几乎看不到了）

（4）基于代理来实现（更加久远的一种实现方式，写法笨重，不建议使用）

参考：面试官：谈谈你对IOC和AOP的理解及AOP四种实现方式[通俗易懂]-腾讯云开发者社区-腾讯云 (tencent.com)