簡介

最近為了加深對(duì)于JAVA的理解，在復(fù)習(xí)JVM，這里面的內(nèi)容大部分都是比較確定的、文檔性質(zhì)的內(nèi)容，目前并沒有特別的總結(jié)。但是看到類文件結(jié)構(gòu)，手癢，想寫了個(gè)解析文件的解析器，那就簡單記錄下吧。

JAVA類文件結(jié)構(gòu)

詳細(xì)內(nèi)容不記了，太多了，有興趣的同學(xué)看虛擬機(jī)相關(guān)書籍了解，這里只簡單介紹下。
1 類文件使用類似結(jié)構(gòu)體的偽結(jié)構(gòu)，基本數(shù)據(jù)類型有兩種：無符號(hào)數(shù)和表。無符號(hào)數(shù)有1、2、4、8四種長度；表可以由無符號(hào)數(shù)或其它復(fù)合類型作為元素，組成數(shù)據(jù)列表。
2 復(fù)合類型也只由上述兩種基本類型組成。
3 類文件按固定結(jié)構(gòu)存儲(chǔ)，表類型例外，因?yàn)槔锩娴脑乜梢允遣煌膹?fù)合類型，因此排列順序不一定是固定順序。
4 常量池。類名、函數(shù)名、字符串等信息，類文件的解析最終都要在常量池中找到對(duì)應(yīng)的索引。不同的常量結(jié)構(gòu)體用tag(數(shù)字)區(qū)分。
5 屬性表。不管是field、method還是類本身，都有屬性表，不同的屬性結(jié)構(gòu)體用屬性名稱(字符串)區(qū)分。

設(shè)計(jì)思路

做過協(xié)議解析的同學(xué)肯定了解，類似這種情況，一般都會(huì)使用TLV（type、length、value）結(jié)構(gòu)解析，知道類型，才知道長度，知道長度才能完整讀出該類型對(duì)應(yīng)的數(shù)據(jù)。無論是協(xié)議，還是class、elf文件，這種方式都是常規(guī)操作。使用這種方式，除了定義完整的類型外，還要在解析中處理不同的類型。
那這次用的是JAVA，想換一個(gè)不一樣的思路，即使用泛型和反射，類型的定義不可避免，那么是否可以減少解析過程中對(duì)于類型的處理？
基于這個(gè)想法，簡單的按照類文件結(jié)構(gòu)進(jìn)行了相關(guān)結(jié)構(gòu)體的定義，并實(shí)現(xiàn)了一版，直接上代碼吧，我個(gè)人覺得基本達(dá)到了目的, 不算打印方法，250行左右，解析邏輯比較簡單。

public class Parser {
    public Parser() {
        initConstantPoolMap();
        initAttributeMap();
    }

    /**
     * 復(fù)合類型解析
     * @param obj 待解析填充的對(duì)象
     * @param inputStream 文件流
     */
    public void parse(Object obj, DataInputStream inputStream) throws ClassNotFoundException, IllegalAccessException, IOException, InstantiationException {
        Field[] fields = obj.getClass().getDeclaredFields();

        for (Field field : fields) {
            System.out.println(field.getName() + " : " + field.getGenericType());

            field.setAccessible(true);
            Type type = field.getGenericType();
            Class fieldClass = null;
            Class[] actualClassArguments = new Class[2];
            if (type instanceof Class) {
                fieldClass = (Class) type;
            } else if (type instanceof ParameterizedType) {
                ParameterizedType parameterizedType = (ParameterizedType) type;
                fieldClass = (Class) parameterizedType.getRawType();
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                actualClassArguments = new Class[actualTypeArguments.length];
                for (int i = 0; i < actualTypeArguments.length; i++) {
                    actualClassArguments[i] = (Class) actualTypeArguments[i];
                }
            } else {
                throw new InstantiationException("illegal field type: " + field.getGenericType());
            }
            if (fieldClass.getSuperclass().equals(AtomicType.class)) {
                AtomicType o = parseAtomic(fieldClass, inputStream);
                field.set(obj, o);
            } else if (fieldClass.equals(Table.class)) {
                Table table = (Table) field.get(obj);
                table.setCountClass(actualClassArguments[0]);
                table.setElementClass(actualClassArguments[1]);
                parseTable(table, inputStream);
            } else {
                field.set(obj, parseMeta(fieldClass, inputStream));
            }
        }
    }

    /**
     * 原子數(shù)據(jù)類型解析(類文件定義的四種無符號(hào)數(shù)據(jù)類型)
     * @param cl 帶解析的類信息
     * @param inputStream 文件流
     * @return 解析后實(shí)例的的對(duì)象
     */
    private AtomicType parseAtomic(Class<?> cl, DataInputStream inputStream) throws IllegalAccessException, InstantiationException, IOException {
        AtomicType obj = (AtomicType) cl.newInstance();
        inputStream.read(obj.getBytes());
        System.out.println(cl.getTypeName() + " parsed: " + obj.getValue());
        return obj;
    }

    /**
     * 通用表結(jié)構(gòu)解析
     * @param table 表對(duì)象
     * @param inputStream 文件流
     */
    private void parseTable(Table table, DataInputStream inputStream) throws IllegalAccessException, InstantiationException, ClassNotFoundException, IOException {
        AtomicType count = parseAtomic(table.getCountClass(), inputStream);
        table.setCount(count);
        System.out.println("table count: " + count.getValue());
        if (count.getIntValue() == 0) {
            return;
        } else if (table.getElementClass().getSuperclass().equals(Number.class)) {
            parseNumber(table, inputStream);
        }  else if (table.getElementClass().getTypeName().equals(cp_info.class.getTypeName())) {
            parseConstantPool(table, inputStream);
        } else if (table.getElementClass().getTypeName().equals(attribute_info.class.getTypeName())) {
            parseAttribute(table, inputStream);
        } else {
            parseMetas(table, inputStream);
        }
    }

    /**
     * 其它復(fù)合類型的表結(jié)構(gòu)解析
     * @param table 表對(duì)象
     * @param inputStream 文件流
     */
    private void parseMetas(Table table, DataInputStream inputStream) throws ClassNotFoundException, IllegalAccessException, InstantiationException, IOException {
        for (int i = 0; i < table.getCount().getIntValue(); i++) {
            table.getData().add(parseMeta(table.getElementClass(), inputStream));
        }
    }

    /**
     * 復(fù)合類型解析(根據(jù)類型實(shí)例化后填充)
     * @param cl 待解析類信息
     * @param inputStream 文件流
     * @return 解析后的實(shí)例
     */
    private Object parseMeta(Class cl, DataInputStream inputStream) throws ClassNotFoundException, IOException, InstantiationException, IllegalAccessException {
        Object o = cl.newInstance();
        parse(o, inputStream);
        return o;
    }

    /**
     * 解析原子數(shù)據(jù)類型(非class文件定義的無符號(hào)數(shù))
     * @param table 表對(duì)象
     * @param inputStream 文件流
     */
    private void parseNumber(Table table, DataInputStream inputStream) throws IOException, InstantiationException {
        for (int i = 0; i < table.getCount().getIntValue(); i++) {
            if (table.getElementClass().equals(Byte.class)) {
                table.getData().add(inputStream.readByte());
            } else if (table.getElementClass().equals(Short.class)) {
                table.getData().add(inputStream.readShort());
            } else {
                throw new InstantiationException("illegal number class : " + table.getElementClass());
            }
        }
    }

    /**
     * 解析常量池
     * @param table 表對(duì)象
     * @param inputStream 文件流
     */
    private void parseConstantPool(Table table, DataInputStream inputStream) throws ClassNotFoundException, IOException, InstantiationException, IllegalAccessException {
        for (int i = 0; i < table.getCount().getIntValue() - 1; i++) {
            table.getData().add(parseConstantPool(inputStream));
        }
    }

    /**
     * 解析單個(gè)常量對(duì)象
     * @param inputStream 表對(duì)象
     * @return 常量對(duì)象
     */
    private Object parseConstantPool(DataInputStream inputStream) throws IllegalAccessException, IOException, InstantiationException, ClassNotFoundException {
        AtomicType tag = parseAtomic(u1.class, inputStream);

        Class cl = constPoolMap.get(tag.getIntValue());
        if (cl == null) {
            throw new InstantiationException("not found const pool class: " + tag.getValue());
        }
        Object obj = cl.newInstance();
        parse(obj, inputStream);
        System.out.println("parse constant pool: tag = " + tag.getValue());
        return obj;
    }

    /**
     * 解析屬性表
     * @param table 表對(duì)象
     * @param inputStream 文件流
     */
    private void parseAttribute(Table table, DataInputStream inputStream) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException {
        for (int i = 0; i < table.getCount().getIntValue(); i++) {
            table.getData().add(parseAttribute(inputStream));
        }
    }

    /**
     * 解析單個(gè)屬性
     * @param inputStream 文件流
     * @return 單個(gè)屬性對(duì)象
     */
    private Object parseAttribute(DataInputStream inputStream) throws ClassNotFoundException, IOException, InstantiationException, IllegalAccessException {
        attribute_info attr = new attribute_info();
        parse(attr, inputStream);
        String name = getUtf8((int) attr.getAttribute_name_index().getValue());
        if (name == null) {
            throw new InstantiationException("not found attribute name: " + attr.getAttribute_name_index().getValue());
        }
        System.out.println("parse attribute: " + name);

        Class cl = attributeMap.get(name);
        if (cl == null) {
            throw new InstantiationException("not found attribute: " + name);
        }

        return parseMeta(cl, inputStream);
    }

    /**
     * 獲取常量池中的對(duì)象
     * @param index 常量池索引
     * @return 常量對(duì)象
     */
    private cp_info getConstant(int index) {
        if (index == 0 || index >= classInfo.getConstant_pool().getData().size()) {
            return null;
        }
        return classInfo.getConstant_pool().getData().get(index - 1);
    }

    /**
     * 獲取字符串對(duì)象
     * @param index 索引
     * @return 字符串
     */
    private String getUtf8(int index) {
        cp_info c = getConstant(index);
        if (c == null) {
            return null;
        }
        if (!(c instanceof utf8_info)) {
            System.out.println("not utf8 constant");
            return null;
        }
        utf8_info utf8 = (utf8_info) c;
        return utf8.toString();
    }

    // 類文件對(duì)象
    private static class_info classInfo = new class_info();
    // 常量池類型映射表
    private static Map<Integer, Class> constPoolMap = new HashMap<>();
    // 屬性映射表
    private static Map<String, Class> attributeMap = new HashMap<>();

    private static void initConstantPoolMap() {
        constPoolMap.put(1, utf8_info.class);
        constPoolMap.put(3, integer_info.class);
        constPoolMap.put(4, float_info.class);
        constPoolMap.put(5, long_info.class);
        constPoolMap.put(6, double_info.class);
        constPoolMap.put(7, constant_class_info.class);
        constPoolMap.put(8, string_info.class);
        constPoolMap.put(9, fieldref_info.class);
        constPoolMap.put(10, methodref_info.class);
        constPoolMap.put(11, interfacemethodref_info.class);
        constPoolMap.put(12, nametype_info.class);
    }

    private static void initAttributeMap() {
        attributeMap.put("Code", code_info.class);
        attributeMap.put("Exceptions", throws_info.class);
        attributeMap.put("LineNumberTable", LineNumberTable.class);
        attributeMap.put("LocalVariableTable", LocalVariableTable.class);
        attributeMap.put("SourceFile", SourceFile.class);
        attributeMap.put("ConstantValue", ConstantValue.class);
        attributeMap.put("InnerClasses", InnerClasses.class);
    }

    private static void print(Class cl, Object obj, String prefix, StringBuilder sb) throws IllegalAccessException, ClassNotFoundException, InstantiationException {
        Field[] fields = cl.getDeclaredFields();

        sb.append(prefix).append(cl.getSimpleName()).append(":{\n");
        for (Field field : fields) {
            field.setAccessible(true);
            Type type = field.getGenericType();
            Class fieldClass = null;
            Class[] actualClassArguments = new Class[2];
            if (type instanceof Class) {
                fieldClass = (Class) type;
            } else if (type instanceof ParameterizedType) {
                ParameterizedType parameterizedType = (ParameterizedType) type;
                fieldClass = (Class) parameterizedType.getRawType();
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                actualClassArguments = new Class[actualTypeArguments.length];
                for (int i = 0; i < actualTypeArguments.length; i++) {
                    actualClassArguments[i] = (Class) actualTypeArguments[i];
                }
            } else {
                throw new InstantiationException("illegal field type: " + field.getGenericType());
            }

            Object o = field.get(obj);
            if (fieldClass.getSuperclass().equals(AtomicType.class) && field.getName().endsWith("_index")) {
                AtomicType v = (AtomicType) o;
                sb.append(prefix).append(field.getName() + ": #" + v.getValue() + " : ");
                printConstant(v.getIntValue(), sb);
                sb.append("\n");
            } else if (fieldClass.getSuperclass().equals(AtomicType.class)) {
                AtomicType v = (AtomicType) o;
                sb.append(prefix + field.getName() + " : " + v.getValue()).append("\n");
            } else if (fieldClass.equals(Table.class)) {
                Table table = (Table) o;

                sb.append(prefix).append(field.getName() + ": ").append("[\n");
                for (int i = 0; i < table.getData().size(); i++) {
                    Class fcl = table.getData().get(i).getClass();
                    if (table.getElementClass().equals(cp_info.class)) {
                        sb.append(prefix).append("    ").append("#" + (i + 1) + " = " + table.getData().get(i).toString()).append("\n");
                    } else if (fcl.equals(Byte.class) || fcl.equals(Short.class)) {
                        sb.append(table.getData().get(i));
                    } else {
                        print(fcl, table.getData().get(i), prefix + "   ", sb);
                    }
                }
                if (table.getCount().getIntValue() > 0 &&
                        (table.getElementClass().equals(Byte.class) || table.getElementClass().equals(Short.class))) {
                    sb.append("\n");
                }
                sb.append(prefix).append("]\n");
            } else {
                sb.append(prefix).append(field.getName() + ": ").append("\n");
                Class fcl = Class.forName(field.getGenericType().getTypeName());
                print(fcl, o, prefix + "    ", sb);
            }
        }
        sb.append(prefix).append("}\n");
    }

    private static void printConstant(int index, StringBuilder sb) throws IllegalAccessException {
        if (index == 0) {
            return;
        }
        cp_info info = classInfo.getConstant_pool().getData().get(index - 1);
        if (info instanceof utf8_info) {
            sb.append(info.toString());
            return;
        }
        sb.append(" -> " + info.getClass().getSimpleName() + " :");
        Field[] fields = info.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (!field.getName().endsWith("_index")) {
                continue;
            }
            field.setAccessible(true);
            AtomicType o = (AtomicType) field.get(info);
            sb.append(field.getName() + " :#");
            sb.append(o.getValue() + " -> ");
            printConstant(o.getIntValue(), sb);
            sb.append("; ");
        }
    }

    public static void main(String[] args) throws IOException {
        Parser parser = new Parser();
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream("Bean.class");

            // Create a new DataInputStream object with the FileInputStream object
            DataInputStream dataInputStream = new DataInputStream(fileInputStream);
            parser.parse(classInfo, dataInputStream);
            StringBuilder sb = new StringBuilder();
            print(class_info.class, classInfo, "", sb);
            System.out.println(sb.toString());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            fileInputStream.close();
        }
    }

}

再補(bǔ)充幾個(gè)結(jié)構(gòu)體定義實(shí)例：

public class Table<N extends AtomicType, T> {
    private N count;
    private LinkedList<T> data = new LinkedList<>();
    private Class countClass;
    private Class elementClass;

    public Table() {

    }
    public N getCount() {
        return count;
    }

    public void setCount(N count) {
        this.count = count;
    }

    public LinkedList<T> getData() {
        return data;
    }

    public void setData(LinkedList<T> data) {
        this.data = data;
    }

    public Class getCountClass() {
        return countClass;
    }

    public Class getElementClass() {
        return elementClass;
    }

    public void setCountClass(Class countClass) {
        this.countClass = countClass;
    }

    public void setElementClass(Class elementClass) {
        this.elementClass = elementClass;
    }

    public String toString() {
        return "count: " + count;
    }
}


public abstract class AtomicType<T extends Number> {
    private int length;
    private byte[] bytes;
    private T value;

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public T getValue() {
        if (value != null) {
            return value;
        }
        parse();
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    public byte[] getBytes() {
        return bytes;
    }

    public void setBytes(byte[] bytes) {
        this.bytes = bytes;
    }

    public abstract void parse();

    public int getIntValue() {
        return getValue().intValue();
    }
}

public class u2 extends AtomicType<Short> {
    public u2() {
        setLength(2);
        setBytes(new byte[2]);
    }

    @Override
    public void parse() {
        short x =  (short) ((((short)(getBytes()[0])) << 8) + (((short)(getBytes()[1])) << 0));
        setValue(x);
    }
}
public class attribute_info {
    public u2 attribute_name_index;
    public u4 attribute_length;

    public u2 getAttribute_name_index() {
        return attribute_name_index;
    }
}
public class cp_info implements Printable {
    public u1 tag;
}
public class class_info {
    public u4 magic;
    public u2 minor_version;
    public u2 major_version;
    public Table<u2, cp_info> constant_pool = new Table<>();
    public u2 access_flags;
    public u2 this_class;
    public u2 super_class;
    public Table<u2, Short> interfaces = new Table<>();
    public Table<u2, field_info> fields = new Table<>();
    public Table<u2, method_info> methods = new Table<>();
    public Table<u2, attribute_info> attributes = new Table<>();

    public Table<u2, cp_info> getConstant_pool() {
        return constant_pool;
    }
}

總結(jié)

不算完美，階段性成果吧。關(guān)于泛型，值得單獨(dú)寫一篇記錄一下。文章來源地址http://www.zghlxwxcb.cn/news/detail-411918.html

到了這里，關(guān)于【JVM學(xué)習(xí)】Class文件解析的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！