上回，简单的看了JDK动态代理与CGLIB动态代理的应用于区别，也了解了下Proxy.newProxyInstance()这个类参数与作用。这次我们接着往下看并提出几个疑问来引导下面的内容。
- 这个代理类到底哪来的？
- invoke()方法到底做了什么，怎么和我们的方法建立联系的？
- 生成的代理类是什么样的？
再次探索Proxy.newProxyInstance
抽出主要的3条关键语句（可在IDEA中通过双击关键词来观察代码的走向）
分别是：克隆-生成指定的代理类-得到构造器-返回代理类
可以得知：生成代理类的内容在第二句话中，那么点进去~
final Class[] intfs = interfaces.clone();
Class cl = getProxyClass0(loader, intfs);
final Constructor cons = cl.getConstructor(constructorParams);
return cons.newInstance(new Object[]{h});
方法头注释我没加进来，意思是欲生成代理类，必先调用checkProxyAccess方法来执行权限检查，而在newProxyInstance方法的前几行遍执行了这个检查。
下面的3行单行注释意为：这个东西是有缓存的，如果有就不要用ProxyClassFactory再生成。
这边只有一个可以进入的方法，进入他！
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);
}
这个方法大量是对缓存的操作，从高频的get()，replace()，和putIfAbsen()，我们都不管。进入一个参数正好为之前传递进来的key和parameter的apply方法。
apply方法是BiFunction
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
前面就是通过对接口的遍历来验证接口，在方法的尾部我们看到一个byte[]字节数组，并从注释得知他的作用是生成指定的代理类。我们点进generateProxyClass方法，发现他有几个参数不同的重载方法。
/*
* Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
下面我们用generateProxyClass方法把返回的字节码写入到文件中来查看其中的东西。
public class GenerateProxy {
public static void main(String[] args) {
Talking talking = new JDKProxy(new TalkingImpl()).getProxy();
talking.say("二狗子");
String path = "C:/$Proxy0.class";
byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0",
TalkingImpl.class.getInterfaces());
try (FileOutputStream out = new FileOutputStream(path)){
out.write(classFile);
out.flush();
} catch (Exception e) {
e.printStackTrace();
}
}
}
因为IDEA自带反编译功能，直接把生成的$Proxy0.class文件拖入IDEA即可。
public final class $Proxy0 extends Proxy implements Talking {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
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);
}
}
public final void say(String var1) throws {
try {
super.h.invoke(this, m3, 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)).intValue();
} 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"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.company.proxy.Talking").getMethod("say", Class.forName("java.lang.String"));
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
可以看到代理类继承于Proxy并实现了Talking接口，并可以看到定义了4个方法与静态块通过反射用来初始化。到这里，一切都豁然开朗了。
接下来回答上面3个问题：
- 是通过ProxyGenerator.generateProxyClass（String, Class[]）来生成的字节码
- invoke方法即建立生成代理类与原被代理接口之间的联系
- 生成的代理类就是酱紫的~