深入浅出JDK动态代理(二)

接上篇《深入浅出JDK动态代理(一)》

代理类解密

对于JDK动态代理，生成的代理类是什么样的？为什么调用代理类的任何方法时都一定会调用invoke方法？下面来进行深入解密。

因为动态代理是在运行时动态生成字节码，编译期看不到相应的class文件，所以不能直观的看到代理类内容。那就从newProxyInstance方法开始(代码分析基于JDK7)，这个方法用于创建代理类对象，这里只关注重要的代码段，

Class<?> cl = getProxyClass0(loader, intfs); /* * Invoke its constructor with the designated invocation handler. */ try { final Constructor<?> cons = cl.getConstructor(constructorParams); final InvocationHandler ih = h; if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) { // create proxy instance with doPrivilege as the proxy class may // implement non-public interfaces that requires a special permission return AccessController.doPrivileged(new PrivilegedAction<Object>() { public Object run() { return newInstance(cons, ih); } }); } else { return newInstance(cons, ih); } } catch (NoSuchMethodException e) { throw new InternalError(e.toString()); }

代码段中

final Constructor<?> cons = cl.getConstructor(constructorParams);

用于获取代理类的构造函数，constructorParams参数其实就是一个InvocationHandler，所以从这里猜测代理类中有一个InvocationHandler类型的属性，并且作为构造函数的参数。那这个代理类是在哪里创建的？注意看上面的代码段中有

Class<?> cl = getProxyClass0(loader, intfs);

这里就是动态创建代理类的地方，继续深入到getProxyClass0方法中，方法如下，

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

继续跟踪代码，进入proxyClassCache.get(loader, interfaces)，这个方法中重点关注如下代码

Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));

继续跟踪代码，进入subKeyFactory.apply(key, parameter)，进入apply方法，这个方法中有很多重要的信息，如生成的代理类所在的包名，发现重要代码，

long num = nextUniqueNumber.getAndIncrement(); String proxyName = proxyPkg + proxyClassNamePrefix + num;

上面代码用于生成代理类名称，nextUniqueNumber是AtomicLong类型，是一个全局变量，所以nextUniqueNumber.getAndIncrement()会使用当前的值加一得到新值；proxyClassNamePrefix声明如下，

private static final String proxyClassNamePrefix = "$Proxy";

所以，这里生成的代理类类名格式为：包名+$Proxy+num，如jdkproxy.$Proxy12。

代理类的类名已经构造完成了，那可以开始创建代理类了，继续看代码，

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);

这里就是真正创建代理类的地方，继续分析代码，进入generateProxyClass方法，

public static byte[] generateProxyClass(final String var0, Class[] var1) { ProxyGenerator var2 = new ProxyGenerator(var0, var1); final byte[] var3 = var2.generateClassFile(); if(saveGeneratedFiles) { AccessController.doPrivileged(new PrivilegedAction() { public Void 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; }

从这里可以很直白的看到，生成的代理类字节码文件被输出到某个目录下了，这里可能很难找到这个字节码文件，没关系，仔细查看这个方法，generateProxyClass方法可以重用，可以在外面调用generateProxyClass方法，把生成的字节码文件输出到指定位置。写到这里，终于可以解释上面实例代码中的createProxyClassFile方法了，这个方法把代理类的字节码文件输出到了/Users路径下，直接到路径下查看这个文件，使用反编译工具查看，得到的代码如下，

public final class LoginServiceProxy extends Proxy implements LoginService { private static Method m1; private static Method m3; private static Method m0; private static Method m2; public LoginServiceProxy(InvocationHandler paramInvocationHandler) throws { super(paramInvocationHandler); } public final boolean equals(Object paramObject) throws { try { return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue(); } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final void login() throws { try { this.h.invoke(this, m3, null); return; } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final int hashCode() throws { try { return ((Integer)this.h.invoke(this, m0, null)).intValue(); } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final String toString() throws { try { return (String)this.h.invoke(this, m2, null); } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") }); m3 = Class.forName("jdkproxy.LoginService").getMethod("login", new Class[0]); m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); return; } catch (NoSuchMethodException localNoSuchMethodException) { throw new NoSuchMethodError(localNoSuchMethodException.getMessage()); } catch (ClassNotFoundException localClassNotFoundException) { throw new NoClassDefFoundError(localClassNotFoundException.getMessage()); } } }

从上面的代码可以看到，当代理类调用目标方法时，会调用InvocationHandler接口实现类的invoke方法，很明了的解释了为什么调用目标方法时一定会调用invoke方法。

总结：

1.静态代理方式虽然简单，但是会出现重复代码的情况；

2.动态代理使用上相对复杂些，但是可以动态创建代理类，避免手动编写重复代码；

3.因为Java的单继承性，JDK动态代理只能对接口创建代理类，不能对实现类创建。