JDKProxy

ContactService.java

public interface ContactService {
    void contact(String userId);
}

ContactServiceImpl.java

public class ContactServiceImpl implements ContactService{
    public void contact(String userId) {
        System.out.println("contact with " + userId);
    }
}

JdkProxy.java

public class JdkProxy {

    public static void main(String args[]){
        final ContactService contactService = new ContactServiceImpl();
        ContactService contactServiceProxy = (ContactService) Proxy
                .newProxyInstance(JdkProxy.class.getClassLoader()
                , new Class[] {ContactService.class}
                , new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("proxy begin...");
                        String proxySimpleClassName = proxy.getClass().getSimpleName();
                        byte[] proxyClassByteArray = ProxyGenerator.generateProxyClass(
                                proxySimpleClassName, proxy.getClass().getInterfaces());
                        FileOutputStream fos = null;
                        try{
                            fos = new FileOutputStream(proxySimpleClassName + ".class");
                            fos.write(proxyClassByteArray);
                            fos.flush();
                        }finally {
                            if(fos != null){
                                fos.close();
                            }
                        }
                        return method.invoke(contactService, args);
                    }
                });
        contactServiceProxy.contact("nafoahnaw");
    }
}

以上代码关键之一在于代理对象contactServiceProxy是如何生成的
要知道这点必须继续深入源码，java.lang.reflect.Proxy#newProxyInstance的关键步骤

        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, intfs);

    /**
     * Generate a proxy class.  Must call the checkProxyAccess method
     * to perform permission checks before calling this.
     */
    private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        // If the proxy class defined by the given loader implementing
        // the given interfaces exists, this will simply return the cached copy;
        // otherwise, it will create the proxy class via the ProxyClassFactory
        return proxyClassCache.get(loader, interfaces);
    }

getProxyClass0方法基于WeakCache实现，WeakCache也是一个类Map的结构

    /**
     * a cache of proxy classes
     */
    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

通过注释和proxyClassCache我们发现ProxyClassFactory是产生代理对象class类的关键
继续深入java.lang.reflect.Proxy.ProxyClassFactory#apply方法,关键代码如下

            /*
             * Generate the specified proxy class.
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);

这样就根据newProxyInstance方法中给出的interfaces创建出了代理对象,继续回到java.lang.reflect.Proxy#newProxyInstance方法,cl就是contactServiceProxy的class对象，通过cl.getConstructor获取构造函数然后生成对象。

/** parameter types of a proxy class constructor */
    private static final Class<?>[] constructorParams =
        { InvocationHandler.class };

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

这里其实有点困惑，cl里为什么会存在一个参数为InvocationHandler的构造函数?回到ProxyClassFactory方法

            /*
             * Generate the specified proxy class.
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);

代理对象Class对象的具体类定义由ProxyGenerator.generateProxyClass方法给出，通过走读sun.misc.ProxyGenerator#generateClassFile源码我们可以发现，sun.misc.ProxyGenerator#generateConstructor是此方法给我们生成的代理对象加上了该构造方法,sun.misc.ProxyGenerator#generateClassFile方法为代理对象继承了Proxy类，关键代码如下

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

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

那么在运行是生成出来的contactServiceProxy对象究竟长啥样呢，我们可以运行最上面的代码，将contactServiceProxy写入到文件中通过idea反编译来看，关键代码如下

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

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

static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("service.ContactService").getMethod("contact", Class.forName("java.lang.String"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }

public final void contact(String var1) throws  {
        try {
            //这个h就是我们匿名构造的InvocationHandler,从Proxy类继承而来
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }