Fichier d`archive Java - JAR - programmer en java, programme java

Fichiers d'archives java - *.jar
Chapitres traités
Originaux
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".
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) {

Ant dans NetBeans
NetBeans est un environnement de
développement intéressant puisqu'il dispose
d'un certain nombre d'outils déjà intégré
sans faire appel à des plugins particuliers.
Surtout, il s'agit d'un IDE gratuit qui plus est
offre de très nombreuses fonctionnalités
dans le monde de Java.
Il propose notamment l'outil Ant qui est
l'équivalent du makefile dans le monde du
langage C++.
Les processus de build est conduit dans Ant
par l'intermédiaire de fichiers XML, dans
lequel les projets, les dépendances et les
phases de travail sont définis sous forme de
tâches. Dans le cas le plus simple, Ant
effectue la compilation d'arborescences de
packages avec du code source Java et
l'exécution des classes. Du fait qu'avec Ant,
on peut faire appel aux systèmes
d'exploitation, il est également possible de
piloter les tâches (task) du processus build
considérablement plus importantes : la
palette des tâches s'étend de la copie du
code source depuis des systèmes de contrôle
de version tels que CVS ou d'un
environnement de développement à la
création de fichiers jar, war, ear, et pour ce
faire, elle s'appuie sur un ensemble de
tâches prédéfinies.
Dans le cas de NetBeans, vous avez deux
fichiers XML qui traitent du processus de
build : le fichier standard build.xml qui fait
appel à un autre fichier de description build-
impl.xml. C'est à l'intérieur de ce dernier que
sont décrites toutes les tâches relatives à
l'ensemble de construction d'un projet,
comme la compilation, la fabrication des
répertoires, l'exécution éventuelle, etc.
Tout est déjà fait dans NetBeans sauf qu'il
est possible de proposer de nouvelles tâches
ou de modifier celles qui sont déjà décrites
pour proposer d'autres alternatives.
Nous allons justement modifier le processus
de fabrication afin de l'adapter à notre
contexte. En effet, par défaut, lorsque nous
compilons des applets, les fichiers <*.class>
correspondant sont placés automatiquement
dans la zone privée de l'application Web,
c'est-à-dire dans le répertoire <WEB-INF/
classes> se qui empêche le bon
fonctionnement de l'application Web. Nous
allons, dans ce fichier de descriptions des
tâches, proposer un déplacement
automatique de ces fichiers <*.class> pour
les placer dans la zone publique, c'est-à-dire
au niveau de la page Web, et ceci après
chaque phase de compilation.
Dans ce fichier de configuration, des zones
ont été prévues afin de proposer d'autres
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
Cette fois-ci, nous avons une application Web. Toute la partie IHM se trouve donc dans une applet.
TexteApplet.java
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);
}

tâches personnalisées. Il en existe une
notamment qui est souvent très utile, il
s'agit de la zone "-post-compile" :
<target name="-post-compile">
<!-- Empty placeholder ... -->
<!-- You can override this target ... -->
</target>
Nous utiliserons donc la tâche <move> afin
d'obtenir notre déplacement :
<target name="-post-compile">
<move todir="${build.web.dir}">
<fileset dir="${build.classes.dir}" />
</move>
</target>
Tâche move
permet le déplacement ou le renommage de
fichiers ou un répertoire, ou pour les
renommer, nous pouvons utiliser l'élément
fileset, qui permet de manipuler des jeux de
fichiers. Voici les attributs possibles pour
cette tâche move :
file
Spécifie le fichier à déplacer.
Obligatoire, en l'absence de
spécification de fileset.
tofile
Spécifie le fichier de destination du
déplacement. tofile ou todir doit être
spécifié.
todir
Le répertoire vers lequel a lieu le
déplacement. tofile ou todir doit être
spécifié.
Voici quelques exemples d'utilisation :
<move file="faux.java" tofile="vrai.java" /
>
renomme un fichier.
<move file="echec.java" todir="jeu/" />
déplacement d'un fichier.
<move todir="premier">
<fileset dir="deuxième" />
</move>
renomme le répertoire.
tâche fileset
Les jeux de fichiers (marqueurs <fileset>)
sont utilisés pour spécifier des ensembles de
fichiers. Ces marqueurs sont normalement
des marqueurs internes à d'autres
marqueurs comme move,copy,delete, etc.
dir
Répertoire d'origine pour la définition
des fichiers.
includes
Liste des noms de fichiers, séparés par
des virgules. Si omis, tous les fichiers
sont ajoutés.
excludes
Liste de tous les fichiers à exclure.
tâche copy
Permet de copier plusieurs fichiers dans un
répertoire. Les fichiers du répertoire source
ne sont copiés que s'ils sont plus récents que
ceux du répertoire de destination ou
lorsqu'ils n'existent pas déjà dans le
répertoire de destination.
file
Le fichier à copier. Au cas où aucun
élément fileset n'est spécifié, file est un
attribut obligatoire.
tofile
Fichier de destination. Est utilisé si
l'attribut file est défini.
todir
Répertoire de destination. A spécifier
lors de la définition de l'attribut file ou
d'un jeu de fichiers.
}
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) {}
}
index.html
<!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 :

L'exemple suivant copie tous les fichiers
*.class dans un autre répertoire :
<copy todir="../../jars">
<fileset dir="tmp" includes="**/*.class"
/>
</move>
L'expression **/ englobe tous les sous-
répertoires.
tâche jar
Permet la création d'une archive jar.
jarfile
Nom du fichier jar à créer.
basedir
Répertoire source, à partir duquel les
fichiers à archiver dans le fichier jar
doivent être lus.
compress
est par défaut true ; autrement dit, le
fichier est compressé. false empêche la
compression.
includes
liste de fichiers ou de modèles séparés
par des virgules, qui doivent être
utilisés.
excludes
Liste des fichiers ou des modèles
séparés par des virgules, qui ne doivent
pas être utilisés.
manifest
Permet la spécification d'un fichier
manifest.
Voici comment créer l'archive correspondant
à l'applet de notre étude qui correspond à la
même archive fabriquée ci-contre :
<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>
Voici-ci dessous le résultat correspondant :
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.
Option Description
cCrée une nouvelle archive vide et y place des fichiers. Une liste de fichiers d'entrée et/ou de répertoires doit
être spécifiée comme argument final de la commande jar. Le nouveau fichier JAR possède un fichier META-
INF/MANIFEST.MF comme premier élément créé automatiquement. Si l'un des noms de fichier indiqué est un
répertoire, le programme jar le traite de façon récursive.
CChange temporairement le répertoire. Par exemple : jar cfv archive.jar -C classes *.class change en direction
du sous-répertoire classes pour ajouter les fichiers classes qui y sont stockés.
eCrée un point d'entrée dans le manifeste (Fichier JAR exécutables).
fIndique que l'archive correspond au fichier JAR dont le nom est spécifié sur la ligne de commande. Si cette
option n'est pas fournie, jar lit un fichier JAR à partir de l'entrée standard (lors de la création d'un fichier JAR)
et/ou envoie un fichier JAR vers la sortie standard (lors de l'extraction d'un fichier JAR).
iCrée un fichier d'indice (pour accélérer les recherches dans une grande archive).
mAjoute un fichier manifest au fichier JAR. Un manifeste est la description du contenu et de l'origine de
l'archive. Toute archive possède un manifest par défaut, mais vous pouvez en fournir un spécial si vous
souhaitez authentifier le contenu de l'archive.
MUtilisé avec la commande cet upour indiquer à la commande jar qu'elle ne doit pas créer de manifeste par
défaut.
tAffiche le contenu de l'archive
uMet à jour le contenu d'une archive. Tous les fichiers énumérés sur la ligne de commande sont ajoutés à
l'archive.
vSortie de messages très détaillés.
xExtrait le contenu d'une archive. Tous les fichiers et les répertoires énumérés sur la ligne de commande sont
extraits et créés dans le répertoire de travail courant. Si aucun fichier ou répertoire n'est spécifié, tous les
fichiers et les répertoires de l'archive sont extraits.
0Stockage sans compression ZIP. Attention : Cette option est le chiffre 0 et non pas la lettre O.
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,tet xqui indiquent respectivement la création d'une archive, la liste du contenu et l'extraction des
fichiers. fsignifie 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
Si vous ajoutez cela au manifeste de votre fichier JAR (en utilisant l'option mdécrite précédemment), vous pouvez exécuter directement votre application à partir d'un
fichier JAR :
java -jar texte.jar
Depuis la version Java SE 6.0, vous pouvez utiliser l'option ede la commande jar pour spécifier le point d'entrée de votre programme (la classe principale de
l'application qui doit être invoquée en premier par le lanceur de programme Java). Ainsi, vous n'avez plus besoin de vous préoccuper du manifeste. Tout ce fait
automatiquement :
jar cvfe texte.jar texte.Principal
Comme au-dessus, vous pouvez exécuter directement votre application à partir d'e la commande suivante :
java -jar texte.jar
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.