AOP 的底座只有一块砖:代理。调用方拿到的不是真实对象,而是一个"壳",壳在把活儿转交出去的路上顺手加了点东西。
这块砖有两种造法——JDK 动态代理(生成接口的实现类)和子类代理(生成目标类的子类)。Spring 的
@Transactional、@Async、@Cacheable底下用的都是它们。
一、代理到底在干什么
业务类想加日志,最直白的写法是侵入式修改:
public class OrderService {
public void createOrder(String orderNo) {
long start = System.currentTimeMillis();
try {
doCreateOrder(orderNo);
} finally {
System.out.println("[after] 耗时 " + (System.currentTimeMillis() - start) + "ms");
}
}
}
问题很明显:每个方法都要改一遍,改一个业务要动十处。
代理模式的解法是:调用方不直接依赖 OrderService,而是依赖一个代理对象。代理对象长得跟目标一模一样,调用它 → 代理先执行增强逻辑 → 再转调真实对象。
调用方 ──调用──▶ 代理对象 ──增强逻辑──▶ 真实对象 ──▶ 业务方法
关键在于:代理对象的类型是哪来的?
- 手写
OrderServiceProxy implements OrderService—— 每个类、每个方法都要手写一遍,这叫静态代理,代码量爆炸 - 动态代理 = 运行时由字节码库生成这个代理类,你只写增强逻辑
这就是"动态"二字的含义:代理类在运行时才诞生。
二、JDK 动态代理:生成接口的实现类
2.1 完整代码
两个角色:InvocationHandler 承载增强逻辑,Proxy 负责生成代理类。
// 业务接口 + 实现
public interface OrderService {
void createOrder(String orderNo);
}
public class OrderServiceImpl implements OrderService {
public void createOrder(String orderNo) {
System.out.println("创建订单: " + orderNo);
}
}
// 增强逻辑载体:所有被拦截的调用都汇到这里
public class LoggingHandler implements InvocationHandler {
private final Object target; // 持有真实对象,转调时用
public LoggingHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long start = System.currentTimeMillis();
System.out.println("[before] 方法: " + method.getName() + ", 参数: " + Arrays.toString(args));
try {
Object result = method.invoke(target, args); // ← 真正的业务执行
System.out.println("[after] 返回: " + result);
return result;
} catch (InvocationTargetException e) {
throw e.getCause(); // 目标方法抛的异常会被包装,这里解包还原
} finally {
System.out.println("[cost] " + (System.currentTimeMillis() - start) + "ms");
}
}
}
组装代理并调用:
public class Main {
public static void main(String[] args) {
OrderService target = new OrderServiceImpl();
OrderService proxy = (OrderService) Proxy.newProxyInstance(
target.getClass().getClassLoader(), // 类加载器
new Class[]{OrderService.class}, // 要代理的接口
new LoggingHandler(target)); // 调用处理器
proxy.createOrder("A20241113001");
}
}
输出:
[before] 方法: createOrder, 参数: [A20241113001]
创建订单: A20241113001
[after] 返回: null
[cost] 0ms
业务代码 OrderServiceImpl 一行没动,增强逻辑全在 LoggingHandler 里。这就是 AOP 的味道。
2.2 原理:那个 $Proxy0 是怎么来的
Proxy.newProxyInstance 内部四步:
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
InvocationHandler h) {
Class<?>[] intfs = interfaces.clone(); // 1. 防御性拷贝 + 校验
Class<?> cl = getProxyClass0(loader, intfs); // 2. 找或生成代理类(核心)
Constructor<?> cons = cl.getConstructor(InvocationHandler.class);
return cons.newInstance(new Object[]{h}); // 3~4. 实例化,把 handler 塞进去
}
第 2 步 getProxyClass0 内部:先查 WeakCache(同一个接口组合 + 同一个类加载器,代理类只生成一次),缓存没有就调 ProxyGenerator.generateProxyClass() 在内存里拼出一份字节码,再用 defineClass0 加载成真正的类。
生成出来的 $Proxy0 长这样(等价伪代码):
public final class $Proxy0 extends Proxy implements OrderService {
// 静态块里预取好每个接口方法的 Method 对象
private static Method m1; // createOrder
static {
try {
m1 = OrderService.class.getMethod("createOrder", String.class);
} catch (NoSuchMethodException e) {
throw new NoSuchMethodException();
}
}
protected $Proxy0(InvocationHandler h) {
super(h); // 交给父类 Proxy 保存
}
// 每个接口方法都生成这样一段:方法体里没有任何业务逻辑
@Override
public final void createOrder(String orderNo) {
super.h.invoke(this, m1, new Object[]{orderNo});
}
}
这就是 JDK 动态代理的全部秘密:代理方法体里只有一句 h.invoke(this, method, args),把"哪个方法、什么参数"打包甩给 InvocationHandler。你在 invoke 里想干什么都行——这就是"切面"能插进来的物理原因。
想看到真实的字节码?加个 JVM 参数让它落盘:
java -Dsun.misc.ProxyGenerator.saveGeneratedFiles=true -cp . Main
会在当前目录生成 $Proxy0.class,用 JD-GUI 反编译就能看到上面那份源码。
2.3 硬性限制
JDK 动态代理只能代理接口。
原因很硬:Java 单继承。生成的 $Proxy0 已经继承了 java.lang.reflect.Proxy(Proxy 需要继承它来持有 h 字段),没有第二个继承位留给目标类。
// ❌ 编译不过:代理对象不是 OrderServiceImpl 的实例
OrderServiceImpl p = (OrderServiceImpl) proxy;
// ✅ 只能当接口用
OrderService p = (OrderService) proxy;
如果目标类根本没有接口,JDK 动态代理直接无解。
三、子类代理:生成目标类的子类
既然接口代理有天花板,另一种思路就来了:不实现接口,而是继承目标类。
目标类:public class OrderService { ... }
生成的代理类:
public class OrderService$$EnhancerBySpringCGLIB extends OrderService {
private OrderService target; // 持有真实对象
@Override
public void createOrder(String orderNo) {
aspect.before();
target.createOrder(orderNo); // 转调真实对象
aspect.after();
}
}
代理类和目标类的关系是继承,所以代理对象可以强转回目标类类型——这是它相对 JDK 代理最大的优势。
3.1 CGLIB:Spring 生态的实际实现
CGLIB 基于 ASM 字节码操作框架,在运行时生成子类。
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class CglibProxyFactory {
public static <T> T createProxy(Class<T> targetClass, MethodInterceptor interceptor) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(targetClass); // 指定父类 = 目标类
enhancer.setCallback(interceptor); // 设置拦截器
enhancer.setUseFactory(false); // 不走 Factory,避免默认构造器要求
return (T) enhancer.create();
}
}
UserService target = new UserService();
UserService proxy = CglibProxyFactory.createProxy(UserService.class, (obj, method, args, proxyMethod) -> {
System.out.println("[before] " + method.getName());
Object result = proxyMethod.invokeSuper(obj, args); // 走 super 调父类原始实现
System.out.println("[after] " + method.getName());
return result;
});
输出:
[before] greet
[after] greet
Hello, Tom
UserService$$EnhancerByCGLIB$$0
CGLIB 的生成规则:
- 生成
目标类名$$EnhancerByCGLIB$$N的子类 - 覆写所有可覆写的方法(public / protected 的非 final 实例方法)
- 每个覆写方法里插入
MethodInterceptor.intercept(...)调用 methodProxy.invokeSuper(obj, args)触发父类原始实现
Spring 里生成的类名会带 $$SpringCGLIB$$ 标签,看到这种长名字就知道走的是子类代理分支。
3.2 ByteBuddy:现代方案
CGLIB 项目已停止维护,在 JDK 17+ 上因模块化限制需要 --add-opens java.base/java.lang=ALL-UNNAMED 才能工作。ByteBuddy 是现在的标准答案——Spring 6 的 CGLIB 重打包版本、Hibernate、Mockito 2+ 全部换成了它。
new ByteBuddy()
.subclass(UserService.class) // 生成目标类的子类
.method(ElementMatchers.any()) // 拦截所有方法
.intercept(InvocationHandlerAdapter.of((proxy, method, args) -> {
System.out.println("[before] " + method.getName());
return method.invoke(proxy.getTarget(), args);
}))
.make() // 生成字节码
.load(UserService.class.getClassLoader()) // 加载成类
.get(UserService.class); // 实例化
流式 API,一眼看得出做了哪几件事:定父类 → 定拦截范围 → 定增强逻辑 → 生成 → 加载。
四、ASM 描述符:和 JNI 签名是同一套语法
第二节看到 $Proxy0 里 Class.getMethod("createOrder", String.class),第四节要用 ASM 手写字节码时会看到 "Ljava/lang/Object;"、"(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;" 这样的字符串。
这两者——以及 JNI 里的方法签名——是同一套 JVM 内部语法,规范定义在 JVMS §4.3:
| 类型 | 描述符 | 示例 |
|---|---|---|
boolean / byte / char / short | Z / B / C / S | |
int / long / float / double | I / J / F / D | |
void | V | |
| 引用类型 | L<内部名>; | String → Ljava/lang/String; |
| 数组 | [ + 元素类型 | String[] → [Ljava/lang/String; |
方法描述符 = ( + 参数类型序列 + ) + 返回类型:
int add(int a, int b) → (II)I
String toString() → ()Ljava/lang/String;
void process(byte[] d, String n) → ([BLjava/lang/String;)V
注意:包名用斜杠分隔,类名末尾有分号——这是内部名,不是 java.lang.String。
同一个描述符字符串,三处通用:
// ① ASM:声明方法
cw.visitMethod(ACC_PUBLIC, "add", "(II)I", null, null);
// ② ASM:调用方法
mv.visitMethodInsn(INVOKESTATIC, "Interceptor", "intercept",
"(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;", false);
// ③ JNI:查方法 ID
jmethodID mid = env->GetMethodID(clazz, "add", "(II)I");
JNI 里 GetMethodID 的第三个参数就是这串描述符,写错一个字符就返回 nullptr。ASM 生成的字节码和 JNI 查找方法,用的是同一套"地址" ——JVM 内部靠它唯一定位一个方法。
五、动手把子类"造"出来:ASM 全过程
前面讲的都是"结论"。这一节我们不依赖任何代理框架,只用 ASM 手写字节码,亲手把一个子类代理生成出来。
5.1 目标:生成出什么样的类
目标类:
public class UserService {
public UserService() { }
public String greet(String who) { return "Hello, " + who; }
public int add(int a, int b) { return a + b; }
public void reset() { }
}
生成出来的 UserService$$Proxy,等价源码长这样:
public class UserService$$Proxy extends UserService {
private Object target; // ① 持有真实对象,转调时用
private static Method m_greet; // ② 静态缓存目标方法
private static Method m_add;
private static Method m_reset;
public UserService$$Proxy(Object target) { // ③ 构造器注入真实对象
super();
this.target = target;
}
static { // ④ 静态块预取 Method
try {
m_greet = UserService.class.getMethod("greet", String.class);
m_add = UserService.class.getMethod("add", int.class, int.class);
m_reset = UserService.class.getMethod("reset");
} catch (NoSuchMethodException e) {
throw new NoSuchMethodException();
}
}
@Override // ⑤ 覆写每个方法,转调 Interceptor
public String greet(String who) {
return (String) Interceptor.intercept(this.target, m_greet, new Object[]{who});
}
@Override
public int add(int a, int b) {
return (Integer) Interceptor.intercept(this.target, m_add, new Object[]{a, b});
}
@Override
public void reset() {
Interceptor.intercept(this.target, m_reset, new Object[]{});
}
}
三个细节:
add(int, int)覆写时参数被装箱成Integer塞进Object[],返回值又要拆箱回int——因为拦截器统一用Object传递greet返回String,父类greet也返回String,签名完全兼容——这正是"子类"的意义,JVM 认它是父类的合法子类- 静态块缓存
Method是性能关键:否则每次调用都要getMethod反射查找
5.2 用 ASM 生成它
ASM 的 API 是"visit"式的——你不是在写代码,而是在描述一个类长什么样:
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class SubclassProxyGenerator {
private static final String PROXY_SUFFIX = "$$Proxy";
private static final String INTERCEPTOR = "Interceptor";
private static final String INTERCEPTOR_DESC =
"(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;";
public static byte[] generate(Class<?> targetClass) {
String superName = internalName(targetClass);
String proxyName = superName + PROXY_SUFFIX;
// COMPUTE_MAXS:让 ASM 自动算 max_stack / max_locals
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
// ① 类头:public class Xxx$$Proxy extends Xxx
cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER,
proxyName, null, superName, null);
// ② 字段:private Object target;
cw.visitField(Opcodes.ACC_PRIVATE, "target", "Ljava/lang/Object;", null, null).visitEnd();
// ③ 每个可覆写方法配一个静态 Method 字段
Method[] methods = targetClass.getDeclaredMethods();
for (Method m : methods) {
if (!isOverridable(m)) continue;
cw.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC,
"m_" + m.getName(), "Ljava/lang/reflect/Method;", null, null).visitEnd();
}
// ④ 构造器:public Xxx$$Proxy(Object target)
MethodVisitor ctor = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>",
"(Ljava/lang/Object;)V", null, null);
ctor.visitCode();
ctor.visitVarInsn(Opcodes.ALOAD, 0);
ctor.visitMethodInsn(Opcodes.INVOKESPECIAL, superName, "<init>", "()V", false); // super()
ctor.visitVarInsn(Opcodes.ALOAD, 0);
ctor.visitVarInsn(Opcodes.ALOAD, 1);
ctor.visitFieldInsn(Opcodes.PUTFIELD, proxyName, "target", "Ljava/lang/Object;");
ctor.visitInsn(Opcodes.RETURN);
ctor.visitMaxs(0, 0);
ctor.visitEnd();
// ⑤ 静态块 <clinit>:预取 Method 对象
MethodVisitor clinit = cw.visitMethod(Opcodes.ACC_STATIC, "<clinit>", "()V", null, null);
clinit.visitCode();
for (Method m : methods) {
if (!isOverridable(m)) continue;
emitGetMethod(clinit, targetClass, m, "m_" + m.getName());
}
clinit.visitInsn(Opcodes.RETURN);
clinit.visitMaxs(0, 0);
clinit.visitEnd();
// ⑥ 逐个覆写目标方法
for (Method m : methods) {
if (!isOverridable(m)) continue;
emitOverride(cw, proxyName, m);
}
cw.visitEnd();
return cw.toByteArray();
}
/** 只有 public + 非 static + 非 final 的实例方法才能被覆写 */
private static boolean isOverridable(Method m) {
int mod = m.getModifiers();
return Modifier.isPublic(mod)
&& !Modifier.isStatic(mod)
&& !Modifier.isFinal(mod);
}
/** 生成静态块中 "Method targetClass.getMethod(name, paramTypes)" 的字节码 */
private static void emitGetMethod(MethodVisitor mv, Class<?> targetClass,
Method m, String fieldName) {
mv.visitLdcInsn(Type.getType(targetClass)); // 目标类的 class 常量
mv.visitLdcInsn(m.getName()); // 方法名字符串
Class<?>[] paramTypes = m.getParameterTypes();
mv.visitIntInsn(Opcodes.BIPUSH, paramTypes.length);
mv.visitTypeInsn(Opcodes.ANEWARRAY, "java/lang/Class");
for (int i = 0; i < paramTypes.length; i++) {
mv.visitInsn(Opcodes.DUP);
mv.visitIntInsn(Opcodes.BIPUSH, i);
emitClassConstant(mv, paramTypes[i]);
mv.visitInsn(Opcodes.AASTORE);
}
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Class", "getMethod",
"(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;", false);
mv.visitFieldInsn(Opcodes.PUTSTATIC, internalName(targetClass) + PROXY_SUFFIX,
fieldName, "Ljava/lang/reflect/Method;");
}
/**
* 把 Class 常量压栈。
*
* 【真坑】引用类型可以直接 LDC class 常量,但基本类型不行!
* Type.getType(int.class) 的内部名是 "I",LDC 出去运行时会报
* NoClassDefFoundError: I —— JVM 会当成去找名为 "I" 的类。
* 必须改用包装类的 TYPE 静态字段。
*/
private static void emitClassConstant(MethodVisitor mv, Class<?> clazz) {
if (!clazz.isPrimitive()) {
mv.visitLdcInsn(Type.getType(clazz));
return;
}
mv.visitFieldInsn(Opcodes.GETSTATIC, wrapperOf(clazz), "TYPE", "Ljava/lang/Class;");
}
/** 生成覆写方法的方法体 */
private static void emitOverride(ClassWriter cw, String proxyName, Method m) {
String desc = Type.getMethodDescriptor(m);
MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, m.getName(), desc, null, null);
mv.visitCode();
Class<?>[] paramTypes = m.getParameterTypes();
int slot = 1; // 实例方法:0 = this,之后是参数
// ---- 压入 this.target ----
mv.visitVarInsn(Opcodes.ALOAD, 0);
mv.visitFieldInsn(Opcodes.GETFIELD, proxyName, "target", "Ljava/lang/Object;");
// ---- 压入静态 Method 字段 ----
mv.visitFieldInsn(Opcodes.GETSTATIC, proxyName, "m_" + m.getName(),
"Ljava/lang/reflect/Method;");
// ---- 压入 Object[] 参数数组(基本类型要装箱)----
mv.visitIntInsn(Opcodes.BIPUSH, paramTypes.length);
mv.visitTypeInsn(Opcodes.ANEWARRAY, "java/lang/Object");
for (int i = 0; i < paramTypes.length; i++) {
mv.visitInsn(Opcodes.DUP);
mv.visitIntInsn(Opcodes.BIPUSH, i);
Class<?> pt = paramTypes[i];
mv.visitVarInsn(loadOpcode(pt), slot);
slot += sizeOf(pt);
emitBox(mv, pt); // 基本类型装箱成包装类
mv.visitInsn(Opcodes.AASTORE);
}
// ---- 调用 Interceptor.intercept(target, method, args) ----
mv.visitMethodInsn(Opcodes.INVOKESTATIC, INTERCEPTOR, "intercept",
INTERCEPTOR_DESC, false);
// ---- 处理返回值(拆箱 / 类型转换 / return)----
emitReturn(mv, m.getReturnType());
mv.visitMaxs(0, 0);
mv.visitEnd();
}
/** 基本类型装箱:Integer.valueOf(int) 等;引用类型原样返回 */
private static void emitBox(MethodVisitor mv, Class<?> pt) {
if (!pt.isPrimitive()) return;
String wrapper = wrapperOf(pt);
mv.visitMethodInsn(Opcodes.INVOKESTATIC, wrapper, "valueOf",
"(" + typeDescriptor(pt) + ")L" + wrapper + ";", false);
}
/** 返回值处理:void 直接丢弃;基本类型拆箱;引用类型 checkcast */
private static void emitReturn(MethodVisitor mv, Class<?> ret) {
if (ret == void.class) {
mv.visitInsn(Opcodes.POP);
mv.visitInsn(Opcodes.RETURN);
} else if (!ret.isPrimitive()) {
mv.visitTypeInsn(Opcodes.CHECKCAST, internalName(ret));
mv.visitInsn(Opcodes.ARETURN);
} else {
String wrapper = wrapperOf(ret);
mv.visitTypeInsn(Opcodes.CHECKCAST, wrapper);
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, wrapper,
ret.getName() + "Value", "()" + typeDescriptor(ret), false);
mv.visitInsn(returnOpcode(ret));
}
}
/** 加载指令:引用类型用 ALOAD,long/double 占 2 个槽 */
private static int loadOpcode(Class<?> t) {
if (t == long.class) return Opcodes.LLOAD;
if (t == double.class) return Opcodes.DLOAD;
if (t == float.class) return Opcodes.FLOAD;
if (t.isPrimitive()) return Opcodes.ILOAD;
return Opcodes.ALOAD;
}
/** 局部变量槽位宽度:long/double 占 2 */
private static int sizeOf(Class<?> t) {
return (t == long.class || t == double.class) ? 2 : 1;
}
private static int returnOpcode(Class<?> t) {
if (t == long.class) return Opcodes.LRETURN;
if (t == double.class) return Opcodes.DRETURN;
if (t == float.class) return Opcodes.FRETURN;
return Opcodes.IRETURN;
}
/** 基本类型 → 包装类的内部名 */
private static String wrapperOf(Class<?> t) {
if (t == int.class) return "java/lang/Integer";
if (t == long.class) return "java/lang/Long";
if (t == boolean.class) return "java/lang/Boolean";
if (t == double.class) return "java/lang/Double";
if (t == float.class) return "java/lang/Float";
if (t == short.class) return "java/lang/Short";
if (t == byte.class) return "java/lang/Byte";
return "java/lang/Character";
}
/** JVM 类型描述符(和 JNI 签名同源) */
private static String typeDescriptor(Class<?> t) {
return Type.getType(t).getDescriptor();
}
private static String internalName(Class<?> clazz) {
return clazz.getName().replace('.', '/');
}
}
这段代码的结构就是第 5.1 节那份等价源码的逐行翻译——visit 系列方法就是"往类里加一个东西":
| ASM 调用 | 等价于源码 |
|---|---|
cw.visit(...) | 类声明 |
cw.visitField(...) | 字段声明 |
cw.visitMethod(...) | 方法声明 |
mv.visitVarInsn(ALOAD, 0) | 读局部变量 |
mv.visitFieldInsn(GETFIELD, ...) | 读字段 |
mv.visitMethodInsn(INVOKESTATIC, ...) | 调用静态方法 |
mv.visitInsn(RETURN) | return |
5.3 加载它,并跑起来
字节码只是一堆 byte[],还得定义成类才能用:
public class Demo {
public static void main(String[] args) throws Exception {
UserService target = new UserService();
// ① 生成字节码
byte[] bytes = SubclassProxyGenerator.generate(UserService.class);
// ② 自定义 ClassLoader:只对这一个类名特殊处理
Class<?> proxyClass = new ClassLoader(Demo.class.getClassLoader()) {
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
if (name.equals("UserService$$Proxy")) {
return defineClass(name, bytes, 0, bytes.length);
}
return super.findClass(name);
}
}.loadClass("UserService$$Proxy");
// ③ 实例化,注入真实对象
Object proxy = proxyClass.getConstructor(Object.class).newInstance(target);
// ④ 直接当父类用——这就是子类代理的意义
UserService typed = (UserService) proxy;
System.out.println(typed.greet("Tom")); // Hello, Tom
System.out.println(typed.add(3, 4)); // 7
typed.reset();
System.out.println("代理类名: " + proxyClass.getName());
System.out.println("父类: " + proxyClass.getSuperclass().getName());
}
}
运行结果:
[before] greet
[after] greet => Hello, Tom
greet -> Hello, Tom
[before] add
[after] add => 7
add -> 7
代理类名: UserService$$Proxy
父类: UserService
代理类名: UserService$$Proxy + 父类: UserService —— 目标达成:我们确实动态生成了目标类的子类。
5.4 反编译看看:字节码长什么样
把生成的 class 落盘,用 javap 反编译:
javap -p -c UserService$$Proxy.class
类结构:
public class UserService$$Proxy extends UserService {
private java.lang.Object target;
private static java.lang.reflect.Method m_greet;
private static java.lang.reflect.Method m_add;
private static java.lang.reflect.Method m_reset;
public UserService$$Proxy(java.lang.Object);
static {};
public java.lang.String greet(java.lang.String);
public int add(int, int);
public void reset();
}
覆写的 add(int,int) ——注意装箱与拆箱,以及那串描述符:
public int add(int, int);
0: aload_0
1: getfield #17 // Field target:Ljava/lang/Object; ← this.target
4: getstatic #40 // Field m_add:Ljava/lang/reflect/Method;
7: bipush 2
9: anewarray #47 // class java/lang/Object ← new Object[2]
12: dup
13: bipush 0
15: iload_1
16: invokestatic #58 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer; ← 装箱
19: aastore
20: dup
21: bipush 1
23: iload_2
24: invokestatic #58 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer; ← 装箱
27: aastore
28: invokestatic #53 // Method Interceptor.intercept:(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;
31: checkcast #34 // class java/lang/Integer
34: invokevirtual #62 // Method java/lang/Integer.intValue:()I ← 拆箱
37: ireturn
静态块里的一个细节——基本类型走的是 GETSTATIC 取包装类的 TYPE 字段,而不是 LDC:
12: ldc #24 // class java/lang/String ← 引用类型:LDC class 常量
33: getstatic #38 // Field java/lang/Integer.TYPE ← 基本类型:GETSTATIC
5.5 和 JDK 的 $Proxy0 对照
用同样的手法导出 JDK 生成的 $Proxy0:
java -Dsun.misc.ProxyGenerator.saveGeneratedFiles=true -cp . Main
# 生成在 com/sun/proxy/$Proxy0.class(JDK 8)
# JDK 9+ 在 jdk.proxy1 模块内,需加 --add-opens java.base/jdk.proxy1=ALL-UNNAMED
反编译:
public final class com.sun.proxy.$Proxy0 extends java.lang.reflect.Proxy
implements JdkProxyOnly$OrderService {
private static java.lang.reflect.Method m1; // equals
private static java.lang.reflect.Method m2; // toString
private static java.lang.reflect.Method m3; // createOrder
private static java.lang.reflect.Method m0; // hashCode
public com.sun.proxy.$Proxy0(java.lang.reflect.InvocationHandler);
}
createOrder 的字节码:
public final void createOrder(java.lang.String);
0: aload_0
1: getfield #16 // Field java.lang/reflect/Proxy.h:Ljava/lang/reflect/InvocationHandler;
4: aload_0
5: getstatic #57 // Field m3:Ljava/lang/reflect/Method;
8: iconst_1
9: anewarray #22 // class java/lang/Object
12: dup
13: iconst_0
14: aload_1
15: aastore
16: invokeinterface #28, 4 // InvocationHandler.invoke:(...)Ljava/lang/Object;
21: pop
22: return
两者结构惊人地相似——都是"静态缓存 Method + 方法体转调"。差别只在三处:
$Proxy0(JDK) | Xxx$$Proxy(子类代理) | |
|---|---|---|
| 真实对象存哪 | 父类 Proxy 的 protected InvocationHandler h 字段 | 自己的 private Object target 字段 |
| 转调方式 | invokeinterface InvocationHandler.invoke | invokestatic Interceptor.intercept |
| 异常处理 | 有 Exception table,把 checked 异常包成 UndeclaredThrowableException | 由拦截器自己决定 |
JDK 版本还多做了一件事:它把 equals / hashCode / toString 也一并代理了(m0/m1/m2),保证代理对象的基础行为可用。子类代理一般不覆写这三个(除非框架特意处理)。
5.6 手写字节码时踩到的两个真坑
坑 1:基本类型不能用 LDC 压 class 常量
我第一版代码是这样写的:
// ❌ 错误
mv.visitLdcInsn(Type.getType(paramTypes[i]));
当参数类型是 int 时,Type.getType(int.class).getInternalName() 返回的是 "I"。字节码里 LDC "I" 会被当成加载名为 I 的类,运行时直接炸:
java.lang.NoClassDefFoundError: I
at UserService$$Proxy.<clinit>(Unknown Source)
Caused by: ClassNotFoundException: I
正确做法:基本类型要走包装类的 TYPE 静态字段。
// ✅ 正确
if (clazz.isPrimitive()) {
mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/Integer", "TYPE", "Ljava/lang/Class;");
} else {
mv.visitLdcInsn(Type.getType(clazz));
}
从反编译结果里能直接看到差别:
12: ldc #24 // class java/lang/String ← 引用类型:LDC class 常量
33: getstatic #38 // Field java/lang/Integer.TYPE ← 基本类型:GETSTATIC
坑 2:visitMaxs 传 0,让 ASM 自己算
// ✅ 推荐
mv.visitMaxs(0, 0);
// ❌ 手动算 stack/locals —— 极易算错,且方法一多就放弃
mv.visitMaxs(3, 3);
前提是 ClassWriter 用 COMPUTE_MAXS 创建:
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
如果目标字节码版本是 JDK 7 及以下,还需要 COMPUTE_FRAMES 来生成 StackMapTable;JDK 8+ 的 COMPUTE_MAXS 就够了。
5.7 这套东西的意义
这一节没有让你更快用上代理——生产环境请直接用 ByteBuddy 或 Spring AOP。
它的价值在于:
- 彻底理解"子类代理"到底生成了什么——以后看到
Xxx$$SpringCGLIB$$0这个类名,你知道它里面装了什么 - 明白 CGLIB/ByteBuddy 帮你省掉了什么——它们把第 5.2 节那 200 行脏活全包了
- 理解 JVM 的"子类多态"为什么能承载 AOP——代理对象是真的父类实例,所以字段、方法、类型转换全都天然兼容
六、小结
- 代理的动机:把增强逻辑从业务代码里剥离,调用方无感知。
- JDK 动态代理:
Proxy.newProxyInstance生成$Proxy0 extends Proxy implements 你的接口,每个方法体只有一句h.invoke(this, method, args)。只能代理接口,代理对象只能当接口用。 - 子类代理:生成
目标类 extends 子类,覆写可覆写方法后转调super。不要求接口,代理对象能转回目标类类型。 - 描述符是通用的:ASM 的
visitMethod/visitMethodInsn和 JNI 的GetMethodID用的是同一套 JVM 内部描述符语法(JVMS §4.3),都是(参数类型)返回类型,包名用斜杠、类名末尾带分号。 - 子类代理的内部结构(已用 ASM 手工生成并反编译验证):
private Object target持有真实对象 + 静态缓存Method+ 每个方法体转调拦截器 + 基本类型自动装箱拆箱。 - 手写字节码的两个坑:基本类型不能用
LDC压 class 常量(会报NoClassDefFoundError: I,要改用包装类的TYPE字段);visitMaxs传 0 交给COMPUTE_MAXS算。 - 现代选型:CGLIB 已停止维护,JDK 17+ 需要
--add-opens;新项目直接用 ByteBuddy,或用 Spring 6 内置的重打包 CGLIB。 - 避坑清单:
final/private/static方法无法被子类代理覆写(final方法静默失效,Spring 启动时有 WARN);子类代理会让目标类构造器执行两次(Spring 用 Objenesis 绕过,代价是代理对象字段全为默认值);自调用(this.inner())绕过了代理,注解直接失效;JDK 代理对象无法注入到具体类类型的字段。