打造一个简单的Java字节码反编译器

本文示范了一种反编译Java字节码的方法，首先通过解析class文件，然后将解析的结果转成java代码。但是本文并没有覆盖所有的class文件的特性和指令，只针对部分规范进行解析。

所有的代码代码都是示范性的，追求功能实现，没有太多的软件工程方面的考量。

Class文件格式

一个Java类或者接口被javac编译后会生成一个class文件，class文件可以用下面代码来描述，u2，u4分表表示2个字节的无符号数和4个字节的无符号数。

    ClassFile {        u4 magic;        u2 minor_version;        u2 major_version;        u2 constant_pool_count;        cp_info constant_pool[constant_pool_count-1];        u2 access_flags;        u2 this_class;        u2 super_class;        u2 interfaces_count;        u2 interfaces[interfaces_count];        u2 fields_count;        field_info fields[fields_count];        u2 methods_count;        method_info methods[methods_count];        u2 attributes_count;        attribute_info attributes[attributes_count];    }

• magic是固定值0xCAFEBABE
• minor_version和major_version分别代表副版本号和主版本号。
• constant_pool_count表示接下来常量池中包含的常量项数量。
• constant_pool表示常量池，常量池中包含了各种不同类型的常量池项，如：字符串常量，类或接口名，方法引用等，每个常量池项的第一个字节表示tag，在解析常量池时，需要先读取tag，然后根据不同的tag类型继续往后面读取固定字节的数据。每个常量池项都有一个编号，外部可以使用这个编号来访问常量池项。
• access_flags表示类或者接口标志，如PUBLIC,FINAL等。
• this_class指向常量池的一个索引号，最终解析出来的是一个类或者接口的名称。
• super_class指向父类，jvm只支持单继承。
• interfaces_count，interfaces分别表示实现的接口数和实现的接口。
• fields_count，fields表示一个类的域。
• methods_count，methods表示一个类或接口包含的方法。
• attributes_count，attributes表示对类的属性。

用Java解析Class文件

本节定义一系列数据结构用来将二进制class数据用java代码来描述。并简述一些基本概念，由于class文件定义项非常多，如果要详细了解，请查看《ava虚拟机规范》 [https://docs.oracle.com/javase/specs/jvms/se8/html/]。

ClassFile

public class ClassFile {    private int magic;    private int minorVersion;    private int majorVersion;    private ConstantPool constantPool;    private AccessFlags accessFlags;    private int thisClass;    private int superClass;    private int interfacesCount;    private int interfaces[];    private int fieldsCount;    private FieldInfo fields[];    private int methodsCount;    private MethodInfo methods[];    private int attributesCount;    private Attribute attributes[];}

ConstantPool

常量池中包含了类的所有符号信息，包括类名，方法名，常量等。常量池项包含了多种类型，每项使用一个tag来识别是哪个常量。定义基类如下：

public abstract class CPInfo {    protected ConstantPool constantPool;}

具体常量池定义如下：

public class ConstantUtf8Info extends CPInfo {    private String value;}public class ConstantStringInfo extends CPInfo {    private int stringIndex;}public class ConstantClassInfo extends CPInfo {    private int nameIndex;}

在解析常量池时，需要先读取一个字节的tag来判断这个常量池项是什么类型，然后按类型来读取接下来的数据，因为每个不同类型的项所包含的数据是不定长的，所以这里显然是需要一个大大的switch了。

由于常量池类型多达10几种，这里不一一列出。具体参考《Java虚拟机规范》。定义一个ConstantPool类来简化对常量池的操作，这个类包含了常量池项的数量和常量池项的数组。

public class ConstantPool {    private int poolCount;    private CPInfo[] pool;    public ConstantPool(DataInputStream dataInputStream) throws IOException {        this.poolCount = dataInputStream.readUnsignedShort();        this.pool = new CPInfo[this.poolCount];                //注意，从下表为1开始访问常量池        for (int i = 1; i < this.poolCount; i++) {            int tag = dataInputStream.readUnsignedByte();            this.pool[i] = CPInfoFactory.getInstance().createCPInfo(tag, dataInputStream, this);        }    }    public int getPoolCount() {        return poolCount;    }    public <T extends CPInfo> T getCPInfo(int index) {        return (T) pool[index];    }    public ConstantUtf8Info getUtf8Info(int index) {        return (ConstantUtf8Info) pool[index];    }}

FieldInfo

FieldInfo用来描述类里的Field，定义如下：

class FieldInfo {    private int accessFlags; //修饰符号    private int nameIndex; //field名称常量在常量池中的索引    private int descriptorIndex;    private int attributesCount;    private Attribute attributeInfo[];}

MethodInfo

用于描述类中方法的数据结构，methodInfo里面包含了一系列的attribute，方法的实际字节码指令就放在CodeAttribute里面。

class MethodInfo {    private AccessFlags accessFlags;    private int nameIndex;    private int descriptorIndex;    private int attributesCount;    private Attribute attributes[];}

Attribute

在ClassFile，FieldInfo，MethodInfo里面都定义了一个Attribute数组，Attribute类型也不少，本文只关注MethodInfo里面的CodeAttribute类型。这个类型包含了一个方法的操作数栈大小，本地变量表大小，指令码：

public class CodeAttribute extends Attribute {    private int maxStack;    private int maxLocals;    private int codeLength;    private byte code[];    private int exceptionTableLength;    private ExceptionData exceptionTable[];    private int attributeCount;    private Attribute attributes[];}

Descriptor

Descriptor是一个字符串，可以用来描述一个方法的参数和返回类型。如下：

(Ljava/lang/Object;[Ljava/lang/Object;)I(II)I

括号中表述参数，括号外表示返回类型。这个Descriptor可以解析成 :

int XXX(Object,Object[]);int XXX(int,int);

L表示引用类型，I表示int类型，[表示数组，具体对应如下：

char2TypeMap.put('B', "byte");char2TypeMap.put('C', "char");char2TypeMap.put('D', "double");char2TypeMap.put('F', "float");char2TypeMap.put('I', "int");char2TypeMap.put('J', "long");char2TypeMap.put('S', "short");char2TypeMap.put('Z', "boolean");

class文件的解析不复杂，但是比较繁琐，本文不全部列出，更多class文件的定义还是要参考《Java虚拟机规范》。

将ClassFile解析成Java代码

ClassFile对象解析出来后，可以开始生成Java代码了。首先构造class的头部：

    //生成class头部：public class Test extends Base     private String generateClassHead() {        StringBuilder javaCode = new StringBuilder();        if (classFile.getAccessFlags().hasFlag(AccessFlags.ACC_PUBLIC)) {            javaCode.append("public ");        } else if (classFile.getAccessFlags().hasFlag(AccessFlags.ACC_PRIVATE)) {            javaCode.append("private ");        } else {            javaCode.append("protected ");        }        if (classFile.getAccessFlags().hasFlag(AccessFlags.ACC_INTERFACE)) {            javaCode.append("interface ");        } else {            javaCode.append("class ");        }        javaCode.append(this.className).append(" ");        //解析实现的接口名        if (classFile.getInterfaces().length > 0) {            javaCode.append(" implements ");        }        for (int i = 0; i < classFile.getInterfaces().length; i++) {            ConstantClassInfo interfaceClassInfo = classFile.getConstantPool().getCPInfo(classFile.getInterfaces()[i]);            javaCode.append(interfaceClassInfo.getName());            boolean isLast = i == (classFile.getInterfaces().length - 1);            if (!isLast) {                javaCode.append(",");            }        }        return javaCode.toString();    }

class的头部代码构造比较简单，最复杂的在于class body部分，本文只实现了MethodInfo的解析，也就是只生成方法，在构造class body之前，要先看一下，如果为MethodInfo生成代码，
首先解析方法头部，方法头部解析比较简单，就是拼凑方法modifiers，方法名称，方法参数，返回等，方法的头部的解析和类解析的头部有一定的相同点，主要区别就是方法头部解析需要根据Descriptor来解析方法的返回类型，方法的参数列表。并根据ExceptionsAttribute来解析这个方法可能抛出的异常（本文不考虑解析Excpetion），比较简单，这里不贴代码了。

接下来解析方法body，方法body里面包含了具体的指令码。需要解析CodeAttribute，只有方法才包含CodeAttribute，CodeAttribute里才包含字节码指令，下面是一个方法用字节码表示的示范：

  public int sum(int, int);    descriptor: (II)I    flags: ACC_PUBLIC    Code:      stack=2, locals=3, args_size=3         0: iload_1         1: iload_2         2: iadd         3: ireturn      LineNumberTable:        line 13: 0      LocalVariableTable:        Start  Length  Slot  Name   Signature            0       4     0  this   Lcom/mypackage/Test;            0       4     1     i   I            0       4     2     j   I

Code节点就是CodeAttribute，里面包含了stack，locals，args_size，以及几条指令。stack表示执行这个方法所需要的栈大小，这个值在编译时已经确定了，locals表示本地变量表的大小，args_size表示方法参数的数量，由于这个方法是个实例方法，所以第一个传进来的参数是实例自身，也就是this，然后才是方法的两个参数，所以参数为3。

JVM用线程来执行方法，每个线程都包含一个线程栈，线程栈存放的是栈帧，每个栈帧都有自己的操作数栈和本地变量表。当一个方法被执行时候，首先会在栈顶push一个栈帧，栈帧的创建就需要指定操作数栈和本地变量表的大小。接下来方法的参数会被传入一个方法的本地变量表，本地变量表的访问采用下表索引的方式来访问，第0个位置会传入this，第1个位置会传入int，第2个位置会传入int。

在栈帧完全准备好后，就可以开始执行执行字节码指令了，上述iload_1,i_load_2分别将本地变量表的1，2位置的数据push到操作数栈中，iadd随后会pop两个值用来做加法操作，并将结果push到操作数栈，最后ireturn将栈顶数据返回。

在理解字节码的执行方式后，可以开始将字节码一条一条的转化成java代码。这里依然需要借助stack。可以用一个stack来暂时存储转换后的java代码，还是用上面代码做示范：
首先声明一个stack:

Stack<String> javaCodeStack=new Stack<String>();

然后依次翻译上述指令，实际上就是模拟指令的行为：

iload_1 -> javaCodeStack.push("var1"); iload_2 -> javaCodeStack.push("var2");iadd    -> javaCodeStack.push(javaCodeStack.pop() + "+" javaCodeStack.pop());ireturn -> javaCodeStack.push("return "+javaCodeStack.pop());

指令执行完毕后，java代码也就翻译完成了，所有有效的java代码都已经放在javaCodeStack里，接下来就是遍历一下javaCodeStack，把里面的字符串打印出来就行了，遍历后得到的结果只有一行java代码，如下：

return var2+var1;

上面只阐述了几种简单指令的翻译方式，但是即使对于复杂的指令，也只需要按照上面的方式来做转换就可以得到java代码。下面代码实现了更多的指令翻译，基本流程就是先得到CodeAttribute，然后准备好操作数栈和本地变量表，接下来就是每次读取一个指令，然后根据指令类型在读取指令的参数（一般是访问常量池的索引号），最后将压入栈的java代码拼接成一个字符串，得到的就是方法体的代码了。

    private String generateMethodBodyCode(MethodInfo methodInfo, List<TypeDescriptor> parametersTypeDescriptors,                                          TypeDescriptor returnTypeDescriptor) throws IOException {        StringBuilder javaCode = new StringBuilder();        String currentMethodName = classFile.getConstantPool().getUtf8Info(methodInfo.getNameIndex()).getValue();        //寻找CodeAttribute        CodeAttribute codeAttribute = findAttribute(methodInfo, Attribute.Code);        if (codeAttribute == null) {            throw new RuntimeException("无法在Method里找到CodeAttribute");        }        Stack<Object> opStack = new Stack<>(/*codeAttribute.getMaxStack()*/);        List<String> localVariableNames = new ArrayList<>(codeAttribute.getMaxLocals());        //初始化本地变量表名，首先如果是实例方法，需要把this放入第一个，然后依次将方法参数名放入        boolean isStaticMethod = methodInfo.getAccessFlags().hasFlag(AccessFlags.ACC_STATIC);        if (!isStaticMethod) {            localVariableNames.add("this");        }        for (int x = 0; x < parametersTypeDescriptors.size(); x++) {            localVariableNames.add("var" + (x + 1));        }        DataInputStream byteCodeInputStream = new DataInputStream(new ByteArrayInputStream(codeAttribute.getCode()));        while (byteCodeInputStream.available() > 0) {            int opCode = byteCodeInputStream.readByte() & 0xff;            switch (opCode) {                case OP_aload_0:                    System.out.println("aload_0");                    opStack.push(localVariableNames.get(0));                    break;                case OP_invokevirtual: {                    int methodRefIndex = byteCodeInputStream.readUnsignedShort();                    System.out.println("invokevirtual #" + methodRefIndex);                    ConstantMethodRefInfo methodRefInfo = classFile.getConstantPool().getCPInfo(methodRefIndex);                    ConstantNameAndTypeInfo nameAndTypeInfo = classFile.getConstantPool().getCPInfo(methodRefInfo.getNameAndTypeIndex());                    String methodName = classFile.getConstantPool().getUtf8Info(nameAndTypeInfo.getNameIndex()).getValue();                    String typeDescriptor = classFile.getConstantPool().getUtf8Info(nameAndTypeInfo.getDescriptorIndex()).getValue();                    int methodParameterSize = new DescriptorParser(typeDescriptor).getParameterTypeDescriptors().size();                    Object targetClassName;                    Object parameterNames[] = new Object[methodParameterSize];                    for (int x = 0; x < methodParameterSize; x++) {                        parameterNames[methodParameterSize - x - 1] = opStack.pop();                    }                    targetClassName = opStack.pop();                    StringBuilder line = new StringBuilder();                    line.append(targetClassName).append(".").append(methodName).append("(");                    for (int x = 0; x < methodParameterSize; x++) {                        line.append(parameterNames[x]);                        if ((x != methodParameterSize - 1)) {                            line.append(",");                        }                    }                    line.append(");");                    opStack.push(line.toString());                    break;                }                case OP_invokespecial: {                    int methodRefIndex = byteCodeInputStream.readUnsignedShort();                    System.out.println("invokespecial #" + methodRefIndex);                    ConstantMethodRefInfo methodRefInfo = classFile.getConstantPool().getCPInfo(methodRefIndex);                    ConstantNameAndTypeInfo nameAndTypeInfo = classFile.getConstantPool().getCPInfo(methodRefInfo.getNameAndTypeIndex());                    String typeDescriptor = classFile.getConstantPool().getUtf8Info(nameAndTypeInfo.getDescriptorIndex()).getValue();                    int methodParameterSize = new DescriptorParser(typeDescriptor).getParameterTypeDescriptors().size();                    Object targetClassName;                    Object parameterNames[] = new Object[methodParameterSize];                    if (methodParameterSize > 0) {                        for (int x = 0; x < methodParameterSize; x++) {                            parameterNames[methodParameterSize - x - 1] = opStack.pop();                        }                    }                    targetClassName = opStack.pop();                    StringBuilder line = new StringBuilder();                    if (currentMethodName.equals("<init>") && targetClassName.equals("this")) {                        line.append("super");                    } else {                        line.append("new ").append(targetClassName);                    }                    line.append("(");                    for (int x = 0; x < methodParameterSize; x++) {                        line.append(parameterNames[x]);                        if ((x != methodParameterSize - 1)) {                            line.append(",");                        }                    }                    line.append(");");                    opStack.push(line.toString());                    break;                }                case OP_getstatic:                    System.out.println("getstatic");                    break;                case OP_return:                    System.out.println("return");                    break;                case OP_new: {                    int classIndex = byteCodeInputStream.readUnsignedShort();                    System.out.println("new #" + classIndex);                    ConstantClassInfo classInfo = classFile.getConstantPool().getCPInfo(classIndex);                    opStack.push(classInfo.getName());                    break;                }                case OP_dup:                    System.out.println("dup");                    Object top = opStack.pop();                    opStack.push(top);                    opStack.push(top);                    break;                case OP_ldc:                    int stringIndex = byteCodeInputStream.readByte() & 0xff;                    System.out.println("ldc #" + stringIndex);                    ConstantStringInfo stringInfo = classFile.getConstantPool().getCPInfo(stringIndex);                    String value = classFile.getConstantPool().getUtf8Info(stringInfo.getStringIndex()).getValue();                    opStack.push(value);                    break;                case OP_iload_1:                    System.out.println("iload_1");                    opStack.push(localVariableNames.get(1));                    break;                case OP_iload_2:                    System.out.println("iload_2");                    opStack.push(localVariableNames.get(2));                    break;                case OP_iadd:                    System.out.println("iadd");                    opStack.push(opStack.pop() + "+" + opStack.pop());                    break;                case OP_ireturn:                    System.out.println("ireturn");                    opStack.push("return " + opStack.pop());                    break;                case OP_iconst_0:                    System.out.println("iconst_0");                    opStack.push("0");                    break;                case OP_iconst_1:                    System.out.println("iconst_1");                    opStack.push("1");                    break;                case OP_iconst_2:                    System.out.println("iconst_2");                    opStack.push("2");                    break;                case OP_astore_1: {                    System.out.println("astore_1");                    String obj = opStack.pop().toString();                    String className = opStack.pop().toString();                    localVariableNames.add(1, "localVar1");                    opStack.push(className + " localVar1=" + obj);                    break;                }                case OP_astore_2: {                    System.out.println("astore_2");                    String obj = opStack.pop().toString();                    String className = opStack.pop().toString();                    localVariableNames.add(1, "localVar2");                    opStack.push(className + " localVar2=" + obj);                    break;                }                case OP_astore_3: {                    System.out.println("astore_3");                    String obj = opStack.pop().toString();                    String className = opStack.pop().toString();                    localVariableNames.add(1, "localVar3");                    opStack.push(className + " localVar3=" + obj);                    break;                }                case OP_aload_1:                    System.out.println("aload_1");                    opStack.push(localVariableNames.get(1));                    break;                case OP_pop:                    System.out.println("pop");                    //opStack.pop();                    break;                default:                    throw new RuntimeException("Unknow opCode:0x" + opCode + " " + currentMethodName);            }        }        for (Object s : opStack) {            javaCode.append("       ").append(s).append("\r\n");        }        return javaCode.toString();    }

最后就是组装一个class了，将类头部，方法头部，方法body，全部拼接后，就是最终的java代码了。

总结

本文涉及的代码只实现了class规范的一部分，并不能反编译所有的class文件（需要补全未识别的指令），下面的字节码通过了测试：

public class com.mypackage.Test  minor version: 0  major version: 52  flags: ACC_PUBLIC, ACC_SUPERConstant pool:   #1 = Methodref          #6.#34         // java/lang/Object."<init>":()V   #2 = Class              #35            // com/mypackage/Test   #3 = String             #36            // hello   #4 = Methodref          #2.#37         // com/mypackage/Test."<init>":(Ljava/lang/String;)V   #5 = Methodref          #2.#38         // com/mypackage/Test.sum:(II)I   #6 = Class              #39            // java/lang/Object   #7 = Utf8               <init>   #8 = Utf8               (Ljava/lang/String;)V   #9 = Utf8               Code  #10 = Utf8               LineNumberTable  #11 = Utf8               LocalVariableTable  #12 = Utf8               this  #13 = Utf8               Lcom/mypackage/Test;  #14 = Utf8               s  #15 = Utf8               Ljava/lang/String;  #16 = Utf8               sum  #17 = Utf8               (II)I  #18 = Utf8               i  #19 = Utf8               I  #20 = Utf8               j  #21 = Utf8               search  #22 = Utf8               (Ljava/lang/Object;[Ljava/lang/Object;)I  #23 = Utf8               o  #24 = Utf8               Ljava/lang/Object;  #25 = Utf8               objects  #26 = Utf8               [Ljava/lang/Object;  #27 = Utf8               main  #28 = Utf8               ([Ljava/lang/String;)V  #29 = Utf8               args  #30 = Utf8               [Ljava/lang/String;  #31 = Utf8               test  #32 = Utf8               SourceFile  #33 = Utf8               Test.java  #34 = NameAndType        #7:#40         // "<init>":()V  #35 = Utf8               com/mypackage/Test  #36 = Utf8               hello  #37 = NameAndType        #7:#8          // "<init>":(Ljava/lang/String;)V  #38 = NameAndType        #16:#17        // sum:(II)I  #39 = Utf8               java/lang/Object  #40 = Utf8               ()V{  public com.mypackage.Test(java.lang.String);    descriptor: (Ljava/lang/String;)V    flags: ACC_PUBLIC    Code:      stack=1, locals=2, args_size=2         0: aload_0         1: invokespecial #1                  // Method java/lang/Object."<init>":()V         4: return      LineNumberTable:        line 8: 0        line 10: 4      LocalVariableTable:        Start  Length  Slot  Name   Signature            0       5     0  this   Lcom/mypackage/Test;            0       5     1     s   Ljava/lang/String;  public int sum(int, int);    descriptor: (II)I    flags: ACC_PUBLIC    Code:      stack=2, locals=3, args_size=3         0: iload_1         1: iload_2         2: iadd         3: ireturn      LineNumberTable:        line 13: 0      LocalVariableTable:        Start  Length  Slot  Name   Signature            0       4     0  this   Lcom/mypackage/Test;            0       4     1     i   I            0       4     2     j   I  public int search(java.lang.Object, java.lang.Object[]);    descriptor: (Ljava/lang/Object;[Ljava/lang/Object;)I    flags: ACC_PUBLIC    Code:      stack=1, locals=3, args_size=3         0: iconst_0         1: ireturn      LineNumberTable:        line 17: 0      LocalVariableTable:        Start  Length  Slot  Name   Signature            0       2     0  this   Lcom/mypackage/Test;            0       2     1     o   Ljava/lang/Object;            0       2     2 objects   [Ljava/lang/Object;  public static void main(java.lang.String[]);    descriptor: ([Ljava/lang/String;)V    flags: ACC_PUBLIC, ACC_STATIC    Code:      stack=3, locals=3, args_size=1         0: new           #2                  // class com/mypackage/Test         3: dup         4: ldc           #3                  // String hello         6: invokespecial #4                  // Method "<init>":(Ljava/lang/String;)V         9: astore_1        10: aload_1        11: iconst_1        12: iconst_2        13: invokevirtual #5                  // Method sum:(II)I        16: pop        17: new           #6                  // class java/lang/Object        20: dup        21: invokespecial #1                  // Method java/lang/Object."<init>":()V        24: astore_2        25: return      LineNumberTable:        line 21: 0        line 22: 10        line 23: 17        line 24: 25      LocalVariableTable:        Start  Length  Slot  Name   Signature            0      26     0  args   [Ljava/lang/String;           10      16     1  test   Lcom/mypackage/Test;           25       1     2     o   Ljava/lang/Object;}SourceFile: "Test.java"

用这个简单的反编译器来执行反编译的结果如下：

public class Test  {    public Test(java.lang.String var1) {        super();   }   public int sum(int var1, int var2) {        return var2+var1   }   public int search(java.lang.Object var1, java.lang.Object[] var2) {        return 0   }   public static void main(java.lang.String[] var1) {        com.mypackage.Test localVar1=new com.mypackage.Test(hello);       localVar1.sum(1,2);       java.lang.Object localVar2=new java.lang.Object();   }}