Une introduction détaillée au bytecode JVM en Java

Cet article vous apporte une introduction détaillée au bytecode JVM en Java. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Il s'agit d'un article sur les bases de Java (JVM). Au départ, je voulais d'abord parler du mécanisme de chargement des classes Java, mais j'y ai ensuite réfléchi. Le rôle de la JVM est de charger le bytecode compilé par le compilateur. et l'interpréter dans un code machine, vous devez d'abord comprendre le bytecode, puis parler du mécanisme de chargement de classe pour charger le bytecode. Cela semble mieux, donc cet article est remplacé par une explication détaillée du bytecode.

En raison de la nature purement orientée objet de Java, tant que le bytecode peut représenter les informations d'une classe, il peut représenter l'intégralité du programme Java. Tant que la JVM peut charger les informations d'une classe. , il peut charger l'intégralité du programme. Par conséquent, qu'il s'agisse du bytecode ou du mécanisme de chargement JVM, l'accent est mis sur les classes. Mes principales préoccupations sont :

1. Puisque le bytecode n'est pas chargé en mémoire d'un seul coup, comment la JVM sait-elle où se trouvent les informations de classe qu'elle souhaite charger dans le fichier .class ?

2. Comment le bytecode représente-t-il les informations de classe ?

3. Le bytecode optimisera-t-il le programme ?

La première question est très simple, car même si un fichier source possède plusieurs classes (une seule classe publique), le compilateur générera un fichier .class pour chaque classe, et la JVM le chargera selon les besoins. charge le nom de la classe chargée.

Pour résoudre le problème suivant, regardons d'abord la composition du bytecode (ouvert avec Hex Fiend sur Mac).

Pour un morceau de code comme celui-ci :

package com.test.main1;

public class ByteCodeTest {

	int num1 = 1;
	int num2 = 2;

	public int getAdd() {

		return num1 + num2;
	}
}

class Extend extends ByteCodeTest {
	public int getSubstract() {
		return num1 - num2;
	}
}

Analysons la classe Extend qu'il contient.

Ouvrez le fichier .class compilé avec Hex Fiend comme ceci (code hexadécimal) :

Puisque le fichier de classe n'a pas de délimiteur, chaque Ce que représente chaque position , la longueur de chaque partie et les autres formats sont strictement réglementés, voir le tableau ci-dessous :

où u1, u2, u4, u8 Un numéro non signé représentant plusieurs octets Dans le fichier hexadécimal décompilé, deux nombres représentent un octet, qui est u1.

Regardez-le un par un du début à la fin :

(1) magie : u4, le nombre magique, signifie que ce fichier est un fichier .class. .jpg, etc. auront également ce nombre magique. En raison du nombre magique, même si *.jpg est remplacé par *.123, il peut toujours être ouvert comme d'habitude.

(2) Version mineure, version majeure : chaque u2, numéro de version, rétrocompatible, c'est-à-dire que la version supérieure du JDK peut utiliser les fichiers .class de version inférieure, mais pas l'inverse.

(3) constant_pool_count : u2, le nombre de constantes dans le pool de constantes, 0019 représente 24.

(4) Viennent ensuite les constantes spécifiques, un total de constant_pool_count-1.

Le pool de constantes stocke généralement deux types de données :

Les littéraux : tels que les chaînes, les constantes finales modifiées, etc. ;

Les références de symboles : telles que le nom complet d'un classe/interface Noms qualifiés, noms et descriptions de méthodes, noms et descriptions de champs, etc.

Sur la base des nombres décompilés, recherchez d'abord le tableau ci-dessous pour obtenir le type et la longueur de la constante. Le nombre suivant égal à la longueur que vous avez recherchée représente la valeur spécifique de la constante.

Par exemple, 070002, cela signifie que le type est CONSTANT_Class_info, sa balise est u1 et la longueur de u2 est l'index pointant vers l'élément constant de nom complet. Cet index doit également être consulté en conjonction avec le fichier de classe ouvert par javap -verbose. Le contenu et l'ordre dans le pool de constantes sont clairement répertoriés ici :

Vous pouvez voir 0002. ici La constante de l'élément d'index est : com/test/main1/Extend, qui est le nom complet de la classe. Si la valeur est une chaîne, vous devez convertir la valeur en décimal et vérifier la table de codes ASCII pour obtenir les caractères spécifiques. Les constantes suivantes sont analysées comme suit :

01001563 6F6D2F74 6573742F 6D61696E 312F4578 74656E64 : com/test/main1/Extend

070004 : com/test/main1/ByteCodeTest

01001B63

filed_info: {
　　u2　　　　　　　　access_flags;　　　
　　u2　　　　　　　　name_index;
　　u2　　　　　　　　descriptor_index;　　　　　　
　　u2　　　　　　　　attributes_count;
　　attribute_info　　　attributes[attributes_count];
}

method_info {
　　u2　　　　　　　　access_flags;　　　　　　　　　　0000　　　　？
　　u2　　　　　　　　name_index;　　　　　　　　　　 0005　　　<init>
　　u2　　　　　　　　descriptor_index;　　　　　　　　 0006　　　　()V
　　u2　　　　　　　　attributes_count;　　　　　　　　 0001　　　　1个
　　attribute_info　　　attributes[attributes_count];　　　0007　　　　Code
}

attribute_info {
　　u2　　attribute_name_index;　　0007　　Code
　　u1　　attribute_length;
　　u1　　info[attribute_length];
}

Code_attribute {　　//Code_attribute包含某个方法、实例初始化方法、类或接口初始化方法的Java虚拟机指令及相关辅助信息
　　u2　　attribute_name_index;　　0007　　　　　　　Code
　　u4　　attribute_length;　　　　0000002F　　　　　 47
　　u2　　max_stack;　　　　　　 0001　　　　　　　　1　//用来给出当前方法的操作数栈在方法执行的任何时间点的最大深度
　　u2　　max_locals;　　　　　　0001　　　　　 　　　1　//用来给出分配在当前方法引用的局部变量表中的局部变量个数
　　u4　　code_length;　　　　　 00000005　　　　　　5　//给出当前方法code[]数组的字节数
　　u1　　code[code_length];　　  2AB70008 B1　　　　42、183、0、8、177　
　　　　　　　　//给出了实现当前方法的Java虚拟机代码的实际字节内容　（这些数字代码实际对应一些Java虚拟机的指令）
　　u2　　exception_table_lentgh; 　　0000　　　　　　 0　　　　　　　  　//异常的信息
　　{
　　　　u2　　start_pc;　　　//这两项的值表明了异常处理器在code[]中的有效范围，即异常处理器x应满足：start_pc≤x≤end_pc
　　　　u2　　end_pc;　　　//start_pc必须在code[]中取值，end_pc要么在code[]中取值，要么等于code_length的值
　　　　u2　　handler_pc;　//表示一个异常处理器的起点
　　　　u2　　catch_type;　//表示当前异常处理器需要捕捉的异常类型。为0，则都调用该异常处理器，可用来实现finally。
　　} exception_table[exception_table_lentgh];　　　　　　在本类中大括号里的结构为空
　　u2　　attribute_count;　　　　0002　　　　　　　　　　2　　　　表示该方法的其它附加属性，本类有1个
　　attribute_info　　attributes[attributes_count];　　　　　  000A、000B　　　  LineNumberTable、LocalVariableTable
}

LineNumberTable_attribute {　//被调试器用来确定源文件中由给定的行号所表示的内容，对应于Java虚拟机code[]数组的哪部分
　　u2　　attribute_name_index;　　　　　　000A
　　u4　　attribute_length;　　　　 　　　　 00000006
　　u2　　line_number_table_length;　　　　 0001
　　{　　u2　　start_pc;　　　　　　　　　　0000　　　　
　　　　 u2　　line_number;　　　　　　　　 000E　　　　　//该值必须与源文件中对应的行号相匹配
　　} line_number_table[line_number_table_length];
}

LocalVariableTable_attribute {
　　u2　　attribute_name_index;　　　　000B
　　u4　　attribute_length;　　　　　　  0000000C
　　u2　　local_variable_table_length; 　 0001
　　{　　u2　　start_pc;　　　　　　　   0000
　　　　 u2　　length;　　　　　　　　   0005
　　　　 u2　　name_index;　　　　　　 000C
　　　　 u2　　descriptor_index;　　　　000D　　　　//用来表示源程序中局部变量类型的字段描述符
　　　　u2　　 index;　　　　　　　　　 0000
　　} local_variable_table[local_variable_table_length];

SourceFile_attribute {
　　u2　　attribute_name_index;　　0017　　　　　SourceFile
　　u4　　attribute_length;　　　　  00000002　　 2
　　u2　　sourcefile_index;　　　     0018　　　　　ByteCodeTest.java　//表示本class文件是由ByteCodeTest.java编译来的
}