Spring AOP 代理机制：CGLIB/JDK 动态代理的字节码差异与性能对比
大家好，今天我们来聊聊 Spring AOP 中两种主要的代理机制：CGLIB 和 JDK 动态代理。理解这两种代理方式的底层原理，特别是它们生成的字节码差异，对于我们选择合适的代理方式，以及优化 AOP 性能至关重要。
1. AOP 代理概述
在 Spring AOP 中，代理对象是核心。当我们配置了 AOP 切面后，Spring 会根据目标对象（被代理的对象）的类型和配置的代理接口，选择合适的代理方式来创建代理对象。代理对象会拦截对目标对象方法的调用，并在调用前后执行增强逻辑（Advice）。
Spring AOP 提供了两种主要的代理方式：
- JDK 动态代理 (JDK Dynamic Proxy): 基于接口实现代理。如果目标对象实现了接口，Spring 默认使用 JDK 动态代理。
- CGLIB (Code Generation Library): 基于继承实现代理。如果目标对象没有实现接口，Spring 会使用 CGLIB 创建代理。
2. JDK 动态代理
JDK 动态代理是 Java 原生提供的代理机制。它通过 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来实现。
原理:
- 接口约束: 目标对象必须实现接口。
- 动态生成代理类: JDK 动态代理在运行时动态生成一个代理类，该代理类实现了目标对象实现的接口。
- InvocationHandler: 代理类的每个方法调用都会被转发到
InvocationHandler的invoke方法。 - 方法拦截与增强: 在
invoke方法中，我们可以拦截方法调用，并在调用目标对象的方法前后执行增强逻辑。
代码示例:
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface MyInterface {
void doSomething();
}
class MyClass implements MyInterface {
@Override
public void doSomething() {
System.out.println("MyClass.doSomething() is called.");
}
}
class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before method: " + method.getName());
Object result = method.invoke(target, args);
System.out.println("After method: " + method.getName());
return result;
}
}
public class JDKDynamicProxyExample {
public static void main(String[] args) {
MyInterface target = new MyClass();
MyInvocationHandler handler = new MyInvocationHandler(target);
MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
handler
);
proxy.doSomething();
}
}字节码差异:
通过反编译 JDK 动态代理生成的类，我们可以看到它实现了目标对象实现的接口，并且所有的接口方法都被转发到 InvocationHandler 的 invoke 方法。
例如，如果 MyInterface 只有一个 doSomething() 方法，那么生成的代理类（假设叫做 $Proxy0）会包含以下内容（简化）：
// $Proxy0
public final class $Proxy0 extends Proxy implements MyInterface {
private static Method m1; // doSomething
public $Proxy0(InvocationHandler h) {
super(h);
}
public final void doSomething() throws Throwable {
try {
super.h.invoke(this, m1, (Object[])null);
} catch (RuntimeException | Error throwable) {
throw throwable;
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
static {
try {
m1 = Class.forName("MyInterface").getMethod("doSomething", (Class[])null);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
}
}
}可以看到：
$Proxy0继承自Proxy类，并实现了MyInterface接口。doSomething()方法调用了super.h.invoke(this, m1, (Object[])null)，其中super.h是InvocationHandler的实例。m1是MyInterface中doSomething()方法的Method对象。
3. CGLIB 代理
CGLIB 是一个强大的高性能代码生成库。它可以在运行时动态生成 Java 类。
原理:
- 继承: CGLIB 通过继承目标类来创建代理类。
- 方法拦截: CGLIB 使用
MethodInterceptor接口来拦截方法调用。 - FastClass: CGLIB 使用
FastClass机制来优化方法调用，避免使用反射，提高性能。
代码示例:
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
class MyClass {
public void doSomething() {
System.out.println("MyClass.doSomething() is called.");
}
public final void doFinalMethod() {
System.out.println("MyClass.doFinalMethod() is called.");
}
private void doPrivateMethod() {
System.out.println("MyClass.doPrivateMethod() is called.");
}
}
class MyMethodInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("Before method: " + method.getName());
Object result = proxy.invokeSuper(obj, args); // 使用 MethodProxy 调用父类方法
System.out.println("After method: " + method.getName());
return result;
}
}
public class CGLIBProxyExample {
public static void main(String[] args) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(MyClass.class);
enhancer.setCallback(new MyMethodInterceptor());
MyClass proxy = (MyClass) enhancer.create();
proxy.doSomething();
proxy.doFinalMethod();
// 私有方法不能被代理，会报错
// proxy.doPrivateMethod();
}
}字节码差异:
通过反编译 CGLIB 生成的代理类，我们可以看到它继承了目标类，并重写了目标类中的方法。
例如，如果 MyClass 有一个 doSomething() 方法，那么生成的代理类（假设叫做 MyClass$$EnhancerByCGLIB$$...）会包含以下内容（简化）：
// MyClass$$EnhancerByCGLIB$$...
public class MyClass$$EnhancerByCGLIB$$... extends MyClass implements Factory {
private MethodInterceptor CGLIB$CALLBACK_0;
private static Method CGLIB$doSomething$0$Method;
private static MethodProxy CGLIB$doSomething$0$Proxy;
final void doSomething() {
super.doSomething();
}
public final void CGLIB$doSomething$0() {
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (var10000 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
if (var10000 != null) {
try {
var10000.intercept(this, CGLIB$doSomething$0$Method, CGLIB$emptyArgs, CGLIB$doSomething$0$Proxy);
} catch (Throwable var2) {
throw var2;
}
} else {
super.doSomething();
}
}
public void doSomething() {
CGLIB$doSomething$0();
}
// ... FastClass 相关代码 ...
}可以看到：
MyClass$$EnhancerByCGLIB$$...继承自MyClass。- 生成了一个
CGLIB$CALLBACK_0字段，用于存储MethodInterceptor的实例。 doSomething()方法被重写，并调用了CGLIB$doSomething$0()方法。CGLIB$doSomething$0()方法负责调用MethodInterceptor的intercept()方法。FastClass用于快速调用父类的方法，避免使用反射。
4. 字节码对比总结
| 特性 | JDK 动态代理 | CGLIB 代理 |
|---|---|---|
| 代理方式 | 基于接口实现 | 基于继承实现 |
| 是否需要接口 | 需要 | 不需要，但不能代理 final 类和方法，以及private方法 |
| 字节码生成方式 | JDK 运行时动态生成 | CGLIB 动态生成 |
| 代理类 | 实现了目标对象实现的接口 | 继承了目标对象 |
| 方法调用 | 通过 InvocationHandler.invoke() 转发 |
通过 MethodInterceptor.intercept() 拦截 |
| 额外优化 | 无 | 使用 FastClass 机制优化方法调用 |
5. 性能对比
一般来说，CGLIB 的性能比 JDK 动态代理要好，特别是在第一次调用代理方法时。
原因:
- 避免反射: CGLIB 使用
FastClass机制来避免使用反射调用目标对象的方法，而 JDK 动态代理需要使用反射调用InvocationHandler的invoke方法，然后再通过反射调用目标对象的方法。 - 减少对象创建: 在某些情况下，CGLIB 可以减少对象创建的数量。
但是，CGLIB 也有一些缺点：
- 代码体积更大: CGLIB 生成的代理类通常比 JDK 动态代理生成的代理类更大，因为 CGLIB 需要生成更多的代码来实现继承和方法拦截。
- 代理类的加载时间更长: 由于 CGLIB 生成的代理类更大，因此加载时间也可能更长。
- 无法代理 final 类和方法: CGLIB 通过继承来实现代理，因此无法代理
final类和方法。
性能测试:
以下是一个简单的性能测试，用于比较 JDK 动态代理和 CGLIB 的性能：
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface TargetInterface {
void execute();
}
class TargetClass implements TargetInterface {
@Override
public void execute() {
// 空方法，只为了测试代理开销
}
}
public class ProxyPerformanceTest {
private static final int ITERATIONS = 1000000;
public static void main(String[] args) {
testJdkDynamicProxy();
testCglibProxy();
}
static void testJdkDynamicProxy() {
TargetInterface target = new TargetClass();
InvocationHandler handler = (proxy, method, args) -> method.invoke(target, args);
TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
TargetClass.class.getClassLoader(),
TargetClass.class.getInterfaces(),
handler);
long startTime = System.nanoTime();
for (int i = 0; i < ITERATIONS; i++) {
proxy.execute();
}
long endTime = System.nanoTime();
System.out.println("JDK Dynamic Proxy: " + (endTime - startTime) / 1000000.0 + " ms");
}
static void testCglibProxy() {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(TargetClass.class);
enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> proxy.invokeSuper(obj, args));
TargetClass proxy = (TargetClass) enhancer.create();
long startTime = System.nanoTime();
for (int i = 0; i < ITERATIONS; i++) {
proxy.execute();
}
long endTime = System.nanoTime();
System.out.println("CGLIB Proxy: " + (endTime - startTime) / 1000000.0 + " ms");
}
}（请注意，这个测试非常简单，并没有考虑 AOP 的增强逻辑。实际应用中，增强逻辑的复杂程度会影响性能。）
6. Spring AOP 的选择策略
Spring AOP 会根据以下规则来选择代理方式：
- 如果目标对象实现了接口，并且配置了
proxy-target-class="false"(默认值)，则使用 JDK 动态代理。 - 如果目标对象实现了接口，并且配置了
proxy-target-class="true"，则使用 CGLIB 代理。 - 如果目标对象没有实现接口，则使用 CGLIB 代理。
proxy-target-class 属性可以在 Spring 的 AOP 配置中使用，用于强制使用 CGLIB 代理。
7. 何时选择哪种代理？
-
JDK 动态代理:
- 优点：简单，易于理解，是 Java 原生提供的代理机制。
- 缺点：必须基于接口，性能可能略低于 CGLIB。
- 适用场景：目标对象实现了接口，并且对性能要求不是非常苛刻。
-
CGLIB 代理:
- 优点：性能通常比 JDK 动态代理更好，可以代理没有实现接口的类。
- 缺点：代码体积更大，无法代理
final类和方法，实现更复杂。 - 适用场景：目标对象没有实现接口，或者对性能要求比较高。
8. 深入理解字节码能带来什么？
深入理解字节码，尤其是代理类的字节码，可以帮助我们：
- 理解 AOP 的底层原理: 了解 AOP 是如何通过动态代理来实现方法拦截和增强的。
- 优化 AOP 性能: 通过分析字节码，我们可以找到性能瓶颈，并采取相应的优化措施。例如，避免在增强逻辑中执行耗时的操作，或者调整 CGLIB 的参数来优化性能。
- 解决 AOP 相关的问题: 当 AOP 出现问题时，例如代理对象创建失败，或者增强逻辑没有正确执行，我们可以通过分析字节码来找到问题的根源。
- 更好地使用 Spring AOP: 了解不同的代理方式的特点，可以帮助我们更好地选择合适的代理方式，并配置 Spring AOP。
总结：选择合适的代理方式，理解字节码有助于深入理解 AOP
在 Spring AOP 中，JDK 动态代理和 CGLIB 都是重要的代理机制。JDK 动态代理基于接口，CGLIB 基于继承。理解它们的字节码差异，以及性能特点，可以帮助我们选择合适的代理方式，并优化 AOP 性能。 深入理解字节码有助于我们理解AOP的底层原理，解决问题和更好地使用Spring AOP。