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)