AOP是什么？Spring Boot AOP 怎么使用？

小灰灰 2023-10-10 19:52 58阅读 0赞

## 1. Spring Boot AOP 是什么？ ##

## 1.1 AOP 是什么？ ##

AOP是面向切面编程（Aspect-Oriented Programming）的缩写。AOP是一种编程范式，旨在通过将横切关注点（cross-cutting concerns）从主要业务逻辑中分离出来，提供一种更好的代码模块化和可维护性，换句话说，**就是对某一类事情的集中处理。**

横切关注点指的是在应用程序中横跨多个模块或层的功能，例如日志记录、事务管理、安全性、缓存、异常处理等。

例如：在不使用AOP的情况下，每个Controller都要写一遍用户登录验证。当功能越来越多的时候，需要在每个功能里都写同样的代码，这就提高了代码的修改和维护的成本。对于这种功能统一，且使用的地方较多的功能，就可以考虑AOP来统一处理了。

## 1.2 Spring Boot AOP 是什么？ ##

Spring Boot AOP是基于Spring框架和Spring AOP的AOP实现方式，专门针对Spring Boot应用程序提供的一种简化配置和使用的方式。

Spring AOP是Spring框架提供的一种AOP实现方式。AOP是一种编程范式，而Spring AOP是Spring框架对AOP的具体实现。

## 2. AOP 的组成 ##

AOP的组成有：切面、连接点、切点、通知

## 2.1 切面(Aspect) ##

切面是横跨一个或多个类的模块化单元，它定义了与横切关注点相关的行为。切面由切点、通知组成，**它通常以类的形式表示。**

## 2.2 切点(Pointcut) ##

切点（Pointcut）在面向切面编程（AOP）中起到了选择性拦截和应用切面的作用，**它可以被理解为一种规则。**

比如：有一个用户对他人的文章进行评价，这时候需要检测该用户是否登录，只有登录后才能评价。这就是切点，它相当于一种规则。

## 2.3 通知(Advice) ##

通知是切面的一部分，它是在特定切点处执行的具体操作。切面由切点和通知组成，切点用于定义在哪些连接点上应用通知的规则，**而通知定义了在这些连接点上执行的具体操作**。在方法上添加相应的注解就表示相应的通知：

*  前置通知（@Before）：在目标方法执行之前执行的通知。可以在该通知中进行一些准备工作或参数验证。
 *  后置通知（@After）：在目标方法执行之后执行的通知。可以在该通知中进行一些清理工作或记录日志。
 *  返回通知（@AfterReturning）：在目标方法成功执行并返回结果后执行的通知。可以在该通知中对方法的返回值进行处理或执行其他操作。
 *  异常通知（@AfterThrowing）：在目标方法抛出异常后执行的通知。可以在该通知中处理异常或执行相应的异常处理逻辑。
 *  环绕通知（@Around）：在目标方法执行之前和之后都执行的通知。它可以完全控制目标方法的执行过程，包括是否执行目标方法以及如何处理返回值和异常。

## 2.4 连接点(Join Point) ##

连接点是指在应用程序执行过程中的特定点或事件，例如方法的调用、方法的执行、异常的抛出、属性的访问等。\*\*它是AOP中可以插入切面逻辑的地方。\*\*具体来说，连接点是在程序执行期间可以被拦截的点。当程序运行到某个连接点时，AOP框架可以介入并执行相应的切面逻辑。

## 3. Spring Boot AOP 的演示 ##

## 3.1 添加 Spring Boot AOP 依赖 ##

添加如下的代码在 pom.xml文件中：

xml复制代码<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-aop</artifactId>
       <version>2.7.11</version>
    </dependency>

## 3.2 定义切面与切点 ##

切面一般是一个类，它里面有切点与通知，下面是切点的定义方式：

为什么是空方法？因为这个方法的作用是当一个标识。

@Pointcut注解里的表达式就是规则，它的含义：

*  @Pointcut 注解用于定义切点，即被切入的位置。
 *  "execution(\* com.example.demo.controller.UserController.\*(..))" 是切点表达式的内容。
 *  execution() 是切点指示符，表示匹配方法的执行。
 *  \* 表示匹配任意返回类型的方法。
 *  com.example.demo.controller.UserController 是目标类的全限定名，表示匹配该类。
 *  \* 表示匹配类中的任意方法名。
 *  (..) 表示匹配任意参数的方法。

综合起来，这个切点表达式的意思是匹配 com.example.demo.controller.UserController 类中的所有方法，无论方法的返回类型和参数如何。换言之，就是UserController中的所有方法都被拦截了。

execution里的语法规则：

java复制代码execution(<修饰符><返回类型><包.类.方法(参数)><异常>)

其中，修饰符、异常部分可以省略，其它的不能省略。

*  \*：匹配任意字符，可以匹配零个或多个字符。在切点表达式中，\* 通配符可以用于匹配包、类或方法的名称中的任意字符部分。
 *  ..：匹配任意字符，可以匹配零个或多个字符、类或包路径。在切点表达式中，.. 通配符可以用于匹配类或包路径的任意部分，例如 com.example.. 表示匹配 com.example 包及其子包下的所有内容。
 *  \+：表示按照类型匹配指定类的所有子类。在切点表达式中，+ 通配符用于表示指定类的所有子类，包括该类本身。例如，com.example.demo.controller.UserController+ 表示匹配 UserController 类及其所有子类。

## 3.3 定义通知 ##

方法在被拦截后需要做处理，处理就是通知。

## （1）前置通知 + 后置通知 ##

@Before、@After等注解中的属性表示需要匹配的连接点（这里就是），以确定在哪些位置要应用切面的通知。

下面是Controller的代码：

java复制代码@RequestMapping("/user")
    @RestController
    public class UserController {
    
        @RequestMapping("/hi")
        public String hi(){
            System.out.println("执行 UserController 的 hi() 方法");
            return "do user";
        }
    
        @RequestMapping("/login")
        public String login(){
            System.out.println("执行 UserController 的 login() 方法");
            return "do login";
        }
    }

运行并访问：

![format_png][]

![format_png 1][]

## （2）环绕通知 ##

java复制代码@Aspect //切面
    @Component //不能省略，要在项目启动的时候启动
    public class UserAOP {
    
        //切点(配置拦截规则)
        @Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
        public void pointcut(){}
        
        //环绕通知
        @Around("pointcut()")
        public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
            System.out.println("开始执行环绕通知：");
            Object obj = joinPoint.proceed();
            System.out.println("结束环绕通知");
            //这里的 obj 就是 连接点方法的返回值，可以对其进行修改
            obj = "do Around " + obj;
            System.out.println(obj);
            return obj;
        }
    }

在方法doAround中，参数ProceedingJoinPoint joinPoint表示连接点（即目标方法），它可以在环绕通知中被调用和操作。

代码的执行顺序如下：

1.  当连接点被触发时，即目标方法即将执行前，环绕通知doAround会被执行。
2.  第一行代码输出"开始执行环绕通知："，表示环绕通知开始执行。
3.  joinPoint.proceed()调用表示继续执行目标方法，此行代码会触发目标方法的执行，并将目标方法的返回值存储在obj变量中。
4.  第三行代码输出"结束环绕通知"，表示环绕通知的执行已经结束。
5.  下一行的代码对目标方法的返回值进行修改，将其改为"do Around " + obj，并将修改后的值赋给obj变量。
6.  接着，输出修改后的obj的值。
7.  最后，将修改后的obj返回作为目标方法的结果。

结果：

![format_png 2][]

## （3）前置、后置通知 + 环绕通知 ##

java复制代码@Aspect //切面
    @Component //不能省略，要在项目启动的时候启动
    public class UserAOP {
    
        //切点(配置拦截规则)
        @Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
        public void pointcut(){}
    
        //前置通知
        @Before("pointcut()")
        public void doBefore(){
            System.out.println("执行前置通知" + LocalDateTime.now());
        }
    
        //后置通知
        @After("pointcut()")
        public void doAfter(){
            System.out.println("执行后置通知" + LocalDateTime.now());
        }
    
        //环绕通知
        @Around("pointcut()")
        public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
            System.out.println("开始执行环绕通知：");
            Object obj = joinPoint.proceed();
            System.out.println("结束环绕通知");
            //这里的 obj 就是 连接点方法的返回值，可以对其进行修改
            obj = "do Around " + obj;
            System.out.println(obj);
            return obj;
        }
    }

结果：

![format_png 3][]

## （4）返回通知 ##

java复制代码//返回通知
    @AfterReturning("pointcut()")
    public void AfterReturning(){
        System.out.println("执行返回通知");
    }

结果：

![format_png 4][]

## （5）异常通知 ##

java复制代码//异常通知
    @AfterThrowing("pointcut()")
    public void AfterThrowing(){
        System.out.println("执行异常通知");
        // 可以在此处进行异常处理逻辑
    }

java复制代码@RequestMapping("/login")
    public String login(){
        System.out.println("执行 UserController 的 login() 方法");
        throw new ArrayIndexOutOfBoundsException();
    }

结果：

![format_png 5][]

## 4. Spring AOP 实现原理 ##

## 4.1 动态代理 ##

Spring AOP 是构建在动态代理基础上，因此 Spring 对 AOP 的⽀持局限于⽅法级别的拦截。

Spring AOP的简要实现原理：

1.  切入点表达式解析：Spring AOP首先解析定义的切入点表达式，该表达式指定了哪些方法将被织入切面逻辑。
2.  切面逻辑定义：开发人员定义切面逻辑，包括要在目标方法执行前、执行后或抛出异常时执行的逻辑。
3.  创建代理对象：Spring使用动态代理机制，在运行时动态地创建一个代理对象，该代理对象实现了目标对象所实现的接口。代理对象将会拦截目标对象的方法调用。
4.  方法拦截：当客户端调用目标对象的方法时，实际上是调用代理对象的对应方法。代理对象会拦截这个方法调用并执行切面逻辑。
5.  执行切面逻辑：在代理对象的对应方法中，根据切入点表达式判断是否需要执行切面逻辑。如果需要，代理对象会调用切面逻辑的相关方法。
6.  调用目标方法：在切面逻辑执行完毕后，代理对象会继续调用目标对象的实际方法。

![format_png 6][]

织入（Weaving）是指将切面逻辑与目标类进行结合的过程。代理对象的生成时机与织入时机有关。根据织入时机的不同，可以将织入分为以下三种方式：

1.  编译期织入（Compile-Time Weaving）： 切面在目标类编译时被织入。 需要特殊的编译器来支持，例如AspectJ的织入编译器。 在目标类编译期间，切面逻辑被直接织入目标类的字节码中。
2.  类加载期织入（Load-Time Weaving）： 切面在目标类加载到JVM时被织入。 需要特殊的类加载器（ClassLoader）来支持。 在目标类被引入应用之前，通过增强目标类的字节码来织入切面逻辑。 AspectJ5的加载时织入（Load-Time Weaving, LTW）支持这种方式。
3.  运行期织入（Runtime Weaving）： 切面在应用运行的某一时刻被织入。 一般情况下，AOP容器会为目标对象动态创建代理对象。 代理对象通过拦截目标对象的方法调用，在适当的时机执行切面逻辑。 **Spring AOP就是以运行期织入的方式来织入切面。**

Spring AOP支持两种类型的代理：JDK动态代理和CGLIB代理。如果目标对象实现了InvocationHandler接口，Spring将使用JDK动态代理来创建代理对象。如果目标对象没有实现InvocationHandler接⼝，Spring将使用CGLIB代理，通过继承目标对象来创建代理对象。

它们主要区别：

1.  接口要求：JDK动态代理要求目标对象实现接口，而CGLIB代理可以代理没有实现接口的类。
2.  生成方式：**JDK动态代理使用Java的反射机制生成代理对象，而CGLIB代理使用CGLIB库生成代理对象，通过修改目标类的字节码来实现。**
3.  代理对象类型：JDK动态代理生成的代理对象是实现了目标对象所实现的接口，而CGLIB代理生成的代理对象是目标对象的子类。

[format_png]: https://img-blog.csdnimg.cn/img_convert/ffbd9216b186bea6ec92434ade757c04.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/969806b4fb71f4c8757fd2a85efb0d8b.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/bca811cc6379248eef5c67973293c5ed.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/6b3a0f6992f6389da87b784ef714e99a.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/1d6d0babadbb3ba215bf8ec1925dafdc.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/bffc5a4150e627f17cc279416d0c67f1.webp?x-oss-process=image/format,png
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/b05fcca93308cddc6db7f4da3a8493a9.webp?x-oss-process=image/format,png