栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

class文件格式解析

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

class文件格式解析

本章介绍 classJava 虚拟机的文件格式。每个class文件都包含单个类或接口的定义。尽管类或接口不需要在文件中包含字面上的外部表示(例如,因为该类是由类加载器生成的),但我们将通俗地说,将类或接口的任何有效表示称为class文件格式.

一个class文件由一个 8 位字节流组成。所有 16 位、32 位和 64 位量都是通过分别读取两个、四个和八个连续的 8 位字节来构造的。多字节数据项始终以大端顺序存储,高字节在先。在 Java SE 平台中,这种格式由接口java.io.DataInput 和java.io.DataOutput类支持,例如 java.io.DataInputStream 和java.io.DataOutputStream。

本章定义了自己的一组表示class文件数据的数据类型:类型u1、u2和u4分别表示无符号的一、二或四字节数量。在 Java SE 平台中,这些类型可以通过 java.io.DataInput接口的readUnsignedByte、 readUnsignedShort、 和readInt等方法读取。

本章介绍了 class使用以类 C 结构表示法编写的伪结构的文件格式。为了避免与类和类实例的字段等混淆,描述 class文件格式的结构的内容被称为items。连续的项目按顺序存储在class文件中,没有填充或对齐。

由零个或多个可变大小项目组成的 表格class用于多个文件结构中。尽管我们使用类似 C 的数组语法来引用表项,但表是不同大小结构的流这一事实意味着不可能将表索引直接转换为表中的字节偏移量。

我们将数据结构称为数组,它由零个或多个连续的固定大小的项组成,并且可以像数组一样被索引。

本章中对 ASCII 字符的引用应解释为对应于 ASCII 字符的 Unicode 代码点。

1 ClassFile结构

https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html
一个class文件由一个ClassFile结构组成:

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];
}

结构中的项目ClassFile 如下:

  1. magic
    该magic项目提供标识class文件格式的幻数;它的值为0xCAFEBABE。

  2. minor_version、major_version
    minor_version 和major_version的次要和主要版本号。class主要和次要版本号一起确定 class文件格式的版本。如果一个class文件的主版本号为 M 和次要版本号为 m,我们将其class文件格式的版本表示为 Mm。因此,class文件格式版本可以按字典顺序排序,例如 1.5 < 2.0 < 2.1。
    class当且仅当 v 位于某个连续范围 Mi.0 ≤ v ≤ Mj.m时, Java 虚拟机实现才能支持版本 v 的文件格式。Java 虚拟机实现所遵循的 Java SE 平台的发布级别负责确定范围。
    JDK 版本 1.0.2 中的 Oracle 的 Java 虚拟机实现支持class文件格式版本 45.0 到 45.3(含)。JDK 发行版 1.1.* 支持class45.0 到 45.65535(含)范围内的文件格式版本。对于 k ≥ 2,JDK 版本 1.k 支持class45.0 到 44+k.0(含)范围内的文件格式版本。

  3. constant_pool_count
    该constant_pool_count项目的值等于表中的条目数constant_pool加一。如果constant_pool索引大于零且小于constant_pool_count,则认为索引有效,但类型常量除外,long并double在 §4.4.5中注明。

  4. constant_pool[]
    这constant_pool是一个结构表,表示在 结构及其子结构中引用的各种字符串常量、类和接口名称、字段名称和其他常量。每个 constant_pool表条目的格式由其第一个“标记”字节指示。
    该constant_pool表的索引从 1 到constant_pool_count- 1。

  5. access_flags
    该access_flags项目的值是一个标志掩码,用于表示对此类或接口的访问权限和属性。表 4.1-A中指定了每个标志在设置时的解释。
    表 4.1-A。类访问和属性修饰符
    标志名称 价值 解释
    ACC_PUBLIC 0x0001 宣布public;可以从其包外部访问。
    ACC_FINAL 0x0010 宣布final;不允许子类。
    ACC_SUPER 0x0020 当被invokespecial指令 调用时,对超类方法进行特殊处理。
    ACC_INTERFACE 0x0200 是接口,不是类。
    ACC_ABSTRACT 0x0400 宣布abstract;不得实例化。
    ACC_SYNTHETIC 0x1000 宣布合成;源代码中不存在。
    ACC_ANNOTATION 0x2000 声明为注解类型。
    ACC_ENUM 0x4000 声明为一种enum类型。
    ACC_INTERFACE接口通过设置的标志 来区分。如果ACC_INTERFACE未设置该标志,则此 class文件定义一个类,而不是一个接口。
    如果ACC_INTERFACE设置了ACC_ABSTRACT标志,则也必须设置标志,并且不能设置ACC_FINAL、ACC_SUPER和 ACC_ENUM标志集。
    如果ACC_INTERFACE未设置该标志,则可以设置 表 4.1-AACC_ANNOTATION中的任何其他标志,除了. 但是,此类class文件不得同时设置其ACC_FINAL和ACC_ABSTRACT标志。
    如果出现在此类或接口中, 该ACC_SUPER标志指示由invokespecial 指令(§invokespecial )表示的两种替代语义中的哪一种。Java 虚拟机指令集的编译器应设置该ACC_SUPER 标志。在 Java SE 8 及更高版本中,Java 虚拟机认为 ACC_SUPER要在每个class文件中设置标志,而不管文件中标志的实际值和class文件的版本。class文件。
    该ACC_SUPER标志的存在是为了向后兼容由 Java 编程语言的旧编译器编译的代码。在 JDK 1.0.2 之前的版本中,生成的编译器access_flags现在表示的标志 ACC_SUPER没有指定的含义,如果设置了标志,Oracle 的 Java 虚拟机实现会忽略该标志。
    该ACC_SYNTHETIC标志表示此类或接口是由编译器生成的,并且不会出现在源代码中。
    注释类型必须ACC_ANNOTATION设置其标志。如果ACC_ANNOTATION设置了ACC_INTERFACE标志,则也必须设置标志。
    该ACC_ENUM标志指示该类或其超类被声明为枚举类型。
    表 4.1-Aaccess_flags中未分配 的项目的所有位都保留供将来使用。它们应该在生成的文件中设置为零,并且应该被 Java 虚拟机实现忽略。

  6. this_class
    项目的值this_class必须是constant_pool表中的有效索引。该 constant_pool索引处的条目必须是一个 CONSTANT_Class_info结构(第 4.4.1 节),表示该class 文件定义的类或接口。

  7. super_class
    对于一个类,super_class 项目的值要么必须为零,要么必须是 constant_pool表中的有效索引。如果super_class项目的值非零,则 constant_pool该索引处的条目必须是 CONSTANT_Class_info表示此class文件定义的类的直接超类的结构。直接超类及其任何超类都不能 在ClassFile结构设置标志access_flags为 ACC_FINAL。
    如果该项的值super_class为零,则此class文件必须表示 class Object,这是唯一没有直接超类的类或接口。
    对于接口, super_class项目的值必须始终是constant_pool表中的有效索引。该constant_pool 索引处的条目必须是CONSTANT_Class_info表示类的结构Object。

  8. interfaces_count
    该interfaces_count项目的值给出了此类或接口类型的直接超接口的数量。

  9. interfaces[]
    数组中的每个值都interfaces必须是constant_pool表中的有效索引。的 constant_pool每个值 interfaces[i] ( 其中 0 ≤ i < interfaces_count)处的条目必须是 CONSTANT_Class_info表示接口的结构,该接口是此类或接口类型的直接超接口,按类型源中给出的从左到右的顺序排列。

  10. fields_count
    fields_count的值给出了表中field_info结构fields的数量。结构表示由此类或接口类型声明的field_info 所有字段,包括类变量和实例变量。

  11. fields[]
    表中的每个值都fields必须是一个 field_info结构(第4.5 节),提供此类或接口中字段的完整描述。该fields表仅包括由此类或接口声明的那些字段。它不包括表示从超类或超接口继承的字段的项。

  12. methods_count
    methods_count 的值给出了表中method_info结构methods的数量。

  13. methods[]
    表中的每个值都methods必须是一个 method_info结构(第 4.6 节),提供此类或接口中方法的完整描述。如果结构项method_info中 access_flags没有设置ACC_NATIVE和ACC_ABSTRACT 标志 ,则还提供实现该方法的 Java 虚拟机指令。
    method_info结构体表示此类或接口类型声明的所有方法,包括实例方法、类方法、实例初始化方法( 第2.9 节)以及任何类或接口初始化方法(第 2.9 节)。该 methods表不包括表示从超类或超接口继承的方法的项目。

  14. attributes_count
    attributes_count的值给出了attributes该类表中的属性数。

  15. attributes[]
    表的每个值都attributes必须是一个 attribute_info结构(§4.7)。
    本规范定义的出现在ClassFile结构attributes表中的属性在表 4.7-C 中列出。
    有关定义出现在ClassFile结构 attributes表中的 属性的规则 在第4.7 节中给出。
    有关ClassFile结构 attributes表 中非预定义属性的规则在第 4.7.1 节中给出。

2 class文件解析 2.1 javap
package com.example;

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("HelloWord");
    }
}

javap -verbose HelloWorld .class

Classfile /D:/git/HelloWorld.class
  Last modified 2022-6-4; size 555 bytes
  MD5 checksum 947d6562ab51ba57f2a1b87fab091919
  Compiled from "HelloWorld.java"
public class com.example.HelloWorld
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #6.#20         // java/lang/Object."":()V
   #2 = Fieldref           #21.#22        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #23            // HelloWord
   #4 = Methodref          #24.#25        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #26            // com/example/HelloWorld
   #6 = Class              #27            // java/lang/Object
   #7 = Utf8               
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lcom/example/HelloWorld;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               SourceFile
  #19 = Utf8               HelloWorld.java
  #20 = NameAndType        #7:#8          // "":()V
  #21 = Class              #28            // java/lang/System
  #22 = NameAndType        #29:#30        // out:Ljava/io/PrintStream;
  #23 = Utf8               HelloWord
  #24 = Class              #31            // java/io/PrintStream
  #25 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #26 = Utf8               com/example/HelloWorld
  #27 = Utf8               java/lang/Object
  #28 = Utf8               java/lang/System
  #29 = Utf8               out
  #30 = Utf8               Ljava/io/PrintStream;
  #31 = Utf8               java/io/PrintStream
  #32 = Utf8               println
  #33 = Utf8               (Ljava/lang/String;)V
{
  public com.example.HelloWorld();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/example/HelloWorld;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String HelloWord
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 6: 0
        line 7: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  args   [Ljava/lang/String;
}
SourceFile: "HelloWorld.java"
2.2 jclasslib-bytecode-viewer

2.3 自定义代码

使用java代码参照https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html实现,通过java.io.DataInput进行解析。解析结果对照 jclasslib-bytecode-viewer和javap用于对比验证。
注意:解析只能从前到后解析,不能跳过。错一个后面都会有问题。

DataInputStream dis = new DataInputStream(new FileInputStream(file));
2.3.1 magic 验证
    private static boolean validateMagic(DataInputStream dis) throws IOException {
        System.out.println("----------magic start----------");
        // magic
        int magic = dis.readInt();
        if(magic != 0xcafebabe) {
            System.out.println("ERROR:无效的class文件");
            return false;
        }
        System.out.println("----------magic end----------n");
        return true;
    }
2.3.2 version
    private static void parseVersion(DataInputStream dis) throws IOException {
        System.out.println("----------version start----------");
        // minor_version
        int minorVersion = dis.readUnsignedShort();
        System.out.println("minorVersion:"+minorVersion);
        // major_version
        int majorVersion = dis.readUnsignedShort();
        System.out.println("majorVersion:"+majorVersion);
        System.out.println("----------version end----------n");
    }
2.3.3 ConstantPool
    private static String[] parseConstantPool(DataInputStream dis) throws Exception {
        // constant_pool[constant_pool_count-1]
        System.out.println("----------constant_pool start----------");
        // constant_pool_count
        int constantPoolCount = dis.readUnsignedShort();
        System.out.println("constantPoolCount:"+constantPoolCount);
        String[] strs = new String[constantPoolCount];
        for (int i = 1; i < constantPoolCount; i++) {
            int tag = dis.readUnsignedByte();
            switch (tag) {
                case 7: {
                    int nameIndex = dis.readUnsignedShort();
                    System.out.println("["+i+"]"+"CONSTANT_Class。nameIndex:" + nameIndex);
                    break;
                }
                case 9: {
                    int classIndex = dis.readUnsignedShort();
                    int nameAndTypeIndex = dis.readUnsignedShort();
                    System.out.println("["+i+"]"+"CONSTANT_Fieldref。classIndex:" + classIndex + ",nameAndTypeIndex:" + nameAndTypeIndex);
                    break;
                }
                case 10: {
                    int classIndex = dis.readUnsignedShort();
                    int nameAndTypeIndex = dis.readUnsignedShort();
                    System.out.println("["+i+"]"+"CONSTANT_Methodref。classIndex:" + classIndex + ",nameAndTypeIndex:" + nameAndTypeIndex);
                    break;
                }
                case 11: {
                    int classIndex = dis.readUnsignedShort();
                    int nameAndTypeIndex = dis.readUnsignedShort();
                    System.out.println("["+i+"]"+"CONSTANT_InterfaceMethodref。classIndex:" + classIndex + ",nameAndTypeIndex:" + nameAndTypeIndex);
                    break;
                }
                case 8: {
                    int stringIndex = dis.readUnsignedShort();
                    System.out.println("["+i+"]"+"CONSTANT_String。stringIndex:" + stringIndex);
                    break;
                }
                case 3: {
                    int bytes = dis.readInt();
                    System.out.println("["+i+"]"+"CONSTANT_Integer。bytes:" + bytes);
                    break;
                }
                case 4: {
                    float bytes = dis.readFloat();
                    System.out.println("["+i+"]"+"CONSTANT_Float。bytes:" + bytes);
                    break;
                }
                case 5: {
                    long bytes = dis.readLong();
                    System.out.println("["+i+"]"+"CONSTANT_Long。bytes:" + bytes);
                    i++;
                    System.out.println("["+i+"]"+"CONSTANT_Long");
                    break;
                }
                case 6: {
                    double bytes = dis.readDouble();
                    System.out.println("["+i+"]"+"CONSTANT_Double。bytes:" + bytes);
                    i++;
                    System.out.println("["+i+"]"+"CONSTANT_Double");
                    break;
                }
                case 12: {
                    int nameIndex = dis.readUnsignedShort();
                    int descriptorIndex = dis.readUnsignedShort();
                    System.out.println("["+i+"]"+"CONSTANT_NameAndType。nameIndex:" + nameIndex + ",descriptorIndex:"+ descriptorIndex);
                    break;
                }
                case 1: {
                    int length = dis.readUnsignedShort();
                    byte[] bytes = new byte[length];
                    dis.read(bytes);
                    String str = new String(bytes);
                    strs[i] = str;
                    System.out.println("["+i+"]"+"CONSTANT_Utf8。length:" + length + ",bytes:"+ new String(bytes));
                    break;
                }
                case 15: {
                    int referenceKind = dis.readUnsignedByte();
                    int referenceIndex = dis.readUnsignedShort();
                    System.out.println("["+i+"]"+"CONSTANT_MethodHandle。referenceKind:" + referenceKind + ",referenceIndex:"+ referenceIndex);
                    break;
                }
                case 16: {
                    int descriptorIndex = dis.readUnsignedShort();
                    System.out.println("["+i+"]"+"CONSTANT_MethodType。descriptorIndex:" + descriptorIndex);
                    break;
                }
                case 18: {
                    int bootstrapMethodAttrIndex = dis.readUnsignedShort();
                    int nameAndTypeIndex = dis.readUnsignedShort();
                    System.out.println("["+i+"]"+"CONSTANT_InvokeDynamic。bootstrapMethodAttrIndex:" + bootstrapMethodAttrIndex + ",nameAndTypeIndex:"+ nameAndTypeIndex);
                    break;
                }
                default:
                    throw new Exception("constant tag");
            }

        }
        System.out.println("----------constant_pool end----------n");
        return strs;
    }
2.3.4 基础信息
        System.out.println("----------base info start----------");
        int accessFlags = dis.readUnsignedShort();
        int thisClass = dis.readUnsignedShort();
        int superClass = dis.readUnsignedShort();
        System.out.println("accessFlags:"+accessFlags+",thisClass:"+thisClass+",superClass:"+superClass);
        System.out.println("----------base info endn----------");
2.3.5 interfaces
        System.out.println("----------interfaces start----------");
        int interfacesCount = dis.readUnsignedShort();
        System.out.println("interfacesCount:"+interfacesCount);
        for(int i = 0; i < interfacesCount; i++) {

            System.out.println("interface:"+ dis.readUnsignedShort());
        }
        System.out.println("----------interfaces end----------n");
2.3.6 fields
    private static void parseFields(DataInputStream dis, String[] strs) throws IOException {
        System.out.println("----------fields start----------");
        int fieldsCount = dis.readUnsignedShort();
        System.out.println("fieldsCount:"+fieldsCount);
        for (int i = 0; i < fieldsCount; i++) {
            int accessFlags = dis.readUnsignedShort();
            int nameIndex = dis.readUnsignedShort();
            int descriptorIndex = dis.readUnsignedShort();
            int attributesCount = dis.readUnsignedShort();
            System.out.println("nameIndex:"+nameIndex+",accessFlags:"+accessFlags+",descriptorIndex:"+descriptorIndex+",attributesCount:"+attributesCount);
            for (int j = 0; j < attributesCount; j++) {
                parseAttribute(dis, strs);
            }
        }
        System.out.println("----------fields end----------n");
    }
2.3.7 methods
    private static void parseMethods(DataInputStream dis, String[] strs) throws IOException {
        System.out.println("----------methods start----------");
        int methodsCount = dis.readUnsignedShort();
        System.out.println("methodsCount:"+methodsCount);
        for (int i = 0; i < methodsCount; i++) {
            int accessFlags = dis.readUnsignedShort();
            int nameIndex = dis.readUnsignedShort();
            int descriptorIndex = dis.readUnsignedShort();
            int attributesCount = dis.readUnsignedShort();
            System.out.println("nameIndex:"+nameIndex+",accessFlags:"+accessFlags+",descriptorIndex:"+descriptorIndex+",attributesCount:"+attributesCount);
            for (int j = 0; j < attributesCount; j++) {
                parseAttribute(dis, strs);
            }
        }
        System.out.println("----------methods end----------n");
    }
2.3.8 attributes
    private static void pareseAttributes(DataInputStream dis, String[] strs) throws IOException {
        System.out.println("----------attributes start----------");
        int attributesCount = dis.readUnsignedShort();
        System.out.println("attributesCount:"+attributesCount);
        for (int j = 0; j < attributesCount; j++) {
            parseAttribute(dis, strs);
        }
        System.out.println("----------attributes end----------n");
    }
2.3.9 attribute
    public static void parseAttribute(DataInputStream dis, String[] strs) throws IOException {
        int attributeNameIndex = dis.readUnsignedShort();
        int attributeLength = dis.readInt();
        System.out.println("attributeNameIndex:"+attributeNameIndex + ",attributeLength:" + attributeLength);

        switch (strs[attributeNameIndex]) {
            case "ConstantValue": {
                int constantvalueIndex = dis.readUnsignedShort();
                System.out.println("constantvalueIndex:" +constantvalueIndex);
                break;
            }
            case "Code": {
                int maxStack = dis.readUnsignedShort();
                int maxLocals = dis.readUnsignedShort();
                int codeLength = dis.readInt();
                System.out.println("maxStack:"+maxStack + ",maxLocals:" + maxLocals+ ",codeLength:" + codeLength);

                for (int i = 0; i < codeLength; i++) {
                    System.out.println("code["+i + "]=" + dis.readUnsignedByte());

                }

                int exception_table_length = dis.readUnsignedShort();
                for (int i = 0; i < exception_table_length; i++) {
                    int startPc = dis.readUnsignedShort();
                    int endPc = dis.readUnsignedShort();
                    int handlerPc = dis.readUnsignedShort();
                    int catchType = dis.readUnsignedShort();
                    System.out.println("startPc:"+startPc + ",endPc:" + endPc+ ",handlerPc:" + handlerPc+ ",catchType:" + catchType);

                }
                int attributes_count = dis.readUnsignedShort();
                for (int i = 0; i < attributes_count; i++) {
                    parseAttribute(dis, strs);
                }
                break;
            }
            case "StackMapTable":{
                int numberOfEntries = dis.readUnsignedShort();
                System.out.println("numberOfEntries:"+numberOfEntries);
                for (int i = 0; i < numberOfEntries; i++) {
                    int frameType  = dis.readUnsignedByte();
                    System.out.println("frameType:"+frameType);

                    if (frameType >= 64 && frameType <= 127) {
                        parseVerificationTypeInfo(dis, strs);
                    } else if (frameType == 247) {
                        int offsetDelta = dis.readUnsignedShort();
                        parseVerificationTypeInfo(dis, strs);
                    } else if (frameType >= 248 && frameType<=250) {
                        int offsetDelta = dis.readUnsignedShort();
                    } else if (frameType == 251) {
                        int offsetDelta = dis.readUnsignedShort();
                    } else if (frameType >=252 && frameType<=254) {
                        int offsetDelta = dis.readUnsignedShort();
                        for (int j = 0; j < frameType - 251; j++) {
                            parseVerificationTypeInfo(dis, strs);
                        }
                    } else if (frameType == 255) {
                        int offsetDelta = dis.readUnsignedShort();
                        int numberOfLocals = dis.readUnsignedShort();
                        for (int j = 0; j < numberOfLocals; j++) {
                            parseVerificationTypeInfo(dis, strs);
                        }
                        int numberOfStackItems = dis.readUnsignedShort();
                        for (int j = 0; j < numberOfStackItems; j++) {
                            parseVerificationTypeInfo(dis, strs);
                        }
                    }
                }
                break;
            }
            case "Exceptions": {
                int numberOfExceptions = dis.readUnsignedShort();
                System.out.println("numberOfExceptions:" +numberOfExceptions);
                for (int i = 0; i < numberOfExceptions; i++) {
                    int exceptionIndex = dis.readUnsignedShort();
                    System.out.println("exceptionIndex:" +exceptionIndex);

                }
                break;
            }
            case "InnerClasses": {
                int numberOfClasses = dis.readUnsignedShort();
                System.out.println("numberOfClasses:" +numberOfClasses);
                for (int i = 0; i < numberOfClasses; i++) {
                    int innerClassInfoIndex = dis.readUnsignedShort();
                    int outerClassInfoIndex = dis.readUnsignedShort();
                    int innerNameIndex = dis.readUnsignedShort();
                    int innerClassAccessFlags = dis.readUnsignedShort();
                    System.out.println("innerClassInfoIndex:" +innerClassInfoIndex+",outerClassInfoIndex:" +outerClassInfoIndex+",innerNameIndex:" +innerNameIndex+",innerClassAccessFlags:" +innerClassAccessFlags);

                }
                break;
            }
            case "EnclosingMethod": {
                int classIndex = dis.readUnsignedShort();
                int methodIndex = dis.readUnsignedShort();

                System.out.println("classIndex:" +classIndex+",methodIndex:" +methodIndex);
                break;
            }
            case "Synthetic": {
                System.out.println("Synthetic");
                break;
            }
            case "Signature": {
                int signatureIndex = dis.readUnsignedShort();
                System.out.println("signatureIndex:" +signatureIndex);
                break;
            }
            case "SourceFile": {
                int sourcefileIndex = dis.readUnsignedShort();
                System.out.println("sourcefileIndex:" +sourcefileIndex);
                break;
            }
            case "SourceDebugExtension": {
                break;
            }
            case "LineNumberTable": {
                int lineNumberTableLength = dis.readUnsignedShort();
                System.out.println("lineNumberTableLength:" +lineNumberTableLength);
                for (int i = 0; i < lineNumberTableLength; i++) {
                    int startPc = dis.readUnsignedShort();
                    int lineNumber = dis.readUnsignedShort();
                    System.out.println("startPc:" +startPc+",lineNumber:" +lineNumber);

                }
                break;
            }
            case "LocalVariableTable": {
                int localVariableTableLength = dis.readUnsignedShort();
                System.out.println("localVariableTableLength:" +localVariableTableLength);
                for (int i = 0; i < localVariableTableLength; i++) {
                    int startPc = dis.readUnsignedShort();
                    int length = dis.readUnsignedShort();
                    int nameIndex = dis.readUnsignedShort();
                    int descriptorIndex = dis.readUnsignedShort();
                    int index = dis.readUnsignedShort();
                    System.out.println("startPc:" +startPc+",length:" +length+",nameIndex:" +nameIndex+",descriptorIndex:" +descriptorIndex+",index:" +index);

                }
                break;
            }
            case "LocalVariableTypeTable": {
                int localVariableTypeTableLength = dis.readUnsignedShort();
                System.out.println("localVariableTypeTableLength:" +localVariableTypeTableLength);
                for (int i = 0; i < localVariableTypeTableLength; i++) {
                    int startPc = dis.readUnsignedShort();
                    int length = dis.readUnsignedShort();
                    int nameIndex = dis.readUnsignedShort();
                    int signatureIndex = dis.readUnsignedShort();
                    int index = dis.readUnsignedShort();
                    System.out.println("startPc:" +startPc+",length:" +length+",nameIndex:" +nameIndex+",signatureIndex:" +signatureIndex+",index:" +index);

                }
                break;
            }
            case "Deprecated": {
                System.out.println("Deprecated");
                break;
            }
            case "RuntimeVisibleAnnotations": {
                int numAnnotations = dis.readUnsignedShort();

                for (int i = 0; i < numAnnotations; i++) {
                    parseAnnotation(dis, strs);
                }
                break;
            }
            case "RuntimeInvisibleAnnotations": {
                int numAnnotations = dis.readUnsignedShort();
                for (int i = 0; i < numAnnotations; i++) {
                    parseAnnotation(dis, strs);
                }
                break;
            }
            case "RuntimeVisibleParameterAnnotations": {
                int numParameters = dis.readUnsignedByte();
                System.out.println("numParameters:"+numParameters);
                for (int i = 0; i < numParameters; i++) {
                    int numAnnotations = dis.readUnsignedShort();
                    System.out.println("numAnnotations:"+numAnnotations);
                    for (int j = 0; j < numAnnotations; j++) {
                        parseAnnotation(dis, strs);
                    }
                }
                break;
            }
            case "RuntimeInvisibleParameterAnnotations": {
                int numParameters = dis.readUnsignedByte();

                for (int i = 0; i < numParameters; i++) {
                    int numAnnotations = dis.readUnsignedShort();
                    for (int j = 0; j < numAnnotations; j++) {
                        parseAnnotation(dis, strs);
                    }
                }
                break;
            }
            case "RuntimeVisibleTypeAnnotations": {
                int numAnnotations = dis.readUnsignedShort();
                for (int i = 0; i < numAnnotations; i++) {
                    parseAnnotation(dis, strs);

                }
                break;
            }
            case "RuntimeInvisibleTypeAnnotations": {
                int numAnnotations = dis.readUnsignedShort();
                for (int i = 0; i < numAnnotations; i++) {
                    parseAnnotation(dis, strs);

                }
                break;
            }
            case "AnnotationDefault": {
                parseElementValue(dis, strs);
                break;
            }
            case "BootstrapMethods": {
                int numBootstrapMethods = dis.readUnsignedShort();
                System.out.println("numBootstrapMethods:" +numBootstrapMethods);
                for (int i = 0; i < numBootstrapMethods; i++) {
                    int bootstrapMethodRef = dis.readUnsignedShort();
                    int numBootstrapArguments = dis.readUnsignedShort();
                    System.out.println("bootstrapMethodRef:" +bootstrapMethodRef+",numBootstrapArguments:" +numBootstrapArguments);
                    for (int j = 0; j < numBootstrapArguments; j++) {
                        int bootstrapArguments = dis.readUnsignedShort();
                        System.out.println("bootstrapArguments:" +bootstrapArguments);

                    }


                }
                break;
            }
            case "MethodParameters": {
                int parametersCount = dis.readUnsignedShort();
                System.out.println("parametersCount:" +parametersCount);
                for (int i = 0; i < parametersCount; i++) {
                    int nameIndex = dis.readUnsignedShort();
                    int accessFlags = dis.readUnsignedShort();
                    System.out.println("nameIndex:" +nameIndex+",accessFlags:" +accessFlags);

                }
                break;
            }
        }

    }
2.3.10 annotation
    public static void parseAnnotation(DataInputStream dis, String[] strs) throws IOException {
        int typeIndex = dis.readUnsignedShort();
        int numElementValuePairs = dis.readUnsignedShort();
        System.out.println("typeIndex:" +typeIndex+",numElementValuePairs:" +numElementValuePairs);
        for (int i = 0; i < numElementValuePairs; i++) {
            int elementNameIndex = dis.readUnsignedShort();
            System.out.println(elementNameIndex);
            parseElementValue(dis, strs);
        }
        
    }
2.3.11 elementValue
    public static void parseElementValue(DataInputStream dis, String[] strs) throws IOException {
        int tag = dis.readUnsignedByte();

        switch (tag) {
            case 'B':
            case 'C':
            case 'D':
            case 'F':
            case 'I':
            case 'J':
            case 'S':
            case 'Z':
            case 's': {
                int constValueIndex = dis.readUnsignedShort();
                System.out.println("tag:" + tag + ",constValueIndex:" + constValueIndex);
                break;
            }
            case 'e': {
                int typeNameIndex = dis.readUnsignedShort();
                int constNameIndex = dis.readUnsignedShort();
                System.out.println("tag:" + tag + ",typeNameIndex:" + typeNameIndex+ ",constNameIndex:" + constNameIndex);
                break;
            }
            case 'c': {
                int classInfoIndex = dis.readUnsignedShort();
                System.out.println("tag:" + tag + ",classInfoIndex:" + classInfoIndex);
                break;
            }
            case '@': {
                parseAnnotation(dis, strs);
                break;
            }
            case '[': {
                int num_values = dis.readUnsignedShort();
                for (int j = 0; j < num_values; j++) {
                    parseElementValue(dis, strs);
                }
                break;
            }
        }
        
    }
2.3.12 verificationTypeInfo
    public static void parseVerificationTypeInfo(DataInputStream dis, String[] strs) throws IOException {
        int tag = dis.readUnsignedByte();
        System.out.println("tag:"+tag);
        if (tag == 7) {
            int cpoolIndex = dis.readUnsignedShort();
            System.out.println("cpoolIndex:"+cpoolIndex);
        } else if (tag == 8) {
            int offset = dis.readUnsignedShort();
            System.out.println("offset:"+offset);
        }

    }
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/952664.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号