在深入理解Class文件-1这篇文章中，大致了解了Class文件的结构，在平时的使用中，我一般都倾向于使用工具来解析并查看class文件，如jdk自带 javap 程序，使用：

javap -c class文件所在路径 。

平时我个人使用IDEA开发，一般使用 <jclasslib Bytecode Viewer> 这个插件查看。

作为一名程序员，为了更深入的了解class文件，靠看是不够的，如果能够自己手写解析class文件的代码，并输出其中的内容，才是学会了class文件的结构。

在开始之前，放一个官方文档的链接
https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.4.7

遇到不懂，先看官方文档。

待解析的类

类

package temp;

import temp.*;


public class TestClassFile extends TestSuperClass implements TestInterface{

    public static String str = "felix.zhu";
    
    @Override
    public void debug() {
        System.out.println("debug");
    }
    
    public static void main(String[] args) {
        TestClassFile tf = new TestClassFile();
        Runtime.getRuntime().totalMemory();
    }
}

超类

package temp;

public class TestSuperClass{
    
    private int value;
    
    public int getValue() {
        return this.value;
    }
}

接口

package temp;

interface TestInterface {
    
    public void debug();
}

将类编译成class文件，放到一个指定的目录

main() 解析方法

目前只解析到接口名称，其他的留到后续的文章

        File file = new File("D:\\temp\\TestClassFile.class");
        DataInput in = getInputStream(file);
        ClassFileReader classFileReader = new ClassFileReader();
        //读取魔数
        classFileReader.readMagic(in);
        //读取版本号
        classFileReader.readVersion(in);
        //读取常量池
        classFileReader.readConstansPool(in);
        //读取访问标识
        classFileReader.readAccessFlag(in);
        //读取class名称
        classFileReader.readClass(in);
        //读取superclass
        classFileReader.readSuperClass(in);
        //读取接口名称
        classFileReader.readInterfaces(in);

getInputString()

public static DataInput getInputStream(File file) throws FileNotFoundException {

        return new DataInputStream(
                new BufferedInputStream(
                        new FileInputStream(file)));
}

由于考虑到字节操作，这里选择DataInputStream,它提供了readInt, readUnsignedShort 等等方法正好适合，尤其喜欢它有一个readUTF函数，由于java的字符串是以Unicode的形式存储的，字符串会经过UTF-8 encode写入到class文件中，读取出来后需要转成可读的字符串就需要写decodeUTF-8函数，这里懒得写，就用现成的了。

读取魔数readMagic()

class文件开头四个字节是魔数，我们用readInt读取出来，在java中Int占4个字节，最后转换成16进制就可以看到啦。

public void readMagic(DataInput input) throws IOException {
        //魔数占4个字节
        int magicNumb = input.readInt();

        print("magic : " + Integer.toHexString(magicNumb));
}

读取版本号readVersion()

public void readVersion(DataInput input) throws IOException {
        int minorVersion = input.readUnsignedShort();

        int majorVersion = input.readUnsignedShort();
        //根据文档描述 实际是 如果两个值都有，最终的版本是  majorVersion.minorVersion
        print("minorVersion: " + minorVersion + " majorVersion: " + majorVersion);

        String classVersion = getMajorVersionName(majorVersion);

        print("当前class文件版本号：" + classVersion);
}

根据文档描述读取出来的版本号最小从45开始，为了方便阅读，写一个版本号转换的函数

public String getMajorVersionName(int majorVersion) {
        switch (majorVersion) {
            case 45:
                return "1.1";
            case 46:
                return "1.2";
            case 47:
                return "1.3";
            case 48:
                return "1.4";
            case 49:
                return "1.5";
            case 50:
                return "1.6";
            case 51:
                return "1.7";
            case 52:
                return "1.8";
            case 53:
                return "1.9";
            default:
                return "unknown value " + majorVersion;
        }
  }

读取常量池readConstansPool()

public void readConstansPool(DataInput input) throws IOException {
       //开头两个字节是常量池的大小
        int poolCount = input.readUnsignedShort();

        indexItems = new int[poolCount]; //常量池index索引数组
        strings = new String[poolCount];

        //根据文档描述 The constant_pool table is indexed from 1 to constant_pool_count-1.
        for (int i = 1; i < poolCount; ++i) {
            byte tag = input.readByte();

            switch (tag) {
                case FIELD:
                case METH:
                case IMETH:
                case INT:
                case FLOAT:
                case NAME_TYPE:
                    input.skipBytes(4);
                    break;
                case CLASS:
                    indexItems[i] = input.readUnsignedShort();
                    break;
                case LONG:
                case DOUBLE:
                    input.skipBytes(8);
                    break;

                case UTF8:
                    strings[i] = input.readUTF();
                    break;

                default:
                    input.skipBytes(2);
                    break;

            }
        }
    }

1 根据文档的描述常量池下标从1开始，i初始化为1
2 indexItems 数组理解成存储对应常量池数据的下标，后面读取的数据都是根据下标到常量池里找数据。
3 strings 用来存储对应下标的String值
4 文档描述常量池里的类型如下：

image.png

常量池里的每个元素都有可能是这些类型当中的其中一个。
这里用CONSTANT_Class 举例

image.png
可以看到开头是一个字节(u1) 的tag，对应上图。
程序里的switch语句是根据读取到的tag做相应的处理，我定义了全局变量
static final int CLASS = 7;
接着u2 name_index表示该class全限定名在常量池的下标。我存到strings这个数组里了。
其他的类型可以自行参考官方文档，我这里用不到这些类型，所以用skipBytes方法跳过。

class文件里的字符串是CONSTANT_Utf8_info结构的，如下图

image.png
readUTF方法会先读取length，在根据length读取字节数组转换成String。

readAccessFlag() 读取访问标识

public void readAccessFlag(DataInput input) throws IOException {
        int flag = input.readUnsignedShort();

        List<String> flagNames = getFlagsByName(flag);

        print("flags: " + String.join(",", flagNames));
    }

将flag转成Name

public List<String> getFlagsByName(int flags) {
        int cpFlags = flags;
        List<String> flagsNames = new ArrayList<>();
        for (AccessFlag classAccessFlag : CLASS_ACCESS_FLAGS) {
        //通过 & 操作，如果存在，这添加
            if((cpFlags & classAccessFlag.getFlag()) != 0) {
                flagsNames.add(flagToName(classAccessFlag));
                flags = ~classAccessFlag.getFlag() & flags;
            }
        }
        return flagsNames;
    }

public static String flagToName(AccessFlag flag) {
        switch (flag) {
            case ACC_PUBLIC:
                return "ACC_PUBLIC";
            case ACC_FINAL:
                return "ACC_FINAL";
            case ACC_SUPER:
                return "ACC_SUPER";
            case ACC_INTERFACE:
                return "ACC_INTERFACE";
            case ACC_ABSTRACT:
                return "ACC_ABSTRACT";
            case ACC_SYNTHETIC:
                return "ACC_SYNTHETIC";
            case ACC_ANNOTATION:
                return "ACC_ANNOTATION";
            case ACC_ENUM:
                return "ACC_ENUM";
            default:
                return null;
        }
    }

class类的修饰，如果是public final class， 读出来的值就是 0x0011

image.png

定义一个枚举表示它

enum AccessFlag{

    ACC_PUBLIC(0x0001, "public"),
    ACC_FINAL(0x0010, "final"),
    ACC_SUPER(0x0020, "Treat superclass methods"),
    ACC_INTERFACE(0x0200, "interface"),
    ACC_ABSTRACT(0x0400, "abstract"),
    ACC_SYNTHETIC(0x1000, "synthetic"),
    ACC_ANNOTATION(0x2000, "annotation"),
    ACC_ENUM(0x4000, "enum");

    AccessFlag(int flag, String name) {
        this.flag = flag;
        this.name = name;
    }

    private int flag;

    private String name;

    public int getFlag() {
        return flag;
    }

    public String getName() {
        return name;
    }
}

readClass() 读取class名称

public void readClass(DataInput input) throws IOException {
        // classInfo结构在常量池的位置
        int classIndex = input.readUnsignedShort();

        //class全名称字符串在常量池的位置
        int stringIndex = indexItems[classIndex];

        String className = strings[stringIndex];


        print("class Name: " + className);
}

这里就用到根据常量池解析出来的indexItems数组和strings数组了

readSuperClass() 超类

public void readSuperClass(DataInput input) throws IOException {
        int superClassIndex = input.readUnsignedShort();

        int stringIndex = indexItems[superClassIndex];

        String superClassName = strings[stringIndex];


        print("superClass Name: " + superClassName);
    }

和读取class名称一样

readInterfaces() 接口

public void readInterfaces(DataInput input) throws IOException {
        //有效索引范围为0~interfaces_count
        int interfaceCount = input.readUnsignedShort();
        String[] interfaces = new String[interfaceCount];
        for(int i = 0; i < interfaceCount; i++) {
            int interfaceIndex = input.readUnsignedShort();
            int stringIndex = indexItems[interfaceIndex];
            String interfaceName = strings[stringIndex];
            interfaces[i] = interfaceName;
        }

        print("interfaces Name: " + String.join(",",interfaces));
    }

java接口是多继承的，可能会有多个，class文件里是数组

最后的结果

image.png

结尾

可以看到，虽然看class文件格式觉得自己理解了，但是解析class文件还是比较复杂的，通过自己动手解析class文件，能加深对class文件的理解，如果你有其他更好的解析class文件的方法，欢迎加入一起探讨。

我是左手落花，一个喜欢通过coding来探究原理的人。