一. AOP是什么？
AOP（Aspect Oriented Programming）：面向切面编程，它是一种编程思想，是对某一类事情的集中处理；它能够在不改原有代码的前提下对其功能进行增强，就是你代码已经写好了，使用 AOP 可以在不改动代码的前提下增强功能，如对于一个功能，可以基于 AOP 完成对该功能执行效率的计算，能够在功能正式执行前或者执行后，添加其他的功能执行，能够在该功能发生异常后，对其异常进行处理。
想象一个场景，我们在做后台系统时，除了登录和注册等几个功能不需要做用户登录验证之外，其他几乎所有页面都需要先验证用户登录的状态，那这个时候我们要怎么处理呢？
如果不使用 AOP，我们就需要在每一个 Controller 层都写一遍验证用户是否已经登录的逻辑，如果你实现的功能有很多，并且这些功能都需要进行登录验证，那你就需要编写大量重复的代码， 这样代码修改和维护的成本也会很高。
但如果使用 AOP，在进入核心的业务代码之前会做统一的一个拦截，去验证用户是否登录，验证通过的就可以继续请求，此时就不需要每一处都写相同的用户登录逻辑了。
除了登录验证功能之外，还有很多功能也可以使用 AOP，比如：
- 统一日志记录与持久化。
- 统一方法执行时间统计。
- 统一数据返回格式。
- 统一处理程序中的异常。
- 统一事务的开启与提交。
也就是说使用 AOP 可以扩充多个对象的某个能力，所以 AOP 可以说是 OOP （Object Oriented Programming，面向对象编程）的补充和完善，它可以将横切关注点从应用程序的主业务逻辑中分离出来，使得这些关注点可以集中处理，从而提高代码复用性、可维护性和系统可扩展性。
SpringAOP 是一个框架，提供了对 AOP 的实现，与 IOC 与 DI 的关系类似。
二. AOP相关概念
- 切面（Aspect）–> 类：某一方面的具体内容处理（AOP实现的某个功能的集合）就是一个切面，由切点（Pointcut）和通知（Advice）组成 ；比如用户登录判断就是一个切面（接口对于登录权限的校验）。
- 切点（Pointcut）–>方法：定义拦截规则；比如切面对于哪些接口需要进行判断拦截。
- 连接点（Joinpoint）：所有可能触发切点的点就是连接点（被这个切面所处理的点）。
- 通知（方法的具体实现）：执行 AO P业务（具体需要执行的拦截方法）。
在 Spring 切面类中，可以在方法上使用以下注解，会设置方法为通知方法，在满足条件后会调用对应满足条件的方法：
- 前置通知使用 @Before∶通知方法会在目标方法调用之前执行。
- 后置通知使用 @After∶通知方法会在目标方法返回或者抛出异常后调用。
- 返回之后通知使用 @AfterReturning∶ 通知方法会在目标方法返回后调用。
- 抛异常后通知使用 @AfterThrowing∶ 通知方法会在目标方法抛出异常后调用。
- 环绕通知使用 @Around∶通知包裹了被通知的方法，在被通知的方法通知之前和调用之后执行自定义的行为。
AOP 整个组成部分的概念如下图所示，以多个⻚⾯都要访问⽤户登录权限为例：
三. SpringAOP的简单演示
1️⃣第一步，添加 Spring Boot AOP 依赖支持。
在 SpringBoot 项目中导入 AOP 依赖时可以不设置版本号，SpringBoot 会帮助我们自动适配。
<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-aop -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
<version>2.7.2</version>
</dependency>
2️⃣第二步，定义切面，我们使用@Aspect注解将类标识为切面类，并使用注解 @Component 将类实例化到容器中。
package com.example.demo.common;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Aspect // 定义切面
@Component
public class UserAspect {
}
3️⃣第三步，定义切点，配置拦截规则，可以使用AspectJ表达式类来进行描述，它的语法格式如下：
切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名）
AspectJ ⽀持三种通配符：
-
*：匹配任意字符，只匹配⼀个元素（包，类，或⽅法，⽅法参数）。 -
..：匹配任意字符，可以匹配多个元素 ，在表示类时，必须和*联合使⽤。 -
+：表示按照类型匹配指定类的所有类，必须跟在类名后⾯，如com.cad.Car+，表示继承该类的
所有⼦类包括本身。
其中访问修饰符和异常可以省略，比如下面这个表达式：
任意声明一个方法，不需要具体实现，使用注解@Pointcut修饰，里面的value属性填写AspectJ表达式，这个方法就可以视为连接目标方法的一个切点。
但要注意，这种表达式的书写是非常繁琐的，目前有更好的AOP实现，可以更加灵活的配置，也就是说这里的写法其实并不常用。
代码实现：
@Aspect // 定义切面
@Component
public class UserAspect {
// 切点
@Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
public void pointcut() {
}
}
4️⃣第四步，创建通知。
有了切点，要对切点处的方法进行相关处理，需要编写具体的增强方法，也就是通知，下面我们需要在切面类中简单编写几个方法来表示通知，通知就是将共性功能抽取出来后形成的方法。
要注意对于环绕通知，由于在实现增强方法时，需要介入到方法执行前和后，那么必须得获取到目标的方法，不然无法控制你实现的那些代码是在目标方法执行前执行的，哪些方法是在目标方法执行后执行的。
对于这项工作，SpringAOP 已经帮我们做了，所有的切点方法都已经加载到ProceedingJoinPoint对象当中，只要调用proceed方法就能够执行目标方法。
package com.example.demo.common;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Aspect // 定义切面
@Component
public class UserAspect {
// 切点
@Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
public void pointcut() {
}
// 前置通知通知
@Before("pointcut()")
public void doBefore() {
System.out.println("执行了前置通知");
}
// 后置通知
@After("pointcut()")
public void doAfter() {
System.out.println("执行了后置通知");
}
// 环绕通知
@Around("pointcut()")
public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("环绕通知执行之前");
// 执行目标方法
Object result = joinPoint.proceed();
System.out.println("环绕通知执行之后");
return result;
}
}
5️⃣第五步，创建连接点。
package com.example.demo.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/user")
public class UserController {
@RequestMapping("/getuser")
public String getUser(){
System.out.println("do getUser");
return "get user";
}
@RequestMapping("/deluser")
public String delUser(){
System.out.println("do delUser");
return "del user";
}
}
🍂此时，就可以启动 SpringAOP 了，然后通过浏览器去访问定义的这两个连接点，看通知效果。
🍂我们可以在Controller层再创建一个ArticleController类用来对照，访问一下看此时是否会执行通知。
package com.example.demo.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/art")
public class ArticleController {
@RequestMapping("/getart")
public String getArticle(){
System.out.println("do getArticle");
return "getArticle";
}
}
结果如下：
因为我们设置的拦截规则不包含这个类，也就不会执行通知了。
四. SpringAOP实现原理
Spring AOP 是构建在动态代理基础上，因此 Spring 对 AOP 的支持局限于方法级别的拦截（使用动态代理技术实现方法的调用）。
Spring AOP 支持 JDK Proxy 和 CGLIB 方式实现动态代理。默认情况下，实现了接口的类，使用 SpringAOP 会基于 JDK 生成代理类，没有实现接口的类，会基于 CGLIB 生成代理类。
下面简单的来说一下原理，首先，要有一个目标对象，在上面的例子中，目标对象就是UserController，然后通过基于这个目标对象，创建一个代理类，并在某一规定的时机生成，这个时机就是织入，最后在这个代理类上加上一些增强的方法，这个过程就叫做引入。
🎯下面又出来了一组相关概念：
目标对象：代理的目标对象。
织入（weaving）: 即代理的生成时机，织入是把切面应用到目标对象并创建新的代理对象的过程，切面在指定的连接点被织入到目标对象中。在目标对象的生命周期里有多个点可以进行织入∶
- 编译期∶切面在目标类编译时被织入。这种方式需要特殊的编译器。AspectJ 的织入编译器就是以这种方式织入切面的。
- 类加载器∶切面在目标类加载到 JVM 时被织入。这种方式需要特殊的类加载器（ClassLoader），它可以在目标类被引入应用之前增强该目标类的字节码。AspectJ5 的加载时织入（load-time weaving.LTW）就支持以这种方式织入切面。
- 运行期∶切面在应用运行的某一时刻被织入。一般情况下，在织入切面时，AOP 容器会为目标对象动态创建一个代理对象。SpringAOP 就是以这种方式织入切面的。
引入（introduction）：在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段。文章来源：https://www.toymoban.com/news/detail-702347.html
🍂JDK Proxy 与 CGLIB 的区别：文章来源地址https://www.toymoban.com/news/detail-702347.html
- 出身不同，一个由 JDK 实现，一个由 CGLIB 实现。
- 实现不同，JDK Proxy 要求代理类实现接口才能实现代理，它只能代理接口中定义的方法；CGLIB 是通过实现代理类的子类完成动态代理，可以为任意一个类创建代理对象，包括没有实现任何接口的类，它能够代理类中所有非 final 的方法。
- 性能不同，JDK7 之后 JDK Proxy 性能是略高于 CGLIB 的; 而在 JDK7 之前 CGLIB 性能是略高于 JDK Proxy 的。
到了这里，关于SpringAOP面向切面编程的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
![[SSM]Spring面向切面编程AOP](https://imgs.yssmx.com/Uploads/2024/02/618178-1.png)
