Spring AOP（1）

一、AOP 概述

什么是Spring AOP？

二、Spring AOP 快速入门

1、引入AOP依赖

2、编写AOP程序

三、Spring AOP 详解

1、Spring AOP的核心概念

（1）切点（Pointcut）

（2）连接点（Join Point）

（3）通知（Advice）

（4）切面（Aspect）

（5）总结

2、通知类型

（1）正常运行的情况

（2）运行失败的情况

（3）@Around 通知类型

（4）注意事项

3、@PointCut

4、切面优先级 @Order

5、切点表达式

（1）execution 表达式

切点表达式

（2）@annotation

① 自定义注解 @MyAspect

② 切面类

③ 添加自定义注解

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

一、AOP 概述

AOP 是 Spring 框架的第二大核心（第一大核心是 IoC）。

AOP 的全称：Aspect Oriented Programming（面向切面编程）。什么是面向切面编程呢？切面就是指某一类特定问题，所以 AOP 也可以理解为面向特定方法编程。

什么是面向特定方法编程呢？比如之前图书馆管理系统的 “登录校验”，就是一类特定问题。登录校验拦截器，就是对 “登录校验” 这类问题的统一处理。所以，拦截器也是 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)