JDK動態代理 - 底層原理

JDK動態代理

是JDK原生提供的動態代理方式，無需添加任何第三方依賴。運行期，生成具體的字節碼，但是不可以修改。被代理類需要有接口。

可以通過ProxyGenerator.generateProxyClass(String s, Class<?>[] classes) 方法獲取生成的字節碼。再通過FileOutputStream#write(byte[] arr)方法寫入到一個文件中。

e.g.

byte[] arr = ProxyGenerator.generateProxyClass("$Proxy0", new Class<?>[]{ISubject.class});
FileOutputStream fos = new FileOutputStream("$Proxy0.class");
fos.write(arr);
fos.close();

Proxy.newProxyInstance(…)

生成代理類實例

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    Objects.requireNonNull(h);
    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }
    /*
     * Look up or generate the designated proxy class.
     */
    Class<?> cl = getProxyClass0(loader, intfs);
    /*
     * Invoke its constructor with the designated invocation handler.
     */
    try {
        if (sm != null) {
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException|InstantiationException e) {
        ......
    } catch (InvocationTargetException e) {
        ......
    } catch (NoSuchMethodException e) {
        ......
    }
}

獲取代理類

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }
    return proxyClassCache.get(loader, interfaces);
}

實際上就是調用ProxyClassFactory#appy(ClassLoader loader, Class<?>[] interfaces)方法。

生成、定義、返回代理類

/**
 * A factory function that generates, defines and returns the proxy class given
 * the ClassLoader and array of interfaces.
 */
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

        Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
        for (Class<?> intf : interfaces) {
            /*
             * Verify that the class loader resolves the name of this
             * interface to the same Class object.
             */
            Class<?> interfaceClass = null;
            try {
                interfaceClass = Class.forName(intf.getName(), false, loader);
            } catch (ClassNotFoundException e) {
            }
            if (interfaceClass != intf) {
                throw new IllegalArgumentException(
                    intf + " is not visible from class loader");
            }
            /*
             * Verify that the Class object actually represents an
             * interface.
             */
            if (!interfaceClass.isInterface()) {
                throw new IllegalArgumentException(
                    interfaceClass.getName() + " is not an interface");
            }
            /*
             * Verify that this interface is not a duplicate.
             */
            if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                throw new IllegalArgumentException(
                    "repeated interface: " + interfaceClass.getName());
            }
        }
        String proxyPkg = null;     // package to define proxy class in
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

        /*
         * Record the package of a non-public proxy interface so that the
         * proxy class will be defined in the same package.  Verify that
         * all non-public proxy interfaces are in the same package.
         */
        for (Class<?> intf : interfaces) {
            int flags = intf.getModifiers();
            if (!Modifier.isPublic(flags)) {
                accessFlags = Modifier.FINAL;
                String name = intf.getName();
                int n = name.lastIndexOf('.');
                String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                if (proxyPkg == null) {
                    proxyPkg = pkg;
                } else if (!pkg.equals(proxyPkg)) {
                    throw new IllegalArgumentException(
                        "non-public interfaces from different packages");
                }
            }
        }

        if (proxyPkg == null) {
			/* "com.sun.proxy." */ 
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }
        /*
         * Choose a name for the proxy class to generate.
         */
        long num = nextUniqueNumber.getAndIncrement();
        String proxyName = proxyPkg + proxyClassNamePrefix + num;
        /*
         * Generate the specified proxy class.
         */
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);
        try {
            return defineClass0(loader, proxyName,
                                proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            throw new IllegalArgumentException(e.toString());
        }
    }
}

生成代理類的字節碼文件

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        final byte[] var4 = var3.generateClassFile();
        if (saveGeneratedFiles) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    try {
                        int var1 = var0.lastIndexOf(46);
                        Path var2;
                        if (var1 > 0) {
                            Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
                            Files.createDirectories(var3);
                            var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                        } else {
                            var2 = Paths.get(var0 + ".class");
                        }
                        Files.write(var2, var4, new OpenOption[0]);
                        return null;
                    } catch (IOException var4x) {
                        throw new InternalError("I/O exception saving generated file: " + var4x);
                    }
                }
            });
        }
        return var4;
    }

生成字節碼文件的內容

private byte[] generateClassFile() {
    this.addProxyMethod(hashCodeMethod, Object.class);
    this.addProxyMethod(equalsMethod, Object.class);
    this.addProxyMethod(toStringMethod, Object.class);
    Class[] var1 = this.interfaces;
    int var2 = var1.length;
    int var3;
    Class var4;
    for(var3 = 0; var3 < var2; ++var3) {
        var4 = var1[var3];
        /* 被代理類中定義的方法 */
        Method[] var5 = var4.getMethods();
        int var6 = var5.length;
        for(int var7 = 0; var7 < var6; ++var7) {
            Method var8 = var5[var7];
            this.addProxyMethod(var8, var4);
        }
    }
    Iterator var11 = this.proxyMethods.values().iterator();
    List var12;
    while(var11.hasNext()) {
        var12 = (List)var11.next();
        checkReturnTypes(var12);
    }
    Iterator var15;
    try {
        this.methods.add(this.generateConstructor());
        var11 = this.proxyMethods.values().iterator();
        while(var11.hasNext()) {
            var12 = (List)var11.next();
            var15 = var12.iterator();
            while(var15.hasNext()) {
                ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();
                /* 添加屬性 */
                this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName, "Ljava/lang/reflect/Method;", 10));
                /* 添加方法 */
                this.methods.add(var16.generateMethod());
            }
        }
        this.methods.add(this.generateStaticInitializer());
    } catch (IOException var10) {
        throw new InternalError("unexpected I/O Exception", var10);
    }
    if (this.methods.size() > 65535) {
        throw new IllegalArgumentException("method limit exceeded");
    } else if (this.fields.size() > 65535) {
        throw new IllegalArgumentException("field limit exceeded");
    } else {
        this.cp.getClass(dotToSlash(this.className));
        this.cp.getClass("java/lang/reflect/Proxy");
        var1 = this.interfaces;
        var2 = var1.length;
        for(var3 = 0; var3 < var2; ++var3) {
            var4 = var1[var3];
            this.cp.getClass(dotToSlash(var4.getName()));
        }
        this.cp.setReadOnly();
        ByteArrayOutputStream var13 = new ByteArrayOutputStream();
        DataOutputStream var14 = new DataOutputStream(var13);
        try {
            var14.writeInt(-889275714);
            var14.writeShort(0);
            var14.writeShort(49);
            this.cp.write(var14);
            var14.writeShort(this.accessFlags);
            var14.writeShort(this.cp.getClass(dotToSlash(this.className)));
            var14.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
            var14.writeShort(this.interfaces.length);
            Class[] var17 = this.interfaces;
            int var18 = var17.length;
            for(int var19 = 0; var19 < var18; ++var19) {
                Class var22 = var17[var19];
                var14.writeShort(this.cp.getClass(dotToSlash(var22.getName())));
            }
            var14.writeShort(this.fields.size());
            var15 = this.fields.iterator();

            while(var15.hasNext()) {
                ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();
                var20.write(var14);
            }
            var14.writeShort(this.methods.size());
            var15 = this.methods.iterator();
            while(var15.hasNext()) {
                ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();
                var21.write(var14);
            }
            var14.writeShort(0);
            return var13.toByteArray();
        } catch (IOException var9) {
            throw new InternalError("unexpected I/O Exception", var9);
        }
    }
}

生成構造器

private ProxyGenerator.MethodInfo generateConstructor() throws IOException {
    ProxyGenerator.MethodInfo var1 = new ProxyGenerator.MethodInfo("<init>", "(Ljava/lang/reflect/InvocationHandler;)V", 1);
    DataOutputStream var2 = new DataOutputStream(var1.code);
    this.code_aload(0, var2);
    this.code_aload(1, var2);
    var2.writeByte(183);
    var2.writeShort(this.cp.getMethodRef("java/lang/reflect/Proxy", "<init>", "(Ljava/lang/reflect/InvocationHandler;)V"));
    var2.writeByte(177);
    var1.maxStack = 10;
    var1.maxLocals = 2;
    var1.declaredExceptions = new short[0];
    return var1;
}

檢查返回類型

private static void checkReturnTypes(List<ProxyGenerator.ProxyMethod> var0) {
    if (var0.size() >= 2) {
        LinkedList var1 = new LinkedList();
        Iterator var2 = var0.iterator();
        boolean var5;
        label49:
        do {
            while(var2.hasNext()) {
                ProxyGenerator.ProxyMethod var3 = (ProxyGenerator.ProxyMethod)var2.next();
                Class var4 = var3.returnType;
                if (var4.isPrimitive()) {
                    throw new IllegalArgumentException("。。。。。。");
                }
                var5 = false;
                ListIterator var6 = var1.listIterator();
                while(var6.hasNext()) {
                    Class var7 = (Class)var6.next();
                    if (var4.isAssignableFrom(var7)) {
                        continue label49;
                    }
                    if (var7.isAssignableFrom(var4)) {
                        if (!var5) {
                            var6.set(var4);
                            var5 = true;
                        } else {
                            var6.remove();
                        }
                    }
                }
                if (!var5) {
                    var1.add(var4);
                }
            }
            if (var1.size() > 1) {
                ProxyGenerator.ProxyMethod var8 = (ProxyGenerator.ProxyMethod)var0.get(0);
                throw new IllegalArgumentException("。。。。。。");
            }
            return;
        } while($assertionsDisabled || !var5);
        throw new AssertionError();
    }
}

添加ProxyMethod

private void addProxyMethod(Method var1, Class<?> var2) {
    String var3 = var1.getName();
    Class[] var4 = var1.getParameterTypes();
    Class var5 = var1.getReturnType();
    Class[] var6 = var1.getExceptionTypes();
    /* var7 : 方法簽名 */
    String var7 = var3 + getParameterDescriptors(var4);
    /* var8 : List<ProxyGenerator.ProxyMethod> */
    Object var8 = (List)this.proxyMethods.get(var7);
    if (var8 != null) {
        Iterator var9 = ((List)var8).iterator();
        while(var9.hasNext()) {
            ProxyGenerator.ProxyMethod var10 = (ProxyGenerator.ProxyMethod)var9.next();
            /* 處理代理接口中的代理方法重複的問題 */
            if (var5 == var10.returnType) {
                ArrayList var11 = new ArrayList();
                collectCompatibleTypes(var6, var10.exceptionTypes, var11);
                collectCompatibleTypes(var10.exceptionTypes, var6, var11);
                var10.exceptionTypes = new Class[var11.size()];
                var10.exceptionTypes = (Class[])var11.toArray(var10.exceptionTypes);
                return;
            }
        }
    } else {
        var8 = new ArrayList(3);
        this.proxyMethods.put(var7, var8);
    }
    ((List)var8).add(new ProxyGenerator.ProxyMethod(var3, var4, var5, var6, var2));
}

獲取參數描述符

private static String getParameterDescriptors(Class<?>[] var0) {
    StringBuilder var1 = new StringBuilder("(");
    for(int var2 = 0; var2 < var0.length; ++var2) {
        var1.append(getFieldType(var0[var2]));
    }
    var1.append(')');
    return var1.toString();
}

private static String getFieldType(Class<?> var0) {
    if (var0.isPrimitive()) {
        return ProxyGenerator.PrimitiveTypeInfo.get(var0).baseTypeString;
    } else {
        return var0.isArray() ? var0.getName().replace('.', '/') : "L" + dotToSlash(var0.getName()) + ";";
    }
}

private static String dotToSlash(String var0) {
    return var0.replace('.', '/');
}

收集兼容的類型

private static void collectCompatibleTypes(Class<?>[] var0, Class<?>[] var1, List<Class<?>> var2) {
    Class[] var3 = var0;
    int var4 = var0.length;
    for(int var5 = 0; var5 < var4; ++var5) {
        Class var6 = var3[var5];
        if (!var2.contains(var6)) {
            Class[] var7 = var1;
            int var8 = var1.length;
            for(int var9 = 0; var9 < var8; ++var9) {
                Class var10 = var7[var9];
                if (var10.isAssignableFrom(var6)) {
                    var2.add(var6);
                    break;
                }
            }
        }
    }
}