一.什么是AOP

AOP，全称为Aspect-Oriented Programming（面向切面编程），是一种编程范式和软件设计思想。它是面向对象编程（OOP）的一种补充和扩展，用于解决OOP中的一些横切关注点（cross-cutting concerns）问题。
用一句话来概括的话,AOP (Aspect Oriented Programming)︰面向切面编程，它是一种思想，它是对某一类事情的集中处理。

二.AOP的组成部分

• 切面
  我一般称之为类.这个切面值得就是具体的内容,一般来说,我们针对一个具体的内容,我们就称之为切面.举个例子来说,用户登录模块就是一个切面.

• 切点
  切点,具体就是一个方法,它定义了拦截规则.

• 通知
  如果说切点是方法的话,通知就是具体的一个实现代码.
  它里面有:
  1.前置通知:在目标方法（实际要执行的方法）调用之前执行的通知;
  2.后置通知:在目标方法调用之后执行的通知;
  3.环绕通知:在目标方法调用前、后都执行的通知l;
  4.异常通知:在目标方法抛出异常的时候执行的通知;
  5.返回通知:在目标方法返回的时候执行通知。

• 连接点
  所有可能触发切点的点,就叫做连接点.

• 织入：
  将切面应用到目标对象中的过程，可以在编译时、加载时或运行时进行

三.SpringAOP的实现

3.1 增加SpringAOP依赖

这里不是spring自带的aop依赖,我们要去下载springboot的aop依赖

<!-- 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.14</version>
</dependency>

3.2 创建切面

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
@Aspect //切面
@Component //不能省略
public class UserAOP {
}

3.2 创建切点

//定义切点@Pointcut("execution(* com.example.demo.controller.UserController.*(..))")public void pointcut() {}

3.3 创建通知

 //前置通知@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("结束环绕通知了");return obj;}

3.4 创建连接点

@RestController
public class UserController {@RequestMapping("/user/sayHi")public String sayHi(){System.out.println("执行了sayHi方法");return "hi spring boot aop.";}@RequestMapping("/user/login")public String Login(){System.out.println("执行了login方法");return "hi spring boot aop.";}}

四.SpringAOP的实现原理

Spring AOP是构建在动态代理基础上，因此Spring对AOP的支持局限于方法级别的拦截。
Spring AOP支持 JDK Proxy和CGLIB方式实现动态代理。默认情况下，实现了接口的类，使用AOP会基于JDK生成代理类，没有实现接口的类，会基于CGLIB生成代理类。

动态代理的常用实现方法有以下两种:
此种实现在设计模式上称为动态代理模式，在实现的技术⼿段上，都是在 class 代码运⾏期，动
态的织⼊字节码。

4.1 JDK动态代理

具体来说，当使用 JDK 动态代理时，需要定义一个实现 InvocationHandler 接口的类，并在该类中实现代理类的具体逻辑。然后，通过 Proxy.newProxyInstance() 方法来创建代理类的实例。该方法接受三个参数：类加载器、代理类要实现的接口列表和 InvocationHandler 对象
代码如下:

import org.example.demo.service.AliPayService;
import org.example.demo.service.PayService;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;//动态代理：使用JDK提供的api（InvocationHandler、Proxy实现），此种方式实现，要求被代理类必须实现接口
public class PayServiceJDKInvocationHandler implements InvocationHandler {//目标对象即就是被代理对象private Object target;public PayServiceJDKInvocationHandler( Object target) {this.target = target;}//proxy代理对象@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//1.安全检查System.out.println("安全检查");//2.记录日志System.out.println("记录日志");//3.时间统计开始System.out.println("记录开始时间");//通过反射调用被代理类的方法Object retVal = method.invoke(target, args);//4.时间统计结束System.out.println("记录结束时间");return retVal;}public static void main(String[] args) {PayService target=  new AliPayService();//方法调用处理器InvocationHandler handler = new PayServiceJDKInvocationHandler(target);//创建一个代理类：通过被代理类、被代理实现的接口、方法调用处理器来创建PayService proxy = (PayService) Proxy.newProxyInstance(target.getClass().getClassLoader(),new Class[]{PayService.class},handler);proxy.pay();}
}

4.2 CGLIB 动态代理

CGLIB 动态代理是一种使用 CGLIB 库来实现动态代理的技术。在 CGLIB 动态代理中，代理类不需要实现接口，而是通过继承被代理类来实现代理。 具体来说，当使用 CGLIB 动态代理时，需要定义一个继承被代理类的子类，并在该子类中实现代理类的具体逻辑。然后，通过 Enhancer.create() 方法来创建代理类的实例。该方法接受一个类作为参数，表示要代理的类，如下代码所示：

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.example.demo.service.AliPayService;
import org.example.demo.service.PayService;import java.lang.reflect.Method;public class PayServiceCGLIBInterceptor implements MethodInterceptor {//被代理对象private Object target;public PayServiceCGLIBInterceptor(Object target){this.target = target;}@Overridepublic Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {//1.安全检查System.out.println("安全检查");//2.记录日志System.out.println("记录日志");//3.时间统计开始System.out.println("记录开始时间");//通过cglib的代理方法调用Object retVal = methodProxy.invoke(target, args);//4.时间统计结束System.out.println("记录结束时间");return retVal;}public static void main(String[] args) {PayService target=  new AliPayService();PayService proxy= (PayService) Enhancer.create(target.getClass(),new PayServiceCGLIBInterceptor(target));proxy.pay();}
}

总结

综上所述，动态代理的实现方法主要有 JDK 动态代理和 CGLIB 动态代理。JDK 动态代理中，代理类必须实现一个或多个接口，而 CGLIB 动态代理中，代理类不需要实现接口，但代理类不能是 final 类型，因为它是通过定义一个被代理类的子类来实现动态代理的，因此开发者需要根据具体的需求选择合适的技术来实现动态代理。