代理（三）jdk动态代理源码分析

        Transfer o = (Transfer) Proxy.newProxyInstance(ProxyTest.class.getClassLoader(), new Class[]{Transfer.class}, new ZiDingYiInvocationHandler(new FixTransfer()));

Proxy.Proxy.newProxyInstance

jdk核心方法Proxy.Proxy.newProxyInstance 静态方法

   /**
     *
     * @param var0 类加载器，是将类的class字节码文件读入到内存，并为之创建一个java.lang.Class对象
     * @param var1 动态代理的目标对象接口数组 如： new Class[]{Transfer.class}
     * @param var2  InvocationHandler 的实现类
     * @return
     * @throws IllegalArgumentException
     */
    public static Object newProxyInstance(ClassLoader var0, Class<?>[] var1, InvocationHandler var2) throws IllegalArgumentException {
        if (var2 == null) {
            throw new NullPointerException();
        } else {
            //  1. 获取代理类的class对象 
            Class var3 = getProxyClass(var0, var1);

            try {
                // 获取代理类的构造方法
                //   private static final Class[] constructorParams = new Class[]{InvocationHandler.class};
                // Proxy类属性   constructorParams   
                Constructor var4 = var3.getConstructor(constructorParams);
                // 利用反射newInstance 方法生成代理类对象
                return var4.newInstance(var2);
            } catch (NoSuchMethodException var5) {
                throw new InternalError(var5.toString());
            } catch (IllegalAccessException var6) {
                throw new InternalError(var6.toString());
            } catch (InstantiationException var7) {
                throw new InternalError(var7.toString());
            } catch (InvocationTargetException var8) {
                throw new InternalError(var8.toString());
            }
        }
    }

getProxyClass

解析getProxyClass方法

    /**
     *
     * @param var0  类加载
     * @param var1  动态代理的目标对象接口数组 如： new Class[]{Transfer.class}
     * @return
     * @throws IllegalArgumentException
     */
    public static Class<?> getProxyClass(ClassLoader var0, Class<?>... var1) throws IllegalArgumentException {
        if (var1.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        } else {
            Class var2 = null;
            String[] var3 = new String[var1.length];
            HashSet var4 = new HashSet(); // 用来存放 动态代理的目标对象接口数组 的Class对象

            for(int var5 = 0; var5 < var1.length; ++var5) {
                String var6 = var1[var5].getName(); // 获取 目标接口名称
                Class var7 = null;

                try {
                    // 获取 目标接口的Class对象
                    var7 = Class.forName(var6, false, var0);
                } catch (ClassNotFoundException var31) {
                }

                if (var7 != var1[var5]) {
                    throw new IllegalArgumentException(var1[var5] + " is not visible from class loader");
                }

                if (!var7.isInterface()) { // 判断是否为接口
                    throw new IllegalArgumentException(var7.getName() + " is not an interface");
                }

                if (var4.contains(var7)) { // 判断动态代理的目标对象接口数组 内是否有重复
                    throw new IllegalArgumentException("repeated interface: " + var7.getName());
                }

                var4.add(var7); // 把 目标接口class对象存入 set集合
                var3[var5] = var6; // 把目标接口名称 存入String[] 数组
            }

            List var35 = Arrays.asList(var3); // String[] 数组 转成 List
            Object var36;
            // private static Map loaderToCache = new WeakHashMap();
            synchronized(loaderToCache) {
                var36 = (Map)loaderToCache.get(var0);
                if (var36 == null) {
                    var36 = new HashMap();
                    loaderToCache.put(var0, var36);
                }
            }

            synchronized(var36) {
                while(true) {
                    Object var8 = ((Map)var36).get(var35);
                    if (var8 instanceof Reference) {
                        var2 = (Class)((Reference)var8).get();
                    }

                    if (var2 != null) {
                        return var2;
                    }
                    // private static Object pendingGenerationMarker = new Object();
                    if (var8 != pendingGenerationMarker) {
                        ((Map)var36).put(var35, pendingGenerationMarker);
                        break;
                    }

                    try {
                        var36.wait();
                    } catch (InterruptedException var30) {
                    }
                }
            }

            try {
                String var37 = null;

                String var10;
                for(int var38 = 0; var38 < var1.length; ++var38) {
                    int var9 = var1[var38].getModifiers();
                    if (!Modifier.isPublic(var9)) {
                        var10 = var1[var38].getName();
                        int var11 = var10.lastIndexOf(46);
                        String var12 = var11 == -1 ? "" : var10.substring(0, var11 + 1);
                        if (var37 == null) {
                            var37 = var12;
                        } else if (!var12.equals(var37)) {
                            throw new IllegalArgumentException("non-public interfaces from different packages");
                        }
                    }
                }

                if (var37 == null) {
                    var37 = "";
                }

                long var39;
                synchronized(nextUniqueNumberLock) {
                    var39 = (long)(nextUniqueNumber++);
                }

                var10 = var37 + "$Proxy" + var39;
                // 生成代理对象classs byte数组
                byte[] var40 = ProxyGenerator.generateProxyClass(var10, var1);
                /*
                    //可以把ProxyGenerator.generateProxyClass 生成的byte数组 转成class 文件
                    FileOutputStream out = null; 
                    String filePath = "D:/workflie/WXWork/dddd.class";
                    out = new FileOutputStream(filePath);
                    out.write(classFile);
                    out.flush();
                 */
                try {
                    var2 = defineClass0(var0, var10, var40, 0, var40.length);
                } catch (ClassFormatError var28) {
                    throw new IllegalArgumentException(var28.toString());
                }

                proxyClasses.put(var2, (Object)null);
            } finally {
                synchronized(var36) {
                    if (var2 != null) {
                        ((Map)var36).put(var35, new WeakReference(var2));
                    } else {
                        ((Map)var36).remove(var35);
                    }

                    var36.notifyAll();
                }
            }

            return var2;
        }
    }

生成的class文件

ProxyGenerator.generateProxyClass 生成的byte数组 转成class 文件

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

import com.deppon.nhr.module.aatest.proxy.Transfer;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy7 extends Proxy implements Transfer {
    private static Method m1;
    private static Method m0;
    private static Method m3;
    private static Method m2;

    public $Proxy7(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int transferIn() throws  {
        try {
            return (Integer)super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m3 = Class.forName("com.deppon.nhr.module.aatest.proxy.Transfer").getMethod("transferIn");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

ProxyGenerator.generateProxyClass 解析

/**
     *
     * @param var0 代理类名称
     * @param var1 代理对象数组
     * @return
     */
    public static byte[] generateProxyClass(final String var0, Class[] var1) {
        /**
         *     private ProxyGenerator(String var1, Class[] var2) {
         *         this.className = var1;
         *         this.interfaces = var2;
         *     }
         */
        ProxyGenerator var2 = new ProxyGenerator(var0, var1); // 创建ProxyGenerator对象
        final byte[] var3 = var2.generateClassFile();  // 生产代理对象 byte数组
        //判断 是否生成代理对象 .class文件
        if (saveGeneratedFiles) {
            AccessController.doPrivileged(new PrivilegedAction() {
                public Object run() {
                    try {
                        FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class");
                        var1.write(var3);
                        var1.close();
                        return null;
                    } catch (IOException var2) {
                        throw new InternalError("I/O exception saving generated file: " + var2);
                    }
                }
            });
        }

        return var3;
    }

generateClassFile 定义反射对象 构造方法

this.methods.add(this.generateConstructor());

这里设置构造方法参数为 InvocationHandler 对象

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