Partager le code puissant pour implémenter un analyseur de classe Java

J'écris actuellement un projet privé appelé ClassAnalyzer Le but de ClassAnalyzer est de nous donner une compréhension approfondie de la conception et de la structure du fichier <span class="wp_keywordlink">Java Class</span>. Le corps principal framework et les fonctions de base ont été complétés, et certaines fonctions détaillées seront ajoutées à l'avenir. En fait, JDK fournit déjà un outil en ligne de commande javap pour décompiler Class fichiers, mais cet article clarifiera mon idée d'implémenter l'analyseur.

Fichier de classe

sert de support d'informations de classe ou d'interface Chaque Class fichier définit complètement une classe. Afin de permettre au programme Java de "écrire une fois et de s'exécuter n'importe où", la spécification de la machine virtuelle Java a des réglementations strictes sur le fichier Class. L'unité de données de base qui constitue le fichier Class est l'octet. Il n'y a pas de séparateur entre ces octets. Cela fait que le contenu stocké dans l'ensemble du fichier Class contient presque toutes les données nécessaires au fonctionnement du programme, qui ne peuvent pas être représentées par un seul octet. . Les données sont représentées par plusieurs octets consécutifs.

Selon la spécification de la machine virtuelle Java, le fichier Class utilise une pseudo-structure similaire à la structure du langage C pour stocker les données. Il n'y a que deux types de données dans ce pseudo. -structure : Tableau de somme non signé. La spécification de la machine virtuelle Java définit u1, u2, u4 et u8 pour représenter respectivement 1 octets, 2 octets, 4 octets et 8. . Les nombres non signés peuvent être utilisés pour décrire des nombres, des indexréférences, des valeurs quantitatives ou des chaînes. Une table est un type de données conforme composé de plusieurs nombres non signés ou d'autres tables en tant qu'éléments de données. Les tables sont utilisées pour décrire des données structurées avec des relations hiérarchiques, de sorte que l'ensemble du fichier Class est essentiellement une table. Dans ClassAnalyzer, u1, u2, u4 et u8 correspondent respectivement à byte, short, int et long, et le fichier Class est décrit comme suit Java gentil.

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

}

Comment analyser les différents éléments de données de

qui composent le fichier Class, tels que le nombre magique, la version du fichier Class et d'autres éléments de données, les indicateurs d'accès, index de classe, les index de classe parent, qui occupent un nombre fixe d'octets dans chaque Class fichier, n'ont besoin que de lire le nombre d'octets correspondant lors de l'analyse. De plus, les principales parties qui doivent être gérées de manière flexible incluent la partie 4 : le pool de constantes, la collection de tables de champs, la collection de tables de méthodes et la collection de tables attributaires. Les champs et les méthodes peuvent avoir leurs propres attributs, et Class lui-même a également les attributs correspondants. Par conséquent, l'analyse de la collection de tables de champs et de la collection de tables de méthodes inclut également l'analyse de la table attributaire.

Le pool de constantes occupe une grande partie des données du fichier Class et est utilisé pour stocker toutes les informations constantes, y compris les constantes numériques et de chaîne, les noms de classe, les noms d'interface, les noms de champs, les noms de méthodes, etc. . JavaLa spécification de la machine virtuelle définit plusieurs types de constantes, chacun ayant sa propre structure. Le pool constant lui-même est une table, et il y a plusieurs points à noter lors de son analyse.

• Chaque type de constante est identifié par une balise de type u1.

• La taille du pool constant (constantPoolCount) indiquée dans l'en-tête est plus grande que la 1 réelle, par exemple, si constantPoolCount est égal à 47, alors il sont Item constant. 46

• La plage d'index du pool constant commence à partir de

  , par exemple, si 1 est égal à constantPoolCount, alors la plage d'index du pool constant est 47. Le concepteur a laissé l'élément 1~46 vide pour exprimer "ne faisant référence à aucun élément de pool constant". La structure de 0

• constante de type contient CONSTANT_Utf8_info de type u1, tag de type u2 et se compose de length morceaux de length type u1, ces bytes octets de données continues sont une chaîne codée en utilisant length (MUTF-8. Modified UTF-8） n'est pas compatible avec MUTF-8. Il y a deux différences principales : Premièrement, UTF-8 Les caractères seront codés en null octets (2 et 0xC0) ; deuxièmement, les caractères supplémentaires sont divisés en paires de substitution et codés séparément selon 0x80. Les détails pertinents peuvent être trouvés ici (variante UTF-8). >

属性表用于描述某些场景专有的信息，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文件的每个字节进行了分析，希望对大家的理解有所帮助。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!