Afficher le bytecode d'un fichier de classe en Java

1. Vue d'ensemble

L'analyse de bytecode est une pratique courante chez les développeurs Java pour de nombreuses raisons, comme la recherche de problèmes avec le code, le profilage de code et la recherche de classes avec des annotations spécifiques.

Dans cet article, nous explorerons des moyens d'afficher le bytecode d'un fichier de classe en Java.

2. Qu'est-ce que le bytecode?

Bytecode est la représentation intermédiaire d'un programme Java, permettant à une JVM de traduire un programme en instructions d'assemblage au niveau de la machine.

Lorsqu'un programme Java est compilé, le bytecode est généré sous la forme d'un fichier .class . Ce fichier .class contient des instructions non exécutables et repose sur une JVM pour être interprété.

3. Utilisation de javap

La ligne de commande Java est fournie avec l' outil javap qui affiche des informations sur les champs, les constructeurs et les méthodes d'un fichier de classe.

En fonction des options utilisées, il peut désassembler une classe et afficher les instructions qui composent le bytecode Java.

3.1. javap

Utilisons la commande javap pour afficher le bytecode de la classe Object la plus courante :

$ javap java.lang.Object

La sortie de la commande affichera la construction minimale de la classe Object :

public class java.lang.Object { public java.lang.Object(); public final native java.lang.Class getClass(); public native int hashCode(); public boolean equals(java.lang.Object); protected native java.lang.Object clone() throws java.lang.CloneNotSupportedException; public java.lang.String toString(); public final native void notify(); public final native void notifyAll(); public final native void wait(long) throws java.lang.InterruptedException; public final void wait(long, int) throws java.lang.InterruptedException; public final void wait() throws java.lang.InterruptedException; protected void finalize() throws java.lang.Throwable; static {}; }

Par défaut, la sortie de bytecode ne contiendra pas de champs / méthodes avec un modificateur d'accès privé .

3.2. javap -p

Pour afficher toutes les classes et tous les membres, nous pouvons utiliser l' argument -p :

public class java.lang.Object { public java.lang.Object(); private static native void registerNatives(); public final native java.lang.Class getClass(); public native int hashCode(); public boolean equals(java.lang.Object); protected native java.lang.Object clone() throws java.lang.CloneNotSupportedException; // ... }

Ici, nous pouvons observer qu'une méthode privée registerNatives est également affichée dans le bytecode de la classe Object .

3.3. javap -v

De même, nous pouvons utiliser l' argument -v pour afficher des informations détaillées telles que la taille de la pile et les arguments des méthodes de la classe Object :

Classfile jar:file:/Library/Java/JavaVirtualMachines/jdk1.8.0_131.jdk/Contents/Home/jre/lib/rt.jar!/java/lang/Object.class Last modified Mar 15, 2017; size 1497 bytes MD5 checksum 5916745820b5eb3e5647da3b6cc6ef65 Compiled from "Object.java" public class java.lang.Object minor version: 0 major version: 52 flags: ACC_PUBLIC, ACC_SUPER Constant pool: #1 = Class #49 // java/lang/StringBuilder // ... { public java.lang.Object(); descriptor: ()V flags: ACC_PUBLIC Code: stack=0, locals=1, args_size=1 0: return LineNumberTable: line 37: 0 public final native java.lang.Class getClass(); descriptor: ()Ljava/lang/Class; flags: ACC_PUBLIC, ACC_FINAL, ACC_NATIVE Signature: #26 // ()Ljava/lang/Class; // ... } SourceFile: "Object.java"

3.4. javap -c

De plus, la commande javap permet de désassembler toute la classe Java en utilisant l' argument -c :

Compiled from "Object.java" public class java.lang.Object { public java.lang.Object(); Code: 0: return public boolean equals(java.lang.Object); Code: 0: aload_0 1: aload_1 2: if_acmpne 9 5: iconst_1 6: goto 10 9: iconst_0 10: ireturn protected native java.lang.Object clone() throws java.lang.CloneNotSupportedException; // ... }

De plus, la commande javap nous permet de vérifier les informations système, les constantes et les signatures de type internes à l'aide de divers arguments.

Nous pouvons lister tous les arguments pris en charge par la commande javap en utilisant l' argument -help .

Maintenant que nous avons vu une solution de ligne de commande Java pour afficher le bytecode d'un fichier de classe, examinons quelques bibliothèques de manipulation de bytecode.

4. Utilisation d'ASM

ASM est un framework de manipulation et d'analyse de bytecode Java de bas niveau et orienté performances.

4.1. Installer

Tout d'abord, ajoutons les dernières dépendances asm et asm-util Maven à notre pom.xml :

 org.ow2.asm asm 8.0.1   org.ow2.asm asm-util 8.0.1 

4.2. Voir Bytecode

Ensuite, nous allons utiliser le ClassReader et TraceClassVisitor pour voir le bytecode de l' objet classe:

try { ClassReader reader = new ClassReader("java.lang.Object"); StringWriter sw = new StringWriter(); TraceClassVisitor tcv = new TraceClassVisitor(new PrintWriter(System.out)); reader.accept(tcv, 0); } catch (IOException e) { e.printStackTrace(); }

Ici, nous noterons que l' objet TraceClassVisitor nécessite l' objet PrintWriter pour extraire et produire le bytecode:

// class version 52.0 (52) // access flags 0x21 public class java/lang/Object { // compiled from: Object.java // access flags 0x1 public ()V L0 LINENUMBER 37 L0 RETURN MAXSTACK = 0 MAXLOCALS = 1 // access flags 0x101 public native hashCode()I // access flags 0x1 public equals(Ljava/lang/Object;)Z L0 LINENUMBER 149 L0 ALOAD 0 ALOAD 1 IF_ACMPNE L1 ICONST_1 GOTO L2 L1 // ... }

5. Utilisation de BCEL

La bibliothèque d'ingénierie de code d'octet, communément appelée Apache Commons BCEL, fournit un moyen pratique de créer / manipuler des fichiers de classe Java.

5.1. Dépendance de Maven

Comme d'habitude, ajoutons la dernière dépendance bcel Maven à notre pom.xml :

 org.apache.bcel bcel 6.5.0 

5.2. Désassembler la classe et afficher le bytecode

Ensuite, nous pouvons utiliser la classe Repository pour générer l' objet JavaClass :

try { JavaClass objectClazz = Repository.lookupClass("java.lang.Object"); System.out.println(objectClazz.toString()); } catch (ClassNotFoundException e) { e.printStackTrace(); }

Ici, nous avons utilisé la méthode toString sur l' objet objectClazz pour voir le bytecode dans un format concis:

public class java.lang.Object file name java.lang.Object compiled from Object.java compiler version 52.0 access flags 33 constant pool 78 entries ACC_SUPER flag true Attribute(s): SourceFile: Object.java 14 methods: public void () private static native void registerNatives() public final native Class getClass() [Signature: ()Ljava/lang/Class;] public native int hashCode() public boolean equals(Object arg1) protected native Object clone() throws Exceptions: java.lang.CloneNotSupportedException public String toString() public final native void notify() // ...

Further, the JavaClass class provides methods like getConstantPool, getFields, and getMethods to view the details of the disassembled class.

assertEquals(objectClazz.getFileName(), "java.lang.Object"); assertEquals(objectClazz.getMethods().length, 14); assertTrue(objectClazz.toString().contains("public class java.lang.Object")); 

Similarly, set* methods are available for bytecode manipulation.

6. Using Javassist

Also, we can use the Javassist (Java Programming Assistant) library that provides high-level APIs to view/manipulate Java bytecode.

6.1. Maven Dependency

First, we'll add the latest javassist Maven dependency to our pom.xml:

 org.javassist javassist 3.27.0-GA 

6.2. Generate ClassFile

Then, we can use the ClassPool and ClassFile classes to generate a Java class:

try { ClassPool cp = ClassPool.getDefault(); ClassFile cf = cp.get("java.lang.Object").getClassFile(); cf.write(new DataOutputStream(new FileOutputStream("Object.class"))); } catch (NotFoundException e) { e.printStackTrace(); }

Here, we've used the write method, which allows us to write the class file using the DataOutputStream object:

// Compiled from Object.java (version 1.8 : 52.0, super bit) public class java.lang.Object { // Method descriptor #19 ()V // Stack: 0, Locals: 1 public Object(); 0 return Line numbers: [pc: 0, line: 37] // Method descriptor #19 ()V private static native void registerNatives(); // Method descriptor #24 ()Ljava/lang/Class; // Signature: ()Ljava/lang/Class; public final native java.lang.Class getClass(); // Method descriptor #28 ()I public native int hashCode(); // ...

Also, the object of the ClassFile class provides access to the constant pool, fields, and methods:

assertEquals(cf.getName(), "java.lang.Object"); assertEquals(cf.getMethods().size(), 14);

7. Jclasslib

Additionally, we can use an IDE based plugin to view the bytecode of a class file. For instance, let's explore the jclasslib Bytecode viewer plugin available for IntelliJ IDEA.

7.1. Installation

First, we'll install the plugin using the Settings/Preferences dialog:

7.2. View Bytecode of the Object Class

Then, we can choose “Show Bytecode With Jclasslib” option under the View menu to view bytecode of the selected Object class:

Next, a dialog will open to show the bytecode of the Object class:

7.3. View Details

Also, we can see various details of the bytecode like constant pool, fields, and methods using the Jclasslib plugin dialog:

Similarly, we have the Bytecode Visualizer Plugin to view the bytecode of a class file using the Eclipse IDE.

8. Conclusion

In this tutorial, we explored ways to view the bytecode of a class file in Java.

First, we examined the javap command along with its various arguments. Then, we went through a few bytecode manipulation libraries that provide the features to view and manipulate the bytecode.

Last, we looked into an IDE based plugin Jclasslib that allows us to view bytecode in IntelliJ IDEA.

As usual, all the code implementations are available over on GitHub.