Spring 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.10</version>
</dependency>

4.2 定义切面，切点，通知

@Aspect // 切面
@Component  // 不能忽略
public class UserAOP {
    // 切点 (配置拦截规则)
    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))") // 切点(配置拦截规则)
    public void pointcut() {
    }

    // 前置通知 @Before里面的参数取决于 切点的方法名
    @Before("pointcut()")
    public void doBefore() {
        System.out.println("执行了前置通知: " + LocalDateTime.now());
    }
}

4.3 定义连接点

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;



@Controller
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 "do user login";
    }
}

访问：localhost:8080/user/sayhi 后：控制台信息如下：

4.4 关于环绕通知的扩展

4.4.1 环绕通知与前后置通知的执行顺序

我们先来看一组代码：

package com.example.demo.common;


import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

@Aspect // 切面
@Component  // 不能忽略
public class UserAOP {
    // 切点 (配置拦截规则)
    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))") // 切点(配置拦截规则)
    public void pointcut() {
    }

    // 前置通知 @Before里面的参数取决于 切点的方法名
    @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;
    }
}

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@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 "do user login";
    }
}

执行结果如下:

我们发现，环绕通知始终是与最外侧的，这是因为joinPoint.proceed执行的是login方法本身，相应的，只有执行到方法本身时候，才会调用相对应的前置通知和后置通知。

因此也就有了这里环绕通知始终在最外侧的体现。

4.4.2 环绕通知和CGLIB的关系

使用以上程序代码，在 Object obj = joinPoint.proceed();处打一个断点，再次访问localhost:8080/user/login 就会发现，其内部是使用了CGLIB代理，通过这个代理调用了方法本身，也就是login方法。

如何利用环绕通知来统计方法的执行时间？

package com.example.demo.common;


import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

@Aspect // 切面
@Component  // 不能忽略
public class UserAOP {
    // 切点 (配置拦截规则)
    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))") // 切点(配置拦截规则)
    public void pointcut() {
    }

    // 前置通知 @Before里面的参数取决于 切点的方法名
    @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("环绕通知开始了");
        long startTime = System.currentTimeMillis();
        Object obj = joinPoint.proceed();
        String methodName = joinPoint.getSignature().getName();
        System.out.println("环绕通知结束了");
        long endTime = System.currentTimeMillis();
        long executionTime = endTime-startTime;
        System.out.println(methodName+"执行时间为: "+executionTime);
        return obj;
    }

}

运行结果：

五、Spring AOP 实现原理

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

Spring AOP 支持 JDK Proxy 和CGLIB 方式实现动态代理。默认情况下，实现了接口的类，使用AOP会基于JDK生成代理类，没有实现接口的类，会基于CGLIB生成代理类。

织入（Weaving）：代理的生成时机

织入是把切面应用到目标对象并创建新的代理对象的过程。

织入的过程可以在编译时，类加载时或运行时进行。根据织入的时间不同，有以下几种织入方式：

编译时织入：在编译源代码成字节码的过程中，将切面代码织入到目标类中。例如 lombok就属于编译时织入。
类加载时织入：在类加载过程中，通过类加载器将切面逻辑织入到目标类中。例如JVM在垃圾回收时有个类就属于类加载织入，其是在类加载过程中就织入到JVM中的。
运行时织入：在目标对象的方法执行过程中，动态的将切面代码织入到方法的不同执行点。

SpringAOP就是属于运行时织入切面的。

5.1 AOP实现技术（静态代理，动态代理）

静态代理

静态代理是一种编译时就已经确认代理关系的代理方式。在静态代理中，代理类和被代理类都要实现同一个接口或继承同一个父类，代理类中包含了被代理类的实例，并在调用被代理的方法前后执行相应的操作。

静态代理的优点是实现简单，易于理解和掌握，但是缺点是需要为每个被代理类编写一个代理类，当被代理类的数量增多时候，代理量会变得很大。

动态代理

动态代理是一种在运行时动态生成代理类的代理方式。在动态代理中，代理类不需要实现同一个接口或继承同一个父类，而是通过Java反射机制动态生成代理类，并在调用被代理类的方法前后执行相应的操作。

动态代理的优点是可以为多个被代理类生成同一个代理类，从而减少了代码量，但是它的缺点是实现相对复杂，需要理解JAVA反射机制和动态生成字节码的技术。

5.2 SpringAOP为什么仅限于对方法级别的拦截

JDK动态代理的限制: JDK动态代理只能代理实现了接口的类。在Spring AOP中，如果目标对象实现了接口，Spring将使用JDK动态代理来创建代理对象。由于JDK动态代理是基于接口实现的，它只能代理目标对象接口中声明的方法，无法代理目标对象内部的其他方法。
CGLIB动态代理的限制:CGLIB动态代理可以代理没有实现接口的类，在SpringAOP中，如果目标对象没有实现接口，Spring将使用CGLIB动态代理来创建代理对象，尽管CGLIB动态代理可以代理目标对象的所有方法，但是也存在限制，比如无法代理被标记为final的方法。

总结:

虽然 Spring AOP 的支持仅限于方法级别，但是这足以满足大部分应用中的拦截和增强需求。对于更复杂的场景，如果需要更精细的控制和更广泛的横切逻辑，可以考虑使用 AspectJ 等更强大的 AOP 框架。

5.3 JDK动态代理和CGLIB动态代理的区别

JDK动态代理和CGLIB动态代理都是最常见的动态代理实现技术，但它们有以下区别：
JDK动态代理基于接口，要求目标对象实现接口；CGLIB动态代理基于类，可以代理没有实现接口的目标对象。
JDK动态代理使用java.lang.reflect.Proxy 和 java.lang.reflect.InvocationHandler 来生成代理对象；CGLIB动态代理使用CGLIB库生成代理对象
JDK动态代理生成的代理对象是目标对象的接口实现，CGLIB动态代理生成的代理对象是目标对象的子类
JDK动态代理性能相对较高，生成代理对象速度较快，CGLIB动态代理性能相对较低，生成代理对象速度较慢。
CGLIB动态代理无法代理final类和final方法，JDK动态代理可以代理任意类。

总结：

简单来说，JDK动态代理要求被代理类实现接口，而CGLIB要求被代理类不能是final修饰的最终类，在JDK8意思版本中，因为JDK动态代理做了专门的优化，所以它的性能比CGLIB高。