Fichiers d'archives java - *.jar

Chapitres traités    Originaux Analyse de l'applet Compression des fichiers Création d'une archive par l'intermédiare de l'utilitaire jar Utilisation de l'archive dans la page Web Packaging des applications Les ressources Vérouiller un paquetage

Les fichiers d'archive Java (fichiers JAR) sont les valises Java. ils constituent le moyen standard et portable d'empaqueter toutes les parties de votre application Java dans un ensemble compact à distribuer ou à installer. Vous pouvez tout mettre dans un fichier JAR : des fichiers de classe Java, des objets sérialisés, des fichiers de données, des images des sons , etc.

Un fichier JAR peut même contenir plusieurs signatures numériques attestant de l'intégrité et de l'authenticité des données. Une signature peut être attachée au fichier global ou à ses éléments individuels.

La machine virtuelle Java reconnaît les fichiers JAR et sait charger des fichiers de classe directement d'une archive. Il est ainsi possible d'empaqueter les classes de votre application dans un fichier JAR et de les placer dans votre répertoire de travail. Vous pouvez faire de même pour les applets, en indiquant le fichier JAR dans l'attribut archive de la balise HTML <applet>.

Il est possible de récupérer d'autres types de fichiers (données, images, etc.) contenus dans votre fichier JAR. En outre, votre code n'a pas besoin de savoir si une ressource est un fichier ou un élément d'une archive JAR.

Qu'un fichier de classe ou de données soit un élément d'un fichier JAR, un fichier individuel du chemin des classes, ou une applet sur un serveur distant, vous pourrez toujours y faire référence de manière standard, et laisser le chargeur de classes de Java trouver son emplacement.

Originaux

Afin de bien montrer l'intérêt de l'archivage de vos différents développements, je vous propose de le visualiser au travers d'une étude traduite d'une part sous la forme d'une application graphique, et d'autre part sous la forme d'une page Web, c'est-à-dire au travers d'une applet Java.

Cette étude comporte plusieurs classes ainsi qu'une image à faire afficher en papier peint. Par ailleurs le texte qui s'affiche est sensible au mouvement du curseur de la souris, puisque lorsque ce dernier se déplace sur le texte, celui-ci change alors de couleur. Le texte reprend ensuite sa couleur d'origine lorsque le curseur de la souris s'en va en dehors de la zone de texte.

Application fenêtrée

Voici donc le premier exemple qui correspond à notre application Java, avec le résultat obtenu suivi de l'architecture de notre arborescence ainsi que le codage de l'ensemble de ces classes écrit dans le même fichier "Principal.java".

package texte;

import java.awt.event.*;
import java.io.*;
import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;

public class Principal extends JFrame {   
   public Principal() throws IOException {
      this.setDefaultCloseOperation(this.EXIT_ON_CLOSE); 
      this.setSize(350, 250);
      this.setTitle("C'est chouette..."); 
     PanneauImage panneau = new PanneauImage(ImageIO.read(new File("chouette.jpg")));
      this.getContentPane().add(panneau);
   }
   public static void main(String[] args) throws IOException {
      new Principal().setVisible(true);
   }
}

class PanneauImage extends JPanel {
  private Image image;
  private Texte invite = new Texte("C'est chouette...");
  public PanneauImage(Image image) { 
     this.image = image;
     invite.setCouleurSurvol(Color.red);
     invite.setCouleurNormale(Color.blue);
     this.add(invite);
  }
  protected void paintComponent(Graphics g) {
    g.drawImage(image, 0, 0, this);
  }
}

class Texte extends JLabel implements MouseListener {
   private Color couleurSurvol, couleurNormale;
   public Texte(String invite) {
      super(invite);
      this.setFont(new Font("Verdana", Font.BOLD, 28));
      this.addMouseListener(this);
   }   
   public void setCouleurSurvol(Color couleur) {
      couleurSurvol = couleur;
   }
   public void setCouleurNormale(Color couleur) {
      this.setForeground(couleurNormale = couleur);
   }
   public void mouseEntered(MouseEvent e) {
      this.setForeground(couleurSurvol);
   }
   public void mouseExited(MouseEvent e) {
      this.setForeground(couleurNormale);
   }   
   public void mouseClicked(MouseEvent e) {}
   public void mousePressed(MouseEvent e) {}
   public void mouseReleased(MouseEvent e) {}   
}

Applet Java

<target name="-post-compile">
	<!-- Empty placeholder ... -->
	<!-- You can override this target ... -->
</target>

<target name="-post-compile">
  <move todir="${build.web.dir}">
    <fileset dir="${build.classes.dir}" />
  </move>
</target>

<move todir="premier">
  <fileset dir="deuxième" />
</move>

<copy todir="../../jars">
  <fileset dir="tmp" includes="**/*.class" />
</move>

<target name="-post-compile">
 <jar jarfile="${build.web.dir}/texte.jar">
    <fileset dir="${build.classes.dir}" />
    <fileset dir="${build.web.dir}"
                  includes="chouette.jpg" />
 </jar>
</target>

Cette fois-ci, nous avons une application Web. Toute la partie IHM se trouve donc dans une applet.

package texte;

import java.awt.event.*;
import java.io.*;
import java.net.*;
import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;

public class TexteApplet extends javax.swing.JApplet { 
   public void init() {
      this.setSize(350, 250);      
      PanneauImage panneau = new PanneauImage(getImage(getDocumentBase(), "chouette.jpg"));
      this.getContentPane().add(panneau);      
   }   
}

class PanneauImage extends JPanel {
  private Image image;
  private Texte invite = new Texte("C'est chouette...");
  public PanneauImage(Image image) { 
     this.image = image;
     invite.setCouleurSurvol(Color.red);
     invite.setCouleurNormale(Color.blue);
     this.add(invite);
  }
  protected void paintComponent(Graphics g) {
    g.drawImage(image, 0, 0, this);
  }
}

class Texte extends JLabel implements MouseListener {
   private Color couleurSurvol, couleurNormale;
   public Texte(String invite) {
      super(invite);
      this.setFont(new Font("Verdana", Font.BOLD, 28));
      this.addMouseListener(this);
   }   
   public void setCouleurSurvol(Color couleur) {
      couleurSurvol = couleur;
   }
   public void setCouleurNormale(Color couleur) {
      this.setForeground(couleurNormale = couleur);
   }
   public void mouseEntered(MouseEvent e) {
      this.setForeground(couleurSurvol);
   }
   public void mouseExited(MouseEvent e) {
      this.setForeground(couleurNormale);
   }   
   public void mouseClicked(MouseEvent e) {}
   public void mousePressed(MouseEvent e) {}
   public void mouseReleased(MouseEvent e) {}   
}

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>
  <head>
    <title>C'est chouette...</title>
  </head>
  <body>
      <h2 align="center">C'est chouette...</h2>
      <hr />
      <div align="center">
         <applet code="texte.TexteApplet.class" width="350" height="250"></applet>
      </div>
      
  </body>
</html>

Analyse de l'applet

L'applet TexteApplet de cette étude utilise trois classes : l'applet elle-même TexteApplet, PanneauImage et Texte. Nous savons que la balise <applet> fait référence au fichier de classes qui contient la classe applet :

<applet code="texte.TexteApplet.class" width="350" height="250"></applet>

Lorsque le navigateur lit cette ligne, il se connecte au serveur Web et recherche le fichier "TexteApplet.class". Le chargeur de classes de la machine virtuelle du navigateur charge la classe TexteApplet de ce fichier. Lors du processus de chargement, le chargeur de classes doit résoudre les références aux autres classes utilisées par cette classe. Il sait alors qu'il a éventuellement besoin de plus d'une classe pour exécuter l'applet et, en ce cas, se connecte de nouveau au serveur Web, un pour chaque fichier de classe. Le chargement d'une applet peut alors nécessiter plusieurs minutes pour peu que le réseau soit lent.

Il faut bien comprendre que ce temps de chargement n'est pas dû à la taille des fichiers classes, relativement petits, mais à la surcharge considérable découlant d'une connexion avec un serveur Web.

Java supporte donc maintenant une méthode améliorée pour le chargement de fichiers de classes : elle permet de rassembler tous les fichiers de classes nécessaires en un seul fichier. Ce fichier peut alors être chargé grâce à une requête HTTP unique vers ce serveur. Ces fichiers sont appelés fichiers JAR (acronyme de "Java Archive"). Ils peuvent contenir à la fois des fichiers de classes et d'autres types de fichiers comme des fichiers images et audios. Les fichiers JAR peuvent également être compressés au format de compression classique ZIP, ce qui réduit le temps de téléchargement.

Compression des fichiers

Il est possible de compresser des éléments de fichier JAR avec le standard de compression ZIP. Les fichiers JAR sont totalement compatibles avec les archives ZIP bien connues des utilisateurs Windows.

La compression accélère le transfert de classes sur un réseau. Un rapide survol de la distribution SDK montre qu'un fichier de classe classique se trouve réduit d'environ 40% après compression. Les fichiers texte de type HTML ou ASCII sont réduits de plus de 75%, donc à un quart de leur taille d'origine ! Par contre, les fichiers images ne gagnent rien à être compressés ; les formats d'image courants possèdent une compression interne.

En termes d'envoi sur le réseau, la compression n'est pas le seul avantage d'un fichier JAR. Placer toutes les classes dans un seul fichier JAR les rend téléchargeables en une seule transaction. Supprimer le coût des requêtes HTTP est une réelle économie, dans la mesure où un fichier de classe est généralement de petite taille, et qu'une applet en utilise beaucoup. D'un autre côté, sur une connexion à faible débit, le temps de démarrage peut augmenter si un gros fichier JAR doit être descendu avant que l'applet ne soit lancée.

Création d'une archive par l'intermédiare de l'utilitaire jar

L'utilitaire jar livré avec le SDK permet de créer et de lire les fichiers JAR. Dans l'installation par défaut, cet outil se trouve dans le répertoire <jdk/bin>. Son interface utilisateur ressemble à la commande tar (tape archive) du monde d'UNIX.

La commande jar doit se conformer à la syntaxe suivante :

jar options Fichier1 Fichier2 ...

Le tableau suivant liste les options possibles avec la commande jar. Elles sont tout-à-fait analogues aux options de la commande tar utilisée par le système UNIX.

La commande la plus courante pour créer un nouveau fichier JAR est la suivante :

jar cf FichierJAR Fichier1 Fichier2 ...

Dans l'exemple de notre applet voici ce que nous pouvons écrire :

jar cvf texte.jar texte/*.class chouette.jpg

Nous stipulons ainsi que nous désirons créer une archive texte.jar qui sera composée de l'ensemble des fichiers *.class qui se trouve dans le paquetage texte avec en plus le fichier image chouette.jpg. Ci-dessous, nous retrouvons le même exemple suivi d'une consultation de l'archive afin de contrôler son contenu. Vous remarquez au passage la fabrication automatique du fichier MANIFEST.MF dans le répertoire <META-INF>.

Les options que nous avons souvent besoin sont les lettres c, t et x qui indiquent respectivement la création d'une archive, la liste du contenu et l'extraction des fichiers. f signifie que l'argument suivant sera le nom du fichier JAR sur lequel opérer. v (verbose) demande à jar d'être plus bavard lorsqu'il affiche des renseignements sur les fichiers : tailles heures de modification, ratios de compression.

Les éléments suivants de la ligne de commande (c'est-à-dire, tout ce qui est différent des lettres indiquant à jar ce qu'il doit faire sur lequel opérer) sont considérés comme des éléments d'archive. Si vous créez une archive, les fichiers et les répertoires indiqués sont archivés. Lors d'une extraction, seuls les noms des fichiers indiqués sont extraits (si vous n'indiquez aucun nom de fichier, tout le contenu de l'archive est extrait).

Utilisation de l'archive dans la page Web

Une fois le fichier JAR créé, il faudra y faire référence dans la balise <applet> de la façon suivante :

<div align="center">
         <applet code="texte.TexteApplet.class" 
                       archive="texte.jar"
                       width="350" 
                       height="250"></applet>
</div>

L'attribut code doit toujours être présent. Il indique au navigateur le nom de l'applet. archive désigne tout simplement une source d'emplacement possible de la classe applet et des autres fichiers. Chaque fois qu'un fichier de classes, d'images ou de son est requis, un navigateur acceptant les fichiers JAR commence par rechercher ces fichiers JAR dans la liste archive. Si le ou les fichiers ne sont pas trouvés dans l'archive, ils seront alors recherchés sur le serveur WEB.

Packaging des applications

Nous quittons maintenant le monde des applets et passons au packaging des applications Java. Lorsque vous livrez une application, vous ne souhaitez généralement pas déployer tout un ensemble de fichiers classe. Comme pour les applets, vous devez packager les fichiers de classe ainsi que d'autres ressources exigées par votre programme dans un fichier JAR. Lorsque le programme est packagé, il peut être chargé par une commande simple ou, si le système d'exploitaiton est correctement configuré, par un double-clic sur le fichier JAR.

Le manifest

Vous pouvez packager des programmes d'application, des composants de programme (parfois appelés des JavaBeans) et des bibiothèques de code dans des fichiers JAR. Par exemple, la bibliothèque du runtime de la JDK est contenue dans un très grand fichier rt.jar.

Un fichier JAR contient des classes, des images et d'autres ressources, ainsi qu'un fichier manifeste qui décrit les caractéristiques particulières de l'archive. Le fichier manifest est appelé MANIFEST.MF et se trouve dans un sous-répertoire <META-INF> du fichier JAR.

Effectivement, la commande jar ajoute automatiquement un répertoire appelé <META-INF> à notre archive. Le répertoire <META-INF> gère les fichiers décrivant le contenu du fichier JAR. Il contient toujours au moins le fichier MANIFEST.MF. Ce fichier contient une liste des noms de fichiers contenus dans l'archive et, pour chacun d'eux, un ensemble d'attributs pouvant être définis au niveau utilisateur.

1. Le manifest minimum légal est un peu terne :

   Manifest-version: 1.0

2. Des manifestes complexes peuvent posséder d'avantage de données. Celles-ci sont regroupées en sections. La première s'appelle Main. Elle s'applique à la totalité du fichier JAR. D'autres données peuvent spécifier les propriétés des entités nommées telles que des fichiers individuels, les packages ou les URL. Ces données doivent commencer par une entrée Name. Les sections sont séparées par des lignes blanches :

   Manifest-version: 1.0
   Lignes décrivant cette archive
   
   Name: Texte.class
   Lignes décrivant ce fichier
   
   Name: texte
   Lignes décrivant ce paquetage

3. Pour créer le manifeste, placez les lignes que vous voulez éditer au manifest dans un fichier texte. Puis exécutez :

   jar cfm FichierJAR FichierManifest FichierClasse ...

4. Par exemple, pour créer un nouveau fichier JAR avec un manifeste, exécutez :

   jar cfm texte.jar manifest.mf texte/*.class chouette.jpg

5. Pour actualiser un fichier JAR existant, placez les ajouts dans un fichier texte et utilisez une commande telle que :

   jar ufm texte.jar manifest-additions.mf

Rendre un fichier JAR exécutable

En plus des attributs, quelques valeurs spéciales peuvent être ajoutées au manifeste. L'une d'elles, Main-Class, vous permet de spécifier la classe contenant la méthode principale main() pour une application contenue dans le fichier JAR :

Main-Class: texte.Principal

Dans certaines configurations du système d'exploitation, vous pouvez lancer l'application en double-cliquant sur l'icône du fichier Jar. Voici les comportements pour les divers systèmes d'exploitation :

1. Sous Windows, l'installateur d'exécution Java crée une association de fichier pour l'extension ".jar" qui lance le fichier avec la commande javaw -jar (à la différence de la commande java, la commande javaw n'ouvre pas de fenêtre shell).
2. Sous Solaris, le système d'exploitation reconnaît le "nombre magique" d'un fichier Jar et le lance avec la commande java -jar.
3. Sous Mac OS X, le système d'exploitation reconnaît l'extension de fichier ".jar" et exécute le programme Java lorsque vous double-cliquez sur un fichier JAR.

Toutefois, un programme Java d'un fichier Jar ne possède pas le même aspect qu'une application native. Sous Windows, vous pouvez employer des utilitaires d'enveloppe tiers qui transforment les fichiers JAR en exécutables Windows. Une enveloppe est un programme Windows possédant l'extension ".exe" bien connue qui localise et lance la machine virtuelle Java (JVM) ou indique à l'utilisateur ce qu'il faut faire lorsque nous ne trouvons aucune JVM.

Sous Macintosh, la situation est un peu plus simple. L'utilitaire de paquetage d'application MRJAppBuilder permet de transformer un fichier JAR en une application Mac de premier niveau.

Récapitulation

Pour packager une application, réunissez tous les fichiers nécessaires à votre application dans un fichier JAR et ajoutez-y un manifeste spécifiant la classe principale de votre programme - celle qui doit être invoquée en premier par le lanceur de programme Java.

La dernière ligne du manifeste doir se terminer par un caractère de nouvelle ligne, faute de quoi le manifeste ne pourra être lu correctement. Produire un fichier texte contenant simplement la ligne Main-Class sans terminaison est une erreur commune.

En reprenant, notre application du début, voici donc en image toute la procédure à suivre :

Voici maintenant le contenu de notre archive texte.jar :

Ajouter une autre archive (bibliothèque non connue de la JVM) à votre projet

Il arrive souvent que nous ayons besoin d'utiliser une autre bibliothèque en même temps que l'archive relative à votre projet. Pour que cette bibliothèque soit accessible par votre projet, il est juste nécessaire de préciser où elle se situe au moyen de l'attribut Class-Path: .

Prenons par exemple un projet qui est archivé sous le nom de <StockerPhoto.jar>. Ce projet, pour fonctionner correctement, doit impérativement disposer de la bibliothèque <metadata-extractor-2.3.1.jar> qui se trouve dans le répertoire <lib>. L'organisation vous est montrée ci-contre. Voici donc ce que devra comporter le manifest de <StockerPhotos.jar> :

Manifest-Version: 1.0
Ant-Version: Apache Ant 1.6.5
Created-By: 1.6.0-b105 (Sun Microsystems Inc.)
Main-Class: Stocker
Class-Path: lib/metadata-extractor-2.3.1.jar
X-COMMENT: Main-Class will be added automatically by build

Les ressources

Il est assez fréquent, à terme, d'avoir besoin de changer le titre d'une fenêtre, de changer un ensemble de messages ou tout simplement de préférer une autre image de fond de celle prévue initialement. Nous pouvons avoir deux approches pour réaliser ces changements. Soit nous changeons dans le code source les références à ces différents éléments ce qui nécessite, bien entendu, de tout recompiler. Ou alors nous plaçons ces éléments dans des fichiers séparés afin de proposer les changements à l'extérieur du programme suivant le désir de l'utilisateur à l'aide d'un tout petit éditeur de texte. L'application se charge ensuite de lire le contenu de ces fichiers afin de configurer correctement les objets requis. Lorsque vous placez des valeurs à l'extérieur de votre programme, ces valeurs sont considérées comme des ressources.

En reprenant l'exemple de notre application, nous pourrions avoir comme type de ressources, le titre de la fenêtre, le message d'invite, ainsi que l'image de fond :

Ainsi, les classes employées à la fois dans les applets et les applications utilisent généralement des fichiers de données ou de configuration associés tels que :

1. des fichiers d'images et de son ;
2. des fichiers de texte contenant les messages et les libellés des boutons ;
3. des fichiers de données binaires, par exemple pour indiquer la disposition d'une carte ;
4. des fichiers contenant l'ensemble des items des menus afin de prendre en compte la langue du pays.

En Java, un fichier associé de ce type est appelée une ressource.
.

Récupérer les valeurs des ressources

Où devons nous placer ces fichiers ressources ? Bien sûr, il serait pratique de les placer au même endroit que les autres programmes, par exemple dans un fichier JAR.

Le chargeur de classe sait comment parcourir chacun des emplacements possibles jusqu'à retrouver le fichier de classes. Toutefois, dans notre cas, nous devons répéter le processus de recherche manuellement pour localiser les fichiers de ressources associés. La fonctionnalité de chargement de ressource automatise cette tâche.

Nous suivrons donc les étapes suivantes pour charger une ressource :

1. Charger l'objet Class pour la classe possédant une ressource, par exemple Principal.class, ou si nous somme dans l'objet représentant la dite classe this.getClass().
2. Appeler la méthode getRessource() ou la méthode getRessourceAsStream() suivant que vous désirez obtenir le fichier ressource en tant qu'URL ou directement les valeurs de ce fichier au travers d'un flux adapté. Cette deuxième méthode est souvent préférable.
3. Si la ressource est un fichier image ou audio, la lire directement à l'aides des méthodes getImage() ou getAudioClip() pour les applets, et pour l'image passer par la classe ImageIO si vous êtes sur une application.

Le chargeur de classes mémorise l'emplacement où il a chargé la classe ; il peut alors rechercher dans cet emplacement la ressource associée.
.

Par exemple, vous pouvez utiliser les instructions suivantes pour créer l'icône de l'application à partir du fichier image "icône.gif" en suivant cette procédure :

URL url = Principal.class.getRessource("icône.gif");
ImageIcon icône = new ImageIcon(url);

Cela revient à rechercher le fichier "icône.gif" au même endroit que celui où vous avez trouvé Principal.class.

Pour lire un fichier texte "titre.txt" représentant le titre de votre application, vous pouvez, par exemple, utiliser les instructions suivantes :

InputStream flux = Principal.class.getRessourceAsStream("titre.txt");

Pour lire ensuite à partir de ce flux, vous devez prendre ensuite un flux de plus niveau afin d'adapter le contenu au type requis. Ici, nous devons récupérer un texte, il faudra donc prendre un flux capable de retrouver ce texte. Pour une entrée, nous avons besoin de la classe Scanner.

Scanner titre = new Scanner(flux);
this.setTitle(titre.nextLine());

Structuration de vos ressources

Il est possible de placer vos fichiers ressources dans un répertoire particulier afin d'éviter de les mélanger avec les fichiers de classes. Vous pouvez même hiérarchiser les noms des ressources. Par exemple, nous pouvons placer toutes nos ressources dans un répertoire appelé justement <ressources>. La localisation se fera alors de la façon suivante :

ressources/titre.txt

Ce nom de ressource relatif est interprété à partir du package de la classe chargeant la ressource. Remarquez l'utilisation obligatoire du séparateur /, quel que soit le séparateur de répertoire du système d'exploitation sur lequel se trouvent finalement les fichiers de ressources. Ainsi, sous Windows, le chargeur de ressources convertit automatiquement / en séparateur \.

Le dispositif de chargement de ressources se limite à l'automatisation du chargement des fichiers. Il n'existe pas de méthodes standard pour interpréter le contenu d'un fichier de ressources. Chaque programme doit interpréter à sa façon le contenu de ses fichiers de ressources.

Codage de l'application en tenant compte des ressources

A titre d'exemple, voici le codage correspondant au ressources données par la structure ci-dessous :

package texte;

import java.awt.event.*;
import java.io.*;
import java.util.Scanner;
import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;

public class Principal extends JFrame {   
   public Principal() throws IOException {
      this.setDefaultCloseOperation(this.EXIT_ON_CLOSE); 
      this.setSize(350, 250);
      Scanner titre = new Scanner(this.getClass().getResourceAsStream("ressources/titre.txt"));
      this.setTitle(titre.nextLine()); 
      Image image = ImageIO.read(this.getClass().getResource("ressources/chouette.jpg"));
      PanneauImage panneau = new PanneauImage(image);
      this.getContentPane().add(panneau);
   }
   public static void main(String[] args) throws IOException {
      new Principal().setVisible(true);
   }
}

class PanneauImage extends JPanel {
  private Image image;
  private Texte invite = new Texte("C'est chouette...");
  public PanneauImage(Image image) {
     Scanner message = new Scanner(this.getClass().getResourceAsStream("ressources/message.txt"));
     invite = new Texte(message.nextLine());
     this.image = image;
     invite.setCouleurSurvol(Color.red);
     invite.setCouleurNormale(Color.blue);
     this.add(invite);
  }
  protected void paintComponent(Graphics g) {
    g.drawImage(image, 0, 0, this);
  }
}

class Texte extends JLabel implements MouseListener {
   private Color couleurSurvol, couleurNormale;
   public Texte(String invite) {
      super(invite);
      this.setFont(new Font("Verdana", Font.BOLD, 28));
      this.addMouseListener(this);
   }   
   public void setCouleurSurvol(Color couleur) {
      couleurSurvol = couleur;
   }
   public void setCouleurNormale(Color couleur) {
      this.setForeground(couleurNormale = couleur);
   }
   public void mouseEntered(MouseEvent e) {
      this.setForeground(couleurSurvol);
   }
   public void mouseExited(MouseEvent e) {
      this.setForeground(couleurNormale);
   }   
   public void mouseClicked(MouseEvent e) {}
   public void mousePressed(MouseEvent e) {}
   public void mouseReleased(MouseEvent e) {}   
}    

Fabrication de l'archive afin d'intégrer ces ressources

Nous commençons a avoir pas mal de fichiers, et du coup, il est largement souhaitable de packager la totalité de ces éléments dans une archive. Vous avez ci-dessous en images, l'ensemble de la procédure à suivre :

Vérouiller un paquetage

Nous pouvons vérouiller (seal) un paquetage en langage Java pour empêcher d'autres classes Java de s'installer. Un paquetage doit être vérouillé si vous utilisez des classes, des méthodes et des attributs visibles pour le paquetage dans votre code. Sans cela, d'autres classes peuvent se placer dans le même paquetage et ainsi obtenir un accès aux fonctionnalités qui lui sont visibles.

Par exemple, si vous vérouillez la paquetage texte, aucune classe extérieure ne peut être définie par l'instruction :

package texte;

public class UneClasseQuelconque {
...
}

Mise en place du vérouillage

Pour ce faire, déposez toutes les classes du paquetage dans un fichier JAR. Par défaut, les paquetages d'un fichier JAR ne sont pas vérouillés.

1. Vous pouvez modifier cela en écrivant la ligne suivante dans la section principale du manifeste :

   Sealed: true

2. Pour chaque paquetage, vous pouvez spécifier si vous désirez qu'il soit vérouillé ou non, en ajoutant une section supplémentaire au manifeste du fichier JAR :

   Name: org/manu/util
   Sealed: true
   
   Name: org/manu/texte
   Sealed: true

3. Pour verrouiller un paquetage, créer un fichier texte avec les instruction du fichier texte. Puis lancez la commande jar de la manière habituelle :

   jar cfm archive.jar manifest.mf fichiers à ajouter