3. Cycle de développement d`un projet

Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Filière open-source
Guide Opératoire de Développement avec
Eclipse 3.1 + Web Tools Platform 1.0
Responsable de document
Nom / Visa
Examinateur
Nom / Visa
Approbateur
Nom / Visa
L. Denanot
Matthieu Guillemette
Gilles Kempf
David Duarte
SOMMAIRE
1.
Plate-forme de développement open-source .................................................................... 4
1.1
Pré-requis (packages)......................................................................................................................... 4
1.2
Configuration des outils de développement ..................................................................................... 4
1.2.1 Configuration du JDK ...................................................................................................................... 4
Dernière impression le 15/04/17
Page 1 sur 100
Note technique
DEI
1.2.2
2.
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Configuration d’Apache Tomcat ..................................................................................................... 6
Paramétrage de l’environnement de développement....................................................... 8
2.1
Premier démarrage d’Eclipse 3.1 ..................................................................................................... 8
2.1.1 Choix de l’espace de travail à utiliser .............................................................................................. 8
2.1.2 Ecran de bienvenue .......................................................................................................................... 9
2.2
Réglage des préférences ....................................................................................................................10
2.2.1 Réglage de présentation de l’interface utilisateur ...........................................................................10
2.2.2 Préférences pour l’historique local .................................................................................................12
2.2.3 Réglage d’accès à Internet via le proxy ..........................................................................................13
2.2.4 Déclaration du JDK 1.4.2 complet à utiliser avec Eclipse ..............................................................14
2.2.5 Déclaration du serveur Tomcat 5 à utiliser avec Eclipse ................................................................16
2.2.6 Préférences de validation des fichiers XML ...................................................................................19
2.3
Perspectives et vues pour le développement d’applications Web .................................................21
2.3.1 Utilisation des Perspectives et Vues standard d’Eclipse .................................................................21
2.3.2 Perspective J2EE et vues associées .................................................................................................23
3.
Cycle de développement d’un projet............................................................................... 29
3.1
Création d’un nouveau projet Web dynamique .............................................................................29
3.1.1 Lancement de l’assistant de création de projet Web dynamique ....................................................29
3.1.2 Réglages du dialogue de l’assistant de projet Web dynamique .....................................................30
3.1.3 Génération de la structure du projet Web dynamique .....................................................................31
3.1.4 Structure du projet Web dynamique ..............................................................................................33
3.2
Développement du projet .................................................................................................................34
3.2.1 Ajout de pages HTML et JSP .........................................................................................................34
3.2.2 Edition de pages HTML et JSP .......................................................................................................35
3.2.3 Création d’une Servlet ....................................................................................................................40
3.3
Tester un projet .................................................................................................................................43
3.3.1 Exécution directe d’un projet avec déclaration d’un serveur de test à la volée...............................43
3.4
Déboguage d’une application sur le serveur ...................................................................................47
3.5
Modification de la configuration d’un serveur ...............................................................................49
3.6
Configuration des propriétés de déploiement d’une application Web .........................................51
3.6.1 Propriétés de déploiement et configuration du serveur ...................................................................51
3.6.2 Avantages liés à l’utilisation du fichier de contexte .......................................................................51
3.6.3 Création d’un fichier de contexte Tomcat (META-INF/context.xml) ............................................52
3.6.4 Exemples de fichiers « context.xml » .............................................................................................61
3.6.5 Notes complémentaires relatives à l’accès aux SGBD ...................................................................63
3.6.6 Problème de prise en compte du fichier de contexte Tomcat .........................................................64
3.7
Génération d’une archive WAR de l’application pour le déploiement ........................................66
3.7.1 Fabrication de l’archive WAR à l’aide de l’assistant d’export .......................................................67
3.7.2 Fabrication de l’archive WAR à l’aide d’un script Ant ..................................................................67
3.8
Génération d’une archive EAR de l’application pour le déploiement ..........................................68
3.8.1 Création d’un projet d’application d’entreprise et ajout d’un module Web ....................................68
3.8.2 Exportation de l’application d’entreprise sous forme d’archive EAR : ..........................................70
3.9
Déploiement des archives WAR ou EAR par DPI .........................................................................70
3.10
Gestion de dépendances entre projets .............................................................................................71
3.10.1
Dépendances entre projets ..........................................................................................................71
3.10.2
Exemple ......................................................................................................................................72
3.11
Développement coopératif : utilisation de CVS ..............................................................................80
Dernière impression le 15/04/17
Page 2 sur 100
Note technique
DEI
3.11.1
3.11.2
3.11.3
3.11.4
3.11.5
4.
V1.2.3
Configuration d’un référentiel CVS dans Eclipse ......................................................................81
Démarrage du projet : publication de la première version dans CVS .........................................82
Organisation du référentiel CVS ................................................................................................85
Importation d’un projet publié dans CVS ...................................................................................86
Synchronisation avec le référentiel CVS ....................................................................................89
Développement avec le framework DEI......................................................................... 98
4.1
5.
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
Configuration des propriétés JNDI liées à l’utilisation du framework DEI ................................98
Historique des versions ................................................................................................. 100
Dernière impression le 15/04/17
Page 3 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
1. Plate-forme de développement open-source
1.1
Pré-requis (packages)
Le développement d’applications Web pour la filière open-source requiert les
packages suivants :
 JDK 1.4.2 de Sun
 Apache Tomcat 5.0.28
 Eclipse 3.1 + Web Tools Platform 1.0
Le serveur de bases de données MySQL est en général installé dans un
environnement de développement/intégration partagé entre tous les membres d’un
projet.
L’accès au SGBD MySQL pour la création de bases, de tables, et la mise au point et
l’exécution de requêtes peut être facilité par l’installation du package optionnel
suivant :
 SQLYog 4.05 Free (outil graphique frontal pour MySQL)
1.2
Configuration des outils de développement
1.2.1 Configuration du JDK
Pour assurer le bon fonctionnement des outils et programmes qui dépendent du
JDK, il est primordial que la variable d’environnement « JAVA_HOME » soit bien
définie.
Note préliminaire : si vous n’avez pas les droits nécessaires pour définir des
variables d’environnement système,
vous pouvez cependant adapter la
procédure suivante pour définir une variable d’environnement utilisateur.
Procédure :
-
A partir du Menu Démarrer, ouvrir « Paramètres  Panneau de
configuration  Système »
-
dans le panneau « Propriétés Système » :
-
sélectionner l’onglet « Avancé »
-
cliquer sur le bouton « Variables d’environnement » :
Dernière impression le 15/04/17
Page 4 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
La boîte de dialogue « Variables d’environnement » s’affiche:
Dernière impression le 15/04/17
Page 5 sur 100
Note technique
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
DEI
-
Réf. : C-LABPR/IFD/05-169
V1.2.3
Cliquer sur le bouton « Nouveau.. » en dessous de la liste « Variables
système » pour créer une nouvelle variable d’environnement
Dans le dialogue « Nouvelle variable système » :
-
entrer « JAVA_HOME » comme nom de la variable,
entrer le répertoire d’installation sélectionné à l’étape 2 dans le champ
« valeur de la variable »
cliquer « OK »
De retour dans le dialogue « Variables d’environnement », vérifier que la
variable système « JAVA_HOME » a été définie correctement, puis cliquer
« OK » pour valider la modification :
1.2.2 Configuration d’Apache Tomcat
Pour assurer le bon fonctionnement des outils et programmes qui dépendent du
JDK, il est primordial que la variable d’environnement « CATALINA_HOME » soit
bien définie.
Procédure :
-
A partir du Menu Démarrer, ouvrir le panneau de configuration « Système »,
sélectionner l’onglet « Avancé » et cliquer sur le bouton « Variables
d’environnement » :
-
Dans la boîte de dialogue « Variables d’environnement » :
- Cliquer sur le bouton « Nouveau.. » en dessous de la liste « Variables
système » pour créer une nouvelle variable d’environnement
- Dans le dialogue « Nouvelle variable système » :
- entrer « CATALINA_HOME » comme nom de la variable,
- entrer le répertoire d’installation sélectionné à l’étape 4 dans le champ
« valeur de la variable »
- cliquer « OK »
Dernière impression le 15/04/17
Page 6 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
De retour dans le dialogue « Variables d’environnement », vérifier que la variable
système « CATALINA_HOME » a été définie correctement, puis cliquer « OK »
pour valider la modification.
Dernière impression le 15/04/17
Page 7 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
2. Paramétrage de l’environnement de développement
2.1
Premier démarrage d’Eclipse 3.1
2.1.1 Choix de l’espace de travail à utiliser
Au premier démarrage d’Eclipse, vous devez choisir l’emplacement où Eclipse
stockera votre espace de travail (« workspace »). L’espace de travail est un dossier
dans lequel Eclipse stockera vos projets. Le mécanisme employé est semblable à
celui d’IBM WebSphere Studio 5.1.1 :
-
L’utilisateur peut configurer plusieurs espaces de travail distincts utilisables
avec l’environnement de développement (pratique recommandée pour éviter
de mélanger différents projets au sein d’un même environnement)
L’utilisateur peut configurer le choix d’un espace de travail par défaut
automatiquement au démarrage.
AVERTISSEMENT IMPORTANT :
Par défaut Eclipse propose de créer l’espace de travail dans un sous-répertoire de
« Mes documents ».

Il est formellement déconseillé d’accepter cet emplacement par défaut :
en effet, la taille d’un espace de travail peut devenir très importante (plusieurs
dizaines de Mo), Or, le répertoire « Mes documents » fait partie du profil
utilisateur, qui est limité à 15 Mo. On risque donc dans ce cas de rapidement
dépasser le quota d’espace alloué et de devoir supprimer ou déplacer des fichiers
pour libérer de l’espace.

Dans tous les cas, éviter absolument d’utiliser des emplacements réseau,
qui d’une part sont soumis à des quotas d’espace, et d’autre part n’offrent pas de
performances suffisantes (débit en lecture/écriture) pour une utilisation correcte.

Il est également déconseillé d’utiliser un sous-répertoire d’Eclipse pour
éviter le risque de perte de données en cas d’une mise à jour du package Eclipse.

RECOMMANDATION : Comme emplacement de « workspace », sélectionner
un répertoire sur le disque dur local de la machine. La meilleure solution est
de créer un sous-répertoire dans le répertoire partagé « C:\Local » (par
exemple : « C:\Local\eclipse\workspace »)
Dernière impression le 15/04/17
Page 8 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Exemple — sélection de « C:\Local\eclipse\workspace » pour l’espace de
travail :
-
cliquer sur « Browse » pour choisir et/ou créer le répertoire à utiliser pour
l’espace de travail, ou le saisir directement dans le champ texte
« Workspace »
-
désactiver la case à cocher indiquant à Eclipse d’utiliser cet emplacement
par défaut. Il est préférable en effet qu’Eclipse demande confirmation de
l’emplacement à utiliser à chaque démarrage. Ceci facilite également le
changement de « workspace » au démarrage.
2.1.1.1 Choix de l’espace de travail à utiliser par option de ligne de commande :
L’utilisateur peut également forcer l’utilisation d’un espace de travail particulier en
créant un raccourci vers le programme eclipse.exe et en ajoutant un argument à
la ligne de commande pour lancer le raccourci :
Syntaxe :
eclipse.exe -data <chemin_de_l’espace_de_travail>
Exemple :
eclipse.exe -data c:\Local\eclipse\workspace_projet1
2.1.2 Ecran de bienvenue
Une fois la sélection de l’espace de travail effectuée, le chargement d’Eclipse se
poursuit jusqu’à l’affichage d’un écran de bienvenue comportant plusieurs liens
vers des informations, fichiers d’aide et exemples concernant Eclipse 3.1. Fermer
l’écran de bienvenue pour accéder à l’espace de travail.
Noter que l’interface utilisateur est en anglais. Une version francisée de
l’interface utilisateur ne sera pas disponible avant août/septembre 2005, au mieux.
Noter également que le thème par défaut est assez différent du thème de WSAD
5.1 ou d’Eclipse 2.1 (notamment, les perspectives sont affichées sur une barre
d’onglets en haut à droite) :
Dernière impression le 15/04/17
Page 9 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Cependant, les réglages des préférences permettront de modifier le thème par
défaut afin qu’il s’apparente plus à l’interface familière de WSAD 5.1.
2.2
Réglage des préférences
Rappel : avec Eclipse ou WSAD, les préférences sont propres à un espace de
travail (« workspace ») donné. Si l’on définit un nouvel espace de travail, il faut
alors re-configurer les préférences pour ce nouvel espace de travail.
Bien qu’Eclipse 3.1 inclue des fonctionnalités d’import et d’export de préférences,
elles ne semblent pas encore fonctionner correctement. Il faudra donc
reconfigurer manuellement les préférences pour chaque nouvel espace de travail
utilisé.
Sélectionner l’option de menu « Window  Preferences ». Le dialogue de réglage
des préférences s’affiche :
- le panneau de gauche contient une liste hiérarchique de catégories
- le panneau de droite affiche les options de réglage de la catégorie sélectionnée
2.2.1 Réglage de présentation de l’interface utilisateur
-
dans le panneau
Appearance »
Dernière impression le 15/04/17
de
gauche,
sélectionner
la
catégorie
« General

Page 10 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Pour modifier le thème par défaut de façon à revenir à une interface utilisateur
similaire à celle de WSAD 5.1, régler les options suivantes (voir copie d’écran cidessus) :
-
dans « Perspective switcher positions », sélectionner « Left »
dans « Current Presentation », sélectionner « Eclipse 2.1 Presentation »
décocher la case « Show text on perspective bar »
cocher la case « Show traditional style tabs »
-
Enfin, cliquer sur « Apply ». Une boîte d’alerte (« Confirm Presentation
Change ») vous informe qu’il faut redémarrer Eclipse afin que les
changements prennent effet. Cliquer « Yes » pour confirmer le
redémarrage.
Une fois le redémarrage effectué, on retrouve
« traditionnelle » d’Eclipse 2.1 et de WSAD 5.1 :
Dernière impression le 15/04/17
la
présentation
Page 11 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Sélectionner à nouveau l’option « Window  Preferences » pour continuer
les réglages.
2.2.2 Préférences pour l’historique local
-
dans le panneau de gauche des préférences, sélectionner la sous-catégorie
« General  Local History »
dans le panneau de droite, modifier les valeurs existantes selon le tableau cidessous :
Intitulé
Description
Days to keep files
Nombre de jours pendant lesquels les modifications
locales réalisées sur les fichiers du projet sont
conservées dans l’historique
Nombre maximal de versions successives d’un même
fichier conservées dans l’historique local
Taille maximale de fichier (en Mo) au dessus de
laquelle aucun historique local n’est conservé. Seuls
les fichiers dont la taille est inférieure à la valeur
indiquée verront leurs modifications enregistrées dans
l’historique local
Entries per file
Maximum file size
Valeur
recommandée
30
50
1
Une fois les valeurs renseignées comme illustré sur la copie d’écran ci-après, cliquer
sur « Apply » pour enregistrer vos modifications.
Dernière impression le 15/04/17
Page 12 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
2.2.3 Réglage d’accès à Internet via le proxy
NOTE IMPORTANTE – Connexion à Internet requise :
Actuellement, il est impératif de disposer d’une connexion à Internet avec
Eclipse Web Tools Platform pour pouvoir effectuer les tâches suivantes :
- créer des nouveaux projets Web dynamiques: Eclipse doit récupérer les
DTDs ou schémas XML correspondant aux descripteurs J2EE, notamment les
descripteurs de déploiement d’applications Web (fichiers web.xml)
- créer des Servlets au sein d’un projet Web dynamique.
- valider les différents fichiers XML des projets
 Si aucune connexion Internet n’est accessible, il sera impossible de
créer de nouveaux projets Web, ou de créer des Servlets dans un projet
Web.
Résolution :
Une solution de contournement à ce problème est à l’étude. Cette solution
s’appuierait sur les fonctionnalités du catalogue XML (« XML Catalog »), mécanisme
permettant de configurer Eclipse afin qu’il utilise des copies locales des schémas XML
et DTDs utilisés au lieu de les récupérer via la connexion Internet (c’est le principe
mise en œuvre dans WebSphere Studio 5.1).
A l’heure actuelle cependant, cette solution n’est pas encore au point.
Dernière impression le 15/04/17
Page 13 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Dans le panneau de gauche des préférences, sélectionner la sous-catégorie
« Internet  Proxy Settings »
Dans
-
-
le panneau de droite :
cocher la case « Enable proxy »
dans « Proxy host », indiquer le nom ou l’adresse IP du proxy ICDC :
« ssproxyep.serv.cdc.fr » ou « 10.12.0.73 »
dans « Proxy port », indiquer le port utilisé par le proxy : 8085
ne pas cocher les cases use « SOCKS » ou
« Enable proxy
authentication ». En effet, le mode de connexion au proxy Internet vient
d’être modifié (au 1er juin 2005) : désormais, l’authentification est
transparente, elle utilise le nom d’utilisateur Windows.
cliquer sur « Apply » pour enregistrer les réglages effectués
2.2.4 Déclaration du JDK 1.4.2 complet à utiliser avec Eclipse
Eclipse 3.1 embarque son propre environnement d’exécution Java (JRE 1.4.2)
dans le sous-répertoire jre/ de l’installation. En effet, intégrant son propre
compilateur Java, Eclipse n’a pas besoin d’un kit de développement Java complet
(JDK) pour compiler les projets Java.
En revanche, l’utilisation du serveur d’application Tomcat à partir d’Eclipse
nécessite l’utilisation d’un JDK complet avec Eclipse : en effet, Tomcat fait appel
au compilateur Java de la bibliothèque « tools.jar » présente uniquement dans le
JDK.
Dernière impression le 15/04/17
Page 14 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Avec Eclipse, il est possible de déclarer et de configurer plusieurs JRE ou JDK
différents, et de modifier celui qui est utilisé par défaut pour tous les projets.
Nous allons donc déclarer sous Eclipse le JDK 1.4.2 complet qui doit avoir été
installé séparément sur le poste, et configurer ce JDK comme environnement Java
par défaut à utiliser pour tous les projets ;
-
dans la fenêtre des préférences, naviguer vers la sous-catégorie
« Java  Installed JREs »
dans le panneau de droite, cliquer sur « Add » pour déclarer un nouvel
environnement Java :
Le dialogue « Add JRE » s’affiche :
Dernière impression le 15/04/17
Page 15 sur 100
Note technique
DEI
-
-
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
dans le champ « JRE name », entrer : « JDK 1.4.2 »
cliquer sur le bouton « Browse… », et naviguer jusqu’au répertoire
d’installation du JDK (par ex.: C:\j2sdk1.4.2_07) et valider.
Le chemin s’affiche dans le champ « JRE Home directory », et la liste des
bibliothèques système associées au JDK s’affiche dans la liste au-dessous de la
case « Use default system libraries ».
cliquer « OK » pour valider la déclaration du JDK
De retour dans la fenêtre des Préférences, cocher la case en regard du JDK
nouvellement ajouté dans la liste « Installed JREs » :
Comme le précise le texte souligné dans la photo d’écran ci-avant, « le JRE
sélectionné sera utilisé par défaut pour compiler et exécuter les programmes
Java ».
Cliquer sur « OK » pour valider le changement de configuration.
2.2.5 Déclaration du serveur Tomcat 5 à utiliser avec Eclipse
Les applications Web développées avec Eclipse 3.1 sont en principe destinées à
être déployées sur le serveur d’application Tomcat v5.0.28
(ou version
supérieure).
Le package Tomcat 5.0.28 doit en principe avoir été installé séparément sur le
poste de développement.
La déclaration du serveur Tomcat local sous Eclipse s’effectue à travers les étapes
suivantes :
Dernière impression le 15/04/17
Page 16 sur 100
Note technique
DEI
-
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Dans le dialogue des préférences, naviguer jusqu’à la sous-catégorie
« Servers  Installed Runtimes ». Dans le panneau de droite, cliquer sur
« Add » pour déclarer l’installation Tomcat locale en tant que serveur sous
Eclipse :
Le dialogue « New Server Runtime » apparaît. Dans la liste hiérarchique des
types de serveurs, sélectionner « Apache  Apache Tomcat v5.0 » et cliquer sur
« Next » :
Dernière impression le 15/04/17
Page 17 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Dans le dialogue suivant :
- cliquer sur « Browse… » et localiser
le répertoire d’installation de Tomcat
5. Le chemin sélectionné apparaîtra
dans
le
champ
« Tomcat
installation directory ».
- dans la liste déroulante « JRE : »,
vérifier que l’environnement Java
sélectionné est bien « JDK 1.4.2 »
déclaré
à
l’étape
2.2.4.
Si
l’environnement sélectionné est un
JRE simple, un message d’alerte sera
affiché en en-tête de la boîte de
dialogue tant que la sélection d’un
JDK complet n’aura pas été effectuée
(comme illustré ci-contre) :
Cliquer ensuite sur « Finish » pour valider la déclaration du serveur.
De retour dans la fenêtre des préférences, cocher la case en regard du serveur
nouvellement déclaré : comme l’indique le texte souligné dans la copie d’écran cidessous, « l’environnement serveur sélectionné sera utilisé par défaut lors de la création
de nouveaux projets ».
Enfin, cliquer sur « OK » pour valider les modifications apportées.
Dernière impression le 15/04/17
Page 18 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
2.2.6 Préférences de validation des fichiers XML
Dans la fenêtre des préférences, la catégorie « Validation » permet de régler les
options relatives :
- au contrôle des documents XML, DTD et XML-Schema (contrôle du caractère
« bien formé » du document, respect de la DTD ou du schéma associé)
- aux contrôles de validation J2EE (conformité des projets WAR/EAR/EJB-JAR
etc.)
La figure suivante illustre les options de validation sélectionnées par défaut :
Attention : les options de validation ne peuvent fonctionner qu’à condition que la
connexion Internet via le proxy ait été correctement configurée (cf. § 2.2.3)
Si l’accès à Internet est désactivé (connexion via le proxy Internet désactivée,
indisponible, ou non autorisée), il est possible de désactiver les options de
validation (décocher l’ensemble des options).
Dernière impression le 15/04/17
Page 19 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Signalement des erreurs/avertissements dans les pages JSP/HTML :
Que les options de validation soient activées ou désactivées, Eclipse signale les
éventuelles erreurs dans les pages JSP ou HTML uniquement dans la fenêtre de
l’éditeur. Les erreurs ou warnings n’apparaissent pas dans la liste des problèmes (vue
« Problems »)
IMPORTANT – Nécessité d’une connexion Internet
Quel que soit le réglage des options de validation, Web Tools Platform essaie
systématiquement d’accéder à Internet à l’ouverture des projets Web, afin notamment
de contrôler les schémas ou DTDs des descripteurs de déploiement. Il est donc impératif
de configurer l’accès à Internet comme indiqué dans les sections précédentes.
Note : avec la configuration actuelle (authentification transparente et automatique),
aucun problème lié à la connectivité Internet ne sera rencontré.
En revanche, en cas de configuration du mode d’authentification manuelle au
proxy, (case « authentification requise » cochée, mais aucun nom d’utilisateur ou mot
de passe précisé), des blocages peuvent se produire. En effet, pour
l’authentification, Eclipse doit afficher une fenêtre de connexion, mais il semble que
dans certains cas le dialogue modal s’affiche par erreur « derrière » la fenêtre principale
d’Eclipse, causant ainsi le blocage total du programme). Si ce cas de figure se produit, a
seule solution est de forcer l’arrêt du processus Eclipse à l’aide du Gestionnaire de
Tâches.
Résolution :
- Ce problème peut généralement être évité si on évite d’ouvrir directement
l’arborescence d’un projet dynamique au démarrage d’Eclipse. Avant d’ouvrir le
projet, il est conseillé d’attendre quelques secondes que la fenêtre d’authentification
au proxy apparaisse spontanément. On peut aussi effectuer un clic droit sur le nom
du projet et sélectionner « Propriétés » ce qui déclenche l’apparition de cette
fenêtre d’authentification.
 Ceci se produit quel que soit le réglage des options de validation.
 La meilleure solution d’éviter cette cause possible de blocage est :
si le proxy est capable de réaliser une authentification transparente (comme c’est
le cas depuis le 1er juin 2005), désactiver l’option « authentification au proxy »
dans les réglages du proxy
dans le cas contraire, activer non seulement l’option « authentification au proxy »,
mais renseigner également le nom et le mot de passe à utiliser pour le proxy
Internet.
Dernière impression le 15/04/17
Page 20 sur 100
Note technique
DEI
2.3
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Perspectives et vues pour le développement d’applications
Web
2.3.1 Utilisation des Perspectives et Vues standard d’Eclipse
Eclipse 3.1 propose en standard un nombre important de perspectives et de vues.
Parmi elles, certaines sont particulièrement utiles pour le développement, ou pour
certaines tâches précises :
2.3.1.1 Ouverture des perspectives et des vues
L’ouverture des différentes perspectives s’effectue via le menu « Window  Open
Perspective ». Ce menu comporte en standard des « raccourcis » vers certaines
perspectives usuelles, ainsi qu’une option « Other… » qui permet de sélectionner
une perspective particulière à ouvrir.
De la même façon, le menu « Window  Show View » permet d’ouvrir différentes
vues. Il propose des « raccourcis » vers certaines vues, ainsi qu’une option
« Other… » permettant de sélectionner une vue particulière à ouvrir.
Le menu « Window  Customize Perspective… » permet de sélectionner les
« raccourcis » présentés dans les menus « Window  Open Perspective » et
« Window  Show View ». Il comporte 2 onglets :
 l’onglet « Shortcuts » : il permet de configurer différents raccourcis dans
les menus. La liste déroulante « Sub-menus » propose plusieurs options
permettant de configurer différents types de raccourcis :
o l’option « New » : permet de configurer quelles options sont présentées
pour la perspective courante, à la fois dans le menu « File  New », et
dans le menu contextuel « New » des vues de type « Explorateur ».
o l’option « Open Perspective » : permet de configurer les perspectives à
présenter sous forme de raccourcis dans le menu « Window  Open
Perspective » pour la perspective courante
o l’option « Show View » : permet de configurer les vues à présenter
sous forme de raccourcis dans le menu « Window  Show View » pour
la perspective courante
 l’onglet « Commands» : il permet d’activer ou de désactiver certaines
options de la barre de menus et certains boutons de la barre d’outils.
2.3.1.2 Principales perspectives utilisées
Les principales perspectives utilisées pour le développement sont :
La perspective « Java » : elle intègre principalement la vue « Package
Explorer » qui présente une vue arborescente des différents projets
Dernière impression le 15/04/17
Page 21 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
dans l’espace de travail. Elle permet d’explorer la structure arborescente
de chaque projet, et présente les différents fichiers source Java suivant la
hiérarchie des packages auxquels ils appartiennent.
La perspective « Resource» : elle intègre principalement la vue
« Navigator » qui présente une vue arborescente des différents projets
dans l’espace de travail. Elle permet d’explorer la hiérarchie des différents
dossiers et fichiers d’un projet.
La perspective « Debug » : utilisée pour le déboguage des applications,
elle intègre plusieurs vues spécifiques comme la liste des points d’arrêt
placés au sein des fichiers source, la pile des appels de méthodes en
cours, et une vue permettant d’examiner le contenu des objets en
mémoire à l’exécution.
La perspective « CVS Repository Exploring » ; elle est utilisée pour
définir des emplacements de référentiels CVS et permet d’importer
localement un projet publié dans CVS en tant que projet dans l’espace de
travail.
La perspective « Team Synchronizing » : elle est utilisée pour les
opérations de mise à jour des fichiers d’un projet entre l’espace de travail
et le référentiel CVS associé au projet.
2.3.1.3 Principales vues utilisées
Par défaut, chaque perspective intègre un certain nombre de vues. Il est cependant
possible de personnaliser les vues affichées dans chaque perspective, en ajoutant
ou en supprimant des vues. Les vues les plus utilisées sont les suivantes


Les vues de type « Explorateur de projets » : notamment, la vue
« Navigator » affichée par défaut dans la perspective « Resource »,
ainsi que la vue « Package Explorer » affichée par défaut dans la
perspective « Java ».
Les vues présentant des informations d’état sur l’environnement ou les
projets : elles sont regroupées dans la catégorie « Basic ». Parmi ces
vues, les plus utilisées sont :
 La vue « Problems » : elle liste les avertissements et erreurs de
compilation présents dans les différents projets ouverts de
l’espace de travail
 La vue « Tasks » : elle recense les items de type « tâche »
présents dans les fichiers sources des projets ouverts. Un item de
type « tâche » est simplement un commentaire Java débutant par
le mot clé « TODO ».
Exemple :
Dernière impression le 15/04/17
public class ClientBean {
public ClientBean() {
// TODO : Add code to the constructor
}
}
Page 22 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0




Réf. : C-LABPR/IFD/05-169
V1.2.3
La vue « Search » : elle présente les résultats d’une recherche
effectuée au sein d’un ou plusieurs fichiers source.
La vue « Console » : à l’exécution d’une application, elle affiche
les différents messages générés par l’application. Les messages
écrits sur la sortie standard (System.out) s’affichent en bleu, et
les messages écrits sur la sortie d’erreur standard (System.err)
s’affichent en rouge.
La vue « Progress » : Eclipse 3.1 permet d’exécuter certaines
tâches longues (comme la recompilation d’un projet) en tâche de
fond, en sélectionnant l’option « Run in Background » dans les
dialogues de progression. Les tâches s’exécutant en arrière-plan
s’affichent alors dans la vue « Progress ». Cette vue permet
également d’annuler une tâche de fond en cours d’exécution.
Les vues spécifiques au débogage : parmi ces vues, on trouve
notamment :
 La vue « Debug » : elle affiche la liste des différents threads des
applications en cours d’exécution, ainsi que leur état (stoppé,
actif, ou terminé). Pour chaque thread, la pile des appels de
méthodes en cours est affichée sous forme arborescente
 La vue « Breakpoints » qui affiche la liste des points d’arrêt
configurés dans les différents fichiers source de l’application.
Cette vue permet de désactiver temporairement ou de supprimer
des points d’arrêt.
 La vue « Variables » : au cours du débogage en mode pas-à-pas
d’un thread, elle affiche la liste des variables (objets) accessibles
à ce thread, et permet d’examiner le contenu de ces objets. Il est
possible de naviguer à travers le « graphe objet » (hiérarchie de
références vers d’autres objets) de chaque variable.
 La vue « Display » : en mode débogage pas-à-pas, elle permet
d’entrer une expression Java, de l’exécuter et d’en examiner le
résultat (objet résultant de l’exécution du code).
 La vue « Expressions » : similaire à la vue « Display », elle
permet en outre de suivre l’évolution au cours du temps de
l’évaluation d’une expression Java : les expressions ajoutées à la
vue « Expressions » sont en effet réévaluées après l’exécution de
chaque instruction.
2.3.2 Perspective J2EE et vues associées
L’environnement de développement Eclipse 3.1 packagé est complété par un
ensemble de plug-ins dédiés au développement J2EE et appelé « Web Tools
Platform ».
Le complément « Web Tools Platform » est basé sur une contribution d’IBM à
Eclipse, et reprend presque à l’identique l’interface utilisateur de WSAD 5.1,
facilitant ainsi l’apprentissage de l’outil.
A la différence de WSAD qui comporte une perspective « Web » et une perspective
« J2EE », le complément « Web Tools Platform » ne propose actuellement qu’une
seule perspective « J2EE ».
Dernière impression le 15/04/17
Page 23 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Pour afficher la perspective « J2EE » par défaut, sélectionner l’option de menu
« Window  Open Perspective  Other… » et choisir « J2EE » dans la liste qui
apparaît :
Présentation par défaut de la perspective J2EE :
L’icône de la perspective J2EE est similaire à celle utilisée dans WSAD.
Dernière impression le 15/04/17
Page 24 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
La perspective J2EE comprend :
 la vue Explorateur de Projets (« Project Explorer ») :
Cette vue correspond à la vue « Hiérarchie J2EE » de WSAD. Les projets de
l’espace de travail y sont classés suivant leur nature :
 projets d’applications d’entreprise (« Enterprise Applications ») :
regroupe les modules d’entreprise au format EAR (Enterprise application
archive)
 projets clients d’applications («Application Client projects ») :
regroupe les projets clients pour les composants EJB, les services Web, etc.,
qui peuvent être packagés sous forme d’archives JAR (Java archive)
 projets de connecteurs J2EE (« Connector Projects ») : regroupe les
projets de connecteurs implémentant l’API J2C (Java2 Connector), et
packagés sous la forme de modules RAR (Resource adapter archive)
 projets EJB (« EJB projects ») : regroupe les projets de composants EJB,
qui sont packagés sous forme d’archives EJB-JAR
 projets d’applications Web (« Dynamic Web Projects ») : regroupe les
projets d’applications Web, qui sont packagés en tant que modules Web au
format WAR (Web application archive)
 projets de services Web (« Web Services ») : regroupe les projets de
services Web développés suivant les normes SOAP et WSDL, et réalisés à
travers les API Java JAX-RPC, JAXM et SAAJ. L’environnement de
développement intègre des fonctions de génération de services Web pour le
toolkit Apache Axis 1.1.
 autres projets (« Other Projects ») : regroupe les projets ne rentrant
pas dans les catégories précitées. On y retrouve, entre autres :
o les projets Java « simples »
o les projets « Serveur » : ils contiennent les configurations de
serveur pour le test et le déploiement d’applications Web. Ces projets
correspondent aux « serveurs » qui apparaissent dans la vue
« Servers » décrite ci-dessous.
 la vue Serveurs (« Servers ») :
Cette vue correspond à la vue « Serveurs » de WSAD : elle liste les différents
serveurs configurés dans l’environnement de développement à des fins de test, et
permet d’effectuer différentes actions :
 créer un nouveau serveur
 associer/retirer des projets à un serveur
Dernière impression le 15/04/17
Page 25 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
 éditer la configuration d’un serveur
 démarrer/arrêter un serveur (exécution en mode normal ou « déboguage »)
Pour l’instant cette vue est vide, car aucun serveur n’a encore été configuré. La
création d’un serveur de test s’effectue typiquement lors de la création d’un
nouveau projet.
 Configuration du Navigateur Internet à utiliser.
Pour tester une application Web, on doit évidemment utiliser un navigateur
Internet. A l’instar de WSAD, l’ensemble de plug-ins « Web Tools Platform »
permet d’utiliser soit un navigateur Internet installé sur la machine, soit un
navigateur Web intégré à l’environnement de développement.
Configuration du Navigateur Web à utiliser :
Lors de l’exécution d’une application Web, Eclipse ouvre automatiquement une
fenêtre de navigateur Web affichant soit la page de démarrage de l’application
exécutée.
Le navigateur Web par défaut utilisé par Eclipse est paramétré dans le dialogue
des préférences (menu « Window  Preferences »), dans la catégorie
« Internet  Web Browser » :
Note : par défaut, le navigateur Web intégré d’Eclipse est sélectionné. Eclipse
détecte é automatiquement si les navigateurs Web Internet Explorer et/ou Mozilla
Firefox sont installés sur la machine. Il est également possible de déclarer
manuellement d’autres navigateurs (par exemple, le navigateur Opera)
en
cliquant sur le bouton « Add… ».
Configuration d’Eclipse pour l’affichage d’une fenêtre de navigateur Web :
Dans la terminologie Eclipse, le navigateur Web n’est pas une « vue », mais un
« éditeur ». En tant que tel, il n’est pas présent dans la liste des vues accessibles
depuis le menu « Window  Show View ». Cependant, il est possible d’ajouter
Dernière impression le 15/04/17
Page 26 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
un bouton dans la barre d’outils d’Eclipse permettant d’ouvrir une fenêtre du
navigateur Web sélectionné dans les préférences :
-
Sélectionner l’option de menu « Window  Customize Perspective… »
Le dialogue « Customize Perspective » s’affiche. Sélectionner l’onglet
« Commands »
Dans la liste « Available commands groups » de l’onglet « Commands »,
scroller tout en bas, cocher l’option « Web Browser », et cliquer sur « OK »
pour valider, comme indiqué sur l’illustration ci-après :
Ceci a pour effet :
 d’ajouter un bouton « Open
Web Browser » à la barre
d’outils
de
la
perspective
courante :
 de rajouter une option « Web
Browser »
dans
le
menu
« Window ». Les différentes
sous-options
de
ce
menu
permettent
de
modifier
le
navigateur par défaut qui sera
utilisé par Eclipse : soit le
navigateur intégré (« Internal
Web Browser »), soit un
navigateur Internet « externe »
Dernière impression le 15/04/17
Page 27 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
(Internet
Explorer,
Mozilla
Firefox,
ou
tout
autre
navigateur configuré dans les
préférences).
Dernière impression le 15/04/17
Page 28 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
3. Cycle de développement d’un projet
3.1
Création d’un nouveau projet Web dynamique
3.1.1 Lancement de l’assistant de création de projet Web dynamique
Cette étape peut s’effectuer :

soit à partir de la barre de menu principal d’Eclipse :
- sélectionner
« File

Project… »
l’option
New

- Dans le dialogue « New
Project »,
dérouler
l’arborescence
des
assistants (« Wizards »)
et
sélectionner
l’item
« Web  J2EE Web
Project »
- cliquer sur « Next >»

soit à partir du menu contextuel de la vue « Project Explorer » dans
la perspective J2EE :
- sélectionner
« Dynamic
Projects »
le
nœud
Web
- effectuer un clic droit
pour afficher le menu
contextuel
- sélectionner l’option
« New 
J2EE Web Project »
Dernière impression le 15/04/17
Page 29 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
3.1.2 Réglages du dialogue de l’assistant de projet Web dynamique
Une fois l’étape précédente effectuée, le dialogue de création de projet Web
dynamique s’affiche :
1. Entrer un nom pour le projet Web dans le champ « Name » (par ex. :
« WebProj1 »).
Attention : Il est fortement déconseillé d’utiliser des espaces dans le
nom ! En effet, par défaut le nom du projet sera celui du contexte Web
(première partie du chemin de l’URL d’accès au module) du projet.
Note — message d’alerte [encadré en bleu sur la copie d’écran ci-dessus] :
Une fois le nom du projet choisi, un message d’alerte apparaît dans le bandeau
supérieur du dialogue. Ceci est du aux valeurs par défaut de certaines options
qu’il nous faudra corriger en modifiant les réglages supplémentaires de
l’assistant. En effet, l’assistant essaie automatiquement d’associer chaque
nouveau projet Web dynamique à un projet d’application d’entreprise (EAR). Or,
le serveur cible sélectionné par défaut (Tomcat 5.0 dans notre cas) n’est pas
compatible avec les projets EAR, et c’est pour cette raison que le message
d’alerte est affiché.
2. Cliquer sur le bouton « Show Advanced > » pour révéler les options
supplémentaires de l’assistant et ajuster les réglages :
-
Tout d’abord, il convient de corriger la version de l’API Servlet sélectionnée :
Dans le champ « Servlet Version », sélectionner la version « 2.3 » à la
place de la version « 2.4 » affichée par défaut.
-
Vérifier ensuite que le serveur cible par défaut (champ « Target Server »)
est bien « Apache Tomcat v5.0 »
-
Désélectionner la case « Add module to an EAR project » : le message
d’alerte précité disparaît du bandeau supérieur.
Dernière impression le 15/04/17
Page 30 sur 100
Note technique
DEI
-
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Vérifier que les cases « Add support for annotated Java classes » et
« Use flexible project structure » sont bien désactivées.
Racine du contexte : Noter que par défaut, le nom du projet Web
(champ « Name » en haut du dialogue) est utilisé comme valeur par
défaut pour le contexte racine de l’application Web (champ
« Context Root » au bas du dialogue).
Il est possible (mais fortement déconseillé pour des raisons d’organisation
et de « cohérence ») d’utiliser une valeur différente du nom du projet pour
la racine du contexte Web.
Une fois les réglages effectués, cliquer sur « Finish » pour terminer la
création du projet.
3.1.3 Génération de la structure du projet Web dynamique
Le générateur de l’assistant commence alors la création de la structure du
projet (organisation en répertoires et sous-répertoires) ainsi que les
squelettes de certains fichiers).
En particulier, le générateur doit créer un squelette pour le
descripteur de déploiement Web du projet (fichier « web.xml » dans le
sous-répertoire « WEB-INF » à la racine du contexte Web de l’application).
Dernière impression le 15/04/17
Page 31 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Dernière impression le 15/04/17
Réf. : C-LABPR/IFD/05-169
V1.2.3
Page 32 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Pour créer ce descripteur de déploiement, le générateur de code doit accéder
au fichier de définition XML du descripteur (fichier DTD ou schéma XML
suivant les versions de J2EE).
Pour ce faire, Eclipse doit accéder à Internet.
Si le paramétrage du proxy n’a pas été effectué correctement, ou si les
informations d’authentification sont invalides, Eclipse ne pourra pas
terminer correctement la création du projet, et des messages d’erreur
apparaîtront.
3.1.4 Structure du projet Web dynamique
Une fois le projet Web dynamique créé, on peut examiner sa structure arborescente
dans l’explorateur de projets (« Project Explorer ») :
On note donc deux principaux sous-répertoires dans la structure du projet :

JavaSource : ce dossier contiendra les différents fichiers source Java du
projet (servlets et autres classes Java) organisés en packages.

WebContent : ce dossier représente la racine du contexte Web de
l’application et contiendra l’ensemble des ressources Web de
l’application qui seront déployées sur le serveur :
Dernière impression le 15/04/17
Page 33 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
o
o
o
o
3.2
Réf. : C-LABPR/IFD/05-169
V1.2.3
les pages HTML et JSP, les images, les fichiers Javascript et
les feuilles de style CSS : ces différentes ressources peuvent
être créées à la racine du dossier « WebContent » ou bien dans
des sous-répertoires spécifiques.
les classes Java compilées, placées automatiquement dans le
sous-répertoire WEB-INF/classes
les bibliothèques Java utilisées par l’application, placées
automatiquement dans le sous-répertoire WEB-INF/lib
le descripteur de déploiement « web.xml », qui est
représenté « en double » et accessible soit :
- sous la forme d’une structure arborescente immédiatement
au-dessous du nœud principal du projet « WebProj1 » (sousnœud « WebProj1 » dont l’icône porte le numéro de la version
de l’API Servlet utilisée)
- sous la forme d’un fichier placé dans le sous-répertoire WEBINF/ comme il est prescrit dans la norme J2EE.
Développement du projet
3.2.1 Ajout de pages HTML et JSP
Les pages JSP et HTML par défaut (« index.html », « index.jsp ») sont
généralement placées à la racine du contexte Web de l’application (qui correspond
au dossier « WebContent » du projet). Les autres pages peuvent être librement
organisées, le plus souvent par « rubriques » classées dans des sous-dossiers.
A la différence de WSAD, Eclipse WTP ne comporte pas encore d’assistants
spécifiques à la création de pages HTML ou JSP (Eclipse WTP offre cependant des
fonctions de colorisation syntaxique et de complétion semi-automatique de code).
Pour créer une page HTML ou JSP :
1. Sélectionner le nœud « WebContent » dans l’explorateur de projets et afficher
le menu contextuel par un clic droit. Sélectionner l’option « New  File ». Une
boîte de dialogue s’affiche.
2. Vérifier que le dossier parent (endroit où sera créée la page) est bien
sélectionné dans la liste arborescente, et entrer le nom désiré pour la page (par
ex. : « index.jsp ») dans le champ « File name ». Cliquer ensuite sur
« Finish » pour valider.
Dernière impression le 15/04/17
Page 34 sur 100
Note technique
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
DEI
V1.2.3
3.2.2 Edition de pages HTML et JSP
L’édition des pages JSP et HTML s’effectue en mode « source » uniquement, avec
l’éditeur de texte Eclipse. Les seules aides disponibles sont :
 la colorisation syntaxique pour les éléments et attributs HTML et JSP
 l’assistance au contenu (« complétion ») pour les tags et attributs HTML
et JSP
 la détection des erreurs de structure XML (tag mal fermé, etc..) et la
détection des erreurs ou avertissements Java dans les pages JSP. Au
sujet de la détection des erreurs Java cependant, 2 points à noter :
o lorsqu’on utilise des inclusions de pages JSP, de « fausses
erreurs » peuvent être signalées, car Eclipse ne réalise pas
l’inclusion des JSP pour effectuer le contrôle d’erreurs
o Les erreurs sont signalées uniquement dans l’éditeur (marques
rouges pour les erreurs, et jaunes pour les avertissements). Les
erreurs ne sont pas reprises dans la vue des erreurs (vue
« Problems »).
3.2.2.1 Fragments de code
Pour faciliter l’édition des pages JSP, on peut utiliser le mécanisme des
« fragments » (« snippets ») qui permet de définir des « bouts de code » ou des
« fragments de page » JSP que l’on peut ensuite réutiliser facilement par
glisser/déplacer.
Les « fragments » sont accessibles par la vue du même nom (« Snippets ») :
A
partir
du
menu
« Window 
Dernière impression le 15/04/17
Show
View 
Other… »,
sélectionner
Page 35 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
« Snippets » dans la catégorie « Basic » :
Les « fragments » sont regroupés par catégories. Par défaut, Eclipse propose une
seule catégorie « JSP » rassemblant des éléments JSP souvent utilisés :
Par exemple, pour insérer une directive « page » dans l’éditeur, à la position
courante du curseur, on peut :
- soit double-cliquer sur le fragment correspondant dans la fenêtre « Snippets »
- soit glisser/déplacer le fragment JSP depuis la fenêtre « Snippets » vers
l’éditeur
Dernière impression le 15/04/17
Page 36 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Il est également possible de créer ses propres fragments réutilisables, et de
les ajouter à des catégories personnalisées, de la manière suivante :
1. Sélection d’une région de texte à sauvegarder en tant que fragment
(ici, la sélection représente le code HTML pour un tableau vide comportant une
ligne et 2 colonnes)
Afficher le menu contextuel sur la sélection (clic droit), et choisir l’option
« Add to Snippets… »
2. Le fragment doit être sauvegardé dans une nouvelle catégorie. Une boîte de
dialogue permet de choisir le nom de la catégorie à créer (ici : « HTML ») :
3. Une fois la catégorie sélectionnée, le dialogue « Customize Palette »
apparaît. Cette boîte de dialogue permet de donner un nom à notre nouveau
fragment, et éventuellement d’en modifier le contenu textuel :
Dernière impression le 15/04/17
Page 37 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
-
dans le champ « Name », remplacer la valeur par défaut (« Unnamed ») par
un nom descriptif : « Tableau 2x1 » indiquant que ce fragment représente un
tableau de 2 cases par une. Le nom modifié est également mis à jour dans le
panneau de gauche qui regroupe l’ensemble des fragments classés par
catégorie.
-
si nécessaire, il est possible de modifier le « texte source » du fragment qui est
affiché dans la zone d’édition « Template Pattern »
Dernière impression le 15/04/17
Page 38 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
4. 4. Une fois le dialogue validé, le nouveau fragment apparaît dans la fenêtre
« Snippets » au sein de la catégorie nouvellement créée :
Par la suite, il est possible de revenir
dans le dialogue « Customize
Palette » afin de modifier les noms,
catégories, et contenus des fragments
nouvellement créés.
Pour afficher le dialogue « Customize
Palette »,
sélectionner l’option
« Customize… » dans le menu
contextuel de la vue « Snippets ».
Note : le dialogue « Customize
Palette » permet uniquement de modifier les nouveaux fragments et catégories créés
par l’utilisateur ; il ne permet pas de modifier les fragments existants dans la catégorie
« JSP ».
3.2.2.2 Complétion dans les éléments HTML et JSP
Les fonctionnalités de complétion sont accessibles à l’aide du raccourci clavier
standard : « Ctrl + Espace ». Les 2 exemples ci-dessous illustrent les possibilités
de complétion disponibles pour les tags HTML et JSP :
Dernière impression le 15/04/17
Page 39 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
3.2.3 Création d’une Servlet
Note préliminaire importante : pour pouvoir créer une Servlet, il faut
impérativement que l’accès Internet via le Proxy soit activé et validé (utilisateur
authentifié). Dans le cas contraire il est impossible de créer une servlet :
l’assistant de création laisse les boutons « Next » et « Finish » grisés et persiste à
afficher un message d’alerte incongru (« The name cannot be empty ») même si
le champ « Name » n’est pas vide.
Dans l’explorateur de projets,
sélectionner
l’icône
du
descripteur
de
déploiement
immédiatement en dessous du
nœud du projet, et choisir
l’option « New  Servlet » du
menu contextuel.
L’assistant de création de Servlet
s’affiche.
Entrer le nom « symbolique »
de la servlet dans le champ
« Name ».
(ce
nom
« symbolique »
sera
utilisé
comme valeur par défaut pour le
nom de la classe de la servlet)
Par défaut, l’assistant crée un
mapping d’URL avec le nom de
la servlet. Ce mapping est
affiché dans la liste « URL
Mappings ».
Dans la plupart des cas, ce
mapping
par
défaut
ne
conviendra pas, et il faudra donc
le modifier.
Important : vérifier que la case « Generate an annotated servlet class » est
bien désactivée (l’activation de cette option provoquerait l’échec de la déclaration
de la servlet et de son mapping dans le descripteur de déploiement, car elle
requiert l’usage d’un outil annexe (XDoclet) qui n’est pas inclus dans le package).
Dernière impression le 15/04/17
Page 40 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Pour modifier le mapping d’URL par défaut de la servlet :
1. Supprimer le mapping créé par défaut : sélectionner le mapping existant dans la
liste « URL mappings » et cliquer sur « Remove »
2. Cliquer sur « Add… » pour créer le nouveau mapping d‘URL
3. Saisir le mapping d’URL désiré et cliquer « OK ». Pour un mapping « simple »
comme ici par exemple, ne pas oublier de préfixer le mapping par un slash
(« /hello »)
4. Le mapping créé apparaît maintenant dans la liste « URL mappings »
Une fois le mapping d’URL modifié, cliquer sur « Next ». Le dialogue suivant de
l’assistant permet de configurer les propriétés de classe Java de la servlet :
Saisir un nom de package pour
la servlet dans le champ « Java
package », ou bien cliquer sur
« Browse… » pour parcourir
l’arborescence des packages
existants dans le projet et en
sélectionner un.
Contrôler ensuite et modifier
éventuellement le nom de la
classe de la servlet dans le
champ « Class Name ».
Cliquer sur « Next » pour
passer au dialogue suivant.
Dernière impression le 15/04/17
Page 41 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Le dernier dialogue de l’assistant
permet principalement de choisir
les méthodes que l’on souhaite
redéfinir pour la servlet :
Par
défaut,
les
méthodes
« doPost » et « doGet » sont
sélectionnées. Dans la plupart
des cas cependant, on ne
souhaite redéfinir que l’une ou
l’autre.
Une fois la ou les méthodes
nécessaires sélectionnées (ici :
« doGet » uniquement), cliquer
sur « Finish » pour terminer
l’assistant.
Une fois la servlet créée,
propriétés
apparaissent
déroulant
le
nœud
descripteur de déploiement
projet Web :
ses
en
du
du
Quant au fichier source de la
Servlet, il est placé dans le
dossier
« JavaSource »
du
projet,
dans
le
package
correspondant :
Ajout de code à la servlet :
Nous allons ajouter du code très simple à la servlet afin qu’elle retourne juste une
simple page HTML avec un message de bienvenue avec la date et l’heure du jour :
Double-cliquer sur le fichier de la servlet pour ouvrir l’éditeur, et modifier la
méthode « doGet() » de la façon suivante :
Dernière impression le 15/04/17
Page 42 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
- dans la signature de la méthode, remplacer les noms des arguments (« arg0 »
et « arg1 ») par des noms explicites « req » pour ‘request’ et « res » pour
‘response’). Ces modifications sont indiquées en caractères gras surlignés en
jaune.
- entrer les nouvelles lignes de codes ajoutées qui apparaissent sur fond gris
clair.
protected void doGet(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
// TODO Auto-generated method stub
java.io.PrintWriter out = res.getWriter();
java.text.SimpleDateFormat fmtDate =
new java.text.SimpleDateFormat(“EEEE d MMMM yyyy”);
java.text.SimpleDateFormat fmtHeure =
new java.text.SimpleDateFormat(“HH:mm”);
java.util.Date now = new java.util.Date();
res.setContentType(“text/html”);
out.println(“<html><head><title>Bienvenue !</title></head>”);
out.println(« <body><h1>Bienvenue !</h1> ») ;
out.print(« <p>Nous sommes le « ) ;
out.print(fmtDate.format(now));
out.println(« , il est « ) ;
out.print(fmtHeure.format(now)) ;
out.println(“.</p></body></html>”);
}
3.3
Tester un projet
Au cours du développement, il est important de pouvoir tester l’application en la
déployant sur… un serveur de test.
A l’image de WSAD, Eclipse permet de paramétrer un ou plusieurs environnements de
test, et de déployer un ou plusieurs projets sur ces environnements.
A l’heure actuelle, le module « Web Tools Platform » d’Eclipse supporte en standard
uniquement le serveur Apache Tomcat (versions 3.x, 4.x, et 5.x). Nous pouvons donc
utiliser l’installation du serveur Tomcat 5.0 que nous avons paramétrée dans les
Préférences (cf. § 1.2.2)
3.3.1 Exécution directe d’un projet avec déclaration d’un serveur de test à la
volée
L’option « Run As  Run on Server … » du menu contextuel du projet ouvre un
assistant qui permet de déclarer à la volée un environnement serveur (Tomcat dans
notre cas) vers lequel le projet sera automatiquement publié ; le serveur sera ensuite
automatiquement démarré, et Eclipse ouvrira un navigateur intégré affichant la page par
Dernière impression le 15/04/17
Page 43 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
défaut de l’application.
Dernière impression le 15/04/17
Page 44 sur 100
Note technique
DEI
-
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Sélectionner le projet à exécuter dans l’explorateur, et choisir l’option « Run As
 Run on Server … » du menu contextuel :
L’assistant d’exécution sur le serveur s’affiche :
-
-
contrôler que le champ « Host name : » contient bien la chaîne « localhost »
(le serveur Tomcat est installé en local)
Dans la liste hiérarchique des types de serveur (« Select the server type »,
sélectionner « Tomcat v5.0 Server »
Eventuellement, on peut cocher la case « Set server as project default » si
l’on souhaite conserver cette définition de serveur comme serveur de test par
défaut pour le projet
cliquer sur « Next >»
Dernière impression le 15/04/17
Page 45 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Le dialogue suivant permet de configurer quels projets doivent être déployés sur
l’environnement de test.
Aucune action n’est ici nécessaire car
notre projet a automatiquement été
ajouté dans la liste des projets
configurés sur le serveur (liste
« Configured projects ») :
Cliquer sur « Finish ». Eclipse lance
automatiquement le serveur Tomcat.
Les messages de démarrage apparaissent dans la vue « Console » (ci-dessous à droite).
Surveiller l’apparition éventuelle de messages affichés en rouge qui indiqueraient des
erreurs au démarrage du serveur :
On remarque également dans la vue « Servers » ci-dessus à gauche que la configuration
du serveur de test apparaît sous le nom « Tomcat v5.0 Server @ localhost ».
Par ailleurs, au démarrage de l’application, Eclipse affiche automatiquement une fenêtre
de navigateur Web intégré qui permet de tester l’application :
Dernière impression le 15/04/17
Page 46 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Par défaut, le navigateur Internet
affiche la racine de l’application
Web, qui correspond à la page par
défaut configurée pour l’application
(ici, il s’agit de « index.jsp »
Pour
tester
la
servlet
« HelloServlet », il suffit donc
d’ajouter le mapping défini pour la
servlet (« /hello ») à l’URL racine
du contexte de l’application dans le
champ d’adresse du navigateur, et
de cliquer sur « Entrée » pour
valider.
La servlet est alors exécutée, et la
page HTML résultante est affichée.
3.4
Déboguage d’une application sur le serveur
A l’instar de WSAD, Web Tools Platform permet de lancer un serveur en mode
« Debug » afin d’exécuter une application en mode pas à pas.
Il est possible de placer des points d’arrêt à n’importe quel endroit du code Java
(Servlets, ou autres classes), y-compris au sein des pages JSP.
Démonstration : nous allons placer un point d’arrêt dans la page JSP d’accueil
(index.jsp) un autre point d’arrêt dans la servlet « HelloServlet »., et exécuter
l’application sur le serveur qui sera cette fois-ci lancé en mode déboguage.
1. Modification de la JSP et pose d’un point d’arrêt
-
Editer le fichier index.jsp de l’application et rajouter les lignes ci-dessous (sur
fond inverse) :
Dernière impression le 15/04/17
Page 47 sur 100
Note technique
DEI
-
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Cliquer dans le bandeau latéral gauche de la fenêtre de l’éditeur pour
positionner un point d’arrêt au niveau d’une des lignes de la page JSP (dans
l’illustration, le point d’arrêt se situe à la ligne contenant le scriptlet « <% i = i
* 3 ; %> »
2. Pose d’un point d’arrêt dans la servlet HelloServlet
Editer la servlet HelloServlet et positionner un point d’arrêt au début de la méthode
doGet() comme illustré ci-dessous :
3. Déboguage de l’application sur le serveur
Dans l’explorateur de projets, sélectionner le projet « WebProj1 ». Dans le menu
contextuel, choisir l’option « Debug As  Debug on Server… »
Si le serveur précédemment utilisé n’a pas été défini comme serveur par défaut, un
dialogue s’affiche pour choisir le serveur à lancer.
Une fois le lancement du serveur effectué, Eclipse affiche un message d’alerte vous
informant que ce type de lancement est configuré pour afficher la perspective
« Debug », et vous demande si vous souhaitez ou non changer de perspective.
Pour l’exemple, cliquer sur « Oui ».
 Déboguage de la page JSP
Dans la perspective Debug, vous
voyez que votre fichier index.jsp
a automatiquement été ouvert
dans l’éditeur, et que l’exécution
est stoppée au niveau de la
ligne
sur
laquelle
a
été
positionné le point d’arrêt :
Vous pouvez utiliser les fonctions habituelles d’Eclipse et les différentes vues de la
perspective Debug pour avancer pas à pas dans l’exécution ou examiner et modifier
le contenu des objets.
Dernière impression le 15/04/17
Page 48 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Une fois l’exécution de la page JSP terminée, le résultat sera affiché dans la fenêtre
du navigateur Web (« Web Browser »).
 Débogage de la servlet
Dans la fenêtre du navigateur Web, entrer l’URL associée à la servlet, et cliquer sur
« Entrée ». Lors de l’appel à la Servlet, Eclipse stoppe l’exécution au niveau du
point d’arrêt précédemment positionné et ouvre automatiquement le fichier source
de la servlet dans une nouvelle fenêtre d’éditeur :
 Arrêt/redémarrage du serveur
La vue serveur offre un menu contextuel qui permet très facilement d’arrêter et
de redémarrer (en mode normal ou en mode déboguage) le serveur :
3.5
Modification de la configuration d’un serveur
La vue « Servers » permet également de modifier certains paramètres liés à la
configuration d’Apache Tomcat, notamment les ports TCP à utiliser. Ainsi, par
défaut, le port HTTP utilisé est le port 8080.
Dernière impression le 15/04/17
Page 49 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Pour afficher et modifier ces paramètres, sélectionner le serveur dans la vue
« Servers » et choisir l’option « Open » dans le menu contextuel.
L’éditeur de configuration du serveur apparaît :
On remarque que cet éditeur comporte 2 onglets (en bas à gauche). L’onglet
« Modules » permet de voir et de configurer les modules Web qui sont déployés sur
le serveur :
Dernière impression le 15/04/17
Page 50 sur 100
Note technique
DEI
3.6
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Configuration
des
application Web
propriétés
de
V1.2.3
déploiement
d’une
3.6.1 Propriétés de déploiement et configuration du serveur
Les options disponibles dans l’éditeur de configuration du serveur sont très limitées.
En effet, l’essentiel des options de configuration sera spécifique à un projet, et
notamment tout ce qui concerne :
- les sources de données JDBC
- les variables d’environnement publiées dans le contexte JNDI
Avec les versions précédentes de Tomcat (3.x, 4.x), il était habituel de paramétrer
les sources de données et autres propriétés spécifiques aux applications dans le
fichier de configuration du serveur : les propriétés des applications étaient
déclarées dans des nœuds « <Context > » dans le fichier « conf/server.xml »
de Tomcat).
Cependant, depuis la version 5.0.x de Tomcat, il est déconseillé de placer les
éléments de configuration spécifiques aux applications dans le fichier de
configuration du serveur.
La procédure recommandée est désormais de créer un fichier «context.xml » dans
le répertoire « META-INF » de l’arborescence WAR de l’application. C’est dans ce
fichier qu’il faut déclarer le nœud XML « <Context> » propre à l’application ainsi
que l’ensemble des paramètres liés à l’application (sources de données, variables
JNDI).
Au déploiement de l’application (format d’archive WAR ou structure arborescente
« éclatée »),
Tomcat
recherche
la
présence
d’un
fichier
« METAINF/context.xml ». Si ce fichier existe, les éléments fils du nœud <Context >
sont traités pour configurer les paramètres définis par l’application.
Le fichier « META-INF/context.xml » est ensuite copié vers le répertoire
« conf/Catalina/localhost »
de
Tomcat,
et
renommé
en :
« NomDuModuleWeb.xml ».
3.6.2 Avantages liés à l’utilisation du fichier de contexte
L’utilisation d’un fichier « context.xml » séparé par application présente plusieurs
avantages par rapport à l’utilisation du fichier de configuration global
« conf/server.xml » :

Pas de « pollution » de la configuration du serveur : il n’ya plus aucune
déclaration de contexte (aucun nœud « <Context> » dans le fichier
« conf/server.xml », qui contient désormais uniquement les valeurs de
configuration strictement relatives au serveur. Les informations de contexte sur
les applications sont dans des fichiers « NomModuleWeb.xml »dans le
répertoire « conf/Catalina/localhost »
Dernière impression le 15/04/17
Page 51 sur 100
Note technique
DEI

Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Isolation des paramétrages entre applications. De plus, lors de l’enlèvement
d’une application, il n’est plus nécessaire de supprimer la configuration de cette
application sur le serveur : l suffit de supprimer le fichier de contexte
correspondant dans « conf/Catalina/localhost ».
3.6.3 Création d’un fichier de contexte Tomcat (META-INF/context.xml)
Dans l’arborescence d’un projet, Eclipse le fichier de contexte doit apparaître
dans l’arborescence du contenu Web : « WebContent\META-INF\context.xml »
Nous allons créer une application de démonstration qui illustrera
-
-
la configuration des propriétés de déploiement JNDI dans un fichier de contexte
Tomcat
la configuration de « variables d’environnement » et l’utilisation de « références
de ressources » dans le descripteur de déploiement Web d’une application
(WEB-INF/web.xml) pour lier des variables JNDI définies dans Tomcat au
contexte JNDI de l’application
la configuration d’une source de données MySQL dans le fichier de contexte
Tomcat
3.6.3.1 Création du projet Web « ContextDemo »
Créer un nouveau projet dynamique Web J2EE appelé « ContextDemo » avec les
propriétés suivantes :
 version de l’API Servlet : « 2.3 »
 serveur cible : « Apache Tomcat 5.0 »
3.6.3.2 Création du fichier de contexte pour Tomcat
-
créer un sous-dossier « META-INF » dans le dossier « WebContent » du
projet
créer un nouveau fichier appelé « context.xml » dans le dossier « METAINF »
Double-cliquer sur le fichier nouvellement créé pour l’ouvrir au sein d’un
éditeur.
Dans ce fichier « context.xml », il faut déclarer un élément racine « <Context> »
qui contient 2 attributs :


docBase : le nom du dossier racine de l’application Web
path :
l’URL de contexte Web de l’application
Au sein d’un projet Eclipse, on utilise simplement le nom du projet pour l’attribut
docBase, le plugin Tomcat se chargeant de spécifier le chemin absolu utilisé au
déploiement en environnement de test.
Pour l’attribut path, on utilise le nom de la racine du contexte de l’application Web
Dernière impression le 15/04/17
Page 52 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
(normalement, c’est le nom du projet Web lui-même) préfixé par un slash (« / »).
Dernière impression le 15/04/17
Page 53 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Le contenu « minimal » du fichier de contexte Tomcat pour notre
application Web sera donc le suivant :
<Context
path= »/ContextDemo »>
</Context>
docBase= »ContextDemo »
3.6.3.3 Ajout d’une entrée d’environnement dans le fichier de contexte
L’élément <Environment> permet de définir des valeurs JNDI dans le contexte
JNDI de Tomcat qui sera associé à l’application.
Les attributs obligatoires sont :
 name :
le nom JNDI de la variable
 type :
le type de la variable
 value :
la valeur de la variable
L’élément <Environment> ne possède pas de contenu et doit donc être fermé
directement en mettant un slash à la fin du tag : <Environment … />
Exemple de définition de variable JNDI :
Pour définir une variable JNDI de type « String » appelée « log/console » et dont la
valeur est « on », nous ajoutons la ligne suivante (en gras) au fichier METAINF/context.xml :
<Context docBase= »TestTomcatContext » path= »/TestTomcatContext »>
<Environment
name= »log/console »
type=”java.lang.String”
value=”on”
/>
</Context>
Dernière impression le 15/04/17
Page 54 sur 100
Note technique
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
DEI
V1.2.3
3.6.3.4 Ajout d’une définition de source de données JDBC dans le fichier de contexte
Dans un fichier de contexte Tomcat, la déclaration d’une source de données JDBC
s’effectue en 2 étapes :
1 – Définition d’une « ressource » de type « source de données » :
On utilise l’élément « Resource » qui comporte 3 attributs obligatoires :
- name : le nom JNDI de la ressource. Il s’agit d’un nom symbolique.
Pour une source de données, il existe une convention de nommage : on
doit utiliser le préfixe « jdbc/ » suivi du nom symbolique de la source de
données, qui n’est pas forcément le véritable nom de la base de données.
Par exemple, « jdbc/MySampleDB » peut être le nom symbolique d’une
base appelée « sample »
- type :
le type de la ressource (classe ou interface Java). Pour une source de
données, il s’agit de l’interface « java.sql.DataSource »
- auth :
mode d’authentification pour l’utilisation de la ressource. Pour une source
de données, l’authentification est géré par le « conteneur » (c’est-à-dire :
le serveur), et on doit donc utiliser la valeur « Container ».
Note : l’élément « <Resource> » ne possédant pas de contenu, il ne faut pas oublier
d’utiliser « /> » pour le fermer.
Voici la définition à ajouter dans le fichier « context.xml »
données appelée « jdbc/SampleDB » :
<Resource
pour déclarer une source de
name=”jdbc/MySampleDB”
type=”javax.sql.DataSource”
auth=”Container” />
2 – Définition des paramètres (propriétés) de la « ressource » :
Pour
définir
les
propriétés
d’une
ressource,
on
utilise
l’élément
« <ResourceParams> », qui possède un attribut « name » dont la valeur doit
être identique à celle de l’élément « <Resource> » qu’il complète.
Dans le corps de l’élément « <ResourceParams> », chaque propriété est définie
par un élément « <parameter> qui précise le nom et la valeur de cette propriété
(au moyen des éléments imbriqués « <name> » et « <value> »).
Les noms des paramètres de définition d’une source de données sont standardisés,
car ils sont utilisés pour la définition d’un pool de connexion qui sera créé par le
serveur.
Dernière impression le 15/04/17
Page 55 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Les paramètres du pool de connexion à définir sont les suivants :
Paramètres de connexion au SGBD :
Paramètre
Description et valeur à employer
factory
nom complet de la classe de fabrique implémentant le pool de
connexion.
Avec
Apache
Tomcat,
on
utilise
généralement
l’implémentation « Apache DBCP » (Apache Data Base Connection Pool).
La
classe
de
fabrique
correspondante
est : «
org.apache.commons.dbcp.BasicDataSourceFactory »
driverClassName
nom de la classe du pilote JDBC utilisé. Cette classe doit implémenter
l’interface javax.sql.DataSource.
 valeur
pour
le
pilote
JDBC
Oracle :
« oracle.jdbc.driver.OracleDriver »
 valeur pour le pilote JDBC MySQL :
« com.mysql.jdbc.Driver »
url
l’URL de connexion à la base de données :
 pour une base Oracle : « jdbc :oracle :thin :@<host> :<port> :<instance> »
avec :
<host> :
nom DNS ou adresse IP du serveur Oracle
<port> :
port de connexion (par défaut : 1521)
<instance> : nom de l’instance Oracle
Exemple : « jdbc :oracle :thin :@localhost :1521 :TEST »
 pour une base MySQL : « jdbc :mysql ://<host> :<port> :<instance> »
avec :
<host> :
nom DNS ou adresse IP du serveur MySQL
<port> :
port de connexion (par défaut : 3306)
<instance> : nom de l’instance MySQL
Exemple :« jdbc :mysql ://localhost :3306/TEST »
username
le nom d’utilisateur pour la connexion au SGBD
password
le mot de passe de l’utilisateur du SGBD
Paramètres techniques de configuration du pool de connexion
Paramètre
Description et valeur à employer
maxActive
Nombre maximal de connexions qui pourront être créées dans le pool.
(Note : La valeur « 0 » est à proscrire absolument, car elle ne fixe
aucune limite)
Il est conseillé de régler ce paramètre sur le nombre d’utilisateurs
maximal envisagé en accès concurrent (minimum recommandé : 10).
Il convient de vérifier que la valeur utilisée n’est pas plus élevée que le
maximum admissible configuré sur le SGBD.
maxIdle
Nombre minimal de connexions à conserver actives dans le pool après
utilisation sans les refermer.
Minimum recommandé : 30% de la valeur de ‘maxActive’ (par
exemple 3 si maxActive = 10).
Maximum : valeur de ‘maxActive’. La valeur maximum ne doit être
utilisée qu’en cas de prévision d’une charge constante sur l’application.
Dernière impression le 15/04/17
Page 56 sur 100
Note technique
DEI
maxWait
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Délai maximal (en ms) d’attente de libération d’une connexion du pool
par l’application cliente. Une exception est levée dans les cas où ce délai
expire.
La valeur « -1 » désactive ce contrôle (à utiliser avec précaution).
La valeur minimale recommandée pour Oracle et MySQL est « 60000 »
(60 sec.)
Un exemple complet de définition d’une source de données avec ses paramètres est
présenté dans la section suivante.
3.6.3.5 Contenu du fichier de contexte « complet »
Voici le contenu « complet » du fichier de contexte de l’application d’exemple, qui
inclut la définition d’une variable d’environnement, et d’une source de données :
<Context docBase=”ContextDemo” path=”/ContextDemo” reloadable=”true”>
<Environment name=”log/console” type=”java.lang.String” value=”on” />
<Resource name=”jdbc/MySampleDB” auth=”Container”
type=”javax.sql.DataSource” />
<ResourceParams name=”jdbc/MySampleDB”>
<parameter>
<name>factory</name>
<value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
</parameter>
<parameter>
<name>driverClassName</name>
<value>oracle.jdbc.driver.OracleDriver</value>
</parameter>
<parameter>
<name>url</name>
<value>jdbc:oracle:thin:@srv-oracle-test:1521:TEST</value>
</parameter>
<parameter>
<name>username</name>
<value>scott</value>
</parameter>
<parameter>
<name>password</name>
<value>tiger</value>
</parameter>
<parameter><name>maxActive</name><value>10</value></parameter>
<parameter><name>maxIdle</name><value>3</value> </parameter>
<parameter><name>maxWait</name><value>30000</value></parameter>
</ResourceParams>
</Context>
Dernière impression le 15/04/17
Page 57 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
3.6.3.6 Edition du descripteur de déploiement Web
Les variables d’environnement et ressources configurées sur le serveur sont
destinées à être utilisées par l’application.
Les dépendances de l’application vis-à-vis des ressources disponibles sur le serveur
doivent être exprimées dans le descripteur de déploiement de l’application, à
travers des d’éléments de type « référence d(environnement de ressource»
(« resource environment reference »).
Le contenu du descripteur de déploiement de l’application « ContextDemo » est
présenté ci-dessous pour illustrer la façon dont doivent être déclarés les références
vers les ressources configurées sur le serveur (les éléments correspondants
apparaissent en gras).
Pour éviter une confusion courante, on illustre la différence entre une référence
d’environnement de ressource et une définition d’entrée d’environnement
(l’éléement correspondant apparaît en italique) :
Une entrée d’environnement permet de définir une valeur paramétrée dans le
descripteur de déploiement de l’application, alors qu’une référence d’environnement
de ressource permet de définir une liaison vers une valeur paramétrée dans la
configuration du serveur lui-même.
< ?xml version= »1.0 » encoding= »UTF-8 » ?>
< !DOCTYPE web-app PUBLIC
« -//Sun Microsystems, Inc.//DTD Web Application 2.3//EN »
« http ://java.sun.com/dtd/web-app_2_3.dtd »>
<web-app >
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<resource-env-ref>
<resource-env-ref-name>jdbc/MySampleDB</resource-env-ref-name>
<resource-env-ref-type>javax.sql.DataSource</resource-env-ref-type>
</resource-env-ref>
<resource-env-ref>
<resource-env-ref-name>log/console</resource-env-ref-name>
<resource-env-ref-type>java.lang.String</resource-env-ref-type>
</resource-env-ref>
<env-entry>
<env-entry-name>intValue</env-entry-name>
<env-entry-value>33</env-entry-value>
<env-entry-type>java.lang.Integer</env-entry-type>
</env-entry>
</web-app>
Dernière impression le 15/04/17
Page 58 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
3.6.3.7 Création d’une page JSP de test
Voici le contenu de la page de test (index.jsp) qui permet de récupérer les
différentes valeurs définies (valeurs de l’entrée d’environnement et des références
d’environnement de ressource déclarées sur le serveur).
Noter que ces variables sont toutes placées dans le contexte JNDI local à
l’application, accessible à travers le préfixe « java :comp/env/ »
Par souci de simplification, cette page de test ne fait que convertir et afficher
l’ensemble de ces valeurs sous forme de chaîne de caractères.
<%@page language= »java »
contentType= »text/html; charset=utf-8 » %>
<html>
<head><title>Démo Propriétés de déploiement JNDI</title></head>
<body>
<h1>Démo Propriétés de déploiement JNDI</h1>
<pre>
<%
String[] jndiNames = { « java :comp/env/log/console »,
« java :comp/env/intValue »,
« java :comp/env/jdbc/MySampleDB »
} ;
javax.naming.InitialContext ic = null ;
try {
ic = new javax.naming.InitialContext();
}
catch (javax.naming.NamingException e) {
out.println(« Erreur à l’instanciation du contexte initial JNDI : «
e) ;
}
+
for(int i=0; i < jndiNames.length; i++) {
try {
String jndiValue = ic.lookup(jndiNames[i]).toString();
out.println(« Valeur de la propriété JNDI ‘ »
+ jndiNames[i] + “’ = “
+ jndiValue);
}
catch (javax.naming.NamingException e) {
out.println(« Erreur au lookup de la propriété JNDI ‘ »
+ jndiNames[i] + “’: “ + e);
}
}
%>
</pre>
</body>
</html>
Dernière impression le 15/04/17
Page 59 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Le résultat de l’exécution de l’application est illustré ci-dessous :
Adresse :
http://localhost:8080/ContextDemo/
Démo Propriétés de déploiement JNDI
Valeur de la propriété JNDI ‘java :comp/env/log/console’ = on
Valeur de la propriété JNDI ‘java :comp/env/intValue’ = 33
Valeur de la propriété JNDI ‘java :comp/env/jdbc/MySampleDB’ =
org.apache.commons.dbcp.BasicDataSource@1a9876e
Dernière impression le 15/04/17
Page 60 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
3.6.4 Exemples de fichiers « context.xml »
Exemple de contenu du fichier « META-INF/context.xml »
l’application d’exemple « FWKSample » :
utilisé
pour
<Context docBase= »FWKSample » path= »/FWKSample » reloadable= »true »>
<Environment description= » » name= »edinat/logintimeout » override= »false » type= »java.lang.String » value= »10 » />
<Environment description= » » name= »edinat/mincount » override= »false » type= »java.lang.String » value= »0 » />
<Environment description= » » name= »edinat/invalidationtimeout » override= »false » type= »java.lang.String » value= »300 » />
<Environment description= » » name= »edinat/op4_courrierlibre/env » override= »false » type= »java.lang.String » value= »dev » />
<Environment description= » » name= »edinat/pwd » override= »false » type= »java.lang.String » value= »defaut » />
<Environment description= » » name= »edinat/user » override= »false » type= »java.lang.String » value= »defaut » />
<Environment description= » » name= »edinat/port » override= »false » type= »java.lang.String » value= »800 » />
<Environment description= » » name= »edinat/debug » override= »false » type= »java.lang.String » value= »5 » />
<Environment description=”” name=”edinat/host” override=”false” type=”java.lang.String” value=”10.12.0.191” />
<Environment description=”” name=”edinat/maxcount” override=”false” type=”java.lang.String” value=”2” />
<Environment description=”” name=”web/aliashttp” override=”false” type=”java.lang.String” value=”/FWKSample” />
<Environment description=”” name=”log/console” override=”false” type=”java.lang.String” value=”on” />
<Environment description=”” name=”log/level” override=”false” type=”java.lang.String” value=”debug” />
<Environment description=”” name=”ldap/gide/pwd” override=”false” type=”java.lang.String” value=”dlabpass” />
<Environment description=”” name=”ldap/gide/initctx” override=”false” type=”java.lang.String” value=”com.sun.jndi.ldap.LdapCtxFactory” />
<Environment description=”” name=”ldap/gide/host” override=”false” type=”java.lang.String” value=”dsgide1.serv.cdc.fr” />
<Environment description=”” name=”ldap/gide/user” override=”false” type=”java.lang.String” value=”uid=fwkuser,dc=cdc,dc=fr” />
<Environment description=”” name=”ldap/gide/port” override=”false” type=”java.lang.String” value=”17391” />
<Environment description=”” name=”ldap/gide/idappli” override=”false” type=”java.lang.String” value=” atalina” />
<Environment description=”” name=”ldap/gide/codeappli” override=”false” type=”java.lang.String” value=”GRES” />
<Resource name=”jdbc/MySampleDB” auth=”Container” type=”javax.sql.DataSource” />
<ResourceParams name=”jdbc/MySampleDB”>
<parameter><name>factory</name>
<value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
</parameter>
<parameter><name>driverClassName</name>
<value>oracle.jdbc.driver.OracleDriver</value>
</parameter>
<parameter><name>url</name>
<value>jdbc:oracle:thin:@dsdublin:1526:dtest_d</value>
</parameter>
<parameter> <name>username</name>
<value>dei13</value>
</parameter>
<parameter><name>password</name>
<value>dei13</value>
</parameter>
<parameter><name>maxActive</name>
<value>5</value>
</parameter>
<parameter><name>maxIdle</name>
<value>1</value>
</parameter>
<parameter><name>maxWait</name>
<value>-1</value>
</parameter>
</ResourceParams>
</Context>
Dernière impression le 15/04/17
Page 61 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Autre exemple de fichier de contexte pour une application utilisant MySQL :
<?xml version=’1.0’ encoding=’utf-8’?>
<Context displayName=”RefAppGIN” docBase=”/daramis-dev/applis/AR/ntiers/RefAppGIN” path=”/RefAppGIN”
reloadable=”true” workDir=”work/Catalina/localhost/RefAppGIN”>
<Logger className=”org.apache.catalina.logger.FileLogger” directory=”/daramis-dev/applis/AR/ntiers/logs/” prefix=”RefAppGIN.”
suffix=”.err” timestamp=”true”/>
<Environment name=”ldap/gide/initctx” override=”false” type=”java.lang.String” value=”com.sun.jndi.ldap.LdapCtxFactory”/>
<Environment name=”ldap/gide/port” override=”false” type=”java.lang.String” value=”17391”/>
<Environment name=”log/console” override=”false” type=”java.lang.String” value=”false”/>
<Environment name=”log/configuratorclass” type=”java.lang.String” value=”fr.icdc.dei.fwk.util.log.ConfigManagerConfigurator”/>
<Environment name=”ldap/gide/host” override=”false” type=”java.lang.String” value=”dsgide1.serv.cdc.fr”/>
<Environment name=”log/level” override=”false” type=”java.lang.String” value=”error”/>
<Environment name=”log/rollingfile/size” override=”false” type=”java.lang.String” value=”1000000”/>
<Environment name=”ldap/gide/codeappli” override=”false” type=”java.lang.String” value=”RA”/>
<Environment name=”log/rollingfile/file” override=”false” type=”java.lang.String” value=”/daramis-dev/applis/AR/ntiers/logs/RefAppGIN.log”/>
<Environment name=”log/rollingfile/status” override=”false” type=”java.lang.String” value=”on”/>
<Environment name=”log/rollingfile/nb” override=”false” type=”java.lang.String” value=”10”/>
<Environment name=”ldap/gide/idappli” override=”false” type=”java.lang.String” value=”543210”/>
<Environment name=”ldap/gide/pwd” override=”false” type=”java.lang.String” value=”dlabpass”/>
<Environment name=”ldap/gide/user” override=”false” type=”java.lang.String” value=”uid=fwkuser,dc=cdc,dc=fr”/>
<Environment name=”web/aliashttp” override=”false” type=”java.lang.String” value=”/RefAppGIN”/>
<Resource auth=”Container” name=”jdbc/RefAppDS” type=”javax.sql.DataSource”/>
<ResourceEnvRef>
<name>ldap/gide/basedn</name>
<type>java.lang.String</type>
</ResourceEnvRef>
<ResourceParams name=”jdbc/RefAppDS”>
<parameter><name>factory</name>
<value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
</parameter>
<parameter><name>url</name>
<value>jdbc:mysql://10.12.3.151:60018/ddaramis</value>
</parameter>
<parameter><name>username</name>
<value>athos</value>
</parameter>
<parameter><name>password</name>
<value>porthos</value>
</parameter>
<parameter><name>maxWait</name>
<value>10000</value>
</parameter>
<parameter><name>maxActive</name>
<value>90</value>
</parameter>
<parameter><name>maxIdle</name>
<value>10</value>
</parameter>
<parameter><name>driverClassName</name>
<value>com.mysql.jdbc.Driver</value>
</parameter>
</ResourceParams>
</Context>
Dernière impression le 15/04/17
Page 62 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
3.6.5 Notes complémentaires relatives à l’accès aux SGBD
3.6.5.1 Installation des bibliothèques de pilotes JDBC
Installation des pilotes JDBC : Les bibliothèques de pilotes JDBC ne doivent
généralement pas être placées dans le répertoire « WEB-INF/lib » du projet, mais dans
le sous-répertoire « common/lib » du répertoire d’installation du serveur Tomcat (en
effet, ces bibliothèques incluent souvent des interfaces du package « javax.sql », et
Tomcat interdit pour raisons de sécurité le chargement de classes « système »
appartenant aux packages « java » ou « javax » depuis le répertoire « WEB-INF/lib »
d’une application).
Utilisation exclusive de fichiers « . JAR » : dans le répertoire « common/lib »,
Tomcat charge uniquement les bibliothèques portant l’extension « .jar » ; il ne charge
pas les fichiers « .zip ». Par conséquent, si on souhaite utiliser par exemple la
bibliothèque de pilote JDBC « classes12.zip » pour Oracle, il faudra renommer le fichier
en « classes12.jar » après l’avoir copié dans le répertoire « common/lib » (le format
JAR est en réalité identique au format ZIP, ceci ne pose donc aucun problème).
Les bibliothèques de pilote JDBC recommandés sont des pilotes de type 4 (« thin ») :
 Oracle 8i / 9i: « classes12.jar » (Oracle 8i) ou « ojdbc14.jar » (Oracle 9i)
 MySQL 4.1 : pilote MySQL Connector/J : « mysql-connector-java-3.1.7-bin.jar »
3.6.5.2 Notes spécifiques liées au paramétrage de sources de données MySQL
Par défaut avec MySQL, le nombre maximal de connexions simultanées possibles est de
100. Lors du paramétrage d’un pool de connexion à MySQL dans le fichier
« context.xml », il est donc important de définir pour le paramètre « maxActive » une
valeur inférieure à 100 (90, pour conserver un peu de « marge » pour des connexions
extérieures à l’application).
Il est possible d’augmenter le nombre maximal de connexions simultanées acceptées par
MySQL en spécifiant une valeur pour la variable système ‘max_connections’ dans le
fichier de configuration du serveur MySQL :
[mysqld]
set-variable=max_connections=500
____________________________
Sous un système Unix, on utilise couramment des valeurs comprises entre 500 et 1000
pour le paramètre « max_connections » pour des applications supportant des charges
moyenne à forte. La valeur maximale utilisable dépend non seulement de la mémoire
vive disponible (chaque connexion consomme une quantité de mémoire non négligeable),
mais également de la qualité d’implémentation de la bibliothèque de threads disponible
sur la plate-forme d’exécution. Ainsi, il est déconseillé sur certains systèmes de monter
au-delà de 1500 (problème de stabilité), alors que MySQL AB indique que les
distributions binaires compilées de façon statique pour Linux peuvent supporter jusqu’à
4000 connexions simultanées.
Dernière impression le 15/04/17
Page 63 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
3.6.6 Problème de prise en compte du fichier de contexte Tomcat
Dans certains cas précis, il se peut que le fichier « META-INF/context.xml » ne soit pas
« reconnu » et « traité » par le plugin Tomcat d’Eclipse lorsqu’on déploie un projet sur un
serveur Tomcat configuré dans Eclipse. Ceci empêche évidemment le bon fonctionnement
de l’application.
La cause de ce problème a pu être identifiée, et une procédure de correction efficace a
été mise au point.
3.6.6.1 Symptômes
La configuration définie dans « META-INF/context.xml » ne semble pas prise en
compte à l’exécution de l’application sur le serveur Tomcat défini dans Eclipse.
En revanche l’application fonctionne correctement si elle est déployée sous forme
d’archive WAR sur un serveur Tomcat lancé en mode « autonome ».
3.6.6.2 Aperçu du processus de publication du plugin Tomcat dans Eclipse
Au démarrage d’un serveur Tomcat, le plugin Tomcat intégré à Eclipse réalise les
opérations suivantes :
-
énumération des projets associés à ce serveur
pour chaque projet configuré, recherche d’un fichier « META-INF/context.xml »
si un tel fichier est trouvé : extraction des nœuds fils de l’élément
« <Context> » défini dans ce fichier pour les recopier dans le fichier
« server.xml » du répertoire utilisé pour la configuration de lancement du
serveur Tomcat.
3.6.6.3 Vérification de l’encodage du fichier de contexte Tomcat
Les fichiers « context.xml » créés dans Eclipse sont normalement créés en utilisant
l’encodage Unicode standard (UTF-8), qui est l’encodage par défaut en XML. Les fichiers
encodés en UTF-8 peuvent comporter en option un en-tête (« byte-order mark »)
constitué de 3 octets indiquant l’ordre d’écriture des séquences comportant plusieurs
octets. (Pour rappel, en UTF-8 on code chaque caractère sur un nombre variable d’octets,
de 1 à 6).
Pour réaliser l’analyse du fichier context.xml (parsing du fichier pour extraction des
nœuds fils de l’élément <Context>), le plug-in utilise le parser XML configuré par défaut
dans Eclipse. Eclipse à son tour fait simplement appel au parser par défaut du JDK, qui se
révèle, pour le JDK 1.4, être le parseur « Crimson ».
Or, il se trouve que le parseur « Crimson » ne reconnaît pas les fichiers encodés en UTF8 qui comportent un en-tête « Byte-Order Mark » : l’analyse d’un tel fichier avec Crimson
provoque la levée d’une exception, qui empêche le traitement correct du fichier
context.xml … Ainsi, les valeurs définies dans le fichier de contexte ne sont pas
propagées dans Tomcat comme elles le devraient, ce qui empêche évidemment le bon
fonctionnement de l’application.
Dernière impression le 15/04/17
Page 64 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
3.6.6.4 Résolution de ce problème :
Pour résoudre ce problème, il faut vérifier si le fichier context.xml comporte un en-tête,
et si oui, le supprimer (la suppression des informations d’en-tête n’entraîne pas de
problème particulier).
La procédure à suivre est la suivante :
- dans
l’explorateur
de
projets,
sélectionner le fichier « WebContent/
META-INF/context.xml » du projet
en question et cliquer sur l’option
« Properties » du menu contextuel
- dans la zone « Text File Encoding »
au bas de la page de propriétés, cliquer
sur l’option « Other » et sélectionner
l’encodage « ISO-8859-1 » au début
de la liste déroulante, puis cliquer sur
« OK ».
- Un message d’avertissement apparaît, vous informant d’un conflit entre l’encodage
sélectionné et l’encodage d’origine du fichier :
- Cliquer sur « Yes » pour passer outre ce contrôle et modifier l’encodage du fichier
- Ensuite, double-cliquer sur le fichier « context.xml » pour l’ouvrir dans l’éditeur XML
intégré à Eclipse. Surprise : on voit apparaître 3 caractères « parasites » au début du
fichier !! Ces caractères sont en fait l’entête « Byte-Order Mark » de l’encodage UTF8:
- Supprimer les 3 caractères parasites d’entête en début de fichier, et sauvegarder le
fichier.
Vous pouvez désormais republier l’application et relancer l’application sur le serveur
Tomcat. Cette fois-ci, les éléments de configuration déclarés dans le fichier
« context.xml » doivent être propagés dans la configuration de lancement du serveur.
Dernière impression le 15/04/17
Page 65 sur 100
Note technique
DEI
3.7
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Génération d’une archive WAR de l’application pour le
déploiement
Une fois l’application complètement testée en local, il convient de fabriquer une archive
de l’application au format WAR (Web Application Archive) pour le déploiement en
environnement d’intégration/ de recette / de production.
Important :
Pour le déploiement en intégration / recette / production, il ne faut pas inclure le
fichier META-INF/context.xml de l’application dans l’archive WAR. Le fichier de
contexte XML doit être fourni séparément. En effet, la plupart des paramètres de
configuration doivent être adaptés pour le déploiement dans un environnement
particulier.
La procédure mise en place avec DPI est la suivante :
(1) Livraison par le projet du module applicatif à DPI
Le projet fournit 2 fichiers pour chaque module (application Web) devant être
déployé :
- NomDuModule.war : archive WAR du module sans le fichier METAINF/context.xml
- NomDuModule.xml : fichier META-INF/context.xml du module, sous forme
séparée
(2)
Premier déploiement du module applicatif par DPI :
DPI effectue les actions suivantes pour un premier déploiement du module :
- édition du fichier NomDuModule.xml pour adapter les paramètres à
l’environnement cible avant déploiement
- copie de l’archive NomDuModule.war vers le répertoire de déploiement propre à
l’instance Tomcat du projet
- copie du fichier de contexte NomDuModule.xml vers le sous-répertoire
conf/Catalina/localhost de l’instance Tomcat du projet.
(3)
Redéploiement d’une nouvelle version d’un module
applicatif livée par le pojet à DPI :
- dans le cas où aucune modification de contexte n’est intervenue dans le fichier
META-INF/context.xml de l’application, le projet doit simplement livrer la
nouvelle version de l’archive WAR de l’applicaton.
- Dans le cas contraire, le projet doit livrer à DPI la nouvelle version de l’archive
WAR de l’application, ainsi que la nouvelle version du fichier de contexte
« META-INF/context.xml », sous forme séparée.
- Au moment du déploiement, DPI met à jour si nécessaire le fichier de contexte
du module applicatif dans le sous-répertoire conf/Catalina/localhost de
l’instance Tomcat du projet.
Dernière impression le 15/04/17
Page 66 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
3.7.1 Fabrication de l’archive WAR à l’aide de l’assistant d’export
Eclipse Web Tools Platform intègre un assistant d’export au format WAR.
Cependant l’assistant ne permet pas de sélectionner les fichiers à inclure ou
exclure : il sélectionne systématiquement l’ensemble des fichiers et répertoires du
dossier « WebContent » du projet.
 Par conséquent, avant d’invoquer l’assistant d’export WAR, il faut
impérativement déplacer ou renommer temporairement le fichier de
contexte (WebContent/META-INF/context.xml) afin qu’il ne soit pas inclus
dans l’archive. (On peut par exemple le renommer temporairement en
« context.disabled »)
Une fois s’être assuré que le fichier de contexte a été déplacé ou renommé,
sélectionner le projet dans l’explorateur de projets J2EE et sélectionner l’option «
Export  WAR File » :
Dans le dialogue d’Export, vérifier
que le projet Web à exporter est
bien sélectionné,
Cliquer sur « Browse… » ou utiliser
le champ texte « Destination : »
pour saisir le nom à utiliser pour le
fichier archive WAR.
Cliquer sur « Finish » : l’archive
WAR
est
automatiquement
construite.
Le fichier d’archive WAR peut alors être envoyé à DPI pour déploiement, en
n’oubliant pas de joindre séparément le fichier de contexte XML de l’application que
l’on aura renommé pour l’occasion d « context.xml » à « NomDuModule.xml ».
3.7.2
Fabrication de l’archive WAR à l’aide d’un script Ant
Pour des cas plus complexes, il est possible de développer pour le projet un script
Ant spécifique réalisant les étapes nécessaires à la fabrication de l’archive WAR.
L’application de démonstration « FWKSample » contient un fichier script Ant de
démonstration qui illustre :
- la réalisation d’une archive WAR
- le déploiement de cette archive en local sur un serveur Tomcat
Les scripts d’exemple sont dans le répertoire BUILD (fichiers « build.xml » et
« build.properties »).
Dernière impression le 15/04/17
Page 67 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
3.8 Génération
déploiement
d’une
archive
EAR
de
V1.2.3
l’application
pour
le
Si le serveur cible pour l’application est WebSphere, l’application doit être packagée
sous forme d’archive EAR. Il faut alors créer un projet d’application d’entreprise
dans Eclipse, avant de pouvoir y ajouter le ou le modules de l’application et de
fabriquer une archive au format EAR.
3.8.1 Création d’un projet d’application d’entreprise et ajout d’un module
Web
Dans l’explorateur de projets, cliquer sur la catégorie « Enterprise Applications », et
choisir l’option « New Enterprise Application Project » dans le menu
contextuel.
L’assistant de création d’application d’entreprise s’affiche. La création du projet va
s’effectuer en 5 étapes (voir illustration ci-après) :
Dernière impression le 15/04/17
Page 68 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
1) Nommage du projet et création d’un nouvel environnement serveur.
Entrer un nom pour le projet dans le champ « Name » (ici : « TestEAR »)
Il faut également associer le projet EAR à un serveur J2EE cible. Etant donné que
Tomcat ne supporte pas le déploiement EAR, il faut déclarer un nouveau serveur
J2EE « générique » en cliquant sur « New… »
2) Déclaration d’un serveur J2EE générique : première partie
Le dialogue « New Server Runtime » s’affiche. Sélectionner « Basic J2EE
Runtime Library » dans la liste arborescente des types de serveurs, et cliquer
sur « Next ».
3) Déclaration d’un serveur J2EE générique : seconde partie
Il convient d’indiquer dans le champ « Location » un répertoire correspondant
auu répertoire des bibliothèques du serveur cible. Ici, nous utilisons un répertoire
contenant la bibliothèque « j2ee.jar » du kit de développement J2EE 1.3.1
téléchargé à partir du site java.sun.com. Cette bibliothèque doit contenir les
définitions nécessaires à la compilation des éléments J2EE constituant l’EAR.
On termine la déclaration du serveur J2EE associé au nouveau projet en cliquant
sur « Finish », ce qui nous ramène au dialogue de l’assistant de création de projet
EAR.
4) Retour à l’assistant de création de projet EAR : étape suivante
De retour dans le dialogue de l’assistant de projet EAR, cliquer sur « Next ».
5) Association de modules J2EE au projet EAR
La dernière étape de l’assistant consiste à associer à notre projet EAR les autres
projets correspondant aux modules J2EE qui feront partie de l’application
d’entreprise.
Sélectionner le projet « FWKSample », et cliquer sur « Finish » pour terminer la
création du projet.
De retour dans l’explorateur de projets,
dérouler l’arborescence du projet EAR
nouvellement créé : il contient uniquement
le descripteur de déploiement
« METAINF/application.xml »
Dernière impression le 15/04/17
Page 69 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
En ouvrant le descripteur de
déploiement,
on
constate
qu’il
contient
bien
une
définition de module Web
pour
l’application
Web
« FWKSample ».
3.8.2
Exportation de l’application d’entreprise sous forme d’archive EAR :
Dans l’explorateur de projets, sélectionner l’application d’entreprise « TestEAR » et
sélectionner l’option « Export… EAR File » dans le menu contextuel.
L’assistant
d’exportation
EAR s’affiche.
Vérifier que le projet Web
à
exporter
est
bien
sélectionné,
Cliquer sur « Browse… »
ou utiliser le champ texte
« Destination : »
pour
saisir le nom à utiliser
pour le fichier d’archive
EAR.
Cliquer sur « Finish » :
l’archive
EAR
est
automatiquement créée.
3.9 Déploiement des archives WAR ou EAR par DPI
DPI réceptionne via l’outil DTI l’archive d’entreprise (fichier .EAR) constituant
l’application et le dossier de déploiement de l’application.
Le déploiement s’effectue comme décrit dans le document « D-SE13_TT_04146_Déploiement Application J2EE.doc ».
Dernière impression le 15/04/17
Page 70 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
3.10 Gestion de dépendances entre projets
3.10.1
Dépendances entre projets
Dans un projet Web on utilise typiquement des bibliothèques de fonctions
additionnelles (frameworks divers, APIs et connecteurs techniques, etc.).
Ces fonctionnalités tierces peuvent être :
- fournies sous forme compilée, packagées en tant que bibliothèques au format
JAR ajoutées au chemin de compilation du projet.
- ou bien regroupées dans un ou plusieurs projets annexes dans l’espace de
travail, contenant les fichiers sources de la bibliothèque.
Le premier cas de figure présente les caractéristiques suivantes :
 pas de possibilité de débogage dans les bibliothèques utilisées par l’application
 la dépendance d’une application face à une bibliothèque est gérée en incluant
l’emplacement du fichier de bibliothèque dans le chemin de compilation de
l’application
Le second cas de figure apporte une possibilité supplémentaire :
 il autorise un débogage « complet » de l’application, y-compris dans le code
source des projets des bibliothèques de fonctionnalités tierces ou communes à
plusieurs applications.
 cependant, il est nécessaire dans ce cas d’ajouter non pas un simple fichier
JAR, mais le projet lui-même au chemin de compilation. On parle dans ce cas
de dépendances projet.
Les dépendances projet doivent être gérées à deux niveaux :
 au niveau développement : le compilateur doit pouvoir localiser les
dépendances du projet vis-à-vis de classes se trouvant dans une bibliothèque
JAR ou dans un projet annexe
 au niveau de l’environnement de test : l’environnement de développement
doit pouvoir exécuter l’application sur l’environnement de test en configurant
le serveur de test de façon à lui indiquer les dépendances de l’application visà-vis des bibliothèques ou projets annexes utilisés.
WSAD 5.1 inclut deux fonctionnalités complémentaires dédiées à la gestion des
dépendances entre projets, qui sont accessibles à partir de la boîte de dialogue
« Propriétés » du menu contextuel d’un projet :
- la rubrique « Chemin de compilation Java » contient un onglet « Projets »
qui permet de cocher les projets de l’espace de travail dont dépend la
compilation du projet actuellement sélectionné. Cette option gère donc les
dépendances au niveau « compilation ».
- la rubrique « Projets de Bibliothèque Web » permet de traiter un projet
Java comme une bibliothèque JAR dans le dossier « WEB-INF/lib » d’un projet
Web. Cette option permet donc de gérer les dépendances au niveau
« exécution » sur le serveur de test.
Dernière impression le 15/04/17
Page 71 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Quant à l’environnement de développement Eclipse 3.1 / Web Tools Platform, il
possède des fonctionnalités similaires mais qui gèrent uniquement à l’heure
actuelle l’aspect « compilation » des dépendances entre projets. Ces
fonctionnalités sont accessibles à partir de l’option « Properties » du menu
contextuel d’un projet :
- la rubrique « Java Build Path » contient un onglet « Projects » qui permet
d’ajouter les projets de l’espace de travail dont dépend la compilation du
projet actuellement sélectionné. Cette option gère donc les dépendances au
niveau « compilation ».
- il existe également une rubrique « Project References » qui permet de
définir quels autres projets de l’espace de travail sont « référencés » par le
projet en cours. Malheureusement cette option n’a pour l’instant pas grande
utilité, et ne prend pas en charge les dépendances au niveau « exécution » sur
le serveur.
Avec Eclipse 3.1 / Web Tools Platform, il est donc nécessaire de trouver une
approche alternative à celle employée avec WSAD pour la configuration des
dépendances entre projets. Cette approche nécessite la mise en œuvre d’une
configuration particulière sur le serveur de test, et impose de suivre une
procédure spécifique pour le lancement du serveur. Ces opérations seront
étudiées à travers un exemple :
3.10.2
Exemple
Nous allons étudier un exemple simple :
- un projet Web (appelé « TestDep_Master ». Ce projet contiendra une servlet
qui utilisera une fonctionnalité (un JavaBean) fourni au travers d’un autre
projet
- un projet Java simple (appelé « TestDep_Util » qui contiendra la fonctionnalité
(le JavaBean) dont dépend le projet « TestDep_Master ».
3.10.2.1 Création du projet utilitaire « TestDep_Util »
Pour créer ce projet Java simple,
sélectionner l’option de menu « File 
New  Java Project… »
Saisir le nom du projet.
Il
est
ensuite
recommandé
de
sélectionner
l’option
« Create
separate
source
and
output
folders » dans la rubrique « Project
layout » afin qu’Eclipse utilise des
répertoires séparés pour les fichiers
sources et les fichiers compilés du
projet.
Dernière impression le 15/04/17
Page 72 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Créer ensuite une classe « UtilBean » dans un nouveau package « testdep.util »
(ce JavaBean sera la fonctionnalité fournie par le projet « TestDep_Util » qui sera
utilisée dans le projet « TestDep_Master »).
Ajoutez un attribut « value » de type « String » à cette classe et générez les
accesseurs (méthodes « getValue » et « setValue ») à l’aide du menu contextuel
« Source  Generate Getters and Setters… » de l’éditeur de source Java.
3.10.2.2 Création du projet principal de l’application Web : « TestDep_Master »
Créez un nouveau projet J2EE dynamique appelé « TestDep_Master », en
sélectionnant « Tomcat 5.0 » comme serveur cible et « 2.3 » comme niveau de
spécification de l’AP Servlet.
Nous allons maintenant créer une servlet qui va référencer un objet du type
« UtilBean » défini précédemment.
Créer une nouvelle servlet avec les propriétés suivantes :
- Nom / Classe :
TestServlet
- package :
testdep.servlet
- mapping d’URL :
/test
- méthodes à redéfinir : doGet()
Ajouter le code suivant à la méthode doGet() de la servlet. (Eclipse détectera des
erreurs de compilation sur les portions de code reproduites ci-dessous
en
rouge) :
testdep.util.UtilBean bean = new testdep.util.UtilBean();
bean.setValue(“Hello, world!”);
java.io.PrintWriter pw = arg1.getWriter();
pw.println(“<html><body>”);
pw.println(“<p>” + bean.getValue() + “</p>”);
pw.println(« </body></html> ») ;
Bien évidemment, Eclipse ne reconnaît pas le type testdep.util.UtilBean défini dans
un autre projet. Il faut donc préciser qu’on fait référence au projet « TestDep_Util »
dans le projet « TestDep_Master ».
Pour indiquer que l’on souhaite faire référence au projet «TestDep_Util » :
- Cliquer sur le projet « TestDep_Master » et sélectionner le menu contextuel
« Properties ».
- Dans la fenêtre des propriétés, sélectionner la rubrique « Project
References », cocher la case correspondant au projet « TestDep_Util ».
Dernière impression le 15/04/17
Page 73 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Avant de cliquer sur « OK », il convient aussi de régler le chemin de compilation
du projet dans cette même fenêtre de propriétés, afin d’y ajouter le projet
nouvellement référencé.
Dans la partie gauche de la fenêtre de propriétés, sélectionner la rubrique « Java
Build Path », puis l’onglet « Projects » dans la partie droite.
Suivre ensuite les étapes suivantes :
(1) cliquer sur le bouton « Add… » pour ajouter un nouveau projet
(2) dans la fenêtre « Required Project Selection », sélectionner le projet
« TestDep_Util » et cliquer « OK ».
(3) le nom du projet apparaît désormais dans la zone de texte « Required
projects on the build path ». Cliquer sur le bouton « OK » de la fenêtre de
propriétés pour confirmer les changements.
Dernière impression le 15/04/17
Page 74 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Une fois ces modifications réalisées, les erreurs de compilation disparaissent.
3.10.2.3 Exécution de l’application « TestDep_Master » sur un serveur de test :
Créer un nouveau serveur de test de type « Apache Tomcat 5.0 », sur la machine
« localhost ». Double-cliquer ensuite sur l’entrée du serveur pour afficher la fenêtre
de configuration du serveur, et renommer le serveur avec le nom suivant :
« TestDep Tomcat5 Server »
Sélectionner ensuite le projet « TestDep_Master », choisir l’option « Run As… 
Run On Server », et sélectionner le serveur « TestDep Tomcat5 Server ».
Dans la fenêtre du navigateur Web qui doit s’afficher au lancement, entrer l’URL
suivante : http://localhost:8080/TestDep_Master/test
A l’exécution de la requête, une exception est renvoyée :
java.lang.NoClassDefFoundError :
testdep/util/UtilBeantestdep.servlet.TestServlet.doGet (TestServlet.java :32)
javax.servlet.http.HttpServlet.service(HttpServlet.java :689)
javax.servlet.http.HttpServlet.service(HttpServlet.java :802)
En fait, les options de « dépendances/ références » entre projets définies
précédemment ne s’appliquent qu’à l’environnement de développement Eclipse,
pour la compilation. Elles ne s’appliquent pas à la configuration du serveur, qu’il va
donc nous falloir également adapter.
3.10.2.4 Modification de la configuration du serveur
Avant tout, arrêter le serveur « TestDep Tomcat5 Server ».
Sélectionner ensuite l’option du menu principal « Run  Run… » qui va nous
permettre d’éditer la configuration de lancement de notre serveur.
Le dialogue de réglage des configurations d’exécution de projets Eclipse apparaît :
ce dialogue permet de définir diverses configurations d’exécution pour différents
types d’applications Java : applications autonomes, applications Swing ou SWT,
applets, ainsi qu’applications J2EE.
On retrouve en effet les définitions des serveurs Tomcat définis dans la vue
« Servers », présentés sous forme arborescente dans la zone de gauche de la
fenêtre (zone « Configurations : ») :
Dernière impression le 15/04/17
Page 75 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Ce qu’il nous faut effectuer est modifier la configuration utilisée par Eclipse pour
lancer notre serveur Tomcat, afin d’inclure dans le chemin de compilation du
serveur le projet dont l’application dépend. Pour cela, il suffit de suivre la procédure
suivante :
(1) Dans la zone « Configurations : » à gauche, sélectionner le serveur
« TestDep Tomcat5 Server ». Sélectionner ensuite l’onglet « Classpath »
dans la zone de droite. puis sélectionner l’item « User Entries » dans la zone
« Classpath : », et cliquer enfin sur le bouton « Add Projects… » à droite de
cette zone
(2) Le dialogue « Project Selection » apparaît. Cocher simplement le nom du
projet à ajouter (ici : « TestDepUtil », puis cliquer sur « OK » pour confirmer
et fermer ce dialogue. Le projet sélectionné est alors ajouté sous
l’arborescence « User Entries : » de la zone « Classpath : » du dialogue
principal.
(3) Cliquer sur « Apply » en bas à droite pour sauvegarder les modifications
apportées à la configuration du serveur
Dernière impression le 15/04/17
Page 76 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
3.10.2.5 Procédure de lancement d’un serveur configuré avec des dépendances projet
Important :
Une fois la modification de la configuration du serveur effectuée, il ne faut surtout
plus utiliser les fonctionnalités classiques de lancement du serveur à partir de la
perspective J2EE, sous peine de perdre les modifications apportées à la
configuration du serveur.
 Les options suivantes ne devront donc plus être utilisées pour démarrer
le serveur dont la configuration a été modifiée :
- option « Run As  Run on Server…” du menu contextuel de l’explorateur
de projets de la perspective J2EE
- boutons et options de menu « Start », « Debug », et « Restart » de la
vue « Servers »
 Le serveur devra uniquement être démarré à partir du menu « Run 
Run… » du menu principal (ou à partir de l’historique des lancements,
comme discuté ci-après)
 Pour l’arrêt du serveur, on utilisera les boutons ou options d’arrêt des
vues « Servers » ou « Console ».
 Premier démarrage du serveur :
Le premier démarrage du serveur
doit s’effectuer à partir de l’option
du menu principal « Run 
Run… » .
Dans le dialogue de réglage des
configurations, il suffit alors de
sélectionner la configuration du
serveur
dans
la
zone
« Configurations : » à gauche (ici
« TestDep Tomcat5 Server »), et
de lancer le serveur en cliquant sur
le bouton « Run » en bas à droite.
Lorsque le serveur démarre, on constate cependant que son état est bien mis à jour
dans la vue « Servers ».
De la même façon, les messages de démarrage du serveur apparaissent toujours
dans la vue « Console ».
Dernière impression le 15/04/17
Page 77 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
 Test du programme :
A la différence de l’option « Run As  Run On Server… », qui affiche
automatiquement une fenêtre de navigateur Web pointant sur l’URL de la
ressource sélectionnée (page de démarrage de l’application, ou autre page ou
mapping de servlet par exemple), le démarrage du serveur via l’option « Run 
Run… » ne déclenche pas automatiquement l’ouverture d(une fenêtre de
navigateur Web.
Pour tester l’application, il convient donc :
- d’utiliser un navigateur Web externe et de le faire pointer vers l’URL associée
à l’application (du type « http ://localhost:8080/NomDuModuleWeb »)
- ou bien d’ouvrir une nouvelle fenêtre de navigateur Web intégré à Eclipse en
cliquant sur le bouton en forme de globe terrien dans la barre d’outils
d’Eclipse, puis de saisir l’URL correspondant à l’application dans la barre
d’adresse de cette fenêtre :
Ici, l’URL d’accès à la servlet de test de l’application est :
http://localhost:8080/TestDep_Master/test
 Arrêt du serveur :
L’arrêt du serveur peut être effectué indifféremment à partir de la vue
« Servers » ou de la vue « Console » à l’aide des options de menu contextuel et
boutons prévus à cet effet :
Dernière impression le 15/04/17
Page 78 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
 Démarrage en mode de débogage :
Le serveur peut également être
démarré en mode débogage à
partir de l’option de menu
principal « Run  Debug… » .
Dans le dialogue de réglage des
configurations, il suffit alors de
sélectionner la configuration du
serveur
dans
la
zone
« Configurations : » à gauche
(ici
« TestDep
Tomcat5
Server »), et de lancer le
serveur en cliquant sur le
bouton « Debug » en bas
à
droite.
 Option de raccourci pour les démarrages suivants :
Eclipse conserve un historique des lancements effectués en mode normal et en
mode débogage, et offre des « raccourcis » pour relancer la dernière
configuration utilisée, ou une configuration particulière de l’historique :
-
-
les options « Run Last Launched » et « Debug Last Launched » du
menu « Run » permettent de relancer la dernière configuration utilisée en
mode normal ou débogage
les sous-menus « Run History » et « Debug History » du menu « Run »
permettent d’accéder à l’historique des derniers lancements de
configuration effectués en mode normal ou débogage.
Ces options peuvent également être
actionnées plus rapidement par
l’intermédiaire de boutons de la barre
d’outils, qui permettent :
- de lancer directement la dernière
configuration utilisée,
- ou d’accéder à l’historique des
lancements pour chacun des deux
modes (normal et débogage), et de
sélectionner
la
configuration
particulière à lancer.
Dernière impression le 15/04/17
Page 79 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
3.11 Développement coopératif : utilisation de CVS
Eclipse et WSAD intègrent des fonctionnalités exactement similaires pour le
développement collaboratif.
L’environnement de développement se connecte aux différents systèmes de
contrôle de version (SCM) existants par l’intermédiaire de plug-ins :
- plugin PVCS pour Merant PVCS
- plugin CVS pour les référentiels CVS
Pour le cycle de développement, il a été décidé de mettre en œuvre CVS pour les
projets.
Le développement coopératif se base sur l’utilisation d’un référentiel commun à
tous les développeurs, ainsi que de référentiels privés pour chaque développeur :
 Référentiel partagé ou « commun » :
Chaque projet disposera de son propre référentiel CVS. Un référentiel est un
espace de données sécurisé qui permet le partage des fichiers du projet et
gère un historique des modifications apportées par les membres de l’équipe
de développement.
 Référentiel privé (Historique local d’Eclipse) :
Chaque installation d’Eclipse sur les postes de développement intègre un
« historique local » (« Local History ») qui conserve un historique des
modifications effectuées en local sur les fichiers des différents projets de
l’espace de travail.
Synchronisation des modifications
L’opération de synchronisation consiste à :
- publier les modifications effectuées en local (dans l’historique local) vers le
référentiel partagé
- recevoir les modifications effectuées par d’autres développeurs à partir du
référentiel commun, et mettre à jour l’historique local avec les nouvelles
versions des fichiers modifiés
- résoudre les éventuels conflits en cas de modification « simultanée » d’un
même fichier par plusieurs développeurs : il faut alors « fusionner » les
modifications effectuées par chacun afin d’aboutir à une version « unifiée »
utilisable par tous.
Dernière impression le 15/04/17
Page 80 sur 100
Note technique
DEI
3.11.1
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Configuration d’un référentiel CVS dans Eclipse
Sélectionner la perspective
Repository Exploring »)
de
l’explorateur
de
référentiels
CVS
(« CVS
Dans la vue « CVS Repositories », afficher le menu contextuel (clic droit) et
sélectionner l’option « New  Repository Location ») pour configurer l’accès à
un référentiel CVS.
Le dialogue d’ajout de référentiel CVS s’affiche :
Note : l’ensemble des informations nécessaires à la configuration de l’accès au
référentiel sera communiqué au chef de projet après qu’il aura effectué la demande de
création de référentiel CVS auprès de DPI. Le chef de projet devra préciser le nom de
chaque utilisateur CVS à créer pour chaque projet, et transmettra les informations à
chaque utilisateur.
- entrer le nom de la machine CVS dans le
champ « Host »
- entrer le chemin du référentiel dans le
champ « Repository path »
- Entrer votre nom d’utilisateur CVS dans
le champ « User », et votre mot de
passe
associé
dans
le
champ
« Password ».
- sélectionner
« pserver » dans
champ « Connection type »,
le
- cocher la case « Use port », et entrer
dans le champ texte le numéro de
port corespondant au référentiel
CVS auquel vous voulez accéder.
- cocher « Validate Connection on
Finish »
- cocher « Save Password »
Dernière impression le 15/04/17
Page 81 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
- cliquer « Finish » : si les informations sont correctes, le nouvel emplacement de
référentiel sera créé dans la vue « CVS Repositories » d’Eclipse.
3.11.2
Démarrage du projet : publication de la première version dans CVS
Avant de pouvoir partager un projet, il faut bien entendu publier une première
version dans le référentiel CVS.
Prenons comme exemple le projet « WebProj1 » créé précédemment. Voici les
différentes étapes à suivre pour partager ce projet :
- Sélectionner le projet dans l’espace de travail.
- Afficher le menu contextuel (clic droit) et choisir l’option « Team  Share
Project… »
L’assistant
« Share
Project » s’affiche :
Choisir l’option
« Use existing repository
location », et sélectionner
dans la liste l’emplacement
de référentiel dans lequel le
projet doit être sauvegardé
et partagé.
Cliquer sur « Next ».
Dans l’écran suivant, sélectionner « Use project name as module name » et
cliquer sur « Next » :
Dernière impression le 15/04/17
Page 82 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Eclipse recense alors les différents fichiers du projet, et affiche une nouvelle page
de l’assistant permettant :
-
de sauvegarder (« commit » = « valider ») l’ensemble des fichiers, ou certains
fichiers seulement, vers le référentiel CVS associé au projet
-
de marquer certains fichiers comme ne devant pas être sauvegardés dans le
référentiel. (bouton « Ignore Selected Resources… » dans le bandeau
supérieur droit de l’arborescence du projet, ainsi que l’option « Add to
.cvsignore » du menu contextuel associé à la liste des fichiers du projet).
Nous reviendrons sur cette fonctionnalité plus tard.
Pour l’instant, il suffit de
cliquer sur « Finish »
pour lancer la sauvegarde
des fichiers du projet
dans le référentiel.
Eclipse lance
automatiquement
l’assistant de validation
(« Commit Wizard ») :
L’assistant de validation repère
immédiatement certains types
de
fichiers
inconnus
(ils
correspondent en fait à des
fichiers utilisés de façon interne
par Eclipse Web Tools Platform
pour gérer certaines propriétés
du projet). :
Pour chacun des types de fichier
détectés, sélectionner l’option
« ASCII Text » dans la colonne
« Content ». En effet, chacun
de
ces
types
de
fichiers
correspond à du contenu XML,
donc textuel.
Cliquer ensuite sur « Next ».
Dernière impression le 15/04/17
Page 83 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
L’assistant
de
validation
vous
propose ensuite d’associer des
commentaires à la première version
des fichiers sauvegardée dans CVS.
Pour
ajouter
un
commentaire
commun (« première version ») à
l’ensemble
des
fichiers
sauvegardés :
-
-
sélectionner le nœud principal
(le nom du projet) dans la liste
arborescente au bas de la
fenêtre
saisir le commentaire à utiliser
dans le champ texte multi-ligne
en haut de la fenêtre.
Cliquer ensuite sur « Finish »
La sauvegarde du projet dans le référentiel CVS s’effectue. Une fois cette opération
terminée, on remarque que le nom du projet dans l’explorateur de projets est désormais
précédé d’indicateurs (icône, et signe « > ») indiquant qu’il s’agit d’un projet partagé
dans CVS. D’autre part, le nom d’hôte su référentiel CVS associé apparaît entre crochets
après le nom du projet :
(Note : la présence en triple du signe « > »
dans la perspective J2EE est due à une
anomalie d’affichage sans conséquence.)
Dernière impression le 15/04/17
Page 84 sur 100
Note technique
DEI
3.11.3
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Organisation du référentiel CVS
Si
on
déroule
l’arborescence
de
l’emplacement
CVS
configuré, on remarque
un premier niveau de
hiérarchie correspondant
à un classement des
« modules » par type de
version (un
« module »
CVS correspond à un
« projet » dans Eclipse) :
Notion de version sous CVS — Il est important de distinguer :

-
-
Présentation arborescente des versions CVS dans l’explorateur CVS
d’Eclipse :

-
-

les numéros de versions des fichiers, attribués par CVS : ils correspondent
en fait à des numéros de révision : à chaque fois qu’un fichier modifié est mis à
jour dans le référentiel, CVS augmente automatiquement son numéro de
révision.
les étiquettes de versions : CVS permet d’apposer à chaque révision d’un
fichier un label de version librement choisi. C’est d’ailleurs par ce mécanisme
que CVS présente la version de travail des fichiers dans le nœud « HEAD ». En
réalité, « HEAD » est simplement un label géré automatiquement par CVS.
Nœud « HEAD » : les versions de travail des projets se trouvent dans ce nœud
Nœud « Branches » : il est possible de créer plusieurs « branches » de
développement d’un même module qui seront alors accessibles à travers ce
nœud.
Nœud « Versions » : comme indiqué plus haut, CVS permet d’étiqueter
chaque version d’un fichier avec un label librement choisi. De cette façon, on
peut apposer un label particulier à une version donnée des différents fichiers
d’un projet afin d’identifier une « version » particulière d’un projet. (Exemple :
la version « 1.0_DEV » du projet « ProjA » est composée de la version 1.2 du
fichier HelloServlet.java, et de la version 1.4 du fichier index.jsp)
Organisation des modules :
A l’intérieur de chaque « nœud », on trouve les différents « modules » CVS, qui
correspondent donc sous Eclipse à des projets. Chaque module est une structure
arborescente pouvant contenir différents dossiers, sous-dossiers et fichiers.
Module système « CVSROOT » :il s’agit d’un module propre à CVS qui contient
les méta-informations du référentiel (informations sur le référentiel CVS luimême).
Dernière impression le 15/04/17
Page 85 sur 100
Note technique
DEI
3.11.4
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Importation d’un projet publié dans CVS
3.11.4.1 Récupération d’un projet depuis un référentiel CVS
Pour récupérer la version la plus récente d’un projet, il suffit de :
 dérouler le nœud « HEAD » et sélectionner le projet désiré
 sélectionner l’option « Check Out » à partir du menu contextuel.
(Note : L’option « Check Out As… » permet de récupérer le projet et de
l’enregistrer localement sous un autre nom dans l’espace de travail)
L’exemple ci-contre illustre
comment
récupérer
la
dernière version du projet
« FWKSample » sur
le
serveur
CVS
de
test
précédemment déclaré :
Une fois le projet récupéré, le
nouveau projet est visible dans la
vue « Project Explorer » de la
perspective J2EE.
(Note : la présence en triple du
signe « > » en regard du nom du
projet est une anomalie sans
conséquence
qui
affecte
uniquement
l’explorateur
de
projets de la perspective J2EE)
3.11.4.2 Corrections des erreurs après récupération d’un projet via CVS
Après récupération d’un projet depuis CVS, il est possible qu’un grand nombre
d’erreurs soit signalé. Ces erreurs peuvent être de plusieurs types :
 erreurs de validation sur des fichiers XML (DTD, XML Schema) : (par
exemple, les fichiers de configuration du framework font référence à une DTD
spécifique qui n’est en général pas incluse avec le fichier).
 Pour supprimer l’apparition de ces erreurs, désactiver l’option de
validation des fichiers XML dans la rubrique « Validation » des
préférences d’Eclipse.
 erreurs de chemin de compilation (« classpath ») incomplet
invalide : ces erreurs peuvent être de plusieurs sources :
Dernière impression le 15/04/17
ou
Page 86 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
o Erreur de liaison d’une variable de bibliothèque : par exemple, il se
peut qu’Eclipse ne parvienne pas à lier les bibliothèques système du JRE
déclaré dans le projet à celles du JRE configuré pour le projet. Cette
situation est signalée comme une erreur dans la vue « Problems », et la
variable est suivie de la mention « unbound » entre parenthèses (« non
liée ») dans l’explorateur de projets.
 Pour corriger cette situation :
- sélectionner la variable mal configurée (ici, le JRE)
- afficher le menu contextuel, et choisir l’option « Configure… »
- La boîte de dialogue « Edit Library » s’affiche. Elle permet de
sélectionner la valeur à utiliser pour la bibliothèque mal configurée.
Pour le JRE par ex., faire pointer la variable vers un JRE adéquat
configuré dans l’environnement de développement. :
o Erreur
de
liaison
d’une
variable de
chemin
(« Classpath
variable ») : Eclipse permet de définir des variables de chemin afin de
faire pointer le projet vers une bibliothèque Java en utilisant un chemin
relatif au lieu d’un chemin absolu. Ces « variables » sont définies au niveau
des préférences de l’environnement de travail (rubrique « Java  Build
Path  Classpath Variables »).
Si l’on récupère un projet depuis CVS, il convient donc de vérifier si le
projet ne déclare pas de variables spécifiques qui doivent être configurées
dans l’environnement de développement.
Les variables définies par un projet sont visibles dans la fenêtre des
propriétés du projet (« Project Properties » accessible depuis le menu
contextuel du projet), rubrique « Java Build Path », onglet « Libraries ».
Dernière impression le 15/04/17
Page 87 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Exemple :
supposons
que
le
projet
déclare
une
variable
« JUNIT_HOME « désignant le répertoire contenant les bibliothèques
Java de JUnit :
Si la variable JUNIT_HOME n’est pas déclarée dans l’espace de travail de
l’environnement de développement, une erreur sera signalée. Il conviendra
alors de définir la variable requise par le projet au niveau des Préférences :
Dernière impression le 15/04/17
Page 88 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
3.11.4.3 Configuration du Serveur utilisé par le projet récupéré via CVS
Dans la plupart des cas, si on utilise Tomcat 5 avec Eclipse, il ne sera pas
nécessaire de publier dans CVS le « projet serveur » associé au projet, comme il
était habituel de le faire avec WSAD.
En effet, avec Tomcat, la quasi-totalité des paramètres de configuration de
l’application sur le serveur sera définie dans un fichier META-INF/context.xml
intégré dans l’arborescence du projet. Ainsi, la configuration du serveur spécifique
à l’application fera partie intégrale du projet.
3.11.5
Synchronisation avec le référentiel CVS
Au cours du développement partagé d’un projet, il est important de régulièrement
synchroniser l’espace de travail d’Eclipse avec le référentiel CVS, c’est-à-dire :
 de mettre à jour le référentiel CVS en y publiant les modifications effectuées
en local
 de mettre à jour le projet dans l’espace de travail en récupérant les
dernières modifications enregistrées par les autres membres de l’équipe dans le
référentiel CVS.
 de résoudre les éventuels conflits résultant de la modification concurrente
d’un même fichier par plusieurs membres de l’équipe.
3.11.5.1 Publication des modifications vers le référentiel
Avec CVS, il est recommandé à chaque développeur de veiller à publier
régulièrement ses modifications vers le référentiel. Ceci limite les risques de
« conflits » liés à des mises à jour concurrentes et les incompatibilités entre
fichiers sources modifiés par les uns et les autres.
Une règle de bon sens doit être observée : ne jamais publier une version
modifiée d’un fichier comportant des erreurs de compilation, ou dont la publication
pourrait occasionner des erreurs de compilation au sein d’autres fichiers source.
3.11.5.2 Marquage visuel des fichiers modifiés ou nouvellement créés
Dans les différentes vues d’explorateur de fichiers ou de packages, Eclipse appose
une marque visuelle (un signe « > ») en regard des nouveaux fichiers créés, ou des
fichiers modifiés par rapport à la dernière version récupérée sur le référentiel CVS.
A la différence de PVCS, CVS ne fonctionne pas selon un mode de verrouillage
exclusif des fichiers : plusieurs personnes peuvent travailler sur un même fichier en
même temps. Lors de la mise à jour vers le référentiel, CVS détecte les éventuels
conflits (modifications concurrentes) en vérifiant si la dernière version du fichier
présente dans le référentiel correspond toujours à la version d’origine récupérée
avant modification locale de ce fichier

Dernière impression le 15/04/17
Page 89 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Par
exemple :
sélectionner
« WebProj1 » créé précédemment.
le
Réf. : C-LABPR/IFD/05-169
V1.2.3
projet
Modifier la page « index.jsp » dans le répertoire
« WebContent ». Puis, créer une nouvelle page
JSP (« page1.jsp ») dans ce même répertoire.
Un signe « > » apparaît en regard des 2 fichiers
JSP pour indiquer que ces fichiers représentent des
modifications vis-à-vis de l’état du référentiel CVS.
On remarque aussi qu’à la différence
« index.jsp » qui porte le n° de version
fichier « page1.jsp » ne comporte pas
n° de version, puisqu’il n’a pas encore
sur le référentiel.
du fichier
« 1.1 », le
encore de
été publié
3.11.5.3 Options de synchronisation avec le référentiel
Pour synchroniser les fichiers du projet dans l’espace de travail en local et le
référentiel, on utilise le menu contextuel « Team ».qui comporte 3 options gérant
la synchronisation entre l’espace de travail et le référentiel CVS.
La « portée » de ces différentes actions dépend de l’élément actuellement
sélectionné dans l’explorateur de fichiers :
- si l’élément est un projet, alors l’action de synchronisation avec le référentiel
s’appliquera à l’ensemble des dossiers et fichiers du projet
- si l’élément est un dossier, alors l’action de synchronisation avec le référentiel
s’appliquera à l’ensemble des sous-dossiers et fichiers de ce dossier.
- si l’élément est un fichier, alors l’action de synchronisation avec le référentiel
s’appliquera uniquement à ce fichier.
- il est également possible d’effectuer une sélection multiple dans l’explorateur de
fichiers, en utilisant les méthodes de sélection standard (Shift+Clic et
Ctrl+Clic) d Windows. Dans ce cas, l’action de synchronisation s’appliquera à
l’ensemble des éléments sélectionnés (par exemple : 2 dossiers et 3 fichiers).
Dernière impression le 15/04/17
Page 90 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
Les 3 actions relatives à la mise à jour des modifications sont donc :
 Synchronize with Repository : déclenche une « comparaison détaillée »
entre chaque dossier/fichier de la sélection et la version des dossiers/fichiers
équivalents présents dans le référentiel. Le résultat de ce « comparatif » est
affiché dans une perspective dédiée : « Team Synchronizing Perspective »
(« perspective de synchronisation avec le référentiel ») que nous étudierons
plus loin.
 Commit… : cette action procède directement à une tentative de publication des
fichiers/dossiers sélectionnés sans mener une « étude d’impact préalable »
comme l’option précédente. Cette tentative de publication pourra uniquement
aboutir s’il n’y a pas de « conflit », c’est-à-dire si personne n’a publié entretemps des changements sur les mêmes fichiers/dossiers dans le référentiel.
 Update : cette action est similaire à l’action précédente, mais est seulement
disponible pour les fichiers modifiés. Elle ne s’applique pas aux nouveaux
fichiers pour lesquels seules les 2 précédentes options sont disponibles.
3.11.5.4 Fonctionnalités de la perspective de synchronisation avec le référentiel
Dans l’explorateur de projets de la perspective J2EE, dérouler l’arborescence du
projet « WebProj1 », sélectionner le dossier « WebContent » et choisir l’option
« Team  Synchronize with Repository » du menu contextuel.
Eclipse affiche un avertissement indiquant que la perspective associée à cette
action est la perspective « Team Synchronizing » et demandant de confirmer le
changement de perspective.
La perspective de synchronisation s’articule autour de la vue « Synchronize »,
qui affiche la liste des fichiers et dossiers à synchroniser. Un groupe de quatre
boutons dans le bandeau supérieur de cette vue contrôle le mode d’affichage des
fichiers :
Dernière impression le 15/04/17
Page 91 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Dernière impression le 15/04/17
Réf. : C-LABPR/IFD/05-169
V1.2.3
Page 92 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
De gauche droite, ces différents modes sont :
 mode « entrant » (« Incoming Mode») :
Ce mode affiche seulement les fichiers du référentiel qui ont été modifiés
depuis la version récupérée en local.
Ce mode permet donc de visualiser les modifications publiées par les autres
membres de l’équipe sur les fichiers du projet.
 mode « sortant » (« Outgoing Mode») :
Ce mode affiche les fichiers du référentiel qui ont été modifiés par rapport à la
dernière version publiée dans le référentiel.
Ce mode permet donc de visualiser les modifications effectuées en local et qui
doivent être publiées vers le référentiel.
 mode « mixte » entrant/sortant (« Incoming/Outgoing Mode») :
Ceci est le mode par défaut sélectionné dans la vue « Synchronize ». Il affiche
donc à la fois les fichiers sortants (modifications locales à publier) entrants et
sortants (modifications externes à récupérer).
 mode « Affichage des conflits » (« Conflicts Mode») :
Ce mode affiche la liste des fichiers qui sont en « conflit ». Un « conflit » peut
se produire lorsque plusieurs personnes modifient le même fichier. Si une de
ces personnes publie ses modifications dans le référentiel, les autres
personnes ayant apporté des modifications et qui essaieront de publier
ultérieurement leur nouvelle version du fichier se retrouveront en situation de
conflit, car la dernière version dans le référentiel ne correspondra plus à la
version qu’ils ont initialement récupérée.
Chaque conflit sur un fichier doit être « résolu ». Pour résoudre un conflit, il
faut comparer la version contenant les modifications locales avec la dernière
version publiée dans le référentiel, et intégrer les changements de part et
d’autre afin de les « fusionner » dans la version locale. La fusion s’opère avec
un éditeur de texte spécifique intégré à Eclipse, qui affiche les différences
entre les 2 versions d’un même fichier (« éditeur « Text Compare »).
Une fois cette opération réalisée, on marque le fichier comme étant
« fusionné » (option « Mark as Merged »). Dès qu’un fichier est marqué
comme « fusionné », il disparaît de la liste des « fichiers en conflit » et se
retrouve dans la liste des « fichiers sortants », d’où il peut être publié
normalement vers le référentiel.
Dernière impression le 15/04/17
Page 93 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
3.11.5.5 Visualisation des modifications sur les fichiers entrants ou sortants
Eclipse intègre un éditeur de texte spécialisé (« Compare Editor ») qui signale
visuellement les modifications entre deux versions d’un fichier. Cet éditeur permet
de comparer les différences existant entre les versions locale (dans l’espace de
travail) et distante (dans le référentiel) d’un même fichier.
L’éditeur « Compare Editor » est accessible depuis n’importe quel mode
d’affichage de la vue « Synchronize ». Pour l’ouvrir, il suffit de sélectionner un
fichier dans la liste, puis de double-cliquer dessus ou de choisir l’option de menu
contextuel « Open In Compare Editor ».
Exemple : un double-clic sur le fichier « index.jsp » dans la vue « Synchronize »
provoque l’ouverture d’une fenêtre « Text Compare ». Cette fenêtre affiche les
modifications entre la versions locale du fichier (côté gauche), et distante (côté
droit).
Les différences entre les deux versions du fichier sont indiquées :
- par des marques cliquables sur le côté droit de la fenêtre (à droite de
l’ascenseur)
- par des tracés (lignes, rectangles) dans les zones de texte qui aident à repérer
les lignes modifiées, ajoutées ou supprimées, et leur correspondance dans
l’autre fichier. (ici, on voit qu’un nouveau paragraphe a été ajouté dans la
version locale du fichier index.jsp).
Dernière impression le 15/04/17
Page 94 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
3.11.5.6 Synchronisation entre l’espace de travail et le référentiel
La synchronisation s’effectue à partir des modes « mixte » ou « entrant » et
« sortant » de la vue « Synchronize ».
- il est possible de publier / mettre à jour des fichiers de manière individuelle en
utilisant les options « Commit… » et « Update » des menus contextuels.
- Il est également possible de mettre à jour / publier automatiquement
l’ensemble des changements dans l’arborescence sélectionnée en utilisant les
boutons « Update All Incoming Changes… » et « Commit All Outgoing
Changes » en mode « mixte » (« Incoming/Outgoing mode »).
Boutons de publication / mise à
jour groupée de la barre d’outils de
la vue « Synchronize » en mode
mixte
(« Incoming/Outgoing
mode » :
Mode
entrant
(« Incoming
mode») : mise à jour individuelle
d’un fichier (ou d’un dossier ou d’une
sélection de fichiers/dossiers) depuis
le référentiel :
Dernière impression le 15/04/17
Page 95 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Mode
sortant (« Outgoing
mode ») :
publication
individuelle
d’une
nouvelle
version d’un fichier (ou d’un nouveau fichier)
vers le référentiel :
3.11.5.7 Résolution d’un conflit
Exemple : on souhaite publier une nouvelle version de la page « index.jsp » à laquelle
on a ajouté un nouveau paragraphe. Entre-temps cependant, un autre utilisateur a
modifié cette page (suppression de la partie affichant la valeur d’une variable « i »), et a
publié sa nouvelle version dans le référentiel. Lorsqu’à notre tour, nous essayons de
publier notre version modifiée dans le référentiel, Eclipse détecte que la version d’origine
sur laquelle nous nous sommes basés a été remplacée depuis par une autre version plus
récente.
Dernière impression le 15/04/17
Page 96 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Réf. : C-LABPR/IFD/05-169
V1.2.3
Supposons que l’on décide en fait de
supprimer la section de texte à
l’origine du conflit.
Ceci ne suffit pas à « résoudre » le
conflit, car CVS et Eclipse n’ont aucun
moyen de « deviner » que les
modifications apportées permettent
de le résoudre.
Une fois les modifications nécessaires
effectuées, il faut donc signaler la
résolution du conflit à Eclipse
en
marquant le fichier en conflit comme
fusionné. Pour cela, sélectionner
l’option « Mark as Merged » dans le
menu contextuel du fichier.
Si les modifications apportées n’ont
pas encore été sauvegardées, Eclipse
affiche
le
dialogue
« Save
Resources ». Cliquer « OK » pour
sauvegarder
les
modifications
apportées et valider le changement
du fichier de l’état « en conflit » à
l’état « fusionné ».
Le changement d’état du fichier
est visible immédiatement : le
fichier
« index.jsp »
porte
désormais
l’icône
« fichier
sortant »
et
est
affiché
uniquement dans les modes
d’affichage
« mixte »
et
« sortant ».
A ce stade, avant qu’un autre
conflit potentiel ne survienne,
il est urgent de sauvegarder
la
version
fusionnée
du
fichier !!
Pour cela, sélectionner l’option
« Commit » du menu contextuel.
Dans le dialogue « Commit
files » ajouter un commentaire
explicatif puis valider.
Dernière impression le 15/04/17
Page 97 sur 100
Note technique
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
DEI
V1.2.3
4. Développement avec le framework DEI
4.1
Configuration des propriétés JNDI liées à l’utilisation du
framework DEI
Liste des Variables d’environnement à définir selon le module employé :
Module
Framework :
HTTP
taglib
Description
Alias HTTP utilisé par la bibliothèque de tags pour la
localisation des ressources statiques
Nom référence
Web/aliashttp
Framework :
persistence
Paramétrage
d’une
DataSource de type
« Server
Managed
DataSource », de nom
applicatif
« ma_source »
Nom JNDI de la data source
niveau de trace du pool de connexions
Nom d’utilisateur pour la création des connexions du pool
SGBD (si différent de l’utilisateur déclaré au niveau de la
source de données)
Mot de passe de l’utilisateur
ds/ma_source/debug
ds/ma_source/user
Framework : log
Niveau de log des appenders : « debug », « error »,
« fatal », « info », « warn »
Activation/désactivation de l’appender console (« on » ou
« off »)
Activation/désactivation de l’appender rollingfile (« on »
ou « off »)
Appender « rollingfile » : Répertoire de stockage des
fichiers
Appender « rollingfile » : Taille maximum des fichiers
Appender « rollingfile » : nombre de fichiers à utiliser
Activation de l’appender userfile (on ou off)
Appender « userfile » : répertoire de stockage des
fichiers
Activation de l’appender mail (on ou off)
Surcharge du niveau de log pour l’appender mail (debug,
error, fatal, info, warn)
Appender mail : nom DNS du serveur SMTP
Appender mail : émetteur des messages
Appender mail : sujet des messages
Appender mail : destinataire des messages
log/level
Mail
Paramétrage
des
propriétés du serveur
mail
Nom du serveur DNS pour un envoi au protocole SMTP
Utilisateur pour connexion au serveur SMTP
Mot de passe de l’utilisateur
mail/smtphost
mail/user
mail/pwd
Edinat
Paramétrage du pool
de connexion au
module Bdoc-Web
Nom DNS du serveur Edinat
Port utilisé par le serveur Edinat
Nom d’utilisateur pour connexion au serveur Edinat
Mot de passe de l’utilisateur
Nombre maximum de connexions du pool
Nombre minimum de connexions du pool
Délai d’expiration lors d’une tentative de connexion (en
secondes)
edinat/host
edinat/port
edinat/user
edinat/pwd
edinat/maxcount
edinat/mincount
edinat/logintimeout
Dernière impression le 15/04/17
ds/ma_source/jndi
ds/ma_source/pwd
log/console
log/rollingfile
log/rollingfile/dir
log/rollingfile/size
log/rollingfile/nb
log/userfile
log/userfile/dir
log/mail
log/mail/level
log/mail/host
log/mail/from
log/mail/subject
log/mail/to
Page 98 sur 100
Note technique
DEI
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
Module
Edinat
Paramétrage
de
l’environnement pour
une édition d’alias
« alias »
LDAP
Paramétrage
d’un
annuaire LDAP de
nom LDAPName
Framework : Divers
Réf. : C-LABPR/IFD/05-169
V1.2.3
Description
Nom référence
Délai d’expiration d’une connexion en cours d’utilisation
(en secondes)
Description du pool de connexion
Niveau de trace du pool
Nom de l’environnement (production, recette, dev, etc.)
utilisé pour affichage au sein de l’édition.
La partie « alias » dans la clé doit être nommée d’après
le nom de la scène logique ou le nom du document.
edinat/invalidationtime
out
Edinat/description
edinat/debug
edinat/alias/env
Nom DNS du serveur LDAP
Port d’écoute du serveur LDAP
Nom d’utilisateur pour la connexion au serveur LDAP
Mot de passe de l’utilisateur
Nom de la classe de fabrique pour la construction du
contexte initial « InitialContext »
Identifiant de l’application (GIDE)
Code application (GIDE)
ldap/ldapname/host
ldap/ldapname/port
ldap/ldapname/user
ldap/ldapname/pwd
ldap/ldapname/initctx
Nom DNS du Reverse Proxy
(Si présent)
Port du Reverse Proxy
fwk/reverseproxyhost
Dernière impression le 15/04/17
ldap/gide/idappli
ldap/gide/codeappli
fwk/reverseproxyport
Page 99 sur 100
Note technique
DEI
Réf. : C-LABPR/IFD/05-169
Guide Opératoire de Développement
avec Eclipse 3.1 + Web Tools Platform 1.0
V1.2.3
5. Historique des versions
Version /
Révision
Date
Commentaire
Chapitre
Origine
V0.1
28/04/2005 Création du document
V0.2
*
LD
v0.3
11/05/2005 Corrections après remarques de
M. Guillemette et D. Duarte
17/05/2005 Draft final pour validation
*
LD
V1.0
19/05/2005 Version 1.0 en diffusion
*
LD
V1.1
27/05/2005 Version 1.1 en diffusion
LD
V1.2
02/06/2005 Version 1.2 en diffusion
3.5, 3.6,
3.10, 3.11
2.2.3,
2.2.6, 3.1
V1.2.1
v1.2.2
v1.2.3
v1.2.4
LD
LD
04/06/2005 Partie CVS : création d’un
nouvel emplacement de
référentiel : définir le port
spécifique associé au référentiel
à la place de l’option « use
default port »
01/07/2005 Corrections
LD
08/11/2005 Correction dans la configuration
des préférences de l’historique
local
Précision pour la partie création
d’application Web et de
servlets : ne pas utiliser les
options relatives aux projets
flexibles, et aux annotations
XDoclet.
en cours corrections typos etc
LD
Dernière impression le 15/04/17
LD
LD
Page 100 sur 100