Springboot AOP 详解

一、测试实例

// 一：拦截有所controller层请求切面定义，注意包路径package com.example.MySpringBootTest;import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;@Aspect
@Component
public class ControllerAspect {@Pointcut("execution(* com.example.MySpringBootTest.controller.*.*(..))")public void controllerMethods() {System.out.println("this is ControllerAspect controllerMethods");}@Before("controllerMethods()")public void beforeControllerMethod(JoinPoint joinPoint) {System.out.println("Before executing controller method: " + joinPoint.getSignature().getName());}@After("controllerMethods()")public void afterControllerMethod(JoinPoint joinPoint) {System.out.println("After executing controller method: " + joinPoint.getSignature().getName());}}// 二：拦截有所service层请求切面定义，注意包路径package com.example.MySpringBootTest;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;@Aspect
@Component
public class ServiceAspect {@Pointcut("execution(* com.example.MySpringBootTest.service.impl.*.*(..))")public void serviceMethod() {}@Before("serviceMethod()")public void beforeMethond() {System.out.println("sevice before method .");}@After("serviceMethod()")public void afterMethod() {System.out.println("service after method .");}@Around("serviceMethod()")public Object aroundControllerMethod(ProceedingJoinPoint pjp) throws Throwable {System.out.println("Around advice - Before calling target method");Object result = pjp.proceed();System.out.println("Around advice - After calling target method");return result;}
}// 三：定义业务service，注意包路径，跟拦截器路径要保持一致，不然拦截器不生效package com.example.MySpringBootTest.service.impl;import org.springframework.cache.annotation.Cacheable;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;@Service
public class Userservice {public String addUser() {System.out.println("Adding user exec .");return "addUser return...";}}// 四：测试结果Before executing controller method: user
Around advice - Before calling target method
sevice before method .
Adding user exec .
service after method .
Around advice - After calling target method
addUser return...
After executing controller method: user

二、原理说明

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它允许开发者在不修改原有业务逻辑的基础上，对程序进行增强，如日志记录、事务管理、权限验证等。下面详细介绍 AOP 的原理及底层实现。

AOP 核心概念

在深入了解 AOP 原理之前，需要先了解几个核心概念：

切面（Aspect）：一个切面可以包含多个通知和切入点，它是横切关注点的模块化，例如日志记录、事务管理等都可以定义为一个切面。
通知（Advice）：通知定义了在目标方法执行的不同时机要执行的操作，常见的通知类型有 @Before（前置通知）、@After（后置通知）、@Around（环绕通知）、@AfterReturning（返回通知）和 @AfterThrowing（异常通知）。
切入点（Pointcut）：切入点用于定义哪些方法会被增强，通过表达式来匹配目标方法，例如 execution(* com.example.service.*.*(..)) 表示匹配 com.example.service 包下所有类的所有方法。
连接点（Join Point）：连接点是程序执行过程中可以插入切面的点，在 Java 中通常指方法的执行。
目标对象（Target Object）：被一个或多个切面增强的对象。
代理对象（Proxy Object）：通过 AOP 框架创建的包含增强逻辑的对象，客户端调用的实际上是代理对象。

AOP 原理

AOP 的核心原理是通过代理模式，在目标对象的基础上创建一个代理对象，将切面逻辑织入到目标对象的方法执行过程中。当客户端调用代理对象的方法时，代理对象会在目标方法执行的前后或周围插入切面逻辑，从而实现对目标方法的增强。

三、AOP 底层实现方式

1. JDK 动态代理

原理：JDK 动态代理是基于接口的代理方式，它通过 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来实现。当使用 JDK 动态代理时，目标对象必须实现至少一个接口，代理对象会实现相同的接口，从而可以替代目标对象。
示例代码：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;// 定义接口
interface Subject {void request();
}// 实现接口的目标对象
class RealSubject implements Subject {@Overridepublic void request() {System.out.println("RealSubject: Handling request.");}
}// 实现 InvocationHandler 接口的代理处理器
class ProxyHandler implements InvocationHandler {private Object target;public ProxyHandler(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("Before method execution");Object result = method.invoke(target, args);System.out.println("After method execution");return result;}
}// 测试代码
public class JdkProxyExample {public static void main(String[] args) {RealSubject realSubject = new RealSubject();ProxyHandler proxyHandler = new ProxyHandler(realSubject);Subject proxySubject = (Subject) Proxy.newProxyInstance(Subject.class.getClassLoader(),new Class<?>[]{Subject.class},proxyHandler);proxySubject.request();}
}

优缺点：
- 优点：基于 JDK 原生实现，无需额外依赖，性能较高。
- 缺点：只能代理实现了接口的类，无法代理普通类。

Springboot 工作流程说明

工作流程概述

当开启 Spring AOP 功能后，Spring 会在容器初始化时为需要增强的目标对象创建代理对象。在客户端调用这些目标对象的方法时，实际上调用的是代理对象的对应方法。代理对象会根据 AOP 配置的切面逻辑，在目标方法执行前后插入相应的通知（如前置通知、后置通知等），然后再调用真实对象的方法，从而实现对真实对象方法的增强。

详细说明

1. 代理对象的创建

Spring 会根据目标对象是否实现接口来选择不同的代理方式：

JDK 动态代理：如果目标对象实现了接口，Spring 会使用 JDK 动态代理创建代理对象。代理对象会实现与目标对象相同的接口，客户端通过接口类型引用代理对象。
CGLIB 代理：如果目标对象没有实现接口，Spring 会使用 CGLIB 代理创建代理对象。CGLIB 代理通过继承目标类来创建代理对象，客户端可以通过目标类类型引用代理对象。

2. 调用过程示例

以下是一个简单的 Spring Boot AOP 示例，展示代理对象的调用过程：

定义接口和实现类

// 定义接口
public interface UserService {void saveUser();
}// 实现接口的目标类
import org.springframework.stereotype.Service;@Service
public class UserServiceImpl implements UserService {@Overridepublic void saveUser() {System.out.println("Saving user...");}
}

定义切面类

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;@Aspect
@Component
public class UserServiceAspect {// 定义切入点@Pointcut("execution(* com.example.service.UserService.*(..))")public void userServiceMethods() {}// 前置通知@Before("userServiceMethods()")public void beforeSaveUser() {System.out.println("Before saving user...");}// 后置通知@After("userServiceMethods()")public void afterSaveUser() {System.out.println("After saving user...");}
}

测试调用

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class DemoApplication implements CommandLineRunner {@Autowiredprivate UserService userService;public static void main(String[] args) {SpringApplication.run(DemoApplication.class, args);}@Overridepublic void run(String... args) throws Exception {// 调用代理对象的方法userService.saveUser();}
}

3. 调用过程分析

当 DemoApplication 中的 userService.saveUser() 被调用时，由于 UserService 是一个接口，Spring 会使用 JDK 动态代理创建一个实现了 UserService 接口的代理对象。
代理对象在接收到 saveUser 方法调用后，会先执行 UserServiceAspect 中定义的前置通知 beforeSaveUser 方法。
接着，代理对象会调用真实的 UserServiceImpl 对象的 saveUser 方法。
最后，代理对象会执行 UserServiceAspect 中定义的后置通知 afterSaveUser 方法。

总结

通过使用代理对象，Spring AOP 可以在不修改目标对象代码的情况下，灵活地在目标方法执行前后插入自定义的增强逻辑，实现诸如日志记录、事务管理、权限验证等功能。

2. CGLIB 代理

1. CGLIB 代理原理概述

CGLIB（Code Generation Library）是一个强大的、高性能的代码生成库，它被广泛用于实现 AOP 中的代理机制。CGLIB 代理的核心原理是通过字节码技术，在运行时动态生成目标类的子类，并重写目标类的方法，在重写的方法中插入额外的增强逻辑，从而实现对目标类方法的代理。与 JDK 动态代理不同，JDK 动态代理要求目标对象必须实现接口，而 CGLIB 代理可以直接对普通类进行代理，因为它是通过继承目标类来实现的。

2. 底层实现细节

CGLIB 主要基于以下几个关键类和技术来实现代理：

Enhancer 类：这是 CGLIB 中用于创建代理对象的核心类。它允许开发者指定要代理的目标类、回调接口（用于处理方法调用）等信息，然后通过 create() 方法创建代理对象。
MethodInterceptor 接口：这是一个回调接口，当代理对象的方法被调用时，会触发 MethodInterceptor 接口的 intercept 方法。在 intercept 方法中，开发者可以编写自定义的增强逻辑，并决定是否调用目标对象的原始方法。
字节码生成技术：CGLIB 使用字节码生成库（如 ASM）来动态生成代理类的字节码。在运行时，它会根据目标类的信息和开发者指定的回调逻辑，生成一个新的子类字节码，并加载到 JVM 中。

3. 用例说明

3.1 添加依赖

如果你使用的是 Maven 项目，需要在 pom.xml 中添加 CGLIB 依赖：

<dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.4.0</version>
</dependency>

3.2 定义目标类

// 目标类，没有实现任何接口
public class TargetClass {public void doSomething() {System.out.println("TargetClass is doing something.");}
}

3.3 实现 `MethodInterceptor` 接口

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;import java.lang.reflect.Method;// 实现 MethodInterceptor 接口，用于处理方法调用
public class MyMethodInterceptor implements MethodInterceptor {@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {// 在目标方法执行前添加增强逻辑System.out.println("Before method execution");// 调用目标对象的原始方法Object result = proxy.invokeSuper(obj, args);// 在目标方法执行后添加增强逻辑System.out.println("After method execution");return result;}
}

3.4 创建代理对象并测试

import net.sf.cglib.proxy.Enhancer;public class CglibProxyExample {public static void main(String[] args) {// 创建 Enhancer 对象Enhancer enhancer = new Enhancer();// 设置要代理的目标类enhancer.setSuperclass(TargetClass.class);// 设置回调接口enhancer.setCallback(new MyMethodInterceptor());// 创建代理对象TargetClass proxy = (TargetClass) enhancer.create();// 调用代理对象的方法proxy.doSomething();}
}

4. 代码解释

Enhancer 类：用于创建代理对象。通过 setSuperclass 方法指定要代理的目标类，通过 setCallback 方法指定回调接口（即 MethodInterceptor 的实现类），最后调用 create 方法创建代理对象。
MyMethodInterceptor 类：实现了 MethodInterceptor 接口，在 intercept 方法中，我们可以在目标方法执行前后添加自定义的增强逻辑。proxy.invokeSuper(obj, args) 用于调用目标对象的原始方法。
测试代码：创建代理对象并调用其方法，此时会触发 MyMethodInterceptor 的 intercept 方法，从而实现对目标方法的增强。

5. 注意事项

由于 CGLIB 是通过继承目标类来实现代理的，所以目标类不能是 final 类，因为 final 类不能被继承。
目标类中的 final 方法也不能被代理，因为 final 方法不能被重写。

四、两种代理方式比较

在 Java 中，JDK 动态代理和 CGLIB 代理是实现 AOP（面向切面编程）时常用的两种代理方式，下面从多个方面对它们进行比较。

1. 代理机制

JDK 动态代理
- 基于接口实现。它通过 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来创建代理对象，代理对象会实现与目标对象相同的接口。客户端调用代理对象时，实际上是调用 InvocationHandler 的 invoke 方法，在该方法中可以实现对目标方法的增强。
CGLIB 代理
- 基于继承实现。CGLIB（Code Generation Library）是一个强大的、高性能的代码生成库，它通过字节码技术在运行时动态生成目标类的子类，并重写目标类的方法，在重写的方法中插入增强逻辑。

2. 适用场景

JDK 动态代理
- 适用于目标对象实现了接口的情况。当目标对象有明确的接口定义时，使用 JDK 动态代理可以保证代码的规范性和可维护性，符合面向接口编程的原则。
CGLIB 代理
- 适用于目标对象没有实现接口的情况。由于 CGLIB 是通过继承目标类来创建代理对象，所以可以对普通类进行代理，弥补了 JDK 动态代理只能代理接口的不足。

3. 性能表现

JDK 动态代理
- 创建代理对象的速度较快，因为它是基于 Java 反射机制实现的，只需要在运行时动态生成代理类的字节码并加载到 JVM 中。但在方法调用时，由于需要通过反射来调用目标方法，会有一定的性能开销。
CGLIB 代理
- 创建代理对象的速度相对较慢，因为它需要使用字节码生成技术动态生成目标类的子类字节码，涉及到复杂的字节码操作。但在方法调用时，由于是直接调用子类的方法，不需要通过反射，所以方法调用的性能较高。

4. 代码复杂度

JDK 动态代理
- 代码相对简单，只需要实现 InvocationHandler 接口，并重写 invoke 方法即可。对于熟悉 Java 反射机制的开发者来说，容易理解和掌握。
CGLIB 代理
- 代码稍微复杂一些，需要引入 CGLIB 库，并且要实现 MethodInterceptor 接口，在 intercept 方法中处理方法调用和增强逻辑。同时，还需要使用 Enhancer 类来创建代理对象。

5. 限制条件

JDK 动态代理
- 只能代理实现了接口的类，无法对普通类进行代理。如果目标对象没有实现接口，使用 JDK 动态代理会抛出异常。
CGLIB 代理
- 目标类不能是 final 类，因为 final 类不能被继承。同时，目标类中的 final 方法也不能被代理，因为 final 方法不能被重写。

6. Spring AOP 中的选择

Spring AOP 在默认情况下会根据目标对象是否实现接口来选择代理方式：
- 如果目标对象实现了接口，Spring AOP 会使用 JDK 动态代理。
- 如果目标对象没有实现接口，Spring AOP 会使用 CGLIB 代理。
- 也可以通过配置强制使用 CGLIB 代理，例如在 Spring Boot 中，可以通过在配置类上添加 @EnableAspectJAutoProxy(proxyTargetClass = true) 注解来实现。