类型信息

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);
    }

    /*
        * 查找和生成代理类
        */
    Class<?> cl = getProxyClass0(loader, intfs);

    /*
        * 使用指定的程序处理器获取构造函数对象
        */
    try {
        if (sm != null) {
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }

        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        // 如果构造器是private的， 就使用反射来setAccessible
        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) {
        throw new InternalError(e.toString(), e);
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString(), t);
        }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString(), e);
    }
}

private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }
    // 如果缓存中包含接口数组和类加载器已存在，则返回缓存副本，否则通过ProxyClassFactory创建一个对应的class对象
    return proxyClassCache.get(loader, interfaces);
}

public V get(K key, P parameter) {
    ...
    ...
    ...
    // create subKey and retrieve the possible Supplier<V> stored by that
    // subKey from valuesMap
    // apply()方法调用ProxyClassFactory的apply方法
    Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
    ...
    ...
    ...
}

public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
    ...
    ...
    ...
    /*
    * 生成指定的代理类
    */
    byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
    proxyName, interfaces, accessFlags);
    try {
    return defineClass0(loader, proxyName,
                        proxyClassFile, 0, proxyClassFile.length);
    } catch (ClassFormatError e) {
    throw new IllegalArgumentException(e.toString());
    }
    ...
    ...
    ...
}

private byte[] generateClassFile() {
    // 将object类中的hashcode，equals，toString方法添加到动态代理类中
    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);
    }
    ...
    ...
    ...
}