89. Les outils du J.D.K.

Niveau :

Elémentaire

Le JDK de Sun/Oracle fournit un ensemble d'outils qui permettent de réaliser des applications. Ces outils sont peu ergonomiques car ils s'utilisent en ligne de commandes mais, en contrepartie, ils peuvent toujours être utilisés.

Ce chapitre contient plusieurs sections :

• Le compilateur javac
• L'interpréteur java/javaw
• L'outil jar
• L'outil appletviewer pour tester des applets
• L'outil javadoc pour générer la documentation technique
• L'outil Java Check Update pour mettre à jour Java
• La base de données Java DB
• L'outil JConsole
• VisualVM

89.1. Le compilateur javac

Cet outil est le compilateur : il utilise un fichier source Java fourni en paramètre pour créer un ou plusieurs fichiers contenant le bytecode Java correspondant. Pour chaque fichier source, un fichier portant le même nom avec l'extension .class est créé si la compilation se déroule bien. Il est possible qu'un ou plusieurs autres fichiers .class soient générés lors de la compilation de la classe si celle-ci contient des classes internes. Dans ce cas, le nom du fichier des classes internes est de la forme classe$classe_interne.class. Un fichier .class supplémentaire est créé pour chaque classe interne.

89.1.1. La syntaxe de javac

La syntaxe est la suivante :

javac [options] [fichiers] [@fichiers]

Cet outil est disponible depuis le JDK 1.0

La commande attend au moins un nom de fichier contenant du code source Java. Il peut y en avoir plusieurs, en les précisant un par un, séparés par des caractères espace ou en utilisant les jokers du système d'exploitation. Tous les fichiers indiqués doivent obligatoirement posséder l'extension .java qui doit être précisée sur la ligne de commandes.

Exemple : pour compiler le fichier MaClasse.

javac MaClasse.java

Exemple : pour compiler tous les fichiers sources du répertoire

javac *.java

Le nom du fichier doit correspondre au nom de la classe contenue dans le fichier source. Il est obligatoire de respecter la casse du nom de la classe même sur des systèmes qui ne sont pas sensibles à la casse comme Windows.

Depuis le JDK 1.2, il est aussi possible de fournir un ou plusieurs fichiers qui contiennent une liste des fichiers à compiler. Chacun des fichiers à compiler doit être sur une ligne distincte. Sur la ligne de commandes, les fichiers qui contiennent une liste doivent être précédés d'un caractère @

Exemple :

javac @liste

Contenu du fichier liste :
test1.java
test2.java

89.1.2. Les options de javac

Les principales options sont :

89.1.3. Les principales erreurs de compilation

public class Test {
  int i
}

javac Test.java
Test.java:3:
  ';' expected
  int i
       ^
1 error

public class Test {
  String[] chaines = new String {"aa","bb","cc"};
}

C:\tmp>javac Test.java
Test.java:3:
  '(' or '[' expected
  String[] chaines = new String {"aa","bb","cc"};
                                ^
1 error

import java.util;
public class Test {
}

C:\tmp>javac Test.java
Test.java:1:
  cannot resolve symbol
symbol  : class util
location:
  package java
import java.util;
            ^
1 error

public class Test {
  int i = 1;
  public void traitement() {
    if (i==0) {
      i =1;
      else i = 0;
    }
  }
}

C:\tmp>javac Test.java
Test.java:8:
  'else' without 'if'
    else i = 0;
    ^
Test.java:11:
  '}' expected
}
 ^
2 errors

public class Test {
  int i = 1;
  public void traitement() {
    if (i==0) {
      i =1;
  }
}

C:\tmp>javac Test.java
Test.java:9: '}' expected
}
 ^
1 error

public class Test {
  int i = 1;
  int i = 0;
}

C:\tmp>javac Test.java
Test.java:4: i is already defined in Test
  int i = 0;
      ^
1 error

import java.util.List;
import java.awt.List;
public class Test {
  List liste = null;
}

C:\tmp>javac Test.java
Test.java:2: java.util.List is already defined in a single-type
  import
import java.awt.List;
^
1 error

import java.util.*;
import java.awt.*;
public
  class Test {
  List liste = null;
}

C:\tmp>javac Test.java
Test.java:5:
  reference to List is ambiguous, both class java.awt.List in java.aw
t and
  class java.util.List in java.util match
  List liste = null;
  ^
1 error

public class Test {
  public void traitement() {
    String chaine;
    System.out.println(chaine);
  }
}

C:\tmp>javac Test.java
Test.java:6:
  variable chaine might not have been initialized
    System.out.println(chaine);
                       ^
1 error

public abstract class Test {
  public static void main(String[] argv) {
    Test test = new Test();
  }
}

C:\tmp>javac Test.java
Test.java:5:
  Test is abstract; cannot be instantiated
    Test test = new Test();
                ^
1 error

public class Test {
  int i = 0;
  public static void main(String[] argv) {
    System.out.println(i);
  }
}

C:\tmp>javac Test.java
Test.java:6:
  non-static variable i cannot be referenced from a
  static context
    System.out.println(i);
                       ^
1 error

public class Test {
  public static void main(String[] argv) {
    System.out.println(i);
  }
}

C:\tmp>javac Test.java
Test.java:5:
  cannot resolve symbol
symbol  : variable i
location:
  class Test
    System.out.println(i);
                       ^
1 error

public class Test {
}
public class TestBis {
}

C:\tmp>javac Test.java
Test.java:6:
  class TestBis is public, should be declared in a
  file named TestBis
.java
public class TestBis {
       ^
1 error

public Test {
}

C:\tmp>javac Test.java
Test.java:2:
  'class' or 'interface' expected
public Test {
       ^
1 error

public class Test {
  public int additionner(int a, int b) {
    return a+b;
  }
  public float additionner(int a, int b) {
    return (float)a+b;
  }
}

C:\tmp>javac Test.java
Test.java:8: additionner(int,int) is
  already defined in Test
  public float additionner(int a, int b) {
               ^
1 error

public class Test {
  public additionner(int a, int b) {
    return a+b;
  }
}

C:\tmp>javac Test.java
Test.java:4:
  invalid method declaration; return type required
  public additionner(int a, int b) {
         ^
1 error

public class Test {
  public byte traitement(int a) {
    byte b = a;
    return b;
  }
}

C:\tmp>javac Test.java
Test.java:5:
  possible loss of precision
found   : int
required:
  byte
    byte b = a;
             ^
1 error

public class Test {
  public int additionner(int a, int b); {
    return a+b;
  }
}

C:\tmp>javac Test.java
Test.java:4:
  missing method body, or declare abstract
  public int additionner(int a, int b); {
             ^
Test.java:5:
  return outside method
    return a+b;
    ^
2 errors

public class Test {
  int i;
  public void Test(int a, int b, int c , int d) {
    if ( a = b || c = d) {
      System.out.println("test");
    }
  }
}

C:\tmp>javac Test.java
Test.java:6:
  incompatible types
found   : int
required: boolean
    if ( a = b || c = d) {
         ^
Test.java:6:
  operator || cannot be applied to int,int
    if ( a = b || c = d) {
               ^
2 errors

public class Test {
  int i;
  public void Test(int a, int b) {
    if ( a = b ) {
      System.out.println("test");
    }
  }        
}

C:\tmp>javac Test.java
Test.java:6:
  incompatible types
found   : int
required: boolean
    if ( a = b ) {
         ^
1 error

public class Test {
  int a;
  public int traitement(int b) {
    a = b;
  }
}

C:\tmp>javac Test.java
Test.java:7:
  missing return statement
  }
  ^
1 error

private class Test {
}

C:\tmp>javac Test.java
Test.java:2:
  modifier private not allowed here
private class Test {
        ^
1 error

89.2. L'interpréteur java/javaw

Ces deux outils sont les interpréteurs de bytecode : ils lancent le JRE, chargent les classes nécessaires et exécutent la méthode main de la classe passée en paramètre.

java ouvre une console pour recevoir les messages de l'application alors que javaw n'en ouvre pas.

89.2.1. La syntaxe de l'outil java

java [ options ] classe [ argument ... ]
java [ options ] -jar fichier.jar [ argument ... ]
javaw [ options ] classe [ argument ... ]
javaw [ options ] -jar fichier.jar [ argument ... ]

Le paramètre classe doit être un fichier .class dont il ne faut pas préciser l'extension. La classe contenue dans ce fichier doit obligatoirement contenir une méthode main(). La casse du nom du fichier doit être respectée.

Cet outil est disponible depuis la version 1.0 du JDK.

Exemple:

java MaClasse

Il est possible de fournir des arguments à l'application.

89.2.2. Les options de l'outil java

Les principales options sont :

89.3. L'outil jar

JAR est le diminutif de Java ARchive. C'est un format de fichier qui permet de regrouper des fichiers contenant du bytecode Java (fichier .class) ou des données utilisées en tant que ressources (images, son, ...). Ce format est compatible avec le format ZIP : les fichiers contenus dans un jar sont compressés de façon indépendante du système d'exploitation.

Les jar sont utilisables depuis la version 1.1 du JDK.

89.3.1. L'intérêt du format jar

Son utilisation est particulièrement pertinente avec les applets, les beans et même les applications. En fait, le format jar est le format de diffusion des composants Java.

Les fichiers jar sont compressés par défaut ce qui est particulièrement intéressant quelque soit leurs utilisations.

Pour une applet, le browser n'effectue plus qu'une requête pour obtenir l'applet et ses ressources au lieu de plusieurs pour obtenir tous les fichiers nécessaires (fichiers .class, images, sons ...).

Un jar peut être signé ce qui permet d'assouplir et d'élargir le modèle de sécurité, notamment celui des applets qui ont des droits restreints par défaut.

Les beans doivent obligatoirement être diffusés sous ce format.

Les applications sous forme de jar peuvent être exécutées automatiquement.

Une archive jar contient un fichier manifest qui permet de préciser le contenu du jar et de fournir des informations sur celui-ci (classe principale, type de composants, signature ...).

89.3.2. La syntaxe de l'outil jar

Le JDK fourni l'outil jar pour créer des archives jar. C'est un outil utilisable avec la ligne de commandes comme tous les outils du JDK.

La syntaxe est la suivante :

jar [option [jar [manifest [fichier

Cet outil est disponible depuis la version 1.1 du JDK.

Les options sont :

Pour fournir des options à l'outil jar, il faut les saisir sans '-' et les accoler les unes aux autres. Leur ordre n'a pas d'importance.

Une restriction importante concerne l'utilisation simultanée du paramètre 'm' et 'f' qui nécessitent respectivement le nom du fichier manifest et le nom du fichier archive en paramètre de la commande. L'ordre de ces deux paramètres doit être identique à l'ordre des paramètres 'm' et 'f' sinon une exception est levée lors de l'exécution de la commande

C:\jumbo\Java\xagbuilder>jar cmf test.jar manif.mf *.class
java.io.IOException: invalid header field
        at java.util.jar.Attributes.read(Attributes.java:354)
        at java.util.jar.Manifest.read(Manifest.java:161)
        at java.util.jar.Manifest.<init>(Manifest.java:56)
        at sun.tools.jar.Main.run(Main.java:125)
        at sun.tools.jar.Main.main(Main.java:904)

Voici quelques exemples de l'utilisation courante de l'outil jar :

• Création d'un jar avec un fichier manifest créé automatiquement contenant tout les fichiers .class du répertoire courant

  jar cf test.jar *.class

  
  
• Lister le contenu d'un jar

  jar tf test.jar

  
  
• Extraire le contenu d'une archive

  jar xf test.jar

89.3.3. La création d'une archive jar

L'option 'c' permet de créer une archive jar. Par défaut, le fichier créé est envoyé sur la sortie standard sauf si l'option 'f' est utilisée. Elle précise que le nom du fichier est fourni en paramètre. Par convention, ce fichier a pour extension .jar.

Si le fichier manifest n'est pas fourni, un fichier est créé par défaut dans l'archive jar dans le répertoire META-INF sous le nom MANIFEST.MF

jar cf test.jar *.class

Il est possible d'ajouter des fichiers contenus dans des sous-répertoires du répertoire courant : dans ce cas, l'arborescence des fichiers est conservée dans l'archive.

jar cfm test.jar manifest.mf .class images

jar cfm test.jar manifest.mf *.class images/*.gif

89.3.4. Lister le contenu d'une archive jar

L'option 't' permet de donner le contenu d'une archive jar.

jar tf test.jar

Le séparateur des chemins des fichiers est toujours un slash quelle que soit la plate-forme car le format jar est indépendant de toute plate-forme. Les chemins sont toujours donnés dans un format relatif et non pas absolu : le chemin est donné par rapport au répertoire courant. Il faut en tenir compte lors d'une extraction.

C:\jumbo\bin\test\java>jar tvf test.jar
  2156 Thu Mar 30 18:10:34 CEST 2000 META-INF/MANIFEST.MF
   678 Thu Mar 23 12:30:00 CET 2000   BDD_confirm$1.class
   678 Thu Mar 23 12:30:00 CET 2000   BDD_confirm$2.class
  4635 Thu Mar 23 12:30:00 CET 2000   BDD_confirm.class
   658 Thu Mar 23 13:18:00 CET 2000   BDD_demande$1.class
   657 Thu Mar 23 13:18:00 CET 2000   BDD_demande$2.class
   662 Thu Mar 23 13:18:00 CET 2000   BDD_demande$3.class
   658 Thu Mar 23 13:18:00 CET 2000   BDD_demande$4.class
  5238 Thu Mar 23 13:18:00 CET 2000   BDD_demande.class
   649 Thu Mar 23 12:31:28 CET 2000   BDD_resultat$1.class
  4138 Thu Mar 23 12:31:28 CET 2000   BDD_resultat.class
   533 Thu Mar 23 13:38:28 CET 2000   Frame1$1.class
   569 Thu Mar 23 13:38:28 CET 2000   Frame1$2.class
   569 Thu Mar 23 13:38:28 CET 2000   Frame1$3.class
  2150 Thu Mar 23 13:38:28 CET 2000   Frame1.class
   919 Thu Mar 23 12:29:56 CET 2000   Test2.class

89.3.5. L'extraction du contenu d'une archive jar

L'option 'x' permet d'extraire par défaut tous les fichiers contenus dans l'archive dans le répertoire courant en respectant l'arborescence de l'archive. Pour n'extraire que certains fichiers de l'archive, il suffit de les préciser en tant que paramètres de l'outil jar en les séparant par un espace. Pour une extraction totale ou partielle de l'archive, les fichiers sont extraits en conservant la hiérarchie des répertoires qui les contiennent.

jar xf test.jar

jar xf test.jar test1.class test2.class

Attention : lors de l'extraction, l'outil jar écrase tous les fichiers existants sans demander de confirmation.

89.3.6. L'utilisation des archives jar

Dans une page HTML, pour utiliser une applet fournie sous forme de jar, il faut utiliser l'option archive du tag applet. Cette option attend en paramètre le fichier jar et son chemin relatif au répertoire contenant le fichier HTML.

<applet code=>em<MonApplet.class>/em<
        archive=">em<MonApplet.jar>/em<"
        width=>em<300>/em< height=>em<200>/em<>
</applet>

Avec Java 1.1, l'exécution d'une application sous forme de jar se fait grâce au JRE. Il faut fournir dans ce cas le nom du fichier jar et le nom de la classe principale.

jre -cp MonApplication.jar ClassePrincipale

Avec Java 1.2, l'exécution d'une application sous forme de jar impose de définir la classe principale (celle qui contient la méthode main) dans l'option Main-Class du fichier manifest. A cette condition l'option -jar de la commande java permet d'exécuter l'application.

java -jar MonApplication.jar

89.3.7. Le fichier manifest

Le fichier manifest contient de nombreuses informations sur l'archive et son contenu. Ce fichier est le support de toutes les fonctionnalités particulières qui peuvent être mises en oeuvre avec une archive jar.

Dans une archive jar, il ne peut y avoir qu'un seul fichier manifest nommé MANIFEST dans le répertoire META-INF de l'archive.

Le format de ce fichier est de la forme clé/valeur. Il faut mettre un ':' et un espace entre la clé et la valeur.

C:\jumbo\bin\test\java>jar xf test.jar META-INF/MANIFEST.MF

Cela crée un répertoire META-INF dans le répertoire courant contenant le fichier MANIFEST.MF :

Manifest-Version: 1.0
Name: BDD_confirm$1.class
Digest-Algorithms: SHA MD5
SHA-Digest: ntbIs5E5YNilE4mf570JoIF9akU=
MD5-Digest: R3zH0+m9lTFq+BlQvfQdHA==
Name: BDD_confirm$2.class
Digest-Algorithms: SHA MD5 
SHA-Digest: 3QEF8/zmiTAP7MHFPU5wZyg9uxc=
MD5-Digest: swBXXptrLLwPMw/bpt6F0Q==
Name: BDD_confirm.class
Digest-Algorithms: SHA MD5
SHA-Digest: pZBT/o8YeDG4q+XrHRgrB08k4HY=
MD5-Digest: VFvY4sGRfjV1ciM9C+QIdg==

Dans le fichier manifest créé automatiquement avec le JDK 1.1, chaque fichier possède au moins une entrée de type 'Name' et des informations la concernant.

Entre les données de deux fichiers, il y a une ligne blanche.

Dans le fichier manifest créé automatiquement avec le JDK 1.2, il n'y a plus d'entrée pour chaque fichier.

Manifest-Version: 1.0
Created-By: 1.3.0 (Sun Microsystems Inc.)

Le fichier manifest généré automatiquement convient parfaitement si l'archive est utilisée uniquement pour regrouper les fichiers. Pour une utilisation plus spécifique, il faut modifier ce fichier pour ajouter les informations utiles.

Par exemple, pour une application exécutable (à partir de Java 1.2) il faut ajouter une clé Main-Class en lui associant le nom de la classe dans l'archive qui contient la méthode main.

89.3.8. La signature d'une archive jar

La signature d'une archive jar joue un rôle important dans les processus de sécurité de Java. La signature d'une archive permet à celui qui utilise cette archive de lui donner des droits étendus une fois que la signature a été reconnue.

Avec Java 1.1 une archive signée possède tous les droits.

Avec Java 1.2 une archive signée peut se voir attribuer des droits particuliers définis dans un fichier policy.

89.4. L'outil appletviewer pour tester des applets

L'intérêt de cet outil est qu'il permet de tester une applet avec la version courante du JDK. Un navigateur classique nécessite un plug-in pour utiliser une version particulière du JRE. Cet outil est disponible depuis la version 1.0 du JDK.

En contrepartie, l'appletviewer n'est pas prévu pour tester les pages HTML. Il charge une page HTML fournie en paramètre, l'analyse, charge l'applet qu'elle contient et exécute cette applet.

La syntaxe est la suivante : appletviewer [option] fichier

L'appletview recherche le tag HTML <APPLET>. A partir du JDK 1.2, il recherche aussi les tags HTML <EMBED> et <OBJECT>.

Il possède plusieurs options dont les principales sont :

L'appletviewer ouvre une fenêtre qui possède un menu avec les options suivantes :

89.5. L'outil javadoc pour générer la documentation technique

Cet outil permet de générer une documentation à partir des données insérées dans le code source. Cet outil est disponible depuis le JDK 1.0

La syntaxe de la commande est la suivante :

javadoc  [  options ] [ nom_packages ] [ fichiers_source ] [ -sous_packages   pkg1:pkg2:...  ] [  @fichiers_arguments ]

L'ordre des arguments n'a pas d'importance :

• nom_packages : un ou plusieurs noms de packages séparés par des espaces. (ces packages sont recherchés en utilisant la variable -sourcepath)
• fichiers_sources : un ou plusieurs fichiers sources Java séparés par des espaces. Il est possible de préciser le chemin de chaque fichier. Il est aussi possible d'utiliser le caractère * pour désigner 0 ou n caractères quelconques.
• sous_packages : un ou plusieurs sous-packages à inclure dans la documentation
• @fichiers_arguments : un ou plusieurs fichiers qui contiennent les options à utiliser par Javadoc

Il faut fournir en paramètres de l'outil javadoc un nom de package ou un ensemble de fichiers sources Java.

Les principales options utilisables sont :

L'outil javadoc utilise un doclet pour réaliser le rendu de la documentation générée : il utilise un doclet par défaut si aucun autre doclet n'est spécifié avec l'option -doclet.

Les principales options utilisables du doclet standard sont :

Il est possible de préciser les paramètres de l'outil javadoc (sauf l'option -J) dans un ou plusieurs fichiers en passant leurs noms précédés des caractères @. Dans un tel fichier les paramètres peuvent être séparés par un espace ou un retour chariot.

Il n'est pas possible d'utiliser le caractère joker * dans les noms de fichiers ni de faire une référence à un autre fichier de paramètres avec le caractère @.

Exemple :

C:>javadoc @javadocparam

-d documentation -use -splitindex

Remarque : l'outil javadoc ne sait pas travailler de façon incrémentale : toute la documentation est à regénérer à chaque fois.

Des informations supplémentaires sur les éléments à inclure dans le code source sont fournies dans le chapitre «JavaDoc».

89.6. L'outil Java Check Update pour mettre à jour Java

Jucheck (Java Update Check) est un outil proposé par Sun pour permettre une mise à jour automatique de l'environnement d'exécution Java.

L'outil jusched.exe est installé par défaut et configuré pour une exécution automatique depuis la version 1.4.2 du J2SE.

Pour lancer manuellement la mise à jour, il suffit d'exécuter le programme jucheck.exe dans le répertoire bin du JRE.

Si aucune mise à jour n'est disponible, un message est affiché :

Sinon une bulle d'aide informe que des mises à jour peuvent être téléchargées.

En laissant le curseur de la souris sur l'icône du programme de mise à jour, une bulle d'aide est affichée.

Pour télécharger les mises à jour, il suffit d'utiliser l'option " Télécharger " du menu contextuel associé à l'icône.

Une boîte de dialogue permet de demander le téléchargement des éléments dont la version est indiquée.

Cliquez sur le bouton " Téléchargement ".

Une fois le téléchargement terminé, une bulle est affichée.

En laissant le curseur de la souris sur l'icône du programme de mise à jour, une bulle d'aide est affichée.

Pour installer les mises à jour, il suffit d'utiliser l'option " Installer " du menu contextuel associé à l'icône.

Cliquez sur le bouton " Installer ".

L'assistant se lance pour diriger les différentes étapes.

L'option " Propriétés " permet d'ouvrir une boîte de dialogue pour gérer les paramètres des mises à jour dans l'onglet " Mettre à jour ".

Le bouton " Avancé " permet de définir les paramètres de recherche automatique.

89.7. La base de données Java DB

Java SE 6 intègre une base de données : Java DB. C'est en fait la base de données open source Apache Derby écrite entièrement en Java. C'est une base de données légère (2 Mb) qui propose cependant des fonctionnalités intéressantes (gestion des transactions et des accès concurrents, support des triggers et des procédures stockées, ...)

Java DB est donc le nom sous lequel Sun propose la base de données open source Derby du groupe Apache dans certains de ses outils notamment le JDK depuis sa version 6.0.

Java DB est stockée dans le sous-répertoire db du répertoire d'installation d'un JDK. Avec le JDK 6.0 c'est la version 10.2 de Java DB qui est fournie.

Remarque : dans cette section Java DB peut être remplacée par Derby et vice versa.

L'ajout de Java DB dans le JDK permet de rapidement écrire des applications qui utilisent une base de données et les fonctionnalités proposées par la version 4.0 de JDBC.

Java DB est idéale dans un environnement de développement car elle est riche en fonctionnalités, facile à utiliser, multiplate-forme puisqu'écrite en Java et peut être mise en oeuvre sur une simple machine de développement.

Java DB peut fonctionner selon deux modes :

• Embedded : la base de données est exécutée comme une partie de l'application
• Client/server : la base de données est exécutée de façon indépendante de l'application

Java DB peut être intégrée dans une application (mode Embedded) ce qui évite d'avoir à installer et configurer une base de données lors du déploiement de l'application.

Java DB propose plusieurs outils pour assurer sa gestion.

L'outil ij permet d'exécuter des scripts sur une base de données.

Le lancement de l'outil ij peut se faire de deux façons :

C:\Program Files\Java\jdk1.6.0\db>java -jar lib\derbyrun.jar ij
version ij 10.2
ij>

ou

C:\Program Files\Java\jdk1.6.0\db>java -cp .\lib\derbytools.jar org.apache.derby
.tools.ij
ij version 10.2
ij>

La création d'une base de données nommée MaBaseDeTest et la connexion à cette nouvelle base se font en utilisant l'outil ij.

ij> CONNECT 'jdbc:derby:MaBaseDeTest;create=true';

Remarque : l'outil ij peut être utilisé avec n'importe quel pilote JDBC.

ij> CREATE TABLE PERSONNE (ID INT PRIMARY KEY, NOM VARCHAR(50), PRENOM VARCHAR(5
0));
0 lignes insérés/mises à jour/supprimées

ij> select * from PERSONNE;
ID         |NOM                                               |PRENOM

--------------------------------------------------------------------------------
---------------------------------

0 lignes sélectionnées

ij> INSERT INTO PERSONNE VALUES (1,'nom1','prenom1'), (2,'nom2','prenom2'), (3,'
nom3','prenom3');
3 lignes insérées/mises à jour/supprimées
ij> select * from PERSONNE;
ID         |NOM                                               |PRENOM

--------------------------------------------------------------------------------
---------------------------------
1          |nom1                                              |prenom1

2          |nom2                                              |prenom2

3          |nom3                                              |prenom3


3 lignes sélectionnées

La commande exit; permet de quitter l'outil ij.

Une fois la base de données créée, il est possible d'utiliser par exemple l'API JDBC pour s'y connecter et effectuer des opérations sur ses données.

package com.jmdoudoux.test.jpa;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Statement;

public class TestDerby {

  private static String dbURL = 
    "jdbc:derby:C:/Program Files/Java/jdk1.6.0/db/MaBaseDeTest;user=APP";

  public static void main(String[] args) {

    try {
      Connection conn = null;
      Statement stmt = null;
      
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver").newInstance();
      conn = DriverManager.getConnection(dbURL);

      stmt = conn.createStatement();
      ResultSet results = stmt.executeQuery("select * from personne");
      ResultSetMetaData rsmd = results.getMetaData();
      int nbColonnes = rsmd.getColumnCount();
      for (int i = 1; i <= nbColonnes; i++) {
        System.out.print(rsmd.getColumnLabel(i) + "\t\t");
      }

      System.out.println("\n-------------------------------------------------");

      while (results.next()) {
        System.out.println(results.getInt(1) + "\t\t" 
          + results.getString(2) + "\t\t" + results.getString(3));
      }
      results.close();
      stmt.close();
      if (conn != null) {
        conn.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

}

Remarque : par défaut dans le mode embeded, les tables sont créées dans le schéma APP.

Pour utiliser Java DB en mode client/serveur, il suffit de remplacer le pilote JDBC par org.apache.derby.jdbc.ClientDriver et de changer dans l'url le chemin local pour l'url de la base de données.

L'outil dblook permet de générer le DDL d'une base de données.

C:\Program Files\Java\jdk1.6.0\db>java -jar lib\derbyrun.jar dblook -d jdbc:derb
y:MaBaseDeTest
-- Horodatage : 2007-06-28 15:42:21.613
-- La base de données source est : MaBaseDeTest
-- L'URL de connexion est : jdbc:derby:MaBaseDeTest
-- appendLogs: false

-- ----------------------------------------------
-- Instructions DDL pour tables
-- ----------------------------------------------

CREATE TABLE "APP"."ADRESSE" ("ID_ADRESSE" INTEGER NOT NULL, "RUE" VARCHAR(250)
NOT NULL, "CODEPOSTAL" VARCHAR(7) NOT NULL, "VILLE" VARCHAR(250) NOT NULL);

CREATE TABLE "APP"."PERSONNE" ("ID" INTEGER NOT NULL, "NOM" VARCHAR(50), "PRENOM
" VARCHAR(50));

-- ----------------------------------------------
-- Instructions DDL pour clés
-- ----------------------------------------------

-- primaire/unique
ALTER TABLE "APP"."ADRESSE" ADD CONSTRAINT "SQL070628114148710" PRIMARY KEY ("ID
_ADRESSE");

ALTER TABLE "APP"."PERSONNE" ADD CONSTRAINT "SQL070627114331220" PRIMARY KEY ("I
D");

L'outil sysinfo permet d'obtenir des informations sur l'environnement et sur la base de données.

C:\Program Files\Java\jdk1.6.0\db>java -cp .\lib\derbytools.jar org.apache.derby
.tools.ij
ij version 10.2
ij> exit;

C:\Program Files\Java\jdk1.6.0\db>java -jar lib\derbyrun.jar sysinfo
------------------ Informations Java  ------------------
Version Java :    1.6.0_01
Fournisseur Java :     Sun Microsystems Inc.
Répertoire principal Java :       C:\Program Files\Java\jre1.6.0_01
Chemin de classes Java :  lib\derbyrun.jar
Nom du système d'exploitation :         Windows XP
Architecture du système d'exploitation :         x86
Version du système d'exploitation :         5.1
Nom d'utilisateur Java :  JMD
Répertoire principal utilisateur Java :  C:\Documents and Settings\jmd
Répertoire utilisateur Java :   C:\Program Files\Java\jdk1.6.0\db
java.specification.name: Java Platform API Specification
java.specification.version: 1.6
--------- Informations Derby --------
JRE - JDBC: Java SE 6 - JDBC 4.0
[C:\Program Files\Java\jdk1.6.0\db\lib\derby.jar] 10.2.1.7 - (453926)
[C:\Program Files\Java\jdk1.6.0\db\lib\derbytools.jar] 10.2.1.7 - (453926)
[C:\Program Files\Java\jdk1.6.0\db\lib\derbynet.jar] 10.2.1.7 - (453926)
[C:\Program Files\Java\jdk1.6.0\db\lib\derbyclient.jar] 10.2.1.7 - (453926)
------------------------------------------------------
----------------- Informations sur lenvironnement local -----------------
Environnement local actuel :  [français/Luxembourg [fr_LU]]
La prise en charge de cet environnement local a été trouvée : [de_DE]
         version : 10.2.1.7 - (453926)
La prise en charge de cet environnement local a été trouvée : [es]
         version : 10.2.1.7 - (453926)
La prise en charge de cet environnement local a été trouvée : [fr]
         version : 10.2.1.7 - (453926)
La prise en charge de cet environnement local a été trouvée : [it]
         version : 10.2.1.7 - (453926)
La prise en charge de cet environnement local a été trouvée : [pt_BR]
         version : 10.2.1.7 - (453926)
------------------------------------------------------

Pour démarrer JavaDB en mode client-server, il faut exécuter l'application org.apache.derby.drda.NetworkServerControl.

C:\Program Files\Java\jdk1.6.0\db>java -cp .\lib\derbyrun.jar org.apache.derby.d
rda.NetworkServerControl start -h localhost
Le serveur est prêt à accepter les connexions au port 1527.

L'option -h permet de préciser le serveur.
L'option - p permet de préciser le port à utiliser si le port 1527 utilisé par défaut ne convient pas.

89.8. L'outil JConsole

Depuis Java SE 5.0, le JDK propose l'outil JConsole qui est une interface de monitoring et de management utilisant JMX. JConsole est une application graphique qui est un client JMX permettant de mettre en oeuvre la plupart des fonctionnalités de JMX.

JConsole est dans le sous-répertoire bin du répertoire d'installation du JDK.

Remarque : Il n'est pas recommandé d'utiliser JConsole en production car son utilisation consomme beaucoup de ressources. Si son utilisation est nécessaire, il est recommandé d'exécuter JConsole sur un système distant de celui de la JVM à surveiller.

Pour utiliser JConsole , il suffit d'exécuter jconsole dans une nouvelle boîte de commande.

Remarque : sous Windows, JMX ne fonctionne correctement que si la partition du système est formatée en NTFS.

Une fenêtre de connexion permet de préciser quel sera le processus d'une JVM à utiliser. Pour une JVM locale, il suffit de sélectionner « Local Process », la JVM parmi celles proposées, et de cliquer sur « Connect ».

Pour une connexion distante, il faut saisir l'url de connexion et éventuellement le user et le mot de passe si l'authentification est activée. Une fois la connexion établie, une fenêtre contenant plusieurs onglets permet d'avoir des informations sur l'état de différentes fonctionnalités.

L'onglet « Overview » fournit un résumé graphique sur quatre données : l'usage du tas (heap) et du processeur (CPU), le nombre de threads et de classes chargées.

L'onglet « Memory » permet d'avoir des informations précises sur la mémoire.

Le contenu du graphique principal et des détails peuvent être sélectionnés dans la liste déroulante chart : Heap Memory Usage, Non-Heap Memory Usage, Eden Space, Survivor Space, Tenured Space, Code Cache, Perm Gen, Perm Gen shared-rw et Perm Gen shared-ro. Ceci permet d'avoir une vue précise sur chaque partie de la mémoire de la JVM.

Le bouton « Perform GC » permet de demander l'exécution du ramasse-miettes.

L'onglet « Threads » permet d'avoir des informations sur les threads en cours d'exécution.

Pour avoir des informations précises sur un thread, il suffit de le sélectionner.

L'onglet « Classes » permet de connaître le nombre de classes chargées.

L'onglet « VM Summary » affiche de nombreuses informations sur l'état de la JVM. Celles-ci sont rafraîchies toutes les 5 secondes.

L'onglet « MBean » permet de gérer les MBeans de l'API JMX qui sont accessibles dans la JVM.

89.9. VisualVM

VisualVM est un outil intégré au JDK  depuis la version 6 update 7: il permet de superviser l'activité d'une JVM et propose quelques fonctionnalités de base pour profiler des applications Java. Ces fonctionnalités sont similaires à celles de JConsole avec des possibilités supplémentaires.

VisualVM offre de nombreuses fonctionnalités proposées par différents autres outils du JDK pour obtenir des informations de la JVM. C'est un outil graphique qui permet de superviser, d'analyser et de profiler une application exécutée dans une JVM.

VisualVM permet de se connecter sur des JVM locales ou distantes. Chaque JVM utilise un onglet : il est donc possible d'ouvrir plusieurs JVM. Chaque onglet d'une JVM possède plusieurs onglets pour afficher les informations selon leur type.

VisualVM est extensible en permettant l'utilisation de plugins.

La page officielle de VisualVM est à l'url https://visualvm.dev.java.net/

Pour exécuter VisualVM, il faut exécuter l'application jvisualvm.exe contenue dans le sous-répertoire bin du répertoire d'installation du JDK.

La splashscreen de Visual VM s'affiche. Lors du premier lancement, une boîte de dialogue informe que l'application va se calibrer.

Cliquez sur le bouton « OK ».

Cliquez sur le bouton « OK ».

Pour utiliser toutes les fonctionnalités de Visual VM, il est nécessaire d'exécuter l'application dans une JVM de Java 6.0 minimum. Le code peut cependant avoir été compilé en Java 5. Il est aussi possible d'utiliser VisualVM sur une JVM 5.0 mais dans ce cas toutes les fonctionnalités ne seront pas utilisables.

En utilisant une JVM de Java version 6 ou supérieure, VisualVM va pouvoir obtenir des informations plus détaillées notamment concernant la mémoire, la CPU, les threads, ...

VisualVM est une application graphique permettant d'obtenir des informations détaillées sur des applications s'exécutant dans une JVM. Ceci permet d'analyser et de contrôler le fonctionnement et les dysfonctionnements d'une application.

Le JDK proposait déjà plusieurs outils pour obtenir certaines de ces informations : jconsole, jmap, jstack, jstat ou jinfo. VisualVM permet d'obtenir des informations équivalentes et supplémentaires tout en les présentant sous une forme graphique.

Les informations fournies par Visual VM peuvent permettre notamment :

• D'obtenir des informations sur la configuration de la JVM
• D'analyser la consommation de mémoire et de CPU
• De visualiser et de gérer les activités du ramasse-miettes
• De capturer et analyser le heap
• D'identifier des fuites de mémoires
• De mesurer les performances pour les améliorer
• De gérer les MBeans

A son lancement, la fenêtre de VisualVM est composée de deux parties :

• Applications : affiche la liste des applications exécutées dans une JVM locale ou distante dont il est possible d'obtenir des informations et de gérer les snapshots
• La partie principale : l'onglet start propose des liens vers des ressources

Un snapshot est une capture d'informations d'une JVM à un moment donné.

Le menu contextuel d'une application permet plusieurs actions :

• Open : ouvrir un onglet pour obtenir des informations sur l'application
• Thread dump : obtenir une image des threads
• Heap dump : obtenir une image du tas (instances de classes)
• Application snapshot : créer une image sauvegardée des informations

Les informations concernant une application sont affichées dans la partie centrale. Chaque application possède son propre onglet.

89.9.1. Les plugins pour VisualVM

VisualVM peut être enrichi de fonctionnalités grâce à des plugins qui peuvent être téléchargés sur le VisualVM plugins Center et gérés dans le plugins manager.

Pour installer un plugin, il faut utiliser le menu Tools/Plugins.

L'onglet Updates permet de mettre à jour les plugins déjà installés.

L'onglet Available Plugins permet d'installer de nouveaux plugins. Il suffit de sélectionner les cases à cocher des plugins souhaités et de cliquer sur le bouton « Install ».

Cliquer sur le bouton « Next ».

Lisez la licence et si vous l'acceptez, sélectionnez la case à cocher et cliquez sur le bouton « Install ». Les plugins sont téléchargés et installés.

Cliquez sur le bouton « Finish » pour prendre en compte les plugins en redémarrant VisualVM.

89.9.2. L'utilisation de VisualVM

La fenêtre principale est composée de deux parties :

• la partie de gauche affiche une arborescence des JVM locales et distantes, les threaddumps et les snapshots
• la partie de droite permet d'obtenir les informations sur la ou les JVM connectées (un onglet par JVM)

L'arborescence de l'onglet Applications comporte plusieurs noeuds principaux :

• local : affiche les JVM en cours d'exécution sur la même machine que VisualVM
• remote : affiche les machines distantes et les JVM à surveiller
• snapshots : affiche les snapshots qui ont été pris

L'arborescence affiche aussi pour chaque JVM, les threaddumps, les heapdumps et les snapshots qui ont été sauvegardés. Sur Solaris ou Linux, les coredumps sont aussi affichés.

Chaque machine distante doit être ajoutée explicitement : elle sera conservée par VisualVM tant qu'il arrivera à s'y connecter au démarrage.

Pour afficher automatiquement les JVM en cours d'exécution sur la machine distante, celle-ci doit exécuter l'utilitaire jstatd fourni avec le JDK de Sun/Oracle.

Le menu contextuel associé à une JVM locale permet plusieurs actions :

• Open : se connecter à la JVM
• Thread Dump : demander la génération d'un thread dump
• Heap Dump : demander la génération d'un heap dump
• Profile : se connecter à la JVM et la profiler
• Application Snapshot : capturer les informations sur la JVM
• Enable Heap Dump on OOME : demander la génération d'un heap dump si une exception de type OutOfMemeoryException est levée dans la JVM

Pour chaque JVM connectée, plusieurs onglets permettent d'obtenir des informations :

• Overview : afficher des informations générales sur la JVM
• Monitor : afficher des informations graphiques sur l'activité de la JVM
• Threads : donner un aperçu de l'activité des threads
• Profiler : analyser le comportement de l'application concernant la CPU et la mémoire

D'autres onglets peuvent aussi être disponibles en fonction des plugins installés.

89.9.3. La connexion à une JVM

VisualVM est capable de détecter et de se connecter automatiquement aux JVM version 6 et supérieures. Pour des JVM version 5 ou distante, il est nécessaire de configurer JMX pour l'activer (en utilisant les propriétés com.sun.management.jmxremote.* lors du lancement de la JVM) et de s'y connecter avec VisualVM.

JMX peut être utilisé pour surveiller et gérer une JVM locale ou distante. Pour activer et configurer la connexion à la JVM, plusieurs propriétés peuvent être fournies au moment de son lancement :

• com.sun.management.jmxremote.port : permet de préciser le port sur lequel il sera possible de se connecter au serveur de MBeans
• com.sun.management.jmxremote.ssl : booléen qui permet de préciser si les échanges sont encryptés avec SSL
• com.sun.management.jmxremote.authenticate : booléen qui permet de préciser si la connection requiert un mot de passe

java
-Dcom.sun.management.jmxremote.port=3456
-Dcom.sun.management.jmxremote.ssl=false
-Dcom.sun.management.jmxremote.authenticate=false MonApp

VisualVM n'est pas capable de détecter et se connecter à une JVM :

• locale exécutée avec un utilisateur différent de celui utilisé pour lancer Visual VM
• distante sur laquelle le démon jstatd n'est pas lancé ou si les utilisateurs utilisés pour lancer jstad et la JVM sont différents

L'outil jps peut uniquement détecter les JVM locales exécutées avec l'utilisateur qui a lancé jps.

L'outil jstatd propose une interface qui permet de se connecter aux JVM exécutées sur la machine depuis une machine distante.

Pour se connecter à une JVM locale avec JMX, il suffit d'utiliser l'option "Add JMX connection" du menu contextuel de l'élément Local de l'arborescence Applications. Une boîte de dialogue permet de saisir les informations de connexions à JMX.

Le plus simple est de saisir le numéro du port du serveur de MBean après les deux points dans la zone de saisie Connection et de cliquer sur le bouton "OK". Un nouvel élément apparaît dans la sous-arborescence du noeud Local avec une icône spéciale.

Pour se connecter à une JVM distante en utilisant JMX , il suffit d'utiliser l'option "Add JMX connection" du menu contextuel hors de tout élément de l'arborescence.

Il suffit alors de saisir le nom de la machine hôte, suivi du caractère deux points et du port JMX à utiliser.

VisualVM permet de se connecter à une JVM distante : les JVM distantes sont affichées comme éléments fils de l'élément Remote dans l'arborescence.

Pour se connecter à une JVM distante sans utiliser JMX, il faut lancer l'outil jstatd fourni avec le JDK sur la machine distante. Ensuite, il faut ajouter cette machine en utilisant l'option "Add Remote Host" du menu contextuel de l'élément "Remote" dans l'arborescence.

Une petite boîte de dialogue permet de saisir le nom de l'hôte ou son adresse I.P. et son nom d'affichage.

Si l'outil jstatd est exécuté sur la machine hôte, les JVM qui s'exécutent sur la machine sont affichées comme éléments fils.

89.9.4. L'obtention d'informations

VisualVM permet d'obtenir des informations générales et sur l'activité de la mémoire et des threads.

89.9.4.1. La génération d'un thread dump

Il est possible d'utiliser VisualVM pour capturer des informations sur les threads dans un thread dump au moment où il est demandé. Un thread dump permet d'obtenir la stacktrace de tous les threads sans arrêter définitivement l'application.

Pour demander un thread dump, il y a deux actions possibles :

• utiliser l'option Thread Dump du menu contextuel de la JVM concernée
• cliquer sur le bouton Thread Dump de l'onglet Threads

Une fois le thread dump généré, un onglet est ajouté pour afficher son contenu ainsi qu'un élément fils de la JVM concernée dans l'arborescence.

Un thread dump est particulièrement utile pour savoir quels traitements sont exécutés par chaque thread.

89.9.4.2. La génération d'un heap dump

Il est possible d'utiliser VisualVM pour capturer des informations sur les objets contenus dans le tas (heap) de la JVM au moment de la demande.

Un heap dump est une image à un instant donné de tous les objets contenus dans le heap d'une JVM. Le parcours d'un heap dump permet de connaître les objets qui ont été créés dans le heap de la JVM.

VisualVM peut être utilisé pour créer un heap dump d'une JVM locale version 6 ou supérieures. Un heap dump créé avec VisualVM est temporaire et doit être explicitement sauvegardé en utilisant l'option Save as du menu contextuel. Si un heap dump n'est pas sauvegardé explicitement, il sera perdu lors de la fermeture de VisualVM.

Pour demander la génération d'un heap dump à VisualVM, il a deux possibilités :

• utiliser l'option "Heap Dump" du menu contextuel de la JVM concernée
• cliquer sur le bouton "Heap Dump" de l'onglet Monitor de la JVM concernée

La génération d'un heap dump crée une entrée dans l'arborescence fille de la JVM et ouvre un nouvel onglet qui va permettre de consulter les informations qu'il contient.

89.9.4.3. Le parcours d'un heap dump

VisualVM permet de parcourir le contenu d'un fichier heap dump et ainsi de voir les objets du tas. Ces fichiers heap dump peuvent être des fichiers .hprof ou des fichiers heap dump créés grâce à VisualVM.

Pour ouvrir un heap dump, il est possible :

• de double cliquer sur un heap dump affiché dans l'arborescence pour les heap dumps créés avec VisualVM
• d'utiliser le menu File/Load et de sélectionner un fichier .hprof

Chaque heap dump s'affiche dans son propre onglet pour la JVM concernée.

VisualVM permet de consulter le contenu d'un heap dump grâce à plusieurs vues :

• Summary : c'est la vue par défaut.
• Classes : permet d'obtenir le nombre d'instances et leur taille pour chaque classe
• Instances : permet d'afficher les instances d'une classe

La vue Summary affiche des informations sur le contenu du heap dump :

• un résumé du contenu
• l'environnement d'exécution
• les propriétés de la JVM
• les threads

La vue Classes permet d'obtenir pour chaque type le nombre d'instances dans le heap et la taille qu'elles y occupent.

Pour visualiser les instances d'une classe, il faut utiliser le menu contextuel « Show in Instances View »

Il est possible :

• de cliquer sur l'en-tête de chaque colonne pour modifier l'ordre de tri des informations.
• de limiter les classes affichées aux sous-classes de celle dont le menu contextuel « Show Only Subclasses » est utilisé.
• de filtrer les classes affichées. Pour cela, il faut saisir tout ou partie du nom de la classe, sélectionner au besoin le type de filtre à appliquer et cliquer sur le bouton vert à droite de la zone de saisie de texte.

Pour annuler le filtre, il faut cliquer sur le bouton rouge à droite de la zone de saisie de texte.

La vue Instances permet d'afficher la liste des instances d'une classe.

La sélection d'une instance permet d'afficher ses champs et ses références.

89.9.4.4. L'onglet Overview

L'onglet Overview affiche des informations générales sur la JVM et son environnement d'exécution :

• PID : l'identifiant du processus de la JVM dans le système
• Host : la machine sur laquelle la JVM s'exécute
• Main class : le nom pleinement qualifié de la classe principale
• Arguments : les arguments passés à la classe principale
• JVM : la version de la JVM
• Java Home : le chemin de la JVM
• JVM flags : les arguments passés à la JVM
• Heap dump on OOME : affiche si l'option Heap dump on OOME de la JVM est activée

C'est l'onglet qui est affiché par défaut lors de la connexion à une JVM.

L'onglet Saved Data affiche le nombre de fichiers créés avec VisualVM pour la JVM.

L'onglet JVM Arguments affiche les arguments fournis à la JVM.

L'onglet System properties affiche les propriétés de la JVM.

89.9.4.5. L'onglet Monitor

L'onglet Monitor affiche des informations en temps réel sur l'évolution de la charge CPU de la JVM, de la taille du Heap et de la PermGen, du nombre de classes chargées et de Threads dans la JVM.

L'utilisation de cet onglet implique uns légère surcharge sur l'utilisation de la JVM.

Les informations sont affichées sous la forme de graphiques en temps réel avec le temps en abscisse :

• CPU : affiche l'utilisation CPU de la JVM et l'utilisation de la CPU par le garbage collector
• Heap : affiche la taille du heap, celle utilisée et sa taille maximale. Le graphique affiche l'évolution de ces deux premières propriétés au cours du temps
• PermGen : affiche la taille de la permanent generation, la taille de la permgen et la taille maximale de la permgen. Le graphique affiche l'évolution de ces deux premières propriétés au cours du temps
• Classes : affiche le nombre total de classes chargées et déchargées ainsi que les classes partagées
• Threads : affiche le nombre de threads actifs et de démons

L'onglet Monitor permet de réaliser deux actions grâce à deux boutons :

• « Perform GC » : faire une demande d'exécution du ramasse-miettes à la JVM
• « Heap Dump » : demander la génération d'un heap dump

89.9.4.6. L'onglet Threads

L'onglet Threads permet de suivre l'activité des threads de la JVM.

L'onglet Timeline affiche en temps réel l'activité des threads en affichant leur état. Cette activité est obtenue grâce à JMX ou une JVM locale si sa version est supérieure ou égale à 6.

Il est possible de cliquer sur les boutons "Zoom in" et "Zoom out" pour modifier l'échelle de la ligne de temps. La liste déroulante permet de sélectionner les threads qui sont affichés : tous les threads, les threads actifs ou les threads terminés.

Il est possible de double-cliquer sur un thread pour basculer sur l'onglet Details.

La liste déroulante permet de sélectionner les threads qui sont affichés : les threads sélectionnés, tous les threads, les threads actifs ou les threads terminés.

Le sous-onglet Details permet d'obtenir l'heure de chaque changement de statut du thread.

L'onglet General affiche des statistiques sur les états du thread.

89.9.5. Le profilage d'une JVM

VisualVM intègre un profiler qui permet de fournir des informations pour analyser la performance et l'utilisation mémoire d'une application. VisualVM ne peut pas être utilisé pour se profiler lui-même ou pour profiler une JVM distante.

Pour profiler une application, il faut utiliser l'option Profile du menu contextuel de la JVM concernée qui affiche l'onglet Profiler.

L'onglet Profiler permet de démarrer et de stopper une session de profiling sur l'utilisation de la CPU ou de la mémoire d'une JVM locale.

Le profiling CPU permet de mesurer les performances des classes exécutées dans la JVM.

Le profiling mémoire permet d'analyser l'utilisation du heap.

Lors du lancement d'une session de profiling, VisualVM se connecte à la JVM et collecte les informations qui sont affichées dans la partie « Profiling results ».

Elle possède plusieurs boutons :

• Update Result Automatically : une fois activé, les informations sont rafraîchies automatiquement toutes les 2 secondes
• Update Result Now : permet de demander le rafraîchissement des informations
• Run Garbage Collection : demande à la JVM d'exécuter le ramasse-miettes
• Reset Collected Results : permet de réinitialiser les informations déjà collectées
• Take Snapshot : permet de prendre un snapshot des informations collectées. Le snapshot est affiché dans un onglet dédié
• Save Current View : permet de sauvegarder l'affichage courant sous la forme d'une image de type png.

Par défaut, aucune classe n'est instrumentée pour permettre la capture d'informations la concernant. Pour configurer la session de profiling, il faut cocher la case "Settings". La modification de la configuration ne peut se faire que si aucune session de profiling n'est en cours d'exécution.

L'onglet CPU settings permet de configurer les classes à instrumenter. La zone de texte "Start profiling from classes" permet de préciser les classes qui serviront de points d'entrées pour le profiling.

En utilisant le caractère * et selon le bouton radio sélectionné, il est possible de préciser le ou les packages des classes à profiler ("Profile only classes") ou au contraire, de celles qui ne le sont pas ("Dot not profile classes").

L'onglet Memory settings permet de configurer le profiling de la mémoire.

Un bouton radio permet de profiler uniquement les objets créés ou les objets créés et l'activité du ramasse-miettes.

Un tableau affiche pour chaque classe : le nombre d'instances créées, la taille occupée par les objets depuis le début du profiling ainsi que le pourcentage correspondant.

La zone de texte en dessous du tableau permet d'appliquer un filtre sur le nom des classes affichées.

89.9.6. La création d'un snapshot

VisualVM permet de créer un snapshot qui va contenir les informations collectées de la JVM. Il est possible de sauvegarder un snapshot pour le réouvrir ultérieurement.

VisualVM peut créer deux types de snapshots :

• Profiler snapshot : le snapshot contient les informations capturées pendant une session de profiling sur l'utilisation de la CPU ou de la mémoire. Ce type de snapshot ne peut être créé que lorsqu'une session de profiling est en cours.
• Application snaphot : le snapshot contient les heap dumps et les thread dumps qui ont été créés

89.9.7. Le plugin VisualGC

VisualGC est un plugin pour VisualVM qui permet de représenter graphiquement l'activité du ramasse-miettes et de certaines activités de la JVM (PermGen, chargement de classes, compilation JIT).

Une représentation graphique affiche l'occupation des espaces mémoires des différentes générations : young generation (Eden, survivor 1 et 2 (S0 et S1)), old generation et PermGen.

Le panneau Compile Time indique le nombre de tâches de compilation exécutées et le temps consacré à cette compilation du bytecode en code natif depuis le lancement de la JVM. La hauteur du graphe n'a pas d'échelle : elle indique simplement une activité de compilation courte ou longue.

Le panneau Class Loader Time indique le nombre de classes chargées, déchargées et le temps passé à ces tâches depuis le démarrage de la JVM. La hauteur du graphe n'a pas d'échelle : il représente l'activité de chargement et de déchargement de classes par la JVM.

Le panneau GC Time indique le nombre d'opérations de récupérations de mémoire réalisées, le temps consacré à ces tâches et la raison de l'exécution de la dernière récupération. La hauteur du graphe n'a pas d'échelle : il représente l'activité du ramasse-miettes.

Le panneau Eden Space indique : la taille maximale de l'espace et l'occupation actuelle entre parenthèses, la taille des objets qu'il contient, le nombre de récupérations de mémoire effectuées dans cet espace et le temps que cela a nécessité depuis le lancement de la JVM. La hauteur du graphe correspond à la taille maximale de l'espace : il représente l'occupation de l'espace Eden.

Les panneaux Survivor 0 et Survivor 1 indiquent la taille maximale de l'espace et l'occupation actuelle entre parenthèses, et la taille des objets qu'il contient. La hauteur du graphe correspond à la taille maximale de l'espace : il représente l'occupation de l'espace Survivor concerné.

Le panneau Old Gen indique la taille maximale de l'espace et l'occupation actuelle entre parenthèses, la taille des objets qu'il contient, le nombre de récupérations de mémoire effectuées dans cet espace (full garbage) et le temps que cela à nécessité depuis le lancement de la JVM. La hauteur du graphe correspond à la taille maximale de l'espace : il représente l'occupation de l'espace Old.

Le panneau PermGen indique la taille maximale de l'espace et l'occupation actuelle entre parenthèses ainsi que la taille des objets qu'il contient. La hauteur du graphe correspond à la taille courante de l'espace : il représente l'occupation de l'espace PermGen.

Le panneau Histogram affiche une répartition de l'âge des objets actifs dans l'espace Survivor après la dernière exécution du ramasse-miettes dans cet espace et les paramètres utilisés pour réaliser la promotion des objets.