Table des matières
Ce tutorial a pour objet de présenter la configuration de base d'un projet dans Eclipse. On y montre comment configurer la JVM qui va faire fonctionner le projet, comment ajouter des librairies en dépendance d'un projet, comment modifier les répertoires source d'un projet, et comment créer une dépendance entre deux projets Eclipse.
Gérer les dépendances d'un projet, que ce soit sous Eclipse ou sous tout autre IDE, peut rapidement prendre des proportions importantes. Les méthodes que nous présentons ici permettent de facilement gérer des dépendances dans un périmètre raisonnable. Pour les projets de grande taille, comportant de nombreux modules, et de grandes quantités de dépendances, on préfèrera probablement utiliser un gestionnaire, tel que Maven par exemple.
Ce tutorial fait suite au tutorial Premiers pas avec Eclipse, que l'on peut consulter pour plus de détails sur l'installation de la version JEE d'Eclipse.
Eclipse est une application Java, qui fonctionne grâce à une JVM, Java Virtual Machine. Le fonctionnement d'Eclipse requiert qu'une JVM soit déjà installée sur la machine sur laquelle on installe Eclipse. Par défaut, tous les projets que l'on crée dans une installation d'Eclipse fonctionne avec cette machine virtuelle.
Il peut arriver, pour toutes sortes de raisons, que l'on veuille changer cette JVM. Examinons comment cela est possible.
Tout d'abord, notons que la JVM utilisée par notre projet est visible directement de la vue package explorer de notre projet : le nœud JRE porte la version de la JVM utilisée.
Changer la JVM utilisée peut se faire en ouvrant la fenêtre des propriétés du projet
courant : menu Project, rubrique Properties.
Les propriétés d'un projet Eclipse s'affichent sur un panneau comportant de nombreuses options. On peut naviguer dans ces options à partir d'un ensemble de nœuds dans la colonne de gauche de ce panneau.
Sélectionnons tout d'abord le nœud Java Build Path dans la liste de gauche. Quatre onglets s'affichent sur la partie droite : Source, Projects, Libraries et Order and Export.
Sélectionnons l'onglet Libraries de la fenêtre qui s'ouvre alors. Nous reviendrons plusieurs fois sur cet onglet dans ce tutorial, dans la mesure où c'est de cet onglet que l'on gère les dépendances d'un projet.
Sur cette fenêtre, sélectionnons le JRE actif, et cliquons sur le bouton Edit....
La fenêtre qui s'ouvre nous montre que le JRE utilisé pour ce projet est bien le JRE utilisé par défaut pour tous les projets de cet espace de travail.
Commençons par déclarer des JRE supplémentaires au niveau de notre espace de travail. Pour cela cliquons sur le bouton Installed JRE... du panneau précédent.
Cela ouvre le panneau précédent, que l'on aurait pu aussi ouvrir en allant chercher la bonne option dans les Preferences d'Eclipse.
Deux options s'offrent ici à nous, qui se ressemblent beaucoup. Ce qu'il faut expliquer à Eclipse, c'est dans quel endroit nous avons installé nos JDK.
Chaque JDK est rangé dans son propre répertoire. Si tous ces répertoires se trouvent sous la même racine de notre disque, alors on peut indiquer ce répertoire racine à Eclipse, qui va se charger de l'explorer complètement. Cette façon de faire peut être un peu longue, surtout si ce répertoire racine contient d'autres sous-répertoires que nos JDK.
La deuxième option consiste à indiquer chaque répertoire qui contient un JDK, un par un.
Explorons la deuxième possibilité, et cliquons sur le bouton Add....
Dans ce cas, nous ajoutons une machine Java standard. Nous sélectionnons donc la troisième option et cliquons sur Next >.
La deuxième étape consiste à indiquer à Eclipse où se trouve notre JRE, ce que l'on fait en cliquant sur le bouton Directory... du panneau précédent. Windows ouvre alors une fenêtre qui nous permet de sélectionner le bon dossier. Une fois que cela est fait et validé, Eclipse scrute le contenu du répertoire, et identifie le JDK qui s'y trouve. Dans notre exemple, il s'agit d'un JDK v5, utile lorsque l'on travaille sur des projets legacy.
Une fois ce choix terminé, le nouveau JDK s'affiche dans la fenêtre des préférences.
Notons que de ce panneau, on peut également modifier le JDK qu'Eclipse utilisera par défaut lors de la création d'un nouveau projet.
On peut répéter cette opération autant de fois que l'on veut. Une fois que l'on a déclaré tous les JDK que l'on voulait, il ne reste plus qu'à choisir celui que l'on veut utiliser dans notre fenêtre de projet.
On constate que le changement de JRE a bien été pris en compte dans les propriétés de notre projet.
Le changement est également visible depuis la vue Package Explorer.
Un projet complet s'appuie en général sur des librairies externes, distribuées sous forme d'un ou plusieurs JARs. Cette partie explique comment ajouter des JARs en dépendance d'un projet Eclipse.
L'exemple que nous allons prendre dans cette partie, consiste à ajouter les JARs de Dom4J en
dépendance de notre projet. Dom4J est une API Java permettant de manipuler des documents XML,
disponible à l'adresse
http://dom4j.sourceforge.net/dom4j-1.6.1/. La distribution de cette API est
composée d'un unique JAR : dom4j-1.6.1.jar. Supposons que nous disposions de ce JAR
(ce n'est pas très compliqué, il suffit de le télécharger) dans un répertoire local.
Ajouter des JARs en dépendance d'un projet se fait à partir du panneau des propriétés d'un projet, le même que celui que nous avons ouvert en début de ce pas à pas. L'onglet dans lequel nous allons travailler est l'onglet Libraries, comme sur l'écran suivant.
Les deux premières options disponibles nous permettent d'ajouter ce JAR à notre projet.
L'option Add JARs... nous permet d'ajouter un JAR qui se trouve dans l'un des répertoires d'un des projets de notre espace de travail.
L'option Add External JARs... nous permet d'ajouter un JAR, quel que soit son emplacement sur le disque.
À l'inverse, le bouton Add JARs... permet d'ajouter un JAR présent dans
notre espace de travail.
Supposons que nous ayons déjà copié notre JAR Dom4J dans un répertoire lib de notre
projet. Le nom de ce répertoire peut être celui que l'on veut, il n'est absolument pas normalisé.
Cette copie se fait simplement par glisser / déposer ou copier / coller classique.
Cliquer sur le bouton Add JARs... du panneau des propriétés de notre projet nous permet de choisir un JAR dans les projets de notre espace de travail.
On constate sur le panneau des propriétés que ce JAR a bien été ajouté.
L'ajout est également visible de la vue Package Explorer. On constate que
le fichier dom4j-1.6.1.jar du noœud lib porte une marque, qui indique
qu'il est utilisé en tant que dépendance du projet.
Cette façon d'ajouter des JARs un par un n'est pas très efficace, surtout si l'on a de nombreux projets, et de nombreux JARs à gérer. Eclipse nous offre deux façons d'organiser les choses : utiliser des variables et des librairies.
Les variables sont configurables à partir des préférences d'Eclipse. On peut accéder à ces préférences à partir des menus de configuration, ou du panneau de gestion des dépendances d'un projet.
Voici le panneau qui s'affiche si l'on clique sur le bouton Add Variable... du panneau des propriétés d'un projet.
Cliquons maintenant sur le bouton Configure Variable.... Le panneau suivant apparaît.
On peut, à partir de ce panneau, ajouter une nouvelle variable en cliquant sur le bouton New....
Supposons que tous nos JARs soient rangés dans un répertoire D:\java\libs.
Commençons par définir une variable MY_LIBS_FOLDER qui pointe sur ce répertoire.
On peut ensuite utiliser cette variable pour ajouter notre JAR Dom4J en dépendance de notre projet. Pour cela, il faut étendre cette variable, en cliquant sur le bouton Extend... du panneau d'ajout de dépendances.
Le panneau qui s'ouvre présente directement les JARs disponibles dans le répertoire pointé par la variable sélectionnée. Il n'y a plus qu'à sélectionner ceux que l'on veut mettre en dépendances de notre projet. Ici, notre répertoire ne compte qu'un seul JAR, celui de Dom4J.
Une fois choisie, notre dépendance vers Dom4J s'affiche de la façon suivante.
L'exemple que nous avons choisi est particulièrement simple : la dépendance que nous voulons ajouter est composée d'un unique JAR. Dans de nombreux cas, ajouter une "dépendance" consiste en fait à ajouter un ensemble de JARs, qui dépendent les uns des autres. L'idée de regrouper tous ces JARs en un paquet unique est donc naturelle. Dans le jargon Eclipse, ce paquet est appelé librairie, et l'on peut définir soi-même de telles librairies.
L'exemple que nous allons prendre est la librairie d'Apache Commons : HttpClient,
en version 3.1. Cette librairie dépend elle-même d'Apache Commons Logging 1.0.4 et
d'Apache Commons Codec 1.2. On a donc regroupé ces trois JARs dans un répertoire
D:\java\libs\common-httpclient-3.1.
Cliquer sur le bouton Add Library... du panneau des propriétés de notre projet nous amène au panneau suivant.
Toutes les librairies configurées au niveau de notre espace de travail sont accessibles sur ce panneau. Nous allons en créer une nouvelle, et sélectionnons donc User Library avant de cliquer sur le bouton Next >.
Nous n'avons créé aucune librairie utilisateur pour notre projet, donc cette fenêtre est vide.
Cliquer sur New... nous permet de préciser le nom de cette librairie. Nous avons le choix de ce nom, rien ne nous oblige à prendre le nom d'un JAR. Cela dit, il vaut mieux que ce nom nous donne une idée précise du contenu de cette librairie.
Cette librairie n'est pas une librairie système, donc on ne coche pas la case correspondante du panneau.
Une fois cette librairie créée, il faut encore lui ajouter les bons JARs.
On clique pour cela sur le bouton Add JARs.... Un explorateur de fichier standard nous permet d'aller chercher nos JARs là où ils se trouvent.
Notre librairie et ses JARs apparaissent finalement dans la liste des librairies utilisateur.
On peut maintenant ajouter cette librairie à notre projet.
Notre librairie apparaît bien en dépendance de notre projet. Tout d'abord, sur le panneau des propriétés de ce projet.
Puis dans la vue Package explorer.
Ajouter un projet en dépendance d'un autre est très simple. Supposons que nous ayons deux projets
dans notre espace de travail : projet-model et projet-process.
Notre projet projet-process utilise les classes du projet projet-model
pour ses propres besoins. Nous avons donc besoin de déclarer que le projet projet-model
est en dépendance du projet projet-process. Cela se fait toujours à partir du panneau
des propriétés du projet projet-process, mais cette fois sur l'onglet
Projects.
Cliquer sur le bouton Add... ouvre une fenêtre dans laquelle on peut sélectionner le projet que l'on veut mettre en dépendance. On peut bien sûr créer des dépendances multiples. Eclipse râlera à coup sûr si l'on crée des dépendances circulaires.
Le projet ajouté apparaît alors dans la liste des projets en dépendance.
En revanche, on peut regretter qu'aucun signe graphique ne signale cette dépendance au niveau de la vue Package Explorer.
Par défaut, lorsque l'on crée un projet Java, Eclipse crée un répertoire src dans lequel
nos fichiers source vont venir se ranger bien sagement. En fait, il existe de nombreuses raisons pour
lesquelles on peut avoir envie de créer d'autres répertoires source :
-
l'utilisation de différents fichiers dans différents langages ;
-
la séparation de nos fichiers de production, et de nos fichiers de tests.
La liste précédente n'est bien sûr pas complète, on peut trouver d'autres raisons.
Supposons que l'on veuille ranger nos fichiers Java de production dans un répertoire
src/main/java et nos fichiers de test dans un autre répertoire src/test/java.
Cette organisation est assez générale : si l'on ajoute des fichiers PHP (par exemple) à notre
projet, ils viendront se ranger naturellement dans un répertoire src/main/php.
La déclaration des répertoires source d'un projet est faite dans l'onglet Source
du panneau de propriétés de notre projet. Lorsque l'on ouvre cet onglet, on se rend compte
que les fichiers source de notre projet sont rangés uniquement dans le répertoire src,
ce que l'on savait déjà.
Commençons par retirer le répertoire src de la liste des répertoires source. Il
suffit pour cela de le sélectionner, et de cliquer sur le bouton Remove.
On peut modifier ce répertoire en cliquant sur le bouton Add Folder....
Eclipse nous ouvre alors un panneau, qui nous montre la structure complète des
répertoires d'un projet. Dans sa configuration par défaut, le répertoire bin qui
apparaît est utilisé pour enregistrer les fichiers compilés à partir de nos fichiers source. Comme
on n'a jamais à interagir avec ces fichiers, Eclipse n'affiche pas ce répertoire dans
la vue Package Explorer.
Ajoutons un répertoire src/main/java à notre structure, cela se fait en cliquant
sur le bouton Create New Folder.... Notons que le chemin que l'on donne
est relatif au répertoire sélectionné dans ce panneau. Si l'on a sélectionné src,
on n'aura donc que main/java à entrer.
On peut cliquer directement sur le bouton Finish, ce qui nous mène à la structure suivante.
Eclipse nous affiche bien la structure que nous avons créée, dans laquelle certains répertoires sont
sélectionnés, et pas d'autres. Les répertoires sélectionnés sont les répertoires finaux qui vont
pouvoir contenir des fichiers source. Dans notre exemple, on doit donc laisser le répertoire
java sélectionné.
De même, on ajoute un répertoire src/test/java.
Une fois nos répertoires ajoutés, on peut cliquer sur le bouton Ok de façon à valider le tout. Le panneau des propriétés de notre projet a alors l'allure suivante.
La structure finale de notre projet est la suivante : on peut ranger nos fichiers de production
dans le répertoire src/main/java et nos fichiers de test dans
src/test/java.
José Paumard © 2011, tous droits réservés