Teilen des leistungsstarken Codes zur Implementierung eines Java-Klassenparsers

Ich schreibe derzeit an einem privaten Projekt namens ClassAnalyzer. Der Zweck von ClassAnalyzer besteht darin, uns ein tiefes Verständnis für das Design und die Struktur der <span class="wp_keywordlink">Java Class</span>-Datei zu vermitteln. Der Hauptteil Framework und die Grundfunktionen wurden fertiggestellt und einige detaillierte Funktionen werden in Zukunft hinzugefügt. Tatsächlich bietet JDK bereits ein Befehlszeilentool javap zum Dekompilieren von Class-Dateien, aber dieser Artikel wird meine Vorstellung von der Implementierung des Parsers verdeutlichen.

Klassendatei

dient als Träger von Klassen- oder Schnittstellen--Informationen. Jede Class-Datei definiert vollständig eine Klasse. Damit das Java-Programm „einmal schreiben und überall ausführen“ kann, enthält die Java Virtual Machine-Spezifikation strenge Vorschriften für die Class-Datei. Die grundlegende Dateneinheit, aus der die Class-Datei besteht, sind Bytes. Zwischen diesen Bytes gibt es keine Trennzeichen. Dadurch sind in der gesamten Class-Datei fast alle für den Programmbetrieb erforderlichen Daten gespeichert, die nicht durch ein einzelnes Byte dargestellt werden können . Daten werden durch mehrere aufeinanderfolgende Bytes dargestellt.

Gemäß der Java-Spezifikation für virtuelle Maschinen verwendet die Class-Datei eine Pseudostruktur, die der C-Sprachstruktur ähnelt, um Daten zu speichern. Es gibt nur zwei Datentypen in diesem Pseudo -Struktur: Vorzeichenlose Summentabelle. Die Java-Spezifikation für virtuelle Maschinen definiert u1, u2, u4 und u8 zur Darstellung von 1 Bytes, 2 Bytes, 4 Bytes bzw. 8 einer vorzeichenlosen Anzahl von Bytes . Vorzeichenlose Zahlen können zur Beschreibung von Zahlen, IndizesReferenzen, quantitativen Werten oder Zeichenfolgen verwendet werden. Eine Tabelle ist ein konformer Datentyp, der aus mehreren vorzeichenlosen Zahlen oder anderen Tabellen als Datenelementen besteht. Tabellen werden zur Beschreibung strukturierter Daten mit hierarchischen Beziehungen verwendet, sodass die gesamte Class-Datei im Wesentlichen eine Tabelle ist. In ClassAnalyzer entsprechen u1, u2, u4 und u8 jeweils byte, short, int und long, und die Datei Class wird wie folgt beschrieben Java nett.

public class ClassFile {

    public U4 magic;                            // magic
    public U2 minorVersion;                     // minor_version
    public U2 majorVersion;                     // major_version
    public U2 constantPoolCount;                // constant_pool_count
    public ConstantPoolInfo[] cpInfo;           // cp_info
    public U2 accessFlags;                      // access_flags
    public U2 thisClass;                        // this_class
    public U2 superClass;                       // super_class
    public U2 interfacesCount;                  // interfaces_count
    public U2[] interfaces;                     // interfaces
    public U2 fieldsCount;                      // fields_count
    public FieldInfo[] fields;                  // fields
    public U2 methodsCount;                     // methods_count
    public MethodInfo[] methods;                // methods
    public U2 attributesCount;                  // attributes_count
    public BasicAttributeInfo[] attributes;     // attributes

}

So analysieren Sie die verschiedenen Datenelemente von

, aus denen die Class-Datei besteht, wie z. B. magische Nummer, Class Dateiversion und andere Datenelemente, Zugriffsflags, Klassenindex, übergeordnete Klassenindizes, die in jeder Class-Datei eine feste Anzahl von Bytes belegen, müssen beim Parsen nur die entsprechende Anzahl von Bytes lesen. Zu den Hauptteilen, die flexibel gehandhabt werden müssen, gehört außerdem der 4-Teil: Konstantenpool, Feldtabellensammlung, Methodentabellensammlung und Attributtabellensammlung. Felder und Methoden können ihre eigenen Attribute haben, und Class selbst verfügt auch über entsprechende Attribute. Daher umfasst das Parsen der Feldtabellensammlung und Methodentabellensammlung auch das Parsen der Attributtabelle.

Der Konstantenpool nimmt einen großen Teil der Daten in der Datei Class ein und wird zum Speichern aller Konstanteninformationen verwendet, einschließlich numerischer Konstanten und Zeichenfolgenkonstanten, Klassennamen, Schnittstellennamen, Feldnamen, Methodennamen usw . JavaDie Spezifikation der virtuellen Maschine definiert mehrere Konstantentypen, und jeder Konstantentyp hat seine eigene Struktur. Der Konstantenpool selbst ist eine Tabelle, und beim Parsen sind mehrere Punkte zu beachten.

• Jeder Konstantentyp wird durch ein Tag vom Typ u1 identifiziert.

• Die in der Kopfzeile angegebene konstante Poolgröße (constantPoolCount) ist größer als die tatsächliche 1. Wenn beispielsweise constantPoolCount gleich 47 ist, dann dort sind Item-Konstante. 46

• Der Indexbereich des Konstantenpools beginnt bei

  . Wenn beispielsweise 1 gleich constantPoolCount ist, ist der Indexbereich des Konstantenpools 47. Der Designer hat das Element 1~46 leer gelassen, um auszudrücken, dass „kein konstantes Poolelement referenziert“ wird. Die Struktur der Typkonstante 0

• enthält CONSTANT_Utf8_info vom Typ u1, tag vom Typ u2 und besteht aus length Teilen vom Typ length u1, diese bytes Bytes kontinuierlicher Daten sind eine Zeichenfolge, die mit length (MUTF-8 codiert ist. Modified UTF-8） ist nicht kompatibel mit MUTF-8. Es gibt zwei Hauptunterschiede: Erstens werden UTF-8 Zeichen verwendet kodiert in null Bytes (2 und 0xC0); zweitens werden Zusatzzeichen in Ersatzzeichenpaare aufgeteilt und entsprechend 0x80 separat kodiert >

属性表用于描述某些场景专有的信息，Class文件、字段表和方法表都有相应的属性表集合。Java虚拟机规范定义了多种属性，ClassAnalyzer目前实现了对常用属性的解析。和常量类型的数据项不同，属性并没有一个tag来标识属性的类型，但是每个属性都包含有一个u2类型的attribute_name_index，attribute_name_index指向常量池中的一个CONSTANT_Utf8_info类型的常量，该常量包含着属性的名称。在解析属性时，ClassAnalyzer正是通过attribute_name_index指向的常量对应的属性名称来得知属性的类型。

字段表用于描述类或者接口中声明的变量，字段包括类级变量以及实例级变量。字段表的结构包含一个u2类型的access_flags、一个u2类型的name_index、一个u2类型的descriptor_index、一个u2类型的attributes_count和attributes_count个attribute_info类型的attributes。我们已经介绍了属性表的解析，attributes的解析方式与属性表的解析方式一致。

Class的文件方法表采用了和字段表相同的存储格式，只是access_flags对应的含义有所不同。方法表包含着一个重要的属性：Code属性。Code属性存储了Java代码编译成的字节码指令，在ClassAnalyzer中，Code对应的Java类如下所示（仅列出了类属性）。

public class Code extends BasicAttributeInfo {

    private short maxStack;
    private short maxLocals;
    private long codeLength;
    private byte[] code;
    private short exceptionTableLength;
    private ExceptionInfo[] exceptionTable;
    private short attributesCount;
    private BasicAttributeInfo[] attributes;
    ...

    private class ExceptionInfo {
        public short startPc;
        public short endPc;
        public short handlerPc;
        public short catchType;
          ...
    }
}

在Code属性中，codeLength和code分别用于存储字节码长度和字节码指令，每条指令即一个字节（u1类型）。在虚拟机执行时，通过读取code中的一个个字节码，并将字节码翻译成相应的指令。另外，虽然codeLength是一个u4类型的值，但是实际上一个方法不允许超过65535条字节码指令。

代码实现

ClassAnalyzer的源码已放在了GitHub上。在ClassAnalyzer的README中，我以一个类的Class文件为例，对该Class文件的每个字节进行了分析，希望对大家的理解有所帮助。

Das obige ist der detaillierte Inhalt vonTeilen des leistungsstarken Codes zur Implementierung eines Java-Klassenparsers. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!