接上篇《深入浅出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动态代理只能对接口创建代理类，不能对实现类创建。
