Comment travailler avec des archives compressées au format ZIP en Java ?

Ce HowTo a pour but de vous expliquer comment créer des archives de fichiers compressées au format ZIP et comment ensuite les ouvrir et extraire les fichiers contenus à l’intérieur. Ce n’est en aucun cas un cours théorique sur la compression de données en Java, il s’agit juste d’un tutoriel. De plus, vous devrez utiliser la documentation de Sun si vous désirez en savoir plus sur, par exemple, la manière d’afficher le nom de tous les fichiers d’une archive. Le cas échéant, écrivez moi à [email protected].

Nous allons dans un premier temps définir une archive ZIP:

Ce tutoriel comprendra 2 parties: pour commencer comment créer une archive ZIP, ensuite, comment en lire une et extraire ses fichiers.

Comment créer une archive ZIP en Java ?

// Créer des flux d'entrée de données, en indiquant comme paramètre le fichier à compresser.
FileInputStream fin1 = new FileInputStream("monPremierFichier.txt");
FileInputStream fin2 = new FileInputStream("monSecondFichier.xls");
FileInputStream fin3 = new FileInputStream("monTroisiemeFichier.doc");

// Créer un flux de sortie pour le fichier ZIP final.
FileOutputStream fout = new FileOutputStream("monFichier.zip");

// Mettre le flux en mémoire tampon (buffered), et le définir comme flux de compression ZIP
BufferedOutputStream bout = new BufferedOutputStream(fout);
ZipOutputStream zout = new ZipOutputStream(bout);

// Définir le taux de compression de l'archive, de 0 à 9 (Optionnel)
zout.setLevel(6);

// Associer un commentaire à l'archive (Optionnel)
zout.setComment("Ceci est un commentaire");

// Les fichiers ZIP sont des archives, elles stockent donc plusieurs fichiers, chaque fichier est contenu dans une "entrée", nous devons donc créer une nouvelle
// entrée pour chaque nouveau fichier de l'archive: (on pourra aussi utiliser ze1.getName() pour récupérer le nom de l'entrée, ceci est très utilse si vous voulez
// programmer un outil du type WinZip qui affiche la liste des fichiers d'une archive.)
ZipEntry ze1 = new ZipEntry("monPremierFichier.txt");
ZipEntry ze2 = new ZipEntry("monSecondFichier.xls");
ZipEntry ze3 = new ZipEntry("monTroisiemeFichier.doc");
zout.putNextEntry(ze1);
zout.putNextEntry(ze2);
zout.putNextEntry(ze3);

// Nous devons ensuite copier le flux d'entrée de fichier dans le flux de sortie compressé. Le code ci-dessous n'est pas commenté, ce n'est pas l'objet de ce tutoriel:
try
{
synchronized (fin)
{
synchronized (zout)
{
byte[] buffer = new byte[256];
while (true)
{
int bytesRead = in.read(buffer);
if (bytesRead == -1) break;
out.write(buffer, 0, bytesRead);
}
}
} }catch(Exception err) {;}

// Une fois les flux copiés nous devons fermer l'entrée
zout.closeEntry();

// Puis fermer les flux...
fin.close();
zout.close();

Comment décompresser les fichiers contenus dans une archive ZIP ?

// Créer un flux d'entrée contenant l'archive ZIP à décompresser
FileInputStream fin = new FileInputStream("monFichier.zip");

// Mettre ce flux en mémoire tampon
BufferedInputStream bis = new BufferedInputStream(fin);

// Identifier le flux tampon comme flux de compression ZIP
ZipInputStream zin = new ZipInputStream(bis);

// Définir un objet ZipEntry
ZipEntry ze = null;

// Tant que cet objet est différent de nul (tant qu'il y a des fichiers dans l'archive)...
while ((ze = zin.getNextEntry()) != null) {

// ... exécuter le code suivant:
// Créer un flux de sortie pour le fichier de l'entrée courante
FileOutputStream fout = new FileOutputStream(ze.getName());
// Copier les flux:
try
{
synchronized (zin)
{
synchronized (fout)
{
byte[] buffer = new byte[256];
while (true)
{
int bytesRead = in.read(buffer);
if (bytesRead == -1) break;
out.write(buffer, 0, bytesRead);
}
}
} }catch(Exception err) {;}

// Fermer l'entrée et le flux de sortie
zin.closeEntry();
fout.close();

// Terminer l'instruction while:
}

// Fermer le flux d'entrée
zin.close();

Tutoriel distribué pour le FAQ Java de Java-France www.java-france.com / www.jgflsoft.com
Réédité pour Valhalla GFBLOG.
Ecrit à Montpellier le 23 avril 2001

Cet article explique comment mettre en place un filtre de fichiers dans un JFileChooser, à partir de leur extension. En effet, cette fonction n’est pas implémentée de manière efficace par défaut, et il nous faudra créer notre propre classe pour un résultat convenable.
Nous allons ensuite créer un JFileChooser et lui assigner notre FileFilter appellé FiltreExtension.

Voici donc le code source de la classe commenté:

public class FiltreExtension extends javax.swing.filechooser.FileFilter
{
// 2 chaînes qui contiendront respectivementl’entension du fichier (de la forme "jpg", "txt", etc…) et la descritpion
// par exemple "Fichier JPEG" ou "Fichier Texte Brut".
String extension;
String description;

// Notre constructeur qui admet donc comme arguments l’extension souhaitée ainsi que la description que l’on lui associe
public FiltreExtension(String extension, String description)
{
// on n’a ainsi pas besoin (on ne doit pas) inclure le "." (point) dans le libellé de l’extension
if (extension.indexOf(‘.’) == -1)
extension = "." + extension;
// on assimile les Strings du départ (variables de classe) aux Strings fournis comme argument au constructeur (variableslocales)
this.extension = extension;
this.description = description;
}

public boolean accept(File fichier)
{
// vérifier si le le fichier finit avec l’extension que nous avons spécifié dans le constructeur, et, dans ce cas "accepter" de l’afficher
// dans la fenêtre du JFileChooser
if (fichier.getName().endsWith(extension))
return true;
// les répertoires aussi doivent êtreaffichés dans la fenêtre du JFileChooser
else if (fichier.isDirectory())
return true;
return false;
}

public String getDescription()
{
// la description du fichier, que l’on associe à son extension, on a un affichage du type: "Fichier JPEG (.jpg)"
return this.description + "(" + extension + ")";
}
}

Une fois ce code écrit dans un fichier du nom de "FiltreExtension.java", nous pouvons incorporer ce fichier dans nos projets Java et l’utiliser.
Pour l’utiliser nous devons créer un JFileChooser et lui assigner un nouveau FileFilter.
Voici la procédure:

1- Créons un JFileChooser pour commencer:

JFileChooser jfc = new JFileChooser();

2 - Définissons le répertoire courant ua répertoired’exécution du programme (optionnel):

jfc.setCurrentDirectory(new File("."));

3 - Assignons le FileFilter:

jfc.addChoosableFileFilter(new FiltreExtension("jpg", "Fichier JPEG"));
jfc.addChoosableFileFilter(new FiltreExtension("bmp", "Fichier Bitmap"));
jfc.addChoosableFileFilter(new FiltreExtension("gif", "Fichier GIF"));
jfc.addChoosableFileFilter(new FiltreExtension("png", "Fichier PNG"));

4 - récupérer le fichier que l’utilisateur a choisi:

int resultat = jfc.showOpenDialog(this);
if (resultat == JFileChooser.APPROVE_OPTION)
{
// code à exécuter comme par exemple:
File fichier;
fichier = jfc.getSelectedFile();
// suite du code…
}

Et voici ce que ça donne en action :

Tutoriel distribué pour le FAQ Java de Java-France www.java-france.com / www.jgflsoft.com
Réédité pour Valhalla GFBLOG.
Ecrit à Montpellier le 17 mars 2001

Cet article explique comment exécuter une commande système, c’est-à-dire comment faire pour que Java transmette au système d’exploitation une commande destinée normalement à une console (fenêtre MS-DOS sous Windows, Terminal sous UNIX, etc…).

Concrètement, si vous désirez exécuter dans l’ordre les instructions suivantes en ligne de commande:
- cd C:\Program Files\Microsoft Office\Office</span>
- Winword.exe
de manière à se placer dans le répertoire C:\Program Files\Microsoft Office\Office\ et à lancer Word 2000, le programme Java peut le faire pour vous. (Dans cet exemple, on peut se passer de la commande cd pour lancer Word, mais c’est aussi pour montrer que l’on ne se limite pas au lancement d’un programme, mais que l’on peut aussi exécuter d’autres commandes).

Ce genre de fonctions sous Java permet, entre autres, de lancer des logiciels externes (ici Word) depuis une application Java, ou de remplacer un script Bash.

Voici la procédure:
(NOTE: si vous connaissez un peu les systèmes d’exploitation et la programmation système, ne vous arrêtez pas aux explications minimales -et très imparfaites- concernant des concepts abstraits comme Runtime ou Processus…)

1 - Créer un objet String qui contient la commande exacte que vous taperiez si vous étiez sous la ligne de commande, par exemple:

// par exemple sous Windows
String command = "C:\Program Files\Microsoft Office\Office\Winword.exe";
// ou sous Linux 2.2.x
String command = "ipchains -P input DENY";

2 - Créer un objet Runtime et lui assigner le "runtime" (c-à-d l’environnement d’exécution, le noyau du système en quelque sorte) courant:

Runtime runtime = Runtime.getRuntime();

3 - Créer un nouveau processus, celui destiné à gérer notre commande:

Process process = null;

4 - Utiliser - assigner au processus - la fonction exec de la classe Runtime avec comme paramètre notre String , ceci est susceptible de générer des exceptions, nous devons donc les "attraper":

try
{
process = runtime.exec(command);
} catch(Exception err) {;}

Si tout se passe bien, la commande est exécutée, comme si vous l’aviez saisie dans une console.
NOTE: sous Unix, il faudra lancer le programme en tant que root pour que des commandes qui requièrent des privilèges élevés soient exécutées.

Tutoriel distribué pour le FAQ Java de Java-France www.java-france.com / www.jgflsoft.com
Réédité pour Valhalla GFBLOG.
Écrit à Montpellier le 17 mars 2001

Ce document a pour but de vous expliquer, comme le dit son titre, comment détecter et afficher tous les fichiers et sous-répertoires d’un répertoire racine. La solution proposée ici utilise la technique de récursivité. Il existe certainement d’autres manières de procéder mais celle-ci est assez élégante.

Un tout petit peu de théorie quand même: une méthode -ou fonction, routine…- dite récursive est fonction qui fait référence à elle-même dans son code, c’est-à-dire une fonction qui, une fois lancée, s’exécute en boucle tant qu’une certaine condition n’est pas remplie.

Si le code est mal programmé, que la condition ne permet jamais l’arrêt de la méthode, on aura une erreur du type StackOverflow, ce qui signifie que vous êtes en train de noyer complètement votre programme avec des calculs astronomiques.

Tous les étudiants en informatique on eu à passer par les célèbres Tours de Hanoï, programme qui doit être réalisé à l’aide de méthodes récursives. A titre indicatif (le but n’est quand même pas de vous faire crouler sous la théorie ;) quand on parle de solution récursive, il existe souvent une autre solution dite itérative (basée sur l’utilisation de boucles for, while, etc). Cette solution itérative est plus rapide à l’exécution, mais plus difficile à programmer.

Dans notre cas, nous voulons parcourir un répertoire (dorénavant appelé répertoire racine) et afficher son contenu, ceci ne nécessite pas de récursivité. Par contre, nous voulons en plus détecter tous les répertoires contenus dans ce répertoire racine, et ainsi de suite jusqu’à ce que toute l’arborescence soit "scannée" ; et c’est pour cela que nous avons besoin de méthodes récursives.

Passons au concret:

1 - Pour commencer, on doit créer une méthode, appelée ici recurseDirs(String répertoire):

public void recurseDirs(String répertoire)
{

2 - Nous devons spécifier un répertoire racine au programme. Pour cela nous allons créer un nouvel objet File, qui peut soit être un fichier proprement dit soit un répertoire (dans notre cas un répertoire). La classe File admet comme paramètre un String. Vous pouvez obtenir ce String de différente manière (en le spécifiant vous-même manuellement, en l’obtenant par l’intermédiaire d’un JFileChooser… ), ce n’est pas notre sujet, dans tous les cas vous devez le transmettre comme paramètre à la méthode pour pouvoir l’utiliser ici et pour pouvoir utiliser la récursivité plus loin.

File fichier = new File(repertoire);

3 - Nous allons créer une matrice (ou tableau) destiné à contenir toutes les entrées du répertoire:

String list[];

4 - Nous devons spécifier une condition: exécuter ce qui suit si et seulement si l’objet File est un répertoire (quand le scan est terminé, qu’il n’y a plus de nouveau répertoire à scanner, File ne satisfait plus la condition et on sort de la méthode).

if (fichier.isDirectory())
{

5 - Ensuite nous entrons toutes les entrées du répertoire racine dans la matrice créée plus haut, en utilisant la méthode list() de la classe File qui renvoie une matrice de String:

list = fichier.list();

6 - Nous entrons ici dans le coeur du code: une récursivité-itérative (si, si!). Nous créons une boucle for qui est exécutée autant de fois que le répertoire racine contient de documents. Au sein de cette boucle for est appelée notre méthode (c’est là que se trouve la récursivité), avec comme argument l’entrée numéro n de la boucle. Le caractère de séparation (separatorChar) de la classe File est nécessaire pour des questions de syntaxe du chemin du répertoire, nous n’avons pas à nous en soucier.

for (int i = 0; i < list.length ; i++)
{
recurseDirs(repertoire + File.separatorChar + list[i]);
}

7 - Nous pouvons maintenant manipuler les noms des fichiers et répertoires, par exemple les rediriger vers la sortie système:

System.out.println("->> " + repertoire);

Tutoriel distribué pour le FAQ Java de Java-France www.java-france.com / www.jgflsoft.com
Réédité pour Valhalla GFBLOG.
Écrit à Montpellier le 16 mars 2001

Ce document a pour but de vous aider à prendre en main un des meilleurs IDE Java: JBuilder 3.5. Vous devez lire la suite si les IDE (environnements de développement intégrés) ne vous sont pas familiers, ou si vous débutez avec JBuilder.

Nous allons vous présenter l’interface graphique, et créer un petit programme pour vous montrer comment se servir d’une des fonctions les plus abouties: la création automatisée d’interfaces utilisateur.

NOTE: ce document contient 11 images, il peut être assez long à charger.

Environnement JBuilder "au repos"

1 - Il s’agit de la zone où est présenté, en temps normal, le code source du fichier ouvert. On peut profiter de divers fonctions concernant cette vue telles que la colorisation automatique du code, l’auto-indentation, une ligne verticale qui définit la zone imprimable, etc…
Chaque fichier ouvert vient créer un nouvel onglet et s’affiche dans cette zone. Il n’y a ici qu’un seul fichier ouvert: MainFrame.java

2 - Il s’agit d’une zone (une JList) où sont affichés les fichiers du projet en cours. On peut voir ici 4 types de fichiers: le fichier central qui "regroupe" tous les fichiers du projet (c’est le fichier "projet") à l’extension .jpr, les fichiers Java source .java, les images .jpg et un fichier JavaDoc .html. Pour ouvrir un de ces fichiers, il suffit de cliquer dessus.

3 - Cette zone concerne le fichier ouvert. Elle affiche ici les imports, les variables, méthodes, et constructeurs de la classe en cours, car on est en mode "source" (voir 5). Si l’on était en mode "conception", dans cette zone serait affichées des informations relatives à la conception d’une GUI.

4 - Cette zone se retrouve dans pratiquement tous les logiciels: une barre de menus, une barre d’icônes. Vous utiliserez le plus souvent l’icône qui représente une flèche verte, en dessous du menu "Outils" et qui permet de compiler et de lancer un programme. Il faut aussi préciser que le menu Aide sera utile car il donne accès à la documentation du JDK de Sun ainsi qu’à la documentation des API et des outils Borland.

5 - Vous pouvez toujours accéder à l’onglet "Source" qui montre, comme ici, le code source de la classe en cours. Si cette classe permet une conception graphique (si elle étend de JFrame, JWindow, JInternalFrame, etc…), vous pourrez cliquer sur l’onglet "Conception" et lancer le concepteur graphique de JBuilder. L’onglet "Bean" permet de créer des Java Beans (composants réutilisables) et l’onglet "Doc" permet de créer des JavaDoc.

JBuilder en action!

Nous allons créer un petit programma avec une interface graphique à l’aide des assistants de JBuilder. Nous allons vous guider dans les étapes. Commençons:

1- Lancez JBuilder
2- Cliquez sur le menu FICHIER -> NOUVEAU PROJET
la fenêtre suivante s’ouvre:

Saisissez dans la zone "Fichier Projet" le chemin et le nom du fichier projet portant l’extension .jpr. Une fois fait, cliquez sur TERMINER.

2- Nous avons créé un projet, nous devons maintenant ajouter des classes. Nous avons choisi de créer une application graphique(JBuilder permet en outre de créer avec des assistants de servlets,des applets, des EJB, etc…). Cliquez sur le menu FICHIER -> NOUVEAU ou faites CRTL+N.
La fenêtre suivante s’ouvre:

Cliquez sur "Application" puis sur le bouton "OK" pour lancer l’assistant de création d’applications.

Une seconde fenêtre s’ouvre:

Le "Paquet" est plus connu sous le nom anglais de "package". En fait, quand dans vos programmes vous écrivez des instruction d’importation du style "import java.io.*;", vous importez toutes les classes de ce paquet. De même si vous voulez lancer votre programme cela devra se faire, dans notre cas, par l’instruction "java sans_titre1.Application1". La "classe" étant la classe principale du programme, celle contenant la méthode main(), celle qu’il faut invoquer pour lancer le programme. Dans la majorité des cas, vous n’aurez pas à modifier le code de cette classe.
Cliquez sur "Suivant >".

Vous accédez à cette fenêtre:

La classe à laquelle l’on fait ici référence est la classe qui définira le cadre principal de l’interface utilisateur.Elle étend de JFrame. Elle sera automatiquement lancée au démarrage du programme (le code pour ça est écrit automatiquement).
Par défaut les 3 cases que vous voyez cochées ici ne le sont pas, cochez-les pour ce tutoriel.
Cliquez sur "TERMINER".

Vous aboutissez à un écran similaire à celui de la première capture d’écran. Le fichier ouvert est "Cadre1.java".

3 - Nous allons créer l’interface. Cliquez sur l’onglet "Conception". Le concepteur met quelques secondes à se lancer, puis une fenêtre comme ceci apparaît:

1 - Cette zone est une simulation de ce à quoi ressemblera votre fenêtre. Vous y ajouterez des composants graphiques (2) par Drag&Drop. Vous pourrez déplacer, redimentionner, etc ces composants directement an cliquant dessus.
ASTUCE: on y pense rarement, mais le bouton droit de la souris est très utile… essayez vous verrez comme les options proposées dans le menu qui surgit sont utiles !

2 - Vous pouvez cliquer sur un des composants de ce panneau, le curseur se transformera en une croix. Cliquez avec cette croix dans la zone (1 )pour déposer le composant. Les composants sont répertoriés dans différents onglets, vous trouverez dans Swing les principaux composants graphiques de Swing, dans Conteneurs Swing des JTabbedPane, JSplitPaneetd’autres gestionnaires de mise en page. DbSwing regroupe des composants Borland(très utiles pour les bases de données notamment).

3 - Ici sont affichées les propriétés du composant graphique sélectionné. La fenêtre elle même étant sélectionnée, on voit ici ses propriétés. Si on clique sur l’onglet "Événements", on a accès à tous les gestionnaires d’évémements accessibles pour le composant sélectionné.

4 - Comme expliqué auparavant, les composants de l’interface -leur nom- sont affichés ici. On voit que "this" est sélectionné, c-à-d le fenêtre elle-même. Cette vue est très pratique pour savoir d’un coup d’oeil quels est le gestionnaire de mise en page d’un conteneur, quels composants il contient, etc…

4 - Cliquez sur l’onglet Conteneurs Swing, et sélectionnez le composant javax.swing.JPanel (le premier que nous désignerons sous le nom de JPanel), déposez-le au centre de this(le cadre gris de la capture d’écran ci-dessus).
Normalement le composant doit s’afficher (cela se matérialise parle fait que la fenêtre devient légèrement plus claire).Une entrée jPanel1 est ajoutée à la zone (4).Cliquez sur cette entrée. Les propriétés de la zone(3) changent. Cliquez sur la propriété layout de manière à faire apparaître une menu déroulant regroupant les gestionnaires de mise en page disponibles. Sélectionnez BorderLayout. Revenez à l’onglet Swing de la zone (2), cliquez sur le composant JButton et déposez-le vers le bas du jPanel1. Le bouton s’affiche automatiquement, remplissant la partie inférieure de la fenêtre. Recommencez la même opération en déposant un composant JTextArea au milieu de la fenêtre.

5 - Nous avons créé l’interface, nous allons peaufiner tout ça pour faciliter l’écriture du code. Dans le concepteur, sélectionnez le bouton en cliquant (1 seule fois !) dessus. Dans ses propriétés, changez:
name: inscrivez "button"
text: effacez ce qui est écrit et ne mettez: "Cliquez ici !".
Faites de même avec la zone de texte:
name: inscrivez "textArea"
text: effacez ce qui est inscrit
lineWrap: mettez la propriété à TRUE

Ce que vous obtenez devrait ressembler à ceci:

6 - Nous avons terminé la partie conception et nous pouvons passer à l’étape écriture du code.
Nous allons assigner des gestionnaires d’événement (en fait un seul au composant "button").

Pour assigner un gestionnaire d’événement à un composant, il y a une seule méthode, par l’onglet "Événements" de la zone (3) du concepteur. Cependant, pour le composant JButton, il existe une autre méthode (qui ne permet que d’assigner un gestionnaire OnClick d’ailleurs), c’est de double-cliquer tout simplement sur le bouton.
Nous allons essayer ici le 1° méthode dans le mesure où elle sera utilisée dans le majorité des cas.

Cliquez donc sur l’onglet "Événements", voici à quoi il ressemble:

La première fois que vous le lancez, la case à droite de "mouseClicked" est identique aux autres cases, c-à-d,vide. Nous vous la montrons ici une fois que vous aurez accompli l’action suivante: double cliquer dessus. Allez-y, double-cliquez. JBuilder repasse en mode "Source" et quitte le concepteur. Le curseur se trouve au milieu de la méthode gestionnaire d’événement mouseClicked du bouton. Complétez cette méthode avec le code visible ci-dessous:

REMARQUE: une des fonction les plus utiles de JBuilder est d’afficher un petit menu déroulant au fur et à mesure de l’écriture du code qui montre les méthodes disponibles pour telle ou telle classe.Par exemple, vous tapez ici "textArea" puis quand vous tapez le ".", le menu apparaît (attendez quelques secondes car si vous tapez la suite du code tout de suite il n’apparaît pas), affichant toutes les méthodes de JTextArea, quand vous continuez à taper "set…", le menu affiche toutes les méthodes commençant pas "set", et ainsi de suite.

Vous comprendrez à quel point ce composant est utile quand vous aurez envie d’appeler une méthode dont vous savez qu’elle existe amis dont vous ne connaissez par exactement la syntaxe. Ceci arrive constamment, et le menu déroulant permet d’éviter des erreurs à la compilation.
Cependant -et oui il faut bien un "mais" - j’ai constaté sur mon système que ce menu ne fonctionnait pas sous Linux, je ne sais pas si c’est dû à un paramétrage qu’il faut faire manuellement, et en plus, du moins je n’ai rien trouvé concernant ce sujet dans la doc… en espérant que ce soit juste un bug chez moi et pas pour tous les linux… (en tout cas sous Windows, ça fonctionne ! :))

7 - Nous avons terminé le programme, cliquez sur la flèche (le triangle vert) verte ou appuyez sur F9, le code se compile, et le programme se lance, cliquez sur notre bouton (dans la nouvelle fenêtre qui vient d’apparaître au bout de quelques secondes, et qui n’est autre que la fenêtre que nous achevons de concevoir) pour tester le programme, voici ce que ça donne:

Avant d’avoir cliqué et …

… après avoir cliqué

Vous avez remarqué que JBuilder a automatiquement ajouté une menu FICHIER -> QUITTER et un menu AIDE -> A PROPOS. Ces 2 menus sont fonctionnels, le code a été généré automatiquement. Cela est dû au fait que nous avions coché les cases "Créer une barre de menus" et "Créer une boîte de dialogue A Propos" à l’étape de définition de notre projet.

Je ne saurais trop vous conseiller de vous entraîner un peu à modifier l’interface, en examinant par exemple le gestionnaire d’événements du menu, en modifiant la conception graphique de la classe qui représente la boîte A Propos (Cadre1_AboutBox.java par défaut).

Voilà, c’est terminé :)

Comme morale à ce tutoriel (oui, oui, ce tutoriel est une vraie fable :) retenez que ce n’est pas parce qu’on utilise JBuilder ou un IDE que l’on doit se contenter de lui laisser tout faire. Personnellement, je ne l’utilise pas beaucoup pour ses codes pré-écrits, et beaucoup de programmeurs à mon instar n’aiment pas trop ça, ils utilisent des IDE pour la conception graphique qui se révèle plus simple et plus rapide. Et pour les gros projets, un Emacs n’est pas mal non plus…

Tutoriel distribué pour le FAQ Java de Java-France www.java-france.com / www.jgflsoft.com
Réédité pour Valhalla GFBLOG
Écrit à Montpellier le 15 mars 2001

Cet article a pour but de vous montrer la marche à suivre pour installer et configurer un environnement de développent Java viable sur une machine tournant sous le système d’exploitation Linux.
Dans ce tutoriel, nous utiliserons:

• le JDK de Sun, version 1.2.2 disponible à l'adresse suivante http://java.sun.com/products/jdk/1.2/download-linux.html
• la ligne de commande, normalement disponible à partir de votrebureau Linux.
• le logiciel XEmacs, fourni avec la majorité des distributions linux, disponible à l'adresse suivante: http://www.xemacs.org

NOTE: cette page contient 12 images haute résolution et assez grandes, cela peut prendre du temps à charger mais nous vous conseillons néanmoins d’attendre car la réalisation des étapes nécessaires et expliquées n’en sera que plus aisée.

Commençons nos explications:

INSTALLATION

1. Téléchargez le JDK, dans la version que vous voulez (NOTE: à l’heure actuelle une version 1.3 existe, mais nous avons choisi la 1.2.2 pour notre tutoriel. Si vous téléchargez la 1.3, la procédure d’installation ne sera modifiée que par le nom des fichiers et des répertoires, jdk1.3 au lieu de jdk1.2.2)

La capture d’écran montre ici le fichier .tar.gz téléchargé sur le site de Sun (adresse ci-dessus) et enregistré sur votre disque dur, à l’adresse ‘/home/guillaume/Downloads/’. Ce sera notre répertoire par défaut pour ce fichier. Vous pouvez bien évidemment l’enregistrer où bon vous semble.

2. Ensuite il nous faut décompresser cette archive, en extraire les fichiers. Pour cela, ouvrez une fenêtre de terminal, placez vous dans le répertoire où se trouve votre archive à l’aide de la commande cd, et décompactez-la grâce àla commande tar -zxvf.

ASTUCE: tapez: ‘tar zxvf jdk’ puis appuyez sur ‘tab’ (la touchequi représente 2 flèche de sens opposé sur la gauche du clavier) et, normalement, le ‘jdk’ que vous venez de taper se transforme automatiquement en le nom du fichier, c-à-d ici ‘jdk-1_2_2_007-linux-i386.tar.gz’ qui est légèrement plus contraignant à taper… Cetteastuce est couramment utilisée par les personnes habituées aux systèmes Unix.

La capture d’écran illustre ce qui est expliqué plus haut, et montre la commande exacte à entrer. Remplacer le nom du fichier donné ici par le nom du votre si celui-ci est différent. (en utilisant TAB…)
Quand vous appuyez sur ENTREE, une liste de fichiers défile dans la console, en voici la fin:(comme vous pouvez le voir sur la capture d’écran l’ascenseur à droite a considérablement rétréci: tous les fichiers ne sont pas affichés sur cet écran, mais vous n’avez normalement pas à vous soucier de cela).

Admettons que votre fichier tar.gz se soit trouvé dansle répertoire ‘/home/guillaume/Downloads’ comme ici, les fichiers serons installés dans le répertoire ‘/home/guillaume/Downloads/jdk1.2.2/’.
NOTE: nous vous conseillons de l’installer dans ‘/usr/local/’ ou ‘/home/guillaume’ (où vous remplacerez ‘guillaume’ par le nom de l’utilisateur voulu).

3. Vous devez ensuite indiquer au système dans quel répertoire il trouvera les fichiers binaires que JDK. Ceci se réalise à l’aide d’un ‘path’ (chemin en anglais). L’instruction estla suivante: export PATH=/home/guillaume/Downloads/jdk1.2.2/bin/:$PATH
NOTE: remplacez /home/guillaume/Downloads/ par le répertoire dans lequel est décompactée votre archive.

Voici la liste des fichiers qui doivent normalement se trouver dansle répertoire /bin/ de votre JDK. (ci-dessus)

Et voici l’instruction à taper pour définir une’PATH’. (ci-dessus)

UTILISATION

1. Ecriture d’un programme
Nous considèrerons ici que vous ne possédez pas d’IDEJava installé sur votre machine, que vous venez juste d’installer Linux et que l’éditeur XEmacs est installé sur votre système. (Il est fourni, le plus souvent installé par défaut, avecle plupart des distributions, si ce n’est toutes). Je vous conseille cependant d’installer JBuilder ou Forte si vous vous lancez dans la conception d’interfaces graphiques compliquées ou si vous désirez avoir des options d’exportation et d’internationalisation plus avancées.
Nous commençons donc par lancer cet éditeur- emacs-, par la lignede commande ou par un menu de votre interface graphique (ici, KDE sous Linux Mandrake 7.2).

Ci-dessus: ouvrez une fenêtre de terminal et tapez simplement ‘xemacs’, le programme devrait se lancer. (OPTIONNEL: Si vous désirez sauvegarder à l’aide de Emacs des fichiers dans des répertoires de votre machine appartenant à l’utilisateur root (par exemple /usr/ ou /var/), tapez ‘su’, puis le mot de passe de root. Poursuivez ensuite avec la commande xemacs qui sera alors lancée avec les droits du root).

Vous pouvez aussi passer par un menu pour ouvrir XEmacs.

2. XEmacs ouvert, nous pouvons taper notre code, et profiter de la colorisation automatique du code ainsi que de l’indentation automatique (entre autres )réalisées automatiquement par Emacs.
Voici ce que ça donne:

3. Compiler et lancer le programme
Nous pouvons compiler et lancer le programme par XEmacs, mais cela donnerait lieu à des paramétrages qui ne concernent pas notre sujet. Nous nous contenterons donc de compiler et de lancher notre programme en ligne de commande.

Une fois le code visible dans la fenêtre XEmacs ci-dessus reproduit à l’identique, vous pouvez sauvegarder votre fichier (sous le même nom que la classe principale, c-à-d sous le nom de «test.java», en tenant compte de la casse).

Une fois le fichier sauvegardé, il faudra ouvrir une fenêtre de terminal, se déplacer jusqu’au répertoire où sesitue le fichier «test.java» à l’aide de la command cd, etle compiler à l’aide de la commande javac.

Dans notre cas la syntaxe est la suivante: javac test.java.

Si aucun message n’est renvoyé, la compilation a réussi. Pour lancer le programme il suffit d’utiliser la commande java, de la manière suivante: java test (‘test’ est le nom du fichier.class créé par le compileur).

La capture d’écran ci-dessous montre comment faire:

PARAMETRAGE (optionnel!)

Nous allons présenter ici un des paramétrages utiles du JDK. Nous allons vous montrer comment configurer KDE (la procédure pour Gnome ou un autre window manager sera légèrement différente) pour exécuter un programme Java d’un seul clic.

Pour cela nous devons créer un fichierJAR EXECUTABLE (la plupart des IDE permettent de le faire dans leur commande d’exportation), et assigner un «ligne de conduite» que KDE devrasuivrequand l’on cliquera sur un tel fichier.

La procédure est la suivante:

• ouvrir le "Panneau de contrôle"
• se placer dans le nemu "Applications" -> "Associations des types de fichiers"
• définir un programme d'ouverture par défaut, ici le programme /../jdk1.2.2/bin/java -jar, pour les fichiers JAR
• enregistrer les changements et quitter.

</p>

La procédure en images:

Vous trouverez l’entrée x-jar dans x-all ou x-applications.

Cliquez sur le bouton «Ajouter» dans le panel «Applications par ordrede préférence».
La fenêtre représentée ci-dessous s’ouvre.

Vous devez inscrire le chemin exact vers le fichier ‘java’ et rajouter l’option ‘-jar’.

Cliquez sur OK, c’est terminé !

Tutoriel distribué pour le FAQ Java de Java-France www.java-france.com / www.jgflsoft.com
Maintenant publié sur Valhalla GFBLOG
Ecrit à Montpellier le 14 mars 2001