Tutoriel sur la modification de classes et de paramètres dans OpenJDK 8

OpenJDK est un projet volumineux. Il comprend de nombreux projets différents, écrits dans plusieurs langages, principalement Java, C et C++. Cet article a pour vocation de présenter le développement dans OpenJDK en commençant par le projet HotSpot, puis le projet JDK. Nous verrons comment ajouter et modifier des classes dans le JDK et des nouveaux paramètres dans la machine virtuelle (VM). Je vous invite à lire mon précédent article sur l'installation et la compilation d'OpenJDK 8, qui vous permettra de commencer avec un environnement stable. Cet article fait partie d'une série dédiée à OpenJDK 8.

II-A. Introduction▲

II-B. Ajouter un paramètre dans la machine virtuelle▲

 product(bool, TutorialGC, false, "Used for this tutorial") \

make

./javac Test.java
./java -XX:+TutorialGC Test

Unrecognized VM option 'TutorialGC'
Error: Could not create the Java Virtual Machine.
Error: A fatal exception has occurred. Program will exit.

II-C. Hello World dans la machine virtuelle▲

if(TutorialGC) {
  gclog_or_tty->print("La machine virtuelle démarre...");
}

La machine virtuelle démarre...Hello World !

Dans cette partie de l'article, nous allons voir comment ajouter notre propre classe dans le JDK et la lier à la compilation. Lors de la création des images, notre classe sera alors directement intégrée aux JAR et accessible comme toutes les autres classes, telles que System ou String.

Dans de nombreux projets, un ensemble de classes utilitaires est toujours développé afin de faciliter le développement. La bibliothèque Apache Commons Lang se retrouve très régulièrement dans les projets et embarque un nombre impressionnant de classes utilitaires. Notre objectif va être d'intégrer la classe SystemUtils d'Apache dans le JDK. J'ai choisi cette classe, car elle ne possède que peu de dépendances externes, donc ne nécessite que très peu de modifications en vue de son intégration.

Il faut bien comprendre que si nous voulons ajouter une « vraie » classe, il faut faire attention à ce à quoi elle est liée et surtout la liste des classes de la bibliothèque qu'elle utilise. Si une classe utilise cinq autres classes du projet Apache Commons Lang, alors nous devons intégrer les cinq autres, qui peuvent, elles aussi, dépendre d'autres classes et ainsi de suite. On se retrouve alors à ajouter une partie entière de la bibliothèque pour une seule classe à la base. Enfin, si vous désirez ajouter et coder votre propre classe, la façon de faire est absolument identique, à la différence près que vous n'aurez aucune dépendance, sauf sur votre propre code et les classes du JDK, ce qui ne pose aucun problème.

Tout d'abord, voyons les principaux répertoires qui vont nous intéresser :

• jdk8/jdk/src/share/classes : contient toutes les classes Java du JDK ;
• jdk8/jdk/src/share/native : contient le code natif, écrit en C, des classes Java. Nous ne nous servirons pas de ce répertoire, mais il peut être utile de savoir où il se trouve. Pour chaque classe ayant au moins une méthode native, vous devez créer un fichier C ayant le même nom que la classe et y inclure votre méthode selon un nommage précis. Le code est alors exécuté dans cette méthode, et peut être lié à la machine virtuelle. C'est comme cela que certaines méthodes du JDK donnent des informations sur HotSpot, comme System.gc() ;
• jdk8/jdk/make/java/java : contient les fichiers de propriétés pour la compilation des classes Java. La déclaration des classes à compiler, des fichiers C, des méthodes natives… Tout cela se fait ici.

Nous allons donc ajouter nos classes dans jdk8/jdk/src/share/classes, puis déclarer que nous devons les compiler et les ajouter comme les autres dans le JDK, grâce aux fichiers situés dans jdk8/jdk/make/java/java.

Passons à la pratique. Télécharger les sources du projet à l'adresse suivante : http://commons.apache.org/proper/commons-lang/download_lang.cgi. Pour cet article, j'ai utilisé la version 3.1.

Puisque nous désirons ajouter une classe utilitaire, nous placerons celle-ci dans le package java.util. Cela n'est en rien une nécessité, mais un choix personnel. Copier les classes SystemUtils et JavaVersion, situées dans src/main/java/org/apache/commons/lang3 dans le répertoire jdk8/jdk/src/share/classes/java/util. Nous devons aussi ajouter l'énumération JavaVersion, car elle est utilisée dans SystemUtils.

Ces deux classes étaient situées dans le package org.apache.commons.lang3, or nous les avons déclarées dans java.util. Nous devons donc éditer les deux classes et remplacer le code suivant :

package org.apache.commons.lang3;

par celui-ci :

package java.util;

Une fois cela fait, allez dans le répertoire jdk8/jdk/make/java/java. Voici une description des principaux fichiers de compilation :

• FILES_java.gmk : contient la liste des classes Java à compiler. Cette liste n'est pas complète, vous pourrez trouver d'autres fichiers comme celui-ci pour certaines implémentations Sun par exemple ;
• FILES_c.gmk : contient la liste des fichiers C à compiler. Les fichiers contiennent le code des méthodes déclarées natives dans une classe. Par exemple la méthode Runtime.gc() est native, vous trouverez donc le code C associé dans le fichier Runtime.c avec comme nom de méthode « Java_java_lang_Runtime_gc » ;
• Exportedfiles.gmk : contient la liste des classes Java pour lesquelles le compilateur doit générer un header C (.h). Ce header généré permet d'appeler des méthodes définies dans un autre fichier. Par exemple, vous pouvez importer le header associé à Runtime, pour faire exécuter des méthodes natives de cette classe ;
• mapfile-vers : contient la liste des méthodes natives de toutes les classes Java. Lorsque vous déclarez une méthode native, celle-ci doit se retrouver dans ce fichier.

Puisque nos deux classes ne contiennent pas de méthodes natives, nous avons uniquement besoin de les déclarer dans le fichier FILES_java.gmk. Ajoutez deux lignes, sur le même modèle que les autres classes, pour nos deux nouvelles classes, soit java/util/SystemUtils.java et java/util/JavaVersion.java. N'oubliez pas d'ajouter des «  \ » à la fin de chaque ligne.

Une fois cela fait, il ne vous reste plus qu'à compiler le JDK en exécutant la commande make, comme fait précédemment.

Pour tester que l'ajout fonctionne bien, il vous suffit de créer une classe dans laquelle vous appelez des méthodes ou des constantes de la classe SystemUtils.

import java.util.SystemUtils;

public class Test {

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

Sur ma machine, le résultat affiché est « 25.0-b39 », correspondant bien à la version compilée, affichée grâce à  l'option « java -version » et me donnant comme affichage :

openjdk version "1.8.0-internal"
OpenJDK Runtime Environment (build 1.8.0-internal-olivier_2013_06_30_00_34-b00)
OpenJDK 64-Bit Server VM (build 25.0-b39, mixed mode)

Nous avons vu comment ajouter des paramètres dans la machine virtuelle HotSpot et des classes dans le JDK. Des explications ont été fournies sur le fonctionnement de ces parties du projet OpenJDK ainsi qu'une description des différents fichiers et répertoires utiles au développement. Il ne vous reste plus qu'à modifier le code et à vous amuser à découvrir l'intérieur d'une plateforme utilisée par des millions d'utilisateurs quotidiennement.

Je tiens à remercier mes professeurs Julien Sopena et Gael Thomas de m'avoir permis de faire un stage sur la machine virtuelle HotSpot, qui donna lieu à cet article ainsi que Mickael Baron pour sa relecture technique et Claude LELOUP pour la correction orthographique.