动态代理两大流派:JDK 代理与子类代理

0 阅读7分钟

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 的生成规则:

  1. 生成 目标类名$$EnhancerByCGLIB$$N 的子类
  2. 覆写所有可覆写的方法(public / protected 的非 final 实例方法)
  3. 每个覆写方法里插入 MethodInterceptor.intercept(...) 调用
  4. 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 / shortZ / B / C / S
int / long / float / doubleI / J / F / D
voidV
引用类型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.invokeinvokestatic 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。

它的价值在于:

  1. 彻底理解"子类代理"到底生成了什么——以后看到 Xxx$$SpringCGLIB$$0 这个类名,你知道它里面装了什么
  2. 明白 CGLIB/ByteBuddy 帮你省掉了什么——它们把第 5.2 节那 200 行脏活全包了
  3. 理解 JVM 的"子类多态"为什么能承载 AOP——代理对象是真的父类实例,所以字段、方法、类型转换全都天然兼容

六、小结

  1. 代理的动机:把增强逻辑从业务代码里剥离,调用方无感知。
  2. JDK 动态代理:Proxy.newProxyInstance 生成 $Proxy0 extends Proxy implements 你的接口,每个方法体只有一句 h.invoke(this, method, args)。只能代理接口,代理对象只能当接口用。
  3. 子类代理:生成 目标类 extends 子类,覆写可覆写方法后转调 super。不要求接口,代理对象能转回目标类类型。
  4. 描述符是通用的:ASM 的 visitMethod/visitMethodInsn 和 JNI 的 GetMethodID 用的是同一套 JVM 内部描述符语法(JVMS §4.3),都是 (参数类型)返回类型,包名用斜杠、类名末尾带分号。
  5. 子类代理的内部结构(已用 ASM 手工生成并反编译验证):private Object target 持有真实对象 + 静态缓存 Method + 每个方法体转调拦截器 + 基本类型自动装箱拆箱。
  6. 手写字节码的两个坑:基本类型不能用 LDC 压 class 常量(会报 NoClassDefFoundError: I,要改用包装类的 TYPE 字段);visitMaxs 传 0 交给 COMPUTE_MAXS 算。
  7. 现代选型:CGLIB 已停止维护,JDK 17+ 需要 --add-opens;新项目直接用 ByteBuddy,或用 Spring 6 内置的重打包 CGLIB。
  8. 避坑清单:final / private / static 方法无法被子类代理覆写(final 方法静默失效,Spring 启动时有 WARN);子类代理会让目标类构造器执行两次(Spring 用 Objenesis 绕过,代价是代理对象字段全为默认值);自调用(this.inner())绕过了代理,注解直接失效;JDK 代理对象无法注入到具体类类型的字段。