前言
不知道，起这个名字算不算是标题党呢？不过如果小伙伴们可以耐心看下去，因为会觉得不算标题党~
这是一个系列文章，目的在于通过动态代理这个很基础的技术，进而深入挖掘诸如：动态生成class；Class文件的结构；用到动态代理的框架源码分析。
对于三部曲来说，我初步打算：
- 上：从源码处看JDK实现的动态代理的方式。
- 中：了解Class文件的结构，看懂.class文件。[动态代理三部曲：中] - 从动态代理，看Class文件结构定义
- 下：Retrofit中动态代理的源码实现。
对于这个系列的上篇来说，开篇我们先带着几个问题：
- 1.、动态代理，所谓的“动态”，“代理”都在哪？
- 2、动态代理如何生成 Class 文件？
自己一直很想好好了解一波动态代理，无论是从技术角度，还是工作角度。
因为作为Android开发，我们日常开发离不开拥有着动态代理思想的Retrofit。而且就冲这个很洋气的名字，学是必须得学的。就算饿死,死外边,从这跳下去，我也要学明白动态代理。
按照正常动态代理的套路，我们需要写一个接口，然后实现接口，然后巴拉巴拉写一堆...写这么多为了干啥？谁呀？咋滴了？不知道啊？
不知道小伙伴们百度动态代理的文章时，是什么感受，反正我是上述的感受。写几行demo，就说深入理解动态代理了？那我学会写demo岂不是资深开发了？所以我个人认为，如果脱离业务去聊技术，恐怕没办法去深入理解这个项技术。所以关于动态代理我们（MDove+一支彩笔）会想办法写成一篇系列文章。后续我（MDove）会结合Android的部分，写一写能真正用起来的效果~
个人理解
首先，先谈一谈我们对动态代理的理解。网上很多资源喜欢把动态代理和静态代理放在一起去对比。这里我们就先不这么来做了，个人感觉静态代理本身重的是一种思想，而本篇动态代理着重去思考它代码套路背后的流程，所以就不放在一起啦。如果有对静态代理感兴趣的小伙伴，可以直接自行了解吧~
关于动态代理，个人喜欢把动态和代理分开理解：
动态：可随时变化的。对应我们编程，可以理解为在运行期去搞事情。
代理：接管我们真正的事务，去代我们执行。在我们生活中有很多充当代理的角色，比如：租房中介。
接下来让我们通过一个：租客通过中介租房子的demo，来展开动态代理的过程。（demo结束之后，我们会从源码的角度，去理解动态代理）
由浅
Demo效果
demo的开始，我们依旧是按照动态代理的语法规则开始入手。简单交代一下demo的剧情~我们有一个租客，身上揣着5000元钱，来到一个陌生的城市里。他想租一个房子，但是人生地不熟的，所以他选择了一个房屋中介...结果中介收了他4500元钱，我们的租客被坑了...
编写代码之前，让我们先看一下效果。
记住这个效果，接下来让我们一步步，看看租客是怎么被坑的~
开始编码
第一步，我们先把上当受骗的租客写出来，定义一个租客的接口
public interface IRentHouseProcessor {
String rentHouse(String price);
}
接下来，便是实现InvocationHandler，编写我们动态代理的重头角色。
按照官方的docs文章，对InvocationHandler的解释：每个代理实例（Proxy,这里提到的Proxy代理实例是哪个？不要着急，往下看。）都有一个关联的调用处理程序（InvocationHandler）。在代理实例上调用方法时，方法会被调度到invoke中。
InvocationHandler是我们动态代理核心方法的一个核心参数。它的实例会在构建Proxy实例的时候以参数的形式传递进入，并在Proxy实例被调用的时候，将真正执行的方法，调度到自身的invoke方法里（形成代理）。后文从我们反编译的Proxy.class可以证实这个问题。
public class RentHouseProcessorHandler implements InvocationHandler {
private Object target;
public RentHouseProcessorHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Log.d(MainActivity.TAG, "-----------------------------");
Log.d(MainActivity.TAG, "我是中介，有人找我租房子了，看看他能出多少钱：" + args[0]);
Log.d(MainActivity.TAG, "我既然是中介，那我收他4000元的好处费，500块钱给你组个地下室，不过分吧？！！");
Object result = method.invoke(target, new Object[]{"500"});
Log.d(MainActivity.TAG, "赚了一大笔钱，美滋滋~");
return result;
}
}
让我们通过一张图来，仔细的理解一下invoke方法的每个参数的含义。
1.1.3、代理开始
编辑好了我们demo故事中的角色，那就让我们开始动态代理之路吧：
首先，我们不使用代理，直接通过租客的实例调用自身实现的接口。这里没啥好说的~只是为了剧情需要，更好的理解流程。
RentHouseProcessorImpl dpImpl = new RentHouseProcessorImpl();
dpImpl.rentHouse("5000");
Log.d(TAG,"我准备找中介去组个房子。");
使用动态代理:
RentHouseProcessorHandler handler = new RentHouseProcessorHandler(dpImpl);
IRentHouseProcessor proxy = (IRentHouseProcessor) Proxy.newProxyInstance(
dpImpl.getClass().getClassLoader(),
dpImpl.getClass().getInterfaces(),
handler);
String content = proxy.rentHouse("5000");
Log.d(TAG, content);
这一步执行完毕，就会得到我们开篇的那个效果。我们的租客本来身上揣了5000元钱，当找了代理之后，真正租房的过程变成了中介（代理）去完成，所以租房的过程变得并不透明（invoke中，进行了一些额外的操作），因此我们的租客被坑了。
这一步我们来解释一下上述提到的那个疑问：代理实例在哪？这个代理实例其实就是Proxy.newProxyInstance()的返回值，也就是IRentHouseProcessor proxy这个对象。这里有一个很严肃的问题？IRentHouseProcessor是一个接口，接口是不可能被new出来的。
所以说proxy对象是一个特别的存在。没错它就是：动态代理动态生成出来的代理实例。而这个实例被动态的实现了我们的IRentHouseProcessor接口，因此它可以被声明为我们的接口对象。
上述docs文档提到，当我们调用proxy对象中的接口方法时，实际上会调度到InvocationHandler方法中的invoke方法中（这个操作同样是在动态生成的Proxy对象中被调度过去的）。
当方法到invoke中，那么问题就出现了：invoke是我们自己重写的，那也就是说：我们拥有至高无上的权利！
所以在我们的租房这个故事中，中介就是在这个invoke方法中，黑掉了我们租户的钱！因为invoke方法中它拥有绝对的操作权限。想干什么就干什么，甚至不执行我们真正想要执行的方法，我们的租客也没办法怎么样。
1.2、入深：“代理”在哪？
接下来让我们走进源码，来解决第一个大问题：1、动态代理，所谓的“动态”，“代理”都在哪？
走到这，不知道小伙伴对动态代理的流程是不是有了一个清晰的认识。动态代理的过程还是套路性比较强的：实现一个InvocationHandler类，在invoke中接受处理proxy对象调度过来的方法（Method）信息，方法执行到此，我们就可以为所欲为的做我们想做的事情啦。而我们的代理类实例是由系统帮我们创建了，我们只需要处理invoke中被调度的方法即可。
接下来让我们了解一下这个被动态生成的代理类实例。“代理”是如何被创建出来的~
1.2.1、“代理”在哪里呀？
第一步，让我们通过动态代理最开始的方法，Proxy.newProxyInstance()入手。
下面的代码，省略了一些判空/try-catch的过程，如果觉得省略不当，可以自行搜索对应的源码。
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h) throws IllegalArgumentException {
//省略：一些判空，权限校验的操作
//[ 标注1 ]
//想办法获取一个代理类的Class对象（$Proxy0）
Class<?> cl = getProxyClass0(loader, intfs);
//省略：try-catch/权限检验
//获取参数类型是InvocationHandler.class的代理类的构造方法对象($Proxy的构造方法的参数就是InvocationHandler类型)
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
//省略：cons.setAccessible(true)过程
//传入InvocationHandler的实例去，构造一个代理类的实例
return cons.newInstance(new Object[]{h});
}
}
[ 标注1 ]
这部分代码，我们可以看到，调用了一个参数是ClassLoader、以及接口类型数组的方法。并且返回值是一个Class对象。实际上这里返回的c1实际上是我们的代理类的Class对象。何以见得？让我们点进去一看究竟：
//从缓存中取代理类的Class对象，如果没有通过ProxyClassFactory->ProxyGenerator去生成
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// 如果存在实现给定接口的给定加载器定义的代理类，则只返回缓存副本; 否则，它将通过ProxyClassFactory创建代理类
return proxyClassCache.get(loader, interfaces);
}
1.2.2、跳过缓存，看背后
上述getProxyClass0方法中，进来之后我们会发现，代码量及其的少。这里很明显是通过了一个Cache对象去想办法获取我们所需要的Class对象。这部分设计到了动态代理的缓存过程，其中用的思想和数据结构比较的多，暂时就先不展开了（篇幅原因，以及也不是我们本次文章重点关注的对象）。如果有感兴趣的小伙伴，可以自行搜索了解呦~
Cache的get过程，最终会转向ProxyClassFactory这个类，由这个类先生成需要的代理类的Class对象。
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>> {
//代理类名称前缀
private static final String proxyClassNamePrefix = "$Proxy";
//用原子类来生成代理类的序号, 以此来确定唯一的代理类
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
//这里遍历interfaces数组进行验证：是否可以由指定的类加载进行加载；是否是一个接口；是否有重复
}
//生成代理类的包名
String proxyPkg = null;
//生成代理类的访问权限, 默认是public和final
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
for (Class<?> intf : interfaces) {
//[ 标注1 ]
// 省略：验证所有非public的代理接口是否在同一个包中。不在则抛异常
throw new IllegalArgumentException("non-public interfaces from different packages");
}
//省略部分代码：生成代理类的全限定名, 包名+前缀+序号, 例如：com.sun.proxy.$Proxy0
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//！！接下来便进入重点了，用ProxyGenerator来生成字节码, 以byte[]的形式存放
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName,
interfaces, accessFlags);
//省略try-catch，根据二进制文件生成相应的Class实例
return defineClass0(loader, proxyName, proxyClassFile,
0, proxyClassFile.length);
}
}
[ 标注1 ]
这部分，可能省略的比较多，因为内容主要是一些判断。这部分的做的事情是：遍历所有接口，看一下是不是public。如果不是，需要看一些些接口是不是在同一个包下，如果不是抛异常。这个很容易理解，非public接口还不在同一个包下，这没得搞啊~
接下来，让我们重点看一下ProxyGenerator.generateProxyClass(proxyName,interfaces, accessFlags);也就是代理类生成的方法。ProxyGenerator类可以通过查看OpenJDK获取
1.2.3、构造代理Class
接下来我们需要注意的是generateProxyClass，这个方法便是：这个Class被构造出来的缘由：
private byte[] generateClassFile() {
//首先为代理类生成toString, hashCode, equals等代理方法（组装成ProxyMethod对象）
addProxyMethod(hashCodeMethod, Object.class);
addProxyMethod(equalsMethod, Object.class);
addProxyMethod(toStringMethod, Object.class);
//省略：遍历每一个接口的每一个方法, 并且为其生成ProxyMethod对象（遍历，调用addProxyMethod()方法）。省略校验过程。
//省略try-catch：组装要生成的class文件的所有的字段信息和方法信息
//添加构造器方法（methods：MethodInfo类型的ArrayList）
methods.add(generateConstructor());
//遍历缓存中的代理方法
for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
for (ProxyMethod pm : sigmethods) {
//添加代理类的静态字段, 例如:private static Method m1;
fields.add(new FieldInfo(pm.methodFieldName,
"Ljava/lang/reflect/Method;", ACC_PRIVATE | ACC_STATIC));
//添加代理类的代理方法
methods.add(pm.generateMethod());
}
}
//添加代理类的静态字段初始化方法
methods.add(generateStaticInitializer());
//省略校验
//通过class文件规则，最终生成我们的$Proxy.class文件
//验证常量池中存在代理类的全限定名
cp.getClass(dotToSlash(className));
//验证常量池中存在代理类父类的全限定名, 父类名为:"java/lang/reflect/Proxy"
cp.getClass(superclassName);
//验证常量池存在代理类接口的全限定名
for (int i = 0; i < interfaces.length; i++) {
cp.getClass(dotToSlash(interfaces[i].getName()));
}
//接下来要开始写入文件了,设置常量池只读
cp.setReadOnly();
ByteArrayOutputStream bout = new ByteArrayOutputStream();
DataOutputStream dout = new DataOutputStream(bout);
//省略try-catch：1、写入魔数
dout.writeInt(0xCAFEBABE);
//2、写入次版本号
dout.writeShort(CLASSFILE_MINOR_VERSION);
//3、写入主版本号
dout.writeShort(CLASSFILE_MAJOR_VERSION);
// 省略其他写入过程
//转换成二进制数组输出
return bout.toByteArray();
}
// 封装构造方法
private MethodInfo generateConstructor() throws IOException {
MethodInfo minfo = new MethodInfo("<init>", "(Ljava/lang/reflect/InvocationHandler;)V",ACC_PUBLIC);
DataOutputStream out = new DataOutputStream(minfo.code);
code_aload(0, out);
code_aload(1, out);
out.writeByte(opc_invokespecial);
out.writeShort(cp.getMethodRef(superclassName,"<init>", "(Ljava/lang/reflect/InvocationHandler;)V"));
out.writeByte(opc_return);
minfo.maxStack = 10;
minfo.maxLocals = 2;
minfo.declaredExceptions = new short[0];
return minfo;
}
以上注释的内容，如果小伙伴们看过字节码格式的话，应该不陌生。这一部分内容就是去创建我们的代理类的Class字节码文件（字段/方法的描述符）。并通过ByteArrayOutputStream的作用，将我们手动生成的字节码内容转成byte[]，并调用defineClass0方法，将其加载到内存当中。
如果对class文件结构感觉的小伙伴，可以查找一些相关的资料，或者《Java虚拟机规范》。当然也可以继续往下看：3、 Class 文件的格式。
末尾return方法，是一个native方法，我们不需要看实现，应该也能猜到，这里的内容是把我们的构造的byte[]加载到内存当中，然后获得对应的Class对象，也就是我们的代理类的Class。
private static native Class<?> defineClass0(ClassLoader var0, String var1, byte[] var2, int var3, int var4);
1.2.4、$Proxy0.class是什么样子？
OK，到这一步，我们的代理类的Class对象就生成出来了。因此我们Proxy.newProxyInstance()所返回出来的类也就很明确了。就是一个：拥有我们所实现接口类的所有方法结构的全新Class对象。也就是我们所说的代理类。
因为拥有我们接口的方法结构，所以可能调用我们的方法。不过着这个过程中，我们所调用的方法，被调度到InvocationHandler中的invoke方法里了。这一步，可能有小伙伴会问，为什么说我们的方法被调度到invoke之中了？要回答这个问题，我们需要看一下我们生成的Proxy代理类是什么样子的。
我总结了网上各种各样查看动态代理生成的.class文件的方法，贴一种成本最小的方式：
使用Eclipse，运行我们的动态代理的方法。运行之前，加上这么一行代码：
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
当然这样运行大概率，ide会报错
Exception in thread "main" java.lang.InternalError:
I/O exception saving generated file: java.io.FileNotFoundException: com\sun\proxy\$Proxy0.class (系统找不到指定的路径。)
那怎么办呢？很简单，在src同级的建三级的文件夹分别是：com/sun/proxy。然后运行，就可以看到我们的$Proxy0.class啦。然后我们把它拖到AndroidStudio当中，查看反编译之后的结果：
public final class $Proxy0 extends Proxy implements IRentHouseProcessor {
private static Method m3;
private static Method m1;
private static Method m0;
private static Method m2;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final String rentHouse(String var1) throws {
try {
return (String)super.h.invoke(this, m3, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
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 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);
}
}
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 {
m3 = Class.forName("proxy.IRentHouseProcessor").getMethod("rentHouse", new Class[]{Class.forName("java.lang.String")});
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
看了Proxy的代码，为什么会被调度到invoke方法中就很清晰了吧？
1.3、入深：“动态”在哪？
我们走完上诉1.2的过程，其实“动态”在哪这个问题的答案已经很明确了吧？ProxyGenerator.generateProxyClass(proxyName,interfaces, accessFlags);方法之中JDK本身就直接帮我们动态的构建了我们所需要的$Proxy0类。
1.4、动态代理如何生成 Class 文件？
这个问题的答案，我们也可以从上诉的过程之中找到答案。在对应生成$Proxy的过程中，我们往DataOutputStream之中写入我们class文件所规定的内容；此外写入了我们字段/方法的描述符。然后通过DataOutputStram将我们的内容转成二进制数组。最后交由我们的native方法，去将此class文件加载到内存之中。
结语
小伙伴们一步步追了下来，不知道有没有对动态代理的过程有了比较清晰的认识。
接下来的内容，会针对动态代理进行实际应用场景的编写；以及对Retrofit动态代理相关内容的分析。