在学习Retrofit源码时，发现retrofit.create(final Class service)是通过Java的动态代理构建了一个代理对象，所以翻看了一下Java源码中关于动态代理如何构建对应的类的代码，本文先简单描述一下Java生成Class文件的过程，动态代理部分后续再写。
Java生成动态代理类的对应的方法是ProxyGenerator 的 public static byte[] generateProxyClass(String className, Class[] classTye)，直接上代码示例：
ClassGen.java
package com.ant.jdk.reflect;
import java.io.FileOutputStream;
import java.io.IOException;
import sun.misc.ProxyGenerator;
public class ClassGen {
public static void main(String[] args) {
String className = "$GenProxy0";
byte[] classData = ProxyGenerator.generateProxyClass(className, RealSubject.class.getInterfaces()); //这个地方第二个参数需要使用对象类实现的接口参数，
不能使用“Subject.class.getInterfaces()”
或“RealSubject.class.getClasses()”，使用这
两个在生成的class文件中都不会有Subject的方法实现
String path = "D:/" + className + ".class";
writeFile(classData, path);
}
private static void writeFile(byte[] classData, String path) {
FileOutputStream classFile = null;
try {
classFile = new FileOutputStream(path);
classFile.write(classData);
classFile.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
classFile.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
RealSubject.java：
package com.ant.jdk.reflect;
public class RealSubject implements Subject {
@Override
public void bye() {
System.out.println("Goodbye!!");
}
@Override
public void hello(String str) {
System.out.println("Hello: " + str);
}
}
Subject.java
package com.ant.jdk.reflect;
public interface Subject {
void bye();
void hello(String str);
}
运行ClassGen，可以在D看到一个生成的$GenProxy0.class文件，对该文件反编译(直接把该文件拖到Intelli J中)后对应的内容如下：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
import com.ant.jdk.reflect.Subject;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $GenProxy0 extends Proxy implements Subject {
private static Method m1;
private static Method m4;
private static Method m2;
private static Method m3;
private static Method m0;
public $GenProxy0(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void bye() throws { // 指定接口实现的方法
try {
super.h.invoke(this, m4, (Object[])null);
} 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);
}
}
public final void hello(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);
} 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"));
m4 = Class.forName("com.ant.jdk.reflect.Subject").getMethod("bye");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.ant.jdk.reflect.Subject").getMethod("hello", 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());
}
}
}
上面文件中重点注意“super.h”这个变量，这个变量就是在构造函数中输入的InvocationHandler，即你需要代理的对象(后续在讲解动态代理的时候会重点描述)。
下面简单分析生成class的代码：
本示例中最核心的就是ProxyGenerator.generateClassFile方法，该方法用于生成class文件，阅读该段代码需要对着class文件结构来理解(关于class文件的结构的文档待补充
调用的基本过程：ProxyGenerator.generateProxyClass --> ProxyGenerator.generateProxyClass ---> ProxyGenerator.generateClassFile
可以对比生成的class文件阅读该方法的流程，该方法主要根据指定的接口和Object类，根据Class文件的格式逐个拼凑Class文件
private byte[] generateClassFile() {
// 下面三个是Object对象的方法
this.addProxyMethod(hashCodeMethod, Object.class);
this.addProxyMethod(equalsMethod, Object.class);
this.addProxyMethod(toStringMethod, Object.class);
Class[] var1 = this.interfaces; // 需要实现的接口， 即调用
ProxyGenerator.generateProxyClass 时的第二个参数
int var2 = var1.length;
int var3;
Class var4;
for(var3 = 0; var3 < var2; ++var3) {
var4 = var1[var3];
Method[] var5 = var4.getMethods();
int var6 = var5.length;
for(int var7 = 0; var7 < var6; ++var7) {
Method var8 = var5[var7];
this.addProxyMethod(var8, var4);
}
}
Iterator var11 = this.proxyMethods.values().iterator();
List var12;
while(var11.hasNext()) {
var12 = (List)var11.next();
checkReturnTypes(var12);
}
Iterator var15;
try {
this.methods.add(this.generateConstructor());
var11 = this.proxyMethods.values().iterator();
while(var11.hasNext()) {
var12 = (List)var11.next();
var15 = var12.iterator();
while(var15.hasNext()) {
ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();
this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName, "Ljava/lang/reflect/Method;", 10));
this.methods.add(var16.generateMethod());
}
}
this.methods.add(this.generateStaticInitializer());
} catch (IOException var10) {
throw new InternalError("unexpected I/O Exception", var10);
}
if (this.methods.size() > 65535) {
throw new IllegalArgumentException("method limit exceeded");
} else if (this.fields.size() > 65535) {
throw new IllegalArgumentException("field limit exceeded");
} else {
this.cp.getClass(dotToSlash(this.className));
this.cp.getClass("java/lang/reflect/Proxy");
var1 = this.interfaces;
var2 = var1.length;
for(var3 = 0; var3 < var2; ++var3) {
var4 = var1[var3];
this.cp.getClass(dotToSlash(var4.getName()));
}
this.cp.setReadOnly();
ByteArrayOutputStream var13 = new ByteArrayOutputStream();
DataOutputStream var14 = new DataOutputStream(var13);
try {
var14.writeInt(-889275714); //转换16进制就是FFFFFFFFCAFEBABE，
CAFEBABE就是Class文件的魔术字
var14.writeShort(0);
var14.writeShort(49); //版本信息，49应该是JDK 1.5
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);
Class[] var17 = this.interfaces;
int var18 = var17.length;
for(int var19 = 0; var19 < var18; ++var19) {
Class var22 = var17[var19];
var14.writeShort(this.cp.getClass(dotToSlash(var22.getName())));
}
var14.writeShort(this.fields.size());
var15 = this.fields.iterator();
while(var15.hasNext()) {
ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();
var20.write(var14);
}
var14.writeShort(this.methods.size());
var15 = this.methods.iterator();
while(var15.hasNext()) {
ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();
var21.write(var14);
}
var14.writeShort(0);
return var13.toByteArray();
} catch (IOException var9) {
throw new InternalError("unexpected I/O Exception", var9);
}
}
}
类的访问权限accessFlags字段：
标志名称 标志值 含义
ACC_PUBLIC 0x0001 是否为public类型
ACC_FINAL 0x0010 是否为final类型，只有类可以设置
ACC_SUPER 0x0020 是否允许使用invokespecial字节码指令的新语义
ACC_INTERFACE 0x0200 标识是一个接口
ACC_ABSTRACT 0x0400 是否为abstract类型
.....
