Développer des Applications Java sur Mac OS X avec Eclipse
Les développeurs Java ont rapidement fait d’Eclipse un des outils de développement les plus populaires sur Mac OS X. Mais bien qu’Eclipse soit un outil agréable à utiliser tous les jours une fois que vous le maîtrisez, il n’est pas si facile que ça d’en faire l’apprentissage. Un article ADC plus ancien, “Eclipse and Mac OS X: A Natural Combination”, apportait une introduction à Eclipse ; cet article va un peu plus loin en vous aidant à démarrer sur un projet, à surmonter les premiers obstacles et à vous sentir à l’aise avec Eclipse.
Cet article est basé sur trois exemples. Le premier, le classique HelloWorld, présente l’IDE, vous montre comment créer un projet et comment créer, complier et exécuter une classe. Dans le second exemple, nous allons importer l’application Swing de base créée par Xcode et travailler avec elle dans Eclipse. Vous allez aussi apprendre à personnaliser l’environnement d’Eclipse et tirer profit des avantages des fonctions de coding spécifiques Java telles que l’assistance au codage et au refactoring. Dans le troisième exemple, nous allons travailler avec un exemple qui introduit au Standard Widget Toolkit (SWT). SWT est un framework GUI créé par la fondation Eclipse que vous pouvez utilisez en lieu et place de Swing. Cet exemple vous montre basiquement les réglages requis pour créer et exécuter une application SWT au sein d’Eclipse.
Démarrer
Pour télécharger Eclipse, lancez Safari sur la page de téléchargement d’Eclipse (NdT : L’archive pèse 80Mo). Le site détecte que vous êtes sur Mac OS X et met en évidence la dernière version en haut de page. La version actuelle (Mars 2005) est Eclipse Platform 3.0.1 Mac OS X ; cependant, compte tenu qu’il y a eu des améliorations apportées à la version Mac OS X d’Eclipse depuis cette version, vous devriez télécharger la dernière version milestone/stable à la place. Vous pouvez voir un lien vers ces fichiers sur la partie droite de la page dans la partie top-10 des meilleurs téléchargements d’Eclipse. La dernière milestone au moment de cet article est la 3.1M5a. Suivez le lien et téléchargez un fichier ayant un nom du style eclipse-SDK-3.1M5a-macosx-carbon.tar.gz. Désarchivez-le dans un dossier nommé Eclipse, regardez à l’intérieur et double-cliquez l’application Eclipse.
Que vous veniez à Eclipse à partir d’un autre IDE tel que Xcode ou que vous veniez d’un éditeur de texte et d’outils en ligne de commande, vous trouverez qu’il y a une certaine dose d’apprentissage à acquérir. La première différence apparaît immédiatement chaque fois que vous lancez Eclipse, lorsque l’on vous demande de choisir un espace de travailo. Tous les projets contenus dans le même espace de travail sont visibles dans certaines vues et vous trouverez peut-être qu’il est conceptuellement préférable de séparer chaque projet en leur attribuant un espace de travail spécifique. C’est une hsitoire de goût mais cela n’est pas obligé car vos fichiers projet n’ont pas à être nécessairement dans l’espace de travail. Vous verrez une illustration de cela dans la prochaine section. Pour le moment, choisissez l’emplacement par défaut comme espace de travail comme illsutré à la Figure 1. Après avoir travaillé avec les trois exemples de cet article, vous devriez avoir une meilleure appréciation de l’opportunité de séparer ou pas vos espaces de travail pour chaque projet individuel ou chaque famille de projets.
Figure 1 : Sélection de l’espace de travail.
Créez un nouveau projet en sélectionnant File > New > Project. Suivez l’assistant et sélectionnez l’option “Java Project” et pressez le bouton Next. Dans la Figure 2, vous pouvez voir que vous avez le choix entre créer le projet dans l’espace de travail ou ailleurs. Vous pouvez aussi créer le projet à partir de codes source existants. Pour le moment, tapez le nom HelloWorld pour le projet et sélectionnez Finish.
Figure 2 : Création d’un projet.
On vous demande ensuite si vous souhaitez passer en perspective Java. Répondez “Yes”. Cela vous aménera vers la vue que vous utiliserez pour un développement Java. Vous pouvez jeter un oeil à la Figure 6 pour voir les composants de la perspective Java. Créez une nouvelle classe en utilisant File > New > Class ou en faisant un clic-droit sur HelloWorld et en sélectionnant dans le menu popup New > Class. Vous voyez alors apparaître le dialogue de création de classe comme illustré à la Figure 3. Entrez “Welcome” dans le champ Name, laissez tels quels les boutons radio dans le Modifiers, et laissez telle quelle la valeur du champ Superclass (java.lang.Object). Toutes les classes d’un programme Java sont des extensions d’autres classes avec la classe Object comme racine de l’arborescence. Traditionnellement, les classes ayant Object pour super-classe ne comprenne pas le terme extends dans leur déclaration. Vous pouvez aussi vous épargner quelques pressions de touches de clavier en spécifiant que vous souhaitez la création d’une méthode public static void main(String[] args). Le formulaire renseigné devrait ressembler à cela :
Figure 3 : Création d’une classe Java.
The code suivant est alors généré :
public class Welcome {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
Pour compléter votre exemple HelloWorld, remplacez la ligne //TODO Auto-generated method stub avec l’habituel System.out.println("Hello, World"); Pour expérimenter la fonction d’assistance au codage, faites une pause après avoir tapé System et le point. La boîte illustré en Figure 4 apparaît avec des suggestions pour compléter le code. La quatrième ligne indique out qui est du type PrintStream. Tapez la lettre “o” et out sera sélectionné puis une seconde boîte apparaîtra avec plus de documentation sur System.out. Vous pouvez configurer le temps après lequel les astuces apparaissent dans Eclipse > Preferences.
Figure 4 : Assistance au codage.
Eclipse facilite le refactoring de votre code. Vous pourrez décider plus tard de changer le nom d’une classe, d’une méthode ou d’une variable. Eclipse vous aide en identifiant toutes les références au nom que vous souhaitez changer. Eclipse est même suffisamment sympa pour se rendre compte que vous avez utilisé le même nom dans différents contextes, ainsi il ne s’arrête pas à un simple rechercher-remplacer global. Le changement de nom est un des aspects du refactoring pris en compte par Eclipse.
Vous pouvez aussi souhaiter déplacer une classe. Notez qu’il y a un avertissement en haut de l’assistant montré à la Figure 3 recommandant de ne pas utiliser le package par défaut. Retournons en arrière et créons un package nommé greetings et déplaçons notre classe Welcome dans ce nouveau package. Si nous faisions cela à la main nous devrions nous rappeler toutes de changer toutes les références à cette classe tout comme ajouter une déclaration de package eu début de la classe Welcome. Utilisez File > New > Package pour créer un nouveau package nommé greetings. Sélectionnez maintenant le fichier Welcome.java. Sélectionnez ensuite le refactoring de déplacement soit avec la commande Refactor > Move . . . soit en faisant un clic-droit sur Welcome.java et en sélectionnant Refactor > Move . . . dans le menu contextuel comme illustré à la Figure 5.
Figure 5 : Refactoring de déplacement de Classes.
Une fois dans la boîte de dilogue, sélectionnez le package greetings et pressez OK. Dans la vue Package Explorer de la perspective Java, la classe Welcome.java a été déplacée sous le package greetings et le package par défaut n’apparaît plus du fait qu’il n’est plus requis. Vous remarquerez que le code source de Welcome.java commence maintenant par la déclaration package greetings; Une des forces d’Eclipse tient dans la quantité d’informations que l’IDE gère à partir de la structure intrinsèque du programme que vous êtes en train d’écrire.
Il ne reste plus qu’à lancer cet exemple. Dans la vue Outline ou dans la vue Package Explorer, remarquez la flèche verte associée à la classe Welcome. Faites un clic-droit sur cette flèche et sélectionnez Run as > Run. Vous devriez voir le résultat dans une fenêtre comme celle montrée à la Figure 6. Vous pouvez aussi lancer l’application en sélectionnant Run > Run et en positionnant les variables Main, Arguments, JRE, Classpath, Source, Environment et Common.
Figure 6 : La Perspective Java.
À ce point, vous devriez avoir une bonne appréciation de la puissance d’Eclipse. Vous avez maintenant téléchargé et commencé à configurer l’IDE. Vous avez spécifié votre espace de travail, créé un projet Java et exploré la perspective Java. Vous avez créé une nouvelle classe et un nouveau pckage et appris combien il était facile d’utiliser les outils de refactoring d’Eclipse pour déplacer votre classe d’un package à un autre. Vous avez créé, compilé et lancé le plus basique des programmes Java. Maintenant, passons à un programme utilisant Swing.
Travailler avec du code existant
Dans cette section, vous allez créer le projet Swing par défaut dans Xcode puis travailler avec les fichiers générés dans Eclipse. Dans Xcode, choisissez File > New Project. Lorsque l’assistant de nouveau projet apparaît, choisissez Java Swing Application, nommez le projet XSwing et créez le dans son emplacement par défaut. Vous pouvez maintenant quitter Xcode.
Dans Eclipse, créez un autre projet Java. Donnez lui le nom de XSwing et cliquez sur le bouton radio “Create project from existing source”. Naviguez jusqu’au répertoire que vous avez créé dans Xcode pour le projet XSwing. Le lieu devrait être dans le genre /Users/votrenom/XSwing. Vous pouvez cliquer sur le bouton Finish si vous le souhaitez ou vous pouvez aller plus loin dans la configuration du projet en cliquant sur le bouton Next. Si vous faites ceci, vous pouvez voir que les fichiers du code source visibles par le compilateur sont AboutBox.java, PrefPane.java et XSwing.java. Cliquez sur Finish maintenant.
Vérifiez que l’élément Project > Build Automatically est sélectionné. Observez le contenu du répertoire /Users/votrenom/XSwing et vous trouverez plus d’une douzaine de fichiers .class qui ont été générés. Eclipse a construit automatiquement votre projet sauvegardé. De retour dans la perspective Java d’Eclipse, cliquez sur l’onglet Problems situé dans la panneau du bas. Vous pouvez voir qu’il y a quatorze avertissements qui ont été générés. Ils indiquent tous qu’une classe sérialisable ne déclare pas de champ final statique serialVersionUID de type long. Ce n’est pas le genre d’avertissement par lequel vous souhaitez être embarrasé.
Ouvrez le panneau des préférences en utilisant Eclipse > Preferences. Vous pouvez voir que Eclipse est très personnalisable. Regardez sous Java > Compiler > Errors/Warnings. Comme illsutré à la Figure 7, localisez l’élément ‘Serializable class without serialVersionUID’ et changez la sélection du menu en Ignore. Lorsque vous pressez OK, on vous indique que les réglages du compilateur ayant été changés, une reconstruction complète est requise. Répondez que vous souhaitez effectuer la reconstruction complète maintenant. Tous les avertissements disparaissent alors.
Figure 7 : Personnaliser les Erreurs.
Il y a trois classes dans le projet XSwing mais seul XSwing.java contient une méthode main(). Faites un clic-droit sur la classe XSwing dans la vue Package Explorer ou dans la vue Outline près de la flèche verte. Sélectionnez Run As > Run et vous voilà dans le dialogue d’exécution. Vous pouvez aussi faire apparaître le dialogue d’exécution en utilisant l’élément de menu Run > Run ou en utilisant la barre d’outils. Heureusement, le raccourci Màj-Commande-F11 vous permet de répéter l’exécution autant de fois que vous le souhaitez.
Dans le dialogue d’exécution, cliquez sur Java applications puis sur New. XSwing apparaît sous Java applications. Avant de lancer l’application, cliquez sur l’onglet Arguments et ajoutez l’argument VM -Dapple.laf.useScreenMenuBar=true. Dans Xcode, cela est ajouté par défaut à votre place. Dans Eclipse, vous devez ajouter manuellement cette option vous-même de façon à ce que la barre de menus apparaisse en haut de l’écran au lieu de faire partie du JFrame. Dans la section suivante, vous verrez que cette étape n’est pas nécessaire si vous utilisez SWT au lieu de Swing. La Figure 8 montre le résultat d’un clic sur le bouton Run.
Figure 8 : La petite application Swing.
Maintenant que l’application est lancée, jetons un oeil à quelques fonctions supplémentaires d’Eclipse qui facilitent le travail d’un code source. Vous pouvez réouvrir le panneau des préférences et personnaliser le “look and feel” du code avec Java > Code Style > Formatter. Changez l’emplacement de l’accolade d’ouverture dans les méthodes et les classes, ajustez l’espace en début de ligne ou dans les méthodes et instructions de contrôle. Vous avez le contrôle sur plein de variables qui vous aident à afficher le code de la façon que vous souhaitez.
Une fois que votre éditeur est configuré comme vous le souhaitez, regardez attentivement le code et recherchez les endroits où vous souhaiteriez apporter des changements. Le refactoring automatique vous apporte une bonne dose de puissance et de flexibilité. Par exemple, considérez la méthode addMenus().
public void addMenus() {
// (1)
fileMenu = new JMenu(resbundle.getString("fileMenu"));
fileMenu.add(new JMenuItem(newAction));
fileMenu.add(new JMenuItem(openAction));
fileMenu.add(new JMenuItem(closeAction));
fileMenu.add(new JMenuItem(saveAction));
fileMenu.add(new JMenuItem(saveAsAction));
// (2)
mainMenuBar.add(fileMenu);
editMenu = new JMenu(resbundle.getString("editMenu"));
editMenu.add(new JMenuItem(undoAction));
editMenu.addSeparator();
editMenu.add(new JMenuItem(cutAction));
editMenu.add(new JMenuItem(copyAction));
editMenu.add(new JMenuItem(pasteAction));
editMenu.add(new JMenuItem(clearAction));
editMenu.addSeparator();
editMenu.add(new JMenuItem(selectAllAction));
mainMenuBar.add(editMenu);
setJMenuBar (mainMenuBar);
}
Selectionnez les lignes comprises entre les commentaires (1) et (2). Faites un clic-droit sur ces lignes et sélectionnez Refactor > Extract Method. La boîte de dialogue suivante apparaît. Remplissez le nom de la méthode avec createFileMenu et pressez OK.
Figure 9 : Extraction de Code pour en faire une Méthode.
Les lignes sélectionnées sont remplacées par un appel à la méthode createFileMenu() nouvellement créée et elles constituent le corsp de cette nouvelle méthode. Eclipse vous demande si vous avez besoin de passer des informations sous la forme de paramètre de méthode ou de type de retour. Dans notre cas, cela n’est pas nécessaire, donc createFileMenu() ne prend aucun argument et retourne le type void. Répétez ce traitement pour former une nouvelle méthode appelée createEditMenu(). Maintenant la méthode addMenus() a cette apparence :
public void addMenus() {
createFileMenu();
mainMenuBar.add(fileMenu);
createEditMenu();
mainMenuBar.add(editMenu);
setJMenuBar (mainMenuBar);
}
Notez que addMenus() se lit presque comme une liste des étapes à suivre pour ajouter les menus. Si vous avez besoin de savoir comment vous avez créé le menu “file”, vous savez où regarder. Pour le moment, vous souhaitez cacher ces détails. Cliquez sur les triangles qui apparaissent dans la marge de gauche près des récentes méthodes createFileMenu() et createEditMenu(). Cette façon de déplier le code facilite la navigation dans le code. La plupart du temps que vous passerez avec la classe XSwing vous n’aurez pas besoin de voir le code de la méthode createFileMenu(), passons donc à la suite et refermez la. La Figure 10 montre une partie de XSwing.java. La classe interne newActionClass est refermée par défaut. Notez le triangle vert placé à gauche au début de la méthode paint(). Il indique que paint() remplace une méthode d’une super-classe.
Figure 10 : Code renfermé.
Vous avez maintenant vu comment Eclipse vous permet de travailler avec du code existant. Vous pouvez facilement ajouter un projet à votre espace de travail même si le code est situé ailleurs. Vous avez appris comment personnaliser le style du code et le niveau de vérification des erreurs avec lequel vous vous sentez à l’aise. Vous avez refermé des parties de code pour rendre le code source plus lisible. De manière plus importante, vous avez tiré avantage de la conscience qu’a Eclipse de la structure du code pour extraire des lignes et les transformer en de nouvelles méthodes.
Une Apparence Légèrement Différente
Dans ce troisième exemple, vous obtiendrez une application SWT prête à l’exécution. SWT, le Standard Widget Toolkit, est fourni par le projet Eclipse en tant que framework GUI alternatif à Swing ou AWT. Vous pouvez développer des applications SWT en utilisant un éditeur de texte ou des outils en ligne de commande ou d’autres IDE. Cela nécessitera un téléchargement séparé des fichiers jar et jnilib de SWT. Jusqu’à récemment, la configuration d’Eclipse sur Mac OS X pour lancer une application SWT lors du développement était compliqué. Maintenant, comme vous allez bientôt le voir, il est assez facile de compiler et de lancer une SWT avec Eclipse.
Dans Eclipse, créez une nouveau projet Java et nommez le XSWT. Faites un clic-droit sur XSWT dans la vue Package Explorer et sélectionnez Properties dans le menu contextuel puis Java Build Path comme illustré à la Figure 11. Vous devez ajouter les fichiers jar SWT à ce projet. Vous les trouvez dans le dossier des plugins de la distribution d’Eclipse dans le répertoire eclipse/plugins/org.eclipse.swt.carbon_3.1.0/ws/carbon. Sélectionnez l’onglet Libraries et cliquez sur le bouton Add External JARs. Naviguez jusqu’à ce répertoire et sélectionnez à la fois les fichiers swt.jar et swt-pi.jar. Pressez Open. Ces fichiers apparaissent maintenant dans l’onglet Libraries tab, vous pouvez donc appuyer sur OK.
Figure 11 : Ajout des fichiers .jar SWT.
Le lancement d’une application SWT dans Eclipse sur Mac OS X a été beaucoup facilité ces derniers temps. D’anciens tutoriaux vous emmènent dans une configuration plus poussée d’Eclipse pour trouver les fichiers natifs correspondants dans le répertoire /eclipse/plugins/org.eclipse.swt.carbon_3.1.0/os/macosx/ppc directory. Cela n’est plus nécessaire. Eclipse peut maintenant trouver les fichiers libswt-carbon-3132.jnilib, libswt-pi-carbon-3123.jnilib et libswt-webkit-carbon-3123.jnilib sans plus d’informations. Notez que le numéro 3132 dans les noms de fichier changeront dans de futures versions.
Le SWT requiert que vous appreniez une nouvelle API. Eclipse vous y aide avec sa fonction d’assistance au codage, mais vous aurez toujours besoin de prendre un livre qui vous donnera une vue globale des bibliothèques. Par exemple, la manipulation des Menus et des MenuItems de SWT diffère de manière significative de ceux de Swing. Voici le coeur de ce que le code de notre exemple va faire :
setUpDisplay();
createLabel();
createMenuBar();
revealDisplay();
Bien qu’il n’y ait pas de correspondances directes entre les composants usuels de Swing et de SWT, vous devriez être capable de lire et de comprendre le code GUI basique. Créez une classe nommée SWTGreeter avec le code suivant :
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.SWT;
public class SWTGreeter {
private Display display;
private Shell shell;
SWTGreeter() {
setUpDisplay();
createLabel();
createMenuBar();
revealDisplay();
}
private void setUpDisplay() {
display = new Display();
shell = new Shell(display);
shell.setSize(200, 100);
shell.setText("SWTGreeter");
}
private void createMenuBar() {
Menu menu = new Menu(shell, SWT.BAR);
shell.setMenuBar(menu);
MenuItem fileMenuItem = new MenuItem(menu, SWT.CASCADE);
fileMenuItem.setText("File");
MenuItem editMenuItem = new MenuItem(menu, SWT.CASCADE);
editMenuItem.setText("Edit");
}
private void createLabel() {
Label label = new Label(shell, SWT.CENTER);
label.setText("Hello SWT");
label.setBounds(shell.getClientArea());
}
private void revealDisplay() {
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
}
public static void main(String[] args) {
new SWTGreeter();
}
}
Les menus File et Edit ne contiennent aucun élément, mais ce code est suffisant pour afficher les deux premiers menus dans la barre de menus. Lancez cela en tant qu’Application SWT en faisant un clic-droit sur SWTGreeter dans la vue Package Explorer et sélectionnez Run As > SWTApplication. Le résultat devrait ressembler à la Figure 12.
Figure 12 : L’Application SWT.
Notez que les menus File et Edit apparaissent là où ils doivent être, dans la barre de menus, sans requérir de paramètres spécifiques. Il y a encore pas mal de travail à fournir pour mettre sur pied une application SWT pleinement fonctionnelle avec un “look and feel” natif Mac, mais cet exemple est un bon endroit pour commencer.
En Résumé
Si vous faites du développement Java sur Mac OS X, Eclipse est IDE open source qui évolue rapidement et qui est déjà doté d’une bonne richesse fonctionnelle conçue pour vous. Il se peut que vous vous preniez la tête la première fois que vous aurez besoin d’accomplir une nouvelle tâche. Comment ajouter un fichier jar ? Comment supprimer cet avertissement ? Comment lancer cette application ? Au fûr et à mesure que vous utiliserez Eclipse pour vos développements quotidiens vous vous demanderez comment vous avez pu vivre sans les fonctions d’assistance au codage, de refactoring automatique et toutes celles qui facilitent l’écriture de votre code.
Pour Plus d’Informations
- Listes de diffusion : www.eclipse.org/mail/index.html
- Archives des plugins : www.eclipse-plugins.info/eclipse/index.jsp
- Rejoindre la communauté : www.eclipse.org/community/index.html
- Eclipse Live, par Bill Dudney (souscription payante).
- Eclipse, par Steve Holzner.
Mise à jour : 2005-02-28
Texte original en anglais sur developer.apple.com : Developing Java Applications On Mac OS X With Eclipse
Chargement
Commentaires récents