发布于 由admin

Java中的动态代理实现：Proxy类如何生成$Proxy字节码文件

Java 动态代理：Proxy 类如何生成 $Proxy 字节码文件

大家好，今天我们来深入探讨 Java 动态代理的实现机制，特别是 Proxy 类是如何在运行时生成 $Proxy 字节码文件的。这是一个理解动态代理工作原理的关键环节。

1. 动态代理概述

动态代理允许我们在运行时创建代理类，而无需预先定义它们。这与静态代理不同，后者需要我们手动编写代理类。动态代理通常用于实现 AOP（面向切面编程）中的横切关注点，例如日志记录、事务管理和权限控制。

Java 提供了 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来实现动态代理。

  • Proxy 类： 它是所有动态代理类的超类。它提供了静态方法 newProxyInstance() 用于创建代理实例。
  • InvocationHandler 接口： 代理实例的方法调用会被转发到实现了此接口的类的 invoke() 方法。

2. 动态代理的使用示例

首先，我们定义一个接口：

public interface MyInterface {
    String doSomething(String arg);
}

然后，创建一个实现该接口的类：

public class MyRealObject implements MyInterface {
    @Override
    public String doSomething(String arg) {
        System.out.println("MyRealObject: Doing something with " + arg);
        return "Result: " + arg;
    }
}

接下来，创建一个实现了 InvocationHandler 接口的类：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInvocationHandler implements InvocationHandler {
    private final Object realObject;

    public MyInvocationHandler(Object realObject) {
        this.realObject = realObject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = method.invoke(realObject, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}

最后，使用 Proxy.newProxyInstance() 创建代理实例：

import java.lang.reflect.Proxy;

public class Main {
    public static void main(String[] args) {
        MyRealObject realObject = new MyRealObject();
        MyInvocationHandler handler = new MyInvocationHandler(realObject);

        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
                MyInterface.class.getClassLoader(),
                new Class<?>[]{MyInterface.class},
                handler
        );

        String result = proxy.doSomething("Hello");
        System.out.println("Result from proxy: " + result);
    }
}

在这个例子中，Proxy.newProxyInstance() 方法创建了一个实现了 MyInterface 接口的代理类。当我们调用代理对象的 doSomething() 方法时，实际上会调用 MyInvocationHandler 的 invoke() 方法。invoke() 方法在调用真实对象的方法前后添加了额外的逻辑。

3. Proxy.newProxyInstance() 的内部实现

Proxy.newProxyInstance() 方法的内部实现可以分为以下几个步骤：

  1. 获取代理类的类加载器： newProxyInstance() 方法的第一个参数是类加载器。通常，我们使用接口的类加载器。

  2. 确定代理类需要实现的接口： newProxyInstance() 方法的第二个参数是一个接口数组。代理类将实现这些接口。

  3. 检查代理类的缓存： Proxy 类内部维护了一个缓存，用于存储已经生成的代理类。如果缓存中存在满足条件的代理类，则直接返回缓存中的类。这提高了性能。

  4. 生成代理类的类名： 如果缓存中没有找到合适的代理类，则需要生成一个新的代理类。代理类的名称通常以 $Proxy 开头，后面跟着一个数字，例如 $Proxy0，$Proxy1 等。

  5. 创建代理类的字节码： 这是最关键的一步。Proxy 类会动态地创建代理类的字节码。这个字节码定义了代理类的结构和行为。

  6. 加载代理类： 使用类加载器将生成的字节码加载到 JVM 中，创建一个 Class 对象。

  7. 创建代理实例： 使用 Class 对象的 newInstance() 方法创建一个代理实例。并将 InvocationHandler 传递给代理类，通常会通过构造方法进行注入。

  8. 返回代理实例： 将创建的代理实例返回给调用者。

4. 字节码的生成过程

现在，我们来详细分析一下 Proxy 类如何生成代理类的字节码。这个过程涉及到一些底层的 JVM 技术，包括类文件格式、字节码指令和类加载机制。

Proxy 类使用 java.lang.reflect.Proxy 内部的工具类和方法来构建字节码。具体步骤如下：

  1. 创建类声明： 代理类的类声明包括类名、父类和实现的接口。代理类继承自 java.lang.reflect.Proxy，并实现传递给 newProxyInstance() 方法的接口。
// 例如：
public final class $Proxy0 extends java.lang.reflect.Proxy implements MyInterface {
    // ...
}
  1. 添加构造方法： 代理类需要一个构造方法，用于接收 InvocationHandler 对象。这个构造方法调用父类 Proxy 的构造方法，将 InvocationHandler 对象传递给父类。
public $Proxy0(java.lang.reflect.InvocationHandler h) {
    super(h);
}
  1. 实现接口方法： 对于代理类需要实现的每个接口方法，Proxy 类都会生成一个对应的方法。这些方法会将调用转发到 InvocationHandler 的 invoke() 方法。
public String doSomething(String arg) {
    try {
        return (String) super.h.invoke(this, m1, new Object[]{arg});
    } catch (RuntimeException | Error e) {
        throw e;
    } catch (Throwable throwable) {
        throw new UndeclaredThrowableException(throwable);
    }
}

这里：

  • super.h 指的是父类 Proxy 中持有的 InvocationHandler 实例。
  • m1 是一个 Method 对象，表示 doSomething() 方法。这个 Method 对象通常在代理类的静态初始化块中创建。
  • new Object[]{arg} 是方法参数。
  • UndeclaredThrowableException 用于包装 invoke() 方法抛出的未声明的异常。
  1. 添加静态初始化块： 代理类通常包含一个静态初始化块，用于获取接口方法的 Method 对象。这些 Method 对象在 invoke() 方法中被使用。
private static Method m1;

static {
    try {
        m1 = Class.forName("MyInterface").getMethod("doSomething", String.class);
    } catch (NoSuchMethodException e) {
        throw new NoSuchMethodError(e.getMessage());
    } catch (ClassNotFoundException e) {
        throw new NoClassDefFoundError(e.getMessage());
    }
}
  1. 生成字节码指令： 上述的类声明、构造方法、接口方法和静态初始化块都需要转换成字节码指令。Proxy 类使用 java.lang.reflect.Proxy 内部的工具类来生成这些指令。

5. 字节码生成工具

虽然我们不能直接访问 java.lang.reflect.Proxy 内部的字节码生成工具，但我们可以使用一些第三方库来模拟这个过程。例如，我们可以使用 ASM 或 Byte Buddy 等库来动态地创建类和生成字节码。

使用 ASM 库生成代理类的示例代码如下：

import org.objectweb.asm.*;

import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.UndeclaredThrowableException;

public class ASMProxyGenerator {

    public static void generateProxyClass(String interfaceName, String proxyClassName) throws IOException {
        ClassReader reader;
        try {
            reader = new ClassReader(interfaceName);
        } catch (IOException e) {
            System.err.println("Error reading interface class: " + e.getMessage());
            return;
        }
        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
        String internalProxyClassName = proxyClassName.replace('.', '/');
        String internalInterfaceName = interfaceName.replace('.', '/');

        // Define the class
        cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL,
                internalProxyClassName, null, "java/lang/reflect/Proxy",
                new String[]{internalInterfaceName});

        // Add a field for the Method object
        cw.visitField(Opcodes.ACC_PRIVATE + Opcodes.ACC_STATIC, "method", "Ljava/lang/reflect/Method;", null, null).visitEnd();

        // Define the constructor
        MethodVisitor constructorVisitor = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "(Ljava/lang/reflect/InvocationHandler;)V", null, null);
        constructorVisitor.visitCode();
        constructorVisitor.visitVarInsn(Opcodes.ALOAD, 0); // Load 'this'
        constructorVisitor.visitVarInsn(Opcodes.ALOAD, 1); // Load the InvocationHandler
        constructorVisitor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/reflect/Proxy", "<init>", "(Ljava/lang/reflect/InvocationHandler;)V", false); // Call the super constructor
        constructorVisitor.visitInsn(Opcodes.RETURN);
        constructorVisitor.visitMaxs(2, 2);
        constructorVisitor.visitEnd();

        reader.accept(new ClassVisitor(Opcodes.ASM8) {
            @Override
            public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
                super.visit(version, access, name, signature, superName, interfaces);
            }

            @Override
            public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
                MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, name, descriptor, signature, exceptions);
                mv.visitCode();

                Label tryStart = new Label();
                Label tryEnd = new Label();
                Label catchBlock = new Label();

                mv.visitTryCatchBlock(tryStart, tryEnd, catchBlock, "java/lang/Throwable");

                mv.visitLabel(tryStart);
                mv.visitVarInsn(Opcodes.ALOAD, 0); // Load 'this'
                mv.visitFieldInsn(Opcodes.GETFIELD, internalProxyClassName, "h", "Ljava/lang/reflect/InvocationHandler;"); // Get the InvocationHandler

                mv.visitVarInsn(Opcodes.ALOAD, 0);  // Load 'this'

                // Load the Method object
                mv.visitFieldInsn(Opcodes.GETSTATIC, internalProxyClassName, "method", "Ljava/lang/reflect/Method;");

                // Create an array of arguments
                createArgumentArray(mv, descriptor);

                mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/lang/reflect/InvocationHandler", "invoke", "(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;", true);

                castResult(mv, descriptor);

                mv.visitLabel(tryEnd);
                mv.visitInsn(Opcodes.ARETURN); // Return the result

                // Catch block
                mv.visitLabel(catchBlock);

                // Store the exception
                mv.visitVarInsn(Opcodes.ASTORE, 1);

                // Throw undeclared throwable exception
                mv.visitTypeInsn(Opcodes.NEW, "java/lang/reflect/UndeclaredThrowableException");
                mv.visitInsn(Opcodes.DUP);
                mv.visitVarInsn(Opcodes.ALOAD, 1);
                mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/reflect/UndeclaredThrowableException", "<init>", "(Ljava/lang/Throwable;)V", false);
                mv.visitInsn(Opcodes.ATHROW);

                mv.visitMaxs(5, 2);  // Adjust max stack and locals based on method signature
                mv.visitEnd();
                return mv;
            }

            private void createArgumentArray(MethodVisitor mv, String descriptor) {
                Type[] argumentTypes = Type.getArgumentTypes(descriptor);
                int argumentCount = argumentTypes.length;

                // Create the array
                mv.visitLdcInsn(argumentCount);
                mv.visitTypeInsn(Opcodes.ANEWARRAY, "java/lang/Object");

                // Fill the array
                int arrayIndex = 0;
                int localVariableIndex = 1; // Start from 1 because 0 is 'this'
                for (Type argumentType : argumentTypes) {
                    mv.visitInsn(Opcodes.DUP);  // Duplicate the array reference
                    mv.visitLdcInsn(arrayIndex); // Load the index

                    // Load the argument based on its type
                    loadArgument(mv, argumentType, localVariableIndex);

                    boxArgument(mv, argumentType);

                    mv.visitInsn(Opcodes.AASTORE); // Store the argument in the array
                    localVariableIndex += argumentType.getSize(); // Increment by the size of the argument type
                    arrayIndex++;
                }
            }

            private void loadArgument(MethodVisitor mv, Type argumentType, int localVariableIndex) {
                switch (argumentType.getSort()) {
                    case Type.BOOLEAN:
                    case Type.BYTE:
                    case Type.CHAR:
                    case Type.SHORT:
                    case Type.INT:
                        mv.visitVarInsn(Opcodes.ILOAD, localVariableIndex);
                        break;
                    case Type.LONG:
                        mv.visitVarInsn(Opcodes.LLOAD, localVariableIndex);
                        break;
                    case Type.FLOAT:
                        mv.visitVarInsn(Opcodes.FLOAD, localVariableIndex);
                        break;
                    case Type.DOUBLE:
                        mv.visitVarInsn(Opcodes.DLOAD, localVariableIndex);
                        break;
                    case Type.OBJECT:
                    case Type.ARRAY:
                        mv.visitVarInsn(Opcodes.ALOAD, localVariableIndex);
                        break;
                    default:
                        throw new IllegalArgumentException("Unsupported argument type: " + argumentType);
                }
            }

            private void boxArgument(MethodVisitor mv, Type argumentType) {
                switch (argumentType.getSort()) {
                    case Type.BOOLEAN:
                        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Boolean", "valueOf", "(Z)Ljava/lang/Boolean;", false);
                        break;
                    case Type.BYTE:
                        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Byte", "valueOf", "(B)Ljava/lang/Byte;", false);
                        break;
                    case Type.CHAR:
                        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Character", "valueOf", "(C)Ljava/lang/Character;", false);
                        break;
                    case Type.SHORT:
                        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Short", "valueOf", "(S)Ljava/lang/Short;", false);
                        break;
                    case Type.INT:
                        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Integer", "valueOf", "(I)Ljava/lang/Integer;", false);
                        break;
                    case Type.LONG:
                        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Long", "valueOf", "(J)Ljava/lang/Long;", false);
                        break;
                    case Type.FLOAT:
                        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Float", "valueOf", "(F)Ljava/lang/Float;", false);
                        break;
                    case Type.DOUBLE:
                        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Double", "valueOf", "(D)Ljava/lang/Double;", false);
                        break;
                    case Type.OBJECT:
                    case Type.ARRAY:
                        // No boxing needed for objects and arrays
                        break;
                    default:
                        throw new IllegalArgumentException("Unsupported argument type: " + argumentType);
                }
            }

            private void castResult(MethodVisitor mv, String descriptor) {
                Type returnType = Type.getReturnType(descriptor);

                switch (returnType.getSort()) {
                    case Type.VOID:
                        mv.visitInsn(Opcodes.POP); // Discard the result of invoke
                        mv.visitInsn(Opcodes.RETURN);
                        break;
                    case Type.BOOLEAN:
                        mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Boolean");
                        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z", false);
                        mv.visitInsn(Opcodes.IRETURN);
                        break;
                    case Type.BYTE:
                        mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Byte");
                        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Byte", "byteValue", "()B", false);
                        mv.visitInsn(Opcodes.IRETURN);
                        break;
                    case Type.CHAR:
                        mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Character");
                        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Character", "charValue", "()C", false);
                        mv.visitInsn(Opcodes.IRETURN);
                        break;
                    case Type.SHORT:
                        mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Short");
                        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Short", "shortValue", "()S", false);
                        mv.visitInsn(Opcodes.IRETURN);
                        break;
                    case Type.INT:
                        mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Integer");
                        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Integer", "intValue", "()I", false);
                        mv.visitInsn(Opcodes.IRETURN);
                        break;
                    case Type.LONG:
                        mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Long");
                        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Long", "longValue", "()J", false);
                        mv.visitInsn(Opcodes.LRETURN);
                        break;
                    case Type.FLOAT:
                        mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Float");
                        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Float", "floatValue", "()F", false);
                        mv.visitInsn(Opcodes.FRETURN);
                        break;
                    case Type.DOUBLE:
                        mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Double");
                        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Double", "doubleValue", "()D", false);
                        mv.visitInsn(Opcodes.DRETURN);
                        break;
                    case Type.OBJECT:
                        mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getObjectType(returnType.getInternalName()).getClassName().replace(".", "/"));
                        mv.visitInsn(Opcodes.ARETURN);
                        break;
                    case Type.ARRAY:
                        mv.visitTypeInsn(Opcodes.CHECKCAST, returnType.getDescriptor());
                        mv.visitInsn(Opcodes.ARETURN);
                        break;
                    default:
                        throw new IllegalArgumentException("Unsupported return type: " + returnType);
                }
            }
        }, 0);

        // Define static initializer
        MethodVisitor staticInitVisitor = cw.visitMethod(Opcodes.ACC_STATIC, "<clinit>", "()V", null, null);
        staticInitVisitor.visitCode();
        try {
            staticInitVisitor.visitLdcInsn(interfaceName);
            staticInitVisitor.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Class", "forName", "(Ljava/lang/String;)Ljava/lang/Class;", false);
            staticInitVisitor.visitLdcInsn("method");
            staticInitVisitor.visitInsn(Opcodes.ACONST_NULL);
            staticInitVisitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Class", "getMethod", "(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;", false);
            staticInitVisitor.visitFieldInsn(Opcodes.PUTSTATIC, internalProxyClassName, "method", "Ljava/lang/reflect/Method;");
        } catch (Exception e) {
            e.printStackTrace();
        }
        staticInitVisitor.visitInsn(Opcodes.RETURN);
        staticInitVisitor.visitMaxs(3, 0);
        staticInitVisitor.visitEnd();

        cw.visitEnd();

        byte[] bytecode = cw.toByteArray();
        try (FileOutputStream fos = new FileOutputStream(proxyClassName + ".class")) {
            fos.write(bytecode);
        }
    }

    public static void main(String[] args) throws IOException {
        generateProxyClass("MyInterface", "ASMProxy");
    }
}

这段代码使用 ASM 库生成一个名为 ASMProxy 的类，它实现了 MyInterface 接口。ASMProxy 继承自 java.lang.reflect.Proxy，并实现了 MyInterface 接口中的所有方法。每个方法都将调用转发到 InvocationHandler 的 invoke() 方法。

6. 类加载

生成的字节码需要通过类加载器加载到 JVM 中才能使用。Proxy.newProxyInstance() 方法使用指定的类加载器来加载代理类。通常，我们使用接口的类加载器，因为接口类加载器可以访问接口的所有依赖项。

7. 性能考量

动态代理的性能通常比静态代理差，因为动态代理需要在运行时生成字节码。但是，Proxy 类内部的缓存机制可以提高性能。如果已经生成了满足条件的代理类，则直接从缓存中返回，而无需重新生成字节码。

此外，现代 JVM 针对动态代理进行了优化，例如通过使用 invokedynamic 指令来提高方法调用的性能。

8. 总结

Java 动态代理是一种强大的技术，允许我们在运行时创建代理类。Proxy 类通过动态地生成字节码来实现动态代理。理解字节码生成的过程有助于我们更好地理解动态代理的工作原理。虽然 Proxy 类的内部实现细节是隐藏的，但我们可以使用第三方库（例如 ASM 或 Byte Buddy）来模拟这个过程。动态代理的性能虽然比静态代理差，但现代 JVM 针对动态代理进行了优化。使用缓存也可以提高性能。

9. 深入理解，灵活应用

Java 动态代理的核心在于 Proxy.newProxyInstance() 方法，它动态生成并加载代理类的字节码。 理解 Proxy 类如何创建类声明、添加构造方法、实现接口方法以及生成字节码指令是掌握动态代理的关键。虽然内部细节被隐藏，但我们可以利用 ASM 等库来模拟字节码生成过程，更深入地理解其实现原理。 最终，灵活运用动态代理，可以极大地提升代码的灵活性和可维护性。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注