CONSERVATOIRE NATIONAL DES ARTS ET METIERS CENTRE REGIONAL ASSOCIE DES PAYS DE LA LOIRE

_______________________

MEMOIRE

Présenté en vue d’obtenir le

DIPLOME d’INGENIEUR CNAM

En

INFORMATIQUE

Par

OLLIVIER Philippe ___________

Participation à la conception d’une application J2E E d’entreprise.

Développement d’une application web de prise de ren dez-vous

avec les frameworks Struts et Hibernate

Version finale

Soutenu le 27 octobre 2006

________________

JURY

Président : Mme Elisabeth METAIS, Professeur des Universités, CNAM Paris Membres : M. Henri BRIAND, Professeur des Universités, Univ. De Nantes M. Guillaume RASCHIA, Maître de Conférence à Polytech’Nantes M. Yves GRUAU, Directeur Commercial, ASI informatique M. Didier CONVERT, Directeur Technique, ASI informatique

Il faut agir en homme de pensée et penser en homme d’action (Henri Bergson. Philosophe. 1859-1941)

REMERCIEMENTS Je tiens à remercier les personnes qui m’ont permis d’obtenir un Congé Individuel de Formation pour réaliser ce mémoire. Les travaux décrits dans la première partie ont été réalisés au Ministère des Affaires étrangères (MAE) à Nantes dans la division des Projets du Système d’Information. Je remercie Messieurs Nicolas TISSOT et Thierry CHAMPENOIS pour m’avoir accueilli dans leur service et m’avoir proposé un sujet de travail intéressant. Je remercie également Monsieur Yves GRUAU Directeur Commercial chez ASI pour m’avoir mis en relation avec le MAE. Merci à Monsieur Guillaume RASCHIA qui m’a assisté et conseillé tout au long de ce mémoire. Je remercie le Président et les membres du Jury d’avoir accepté de juger ce travail. Enfin je tiens à remercier tout particulièrement la femme que j’aime pour m’avoir soutenu pendant mon mémoire et nos enfants pour leur joie de vivre.

Table des matières

1. INTRODUCTION.......................................................................................................... 6

2. PARTIE 1 : LE PROJET «RENDEZ-VOUS » ........................................................... 8

2.1. INTRODUCTION........................................................................................................... 9 2.2. ETAT DE L’ART DU DEVELOPPEMENT D’APPLICATION WEB......................................... 9 2.3. METHODES POUR LA CREATION D’APPLICATIONS WEB............................................. 21 2.4. ORGANISATION DU MAE.......................................................................................... 27 2.5. SOLUTIONS EXISTANTES POUR LA PRISE DE RENDEZ-VOUS ....................................... 29 2.6. OUTILS ACUBE ......................................................................................................... 32 2.7. NORMES ACUBE ....................................................................................................... 35 2.8. METHODOLOGIE DE PROJET ACUBE.......................................................................... 36 2.9. UML DANS ACUBE................................................................................................... 38 2.10. PRESENTATION DU PROJET RENDEZ-VOUS DU MAE................................................. 39 2.11. MA CONTRIBUTION AU PROJET RENDEZ-VOUS DU MAE ........................................... 41 2.12. CONCLUSION............................................................................................................ 45

3. PARTIE 2 : CREATION D’UNE VERSION SIMPLIFIEE DE L’A PPLICATION « RENDEZ-VOUS » AVEC J2EE ........................................................................................ 46

3.1. INTRODUCTION......................................................................................................... 47 3.2. CAHIER DES CHARGES DE L’APPLICATION « RENDEZ-VOUS » SIMPLIFIEE.................. 47 3.3. SELECTION ET INSTALLATION DE L’OUTILLAGE ........................................................ 51 3.4. FORMATION J2EE..................................................................................................... 60 3.5. PRESENTATION DE L’APPLICATION RENDEZ-VOUS REALISEE.................................. 100 3.6. CONCLUSION.......................................................................................................... 105

4. CONCLUSION........................................................................................................... 106

5. GLOSSAIRE............................................................................................................... 107

6. BIBLIOGRAPHIE..................................................................................................... 109

7. ANNEXES................................................................................................................... 110

7.1. FILEZILLA ............................................................................................................... 110 7.2. GIMP ..................................................................................................................... 110 7.3. IRFANVIEW ............................................................................................................. 110 7.4. JARSBROWSER 3.0.................................................................................................. 110 7.5. FREEDIFF................................................................................................................ 110 7.6. JDECOMPILER......................................................................................................... 111

5

Table des figures FIGURE 1 : LE CLIENT-SERVEUR A CLIENT PASSIF........................................................................ 9 FIGURE 2 : LE CLIENT-SERVEUR DE DONNEES............................................................................ 10 FIGURE 3 : LE CLIENT-SERVEUR DISTRIBUE............................................................................... 10 FIGURE 4 : LE CLIENT-SERVEUR HTML/WEB ........................................................................... 11 FIGURE 5 : DEROULEMENT DE L'EXECUTION D'UN PROGRAMME CGI ........................................ 13 FIGURE 6 : EXECUTION D’UNE APPLICATION PHP ..................................................................... 15 FIGURE 7 : ARCHITECTURE D'UN SERVEUR D'APPLICATION J2EE .............................................. 16 FIGURE 8 : LE COMMON RUNTIME LANGAGE............................................................................ 18 FIGURE 9 : ITERATIONS, PHASES RUP ET JALONS PRINCIPAUX.................................................. 23 FIGURE 10 : L'APPROCHE MATRICIELLE D'UNIFIED PROCESS..................................................... 24 FIGURE 11 : ORGANISATION DU MAE....................................................................................... 27 FIGURE 12 : RECAPITULATIF DES LIVRABLES............................................................................. 37 FIGURE 13 : MAQUETTE - GESTION DES SEMAINES TYPES......................................................... 43 FIGURE 14 : MODELISATION DES DONNEES REALISEE AVEC DBDESIGNER................................. 48 FIGURE 15 : MODELISATION DES DONNEES SIMPLIFIEE.............................................................. 49 FIGURE 16 : DIAGRAMME DES CAS D'UTILISATION REALISE AVEC ARGOUML ........................... 50 FIGURE 17 : ARCHITECTURE RETENUE POUR L’APPLICATION RENDEZ-VOUS ............................. 53 FIGURE 18 : ARCHITECTURE DE SPRING.................................................................................... 58 FIGURE 19: ARCHITECTURE COMBINANT LES FRAMEWORKS STRUTS, SPRING ET HIBERNATE... 58 FIGURE 20 : CREATION D'UN DIAGRAMME DE CLASSES AVEC ARGOUML .................................. 59 FIGURE 21 : EXEMPLE HTML ................................................................................................... 62 FIGURE 22 : COMPOSANTS DU PATTERN MVC TYPE 2............................................................... 75 FIGURE 23 : STRUTS ET LE MODELE MVC................................................................................. 77 FIGURE 24 : PAGE CREEE AVEC LA TECHNOLOGIE TILES............................................................ 90 FIGURE 25 : ARCHITECTURE D’HIBERNATE ............................................................................... 92 FIGURE 26 : REGLES DE NAVIGATION...................................................................................... 100

6

1. INTRODUCTION Contexte général Il y a un peu plus de 10 ans, la première fois ou l’on m’a parlé d’Internet, je me rappelle avoir émis des doutes sur le fait que cette technologie pourrait supplanter le minitel (technologie française apparue au début des années 1980 permettant pour la première fois à des particuliers d’accéder depuis leur domicile à une multitude d’informations en ligne). Peu de temps après, l’un de mes fournisseurs m’ayant permis de participer à une démonstration j’ai pu constater par moi même qu’Internet était bel et bien un outil révolutionnaire. Aujourd’hui beaucoup d’applications informatiques à destination du grand public ou des entreprises sont écrites pour être accessibles depuis un navigateur 1 Web. L’informatique s’est démocratisée. Plus d’un ménage sur deux possède un micro-ordinateur (étude Insee - mars 2005). 37 % des foyers français sont connectés à Internet. 21 % sont connectés en haut-débit (majoritairement avec ADSL) et peuvent accéder à des supports multimédia (images, vidéos, musiques) avec un confort satisfaisant. Être capable de développer pour un coût raisonnable des applications web robustes et faciles à faire évoluer est devenu aujourd’hui un enjeu important. Objectifs du mémoire Il est nécessaire pour le chef de projet chargé de réaliser une proposition pour un client de bien comprendre le besoin de ce dernier et d’estimer au plus juste la charge de travail. Une bonne compréhension des contraintes techniques du projet peut lui permettre d’estimer les travaux en limitant les risques et sans avoir à prendre conseil auprès d’experts. De même, les compétences techniques du chef de projet peuvent lui être utiles lorsqu’il est chargé de réaliser un recrutement, lorsqu’il doit défendre une proposition devant un client ou lorsqu’un problème se pose pendant le développement. Aujourd’hui, les technologies java et open source 2 sont beaucoup utilisées pour développer des applications web.

1 Navigateur (Web Browser) : Logiciel dont la fonction première est d'interpréter les adresses des pages Web, de les afficher et d'exploiter les liens hypertextes à l'intérieur de celles-ci (ex : Internet Explorer de Microsoft). 2 Open Source : FONTAINE (2003) donne une définition précise des logiciels Open Source en s’appuyant sur celle donnée par les membres de la FSF (Free Software Foundation). Nous retiendrons que les logiciels Open Source doivent être distribués gratuitement et que le code source complet doit être disponible. Enfin il est possible de modifier un logiciel Open Source, de distribuer la version modifiée et de l’exécuter pour n'importe quel usage.

7

L’objectif de ce mémoire qui s’est déroulé sur la période de septembre 2005 à juin 2006 était de me permettre d’approfondir mes connaissances dans le domaine du développement web et notamment en ce qui concerne les outils puisque je ne possède pas cette expérience et que je la juge nécessaire pour la profession que j’exerce actuellement à savoir celle de chef de projet informatique. Plan du mémoire Ce mémoire s‘articule autour de deux parties. La première est en lien avec l’expérience acquise lors de ma participation au projet « rendez-vous » du MAE. Après avoir balayé rapidement les technologies les plus utilisées actuellement pour le développement d’application web, vous y trouverez une description des objectifs de ce projet et une présentation de la manière dont il a été abordé (présentation de la filière « Acube 3 » créée par le MAE pour définir comment gérer les projets de développement d’application web tant sur le plan technique qu’organisationnel). Cette partie sera également l’occasion de présenter brièvement quelques méthodes pouvant être utilisées pour gérer un projet de développement (RUP, XP) en fixant leurs limites. La deuxième partie de ce mémoire concerne la réalisation d’une application « rendez-vous ». Elle contient une description des objectifs à atteindre pour le projet « rendez-vous », une présentation, une justification des technologies retenues (J2EE, struts, hibernate, …) et une présentation du résultat obtenu. Après une conclusion qui sera l’occasion de faire le bilan sur les sujets étudiés et de parler des perspectives à venir, vous trouverez en annexe la description de quelques outils dont la connaissance peut s’avérer utile pour le développeur ou le chef de projet J2EE. Avertissement Ce mémoire ne prétend pas étudier de façon exhaustive toutes les technologies ou méthodes pouvant être mises en oeuvre pour le développement d’une application web avec J2EE. Le sujet est trop vaste et en perpétuelle évolution. Nous nous limiterons donc à la présentation de solutions reconnues en privilégiant les solutions « open source » permettant de réaliser les développements sous MS Windows.

3 Acube, RUP, XP, J2EE, Struts, Hibernate : Les acronymes présents dans l’introduction seront explicités dans la suite de ce document ainsi que dans le glossaire.

Partie 1

8

2. PARTIE 1 : LE PROJET «RENDEZ-VOUS »

Partie 1

9

2.1. Introduction De Septembre 2005 à Décembre 2005, j’ai participé en tant que chef de projet au lancement et à l’analyse des besoins du projet « rendez-vous » au sein du département des applications Diplomatiques et Consulaires (CXI/PSI/DC) du Ministère des affaires étrangères (MAE) à Nantes. Cette partie se rapporte à l’expérience acquise au cours de cette période.

2.2. Etat de l’art du développement d’application w eb Il existe de nombreuses possibilités pour créer des applications web. La solution basée sur le concept appelé CGI (Common Gateway Interface) est la plus ancienne. Elle ne s’appuie pas sur un serveur d’application. Les solutions les plus utilisées aujourd’hui sont le PHP, .Net et J2EE. De nouvelles solutions apparaissent régulièrement sur le marché. On entend beaucoup parler de la solution Ruby on rails depuis peu.

2.2.1. Architecture générale d’une application web Toutes les architectures informatiques client-serveur présentent des caractéristiques communes :

� Elles intègrent une interface utilisateur (souvent graphique) � Elles fonctionnent grâce à des applications � Les applications qui les animent manipulent des données

C’est la répartition de ces trois composantes entre le client et le (ou les) serveur(s) qui caractérise les différentes architectures.

Figure 1 : Le client-serveur à client passif

Dans cette architecture apparue bien avant les technologies Internet, toute la logique et les données sont sur le serveur. Le terme client-serveur appliqué à ce type d’architecture est un peut abusif puisque le client n’exécute rien. Cette solution est sécurisée, robuste et le développement des applications est simple. L’interface

Terminal ou émulateur

Mainframe

Données Traitements

+ Logique de

présentation

Partie 1

10

graphique est souvent pauvre et l’utilisateur n’accède qu’aux applications présentes sur le mainframe.

Figure 2 : Le client-serveur de données

Ce type d’architecture est apparu au milieu des années 80. Tout est sur le client, sauf les données. L’interface utilisateur est plus conviviale, mais le déploiement à grande échelle est complexe et coûteux.

Figure 3 : Le client-serveur distribué

Dans cette architecture le client se trouve déchargé d’une bonne part des traitements et les données ne circulent presque plus qu’entre le serveur d’application et la base de données. Ces systèmes sont basés sur des technologies en général propriétaires. Ils ne solutionnent pas complètement la problématique de déploiement.

Appels RPC

PC

Mid

dlew

are

RP

C

PC SGBDR

Données Traitements

Flux de données

Serveur de données

(SGBDR, …) Traitements

Flux de données

1 2 Serveur

d’application

Traitements Mid

dlew

are

RP

C

Partie 1

11

Figure 4 : Le client-serveur HTML/Web

Cette architecture est la plus répandue aujourd’hui pour les applications web. Le navigateur agit comme un simple afficheur de pages HTML 4 et n’exécute aucun traitement (sauf peut-être des traitements locaux comme par exemple la gestion des erreurs de saisie en JavaSript). L’appel d’une page dynamique se déroule de la façon suivante

� 1). Affichage du formulaire de saisie sur le navigateur; remplissage et validation des champs, transfert des saisies vers le serveur web (requête http 5 envoyée par le navigateur).

� 2). Si l'URL 6 porte sur une page dynamique c'est à dire nécessitant un traitement, le serveur Web aiguille cette demande vers le serveur d'application.

� 3). Le serveur d’application effectue le traitement. � 4). Le serveur d'application renvoie le résultat (page HTML ou autre format) au

serveur Web. � 5). Le serveur Web se charge de router le résultat vers le bon destinataire.

Le rôle du serveur Web est indispensable mais relativement limité sur le plan applicatif. Grossièrement, il transmet au client lui ayant fait une demande HTTP via 4 HTML (Hyper Text Mark-up Language) : ‘’Langage’’ utilisé pour décrire les pages web. Des balises sont insérées dans le texte pour définir les fontes de caractères, les styles, ainsi que les liens vers d'autres documents. 5 http (Hypertext Transfer Protocol) : Protocole régissant les communications entre les serveurs du Web. Sa fonction première est d'établir la connexion avec un serveur, qui contient la page que l'on veut voir afficher, et de rapatrier cette page sur le poste de l'internaute. 6 URL : Une URL (Uniform Resource Locator) est l’adresse d’une ressource sur Internet. Pour une page par exemple, son URL est composée du protocole http:// suivi du nom de domaine du serveur, puis du chemin d’accès à la page.

Flu

x de

do

nnée

s

Serveur de données

Logi

que

de

prés

enta

tion

(HT

ML)

Navigateur Internet

Visualise les pages

HTML

Serveur d’application

Traitements

Serveur Web A

PI

1

2

3

(SGBDR, …)

4

5

Partie 1

12

URL, les fichiers statiques présents sur le disque dur (pages HTML , images, fichiers CSS,...). Le serveur d'application est l'environnement d'exécution des applications côté serveur. Il prend en charge l'ensemble des fonctionnalités qui permettent à N clients d'utiliser une même application :

� Gestion de la session utilisateur. � Gestion des montées en charge et reprise sur incident. � Ouverture sur de multiples sources de données.

Le marché des serveurs Web est largement dominé par Apache, un serveur Web issu du logiciel libre. Si on ajoute aux parts de marché d'Apache celles de Microsoft IIS, on couvre plus de 90% du marché. L’architecture client-serveur HTML/Web permet de contourner le problème de déploiement en conservant une interface graphique. Le client peut se connecter à des applications hébergées sur différents serveurs. Pour maintenir un contexte de session utilisateur, il faut utiliser une session virtuelle car le protocole http fonctionne en mode non connecté. Le protocole http s’appuie sur le protocole TCP/IP. Il existe aujourd’hui deux grands modèles d’architecture de serveurs d’applications :

� Java 2 Entreprise edition (J2EE) soutenu par Sun, IBM, Oracle, HP, BEA, etc. ;

� .NET proposé et soutenu par Microsoft. Les applications Web peuvent s‘appuyer sur une architecture légèrement différente (ex : architecture à code mobile). Elles s’appuient cependant toujours sur la technologie Internet (navigateur internet, HTML, serveur http, …). A la différence des sites Internet qui sont statiques, une application web permet d’accéder de manière dynamique à une base de données par le biais de requêtes. Certaines notions seront décrites plus en détail dans la partie consacrée à la formation J2EE.

2.2.2. CGI (Common Gateway Interface) : CLOUX (2002) nous rappel que CGI (Common Gateway Interface) est une norme apparue presque en même temps que les premières spécifications de HTML avec pour objectif la création de documents HTML de manière dynamique.

Partie 1

13

Le déroulement de l’appel d’un programme CGI peut être représenté par la figure suivante :

Navigateur

Nom : Dupont

Submit

Serveur Web

Démon HTTP

TCP/IP

Programme CGI

Variables d’environnement

Serveur de donnéesSGBD

Document HTML

http://www.RDV.fr/cgi-bin/Enreg?nom=Dupont

1

Poste client

Document HTML

3

4

5

6

2

Figure 5 : Déroulement de l'exécution d'un programm e CGI

1. L’utilisateur complète un formulaire HTML puis clique sur un bouton Submit

présent sur ce formulaire. Le navigateur envoie une requête http au serveur Web contenant le nom d’un programme CGI localisé dans le répertoire cgi-bin de ce serveur. Les paramètres du formulaire sont transmis soit dans une chaîne de caractère à la fin de l’URL (méthode GET), soit dans le corps de la requête http (méthode POST).

2. Le serveur Web (également appelé démon http) reçoit la requête. La référence au répertoire cgi-bin lui indique qu’il doit procéder à l’exécution d’un programme au lieu de renvoyer simplement le contenu d’une page HTML statique. Il exécute alors ce programme dans un processus distinct en mettant à sa disposition certaines variables d’environnement (les variables CGI).

3. En fonction des informations de contexte (apportées par les variables CGI) et des informations saisies par l’utilisateur, le programme peut extraire des enregistrements dans une base de données ou le mettre à jour.

4. Les données extraites de la base sont transmises au programme CGI. 5. Une nouvelle page HTML est alors générée dynamiquement. Ce flux est

intercepté par le serveur Web. 6. Le serveur Web redirige le flux dynamique intercepté vers le navigateur Web

qui se charge de l’afficher.

Partie 1

14

Pour réaliser des programmes CGI, le langage le plus utilisé est le langage Perl. Il est possible d’utiliser d’autres langages comme le langage C par exemple. Le langage Perl est un langage de script bien connu des développeurs du monde Unix, bien que moins performant que le C car interprété, il est aussi beaucoup plus simple à utiliser. L’architecture CGI est simple, mais associée à des performances médiocres lorsque le nombre d’utilisateurs connectés simultanément au même serveur Web augmente. En effet, pour chaque appel d’une page dynamique, un nouveau processus est lancé. Or l’allocation d’un nouvel espace mémoire avec un nouvel environnement d’exécution est consommateur de ressources système. D’autre part, lorsque des opérations sont effectuées sur une base de données, une connexion au SGBD est initiée pour chaque page Web dynamique. Cette connexion est ensuite fermée dès que la requête pour cette page est terminée. Les temps de réponse s’en trouvent nettement allongés. Enfin, les applications CGI sont caractérisées par l’absence de séparation des traitements et de l’interface graphique. Le programme CGI produit un écran HTML en réponse à une requête du client. Toute modification de l’aspect de cet écran nécessite une modification du code du programme, ce qui peut poser d’importants problèmes de maintenance.

2.2.3. PHP FONTAINE (2003) écrit que le PHP est un langage de script open source fortement inspiré du C et de Perl. C’est le 5ième langage le plus utilisé dans le monde. Il est interprété et ne nécessite pas d’être compilé pour être exécutable. Il est souvent associé à la base de données open source MySQL et au serveur Apache pour réaliser des sites web dynamiques. Il permet d’exploiter bien d’autres bases de données, notamment celles dotées d’un pilote ODBC (Open Database Connectivity). Les applications développées avec PHP / MySql peuvent être hébergées pour un prix modeste. PHP est supporté par le serveur Web Apache, mais fonctionne également avec d’autres serveurs Web (IIS de Microsoft, IPlanet, …). Le langage PHP permet d'écrire des pages dynamiques rapidement.

Partie 1

15

Exemple : MaPage.PHP <html> <head> <title>Exemple</title> </head> <body> <?php echo "Message affiché par un script PHP"; ?> </body> </html> Le code PHP est inclus entre une balise de début et une balise de fin, directement dans la page HTML. Ce code est exécuté sur le serveur (dans l’exemple ci-dessus ce code permet l’affichage d’un texte). Le client ne reçoit que le résultat du script, sans aucun moyen d'avoir accès au code qui a produit ce résultat.

Figure 6 : Exécution d’une application PHP

� 1). Le serveur Web reçoit la requête http envoyée par le navigateur ; � 2). Il demande à l’interpréteur PHP de compléter une page HTML contenant

du code PHP ; � 3). L’interpréteur PHP interprète à la volée le code PHP de la page et le

remplace par le résultat obtenu à partir de la base de données; � 4). Le serveur Web reçoit la page HTML complétée; � 5). Il se charge de la router vers le bon destinataire.

PHP fonctionne sur de multiples plates-formes (Windows, Unix, Linux, Mac OS). Des extensions dynamiques permettent au PHP de générer des fichiers PDF, de s’interfacer avec des serveurs de messagerie, des serveurs LDAP, de générer de la cartographie, des images et graphiques à la volée, ou encore de générer des animations flash. Le succès du PHP est lié à sa simplicité de mise en œuvre et à sa gratuité. D’un simple langage de script (exécuté côté serveur) conçu pour la première fois en 1995 par Rasmus Lerdorf, PHP s’est peu à peu enrichi de nombreuses fonctionnalités.

Navigateur Internet

Serveur Web

1 2

3

4

5

Page HTML avec du code PHP Intégré

Interpréteur PHP

Page HTML avec les résultats donnés par l’exécution du programme PHP

Base de donnée

Partie 1

16

Grâce à l’intégration d’un vrai modèle objet, du support de XML et des services web, PHP 5 s’affirme aujourd’hui comme une plate-forme de développement concurrente de J2EE et de .NET.

2.2.4. J2EE SUN (le concepteur de java) a mis en place un ensemble de technologies permettant de réaliser des applications web reposant sur java. Ces technologies sont regroupées sous le nom de J2EE (Java 2 Entreprise Edition). J2EE est une norme qui définit une infrastructure d’exécution (pour faire tourner les applications) et un ensemble de services accessibles via l’API J2EE. Le standard J2EE s’appuie sur plusieurs piliers :

� La spécification J2EE ; � Une suite de tests de compatibilité (J2EE compatibility test suite) qui garantit

le respect des spécifications par les éditeurs ; � Une implémentation de référence

Cette implémentation de référence est produite par JavaSoft (filiale de Sun) et est nommée JAVA EE 5 SDK. Il s’agit d’une implémentation des API J2EE qui n’a pas pour vocation d’être utilisée en production. Tomcat est l'implémentation de référence pour la partie Conteneur de Servlets. J2EE est aujourd’hui supporté par de nombreux serveurs. Au total, on compte près d’une trentaine d’implémentations commerciales ou Open Source de la spécification J2EE.

Figure 7 : Architecture d'un serveur d'application J2EE

Une Servlet est un programme java exécuté côté serveur dans un conteneur. Une JSP (Java Server Pages) est une page HTML contenant du code java. Les JSP sont transformées en servlets à l’exécution. La technologie JSP permet de générer des

Client (navigateur)

Client (navigateur, application)

JDBC JNDI JTA JavaMail JMS JAAS

Serveur J2EE

Servlet JSP

Conteneur de Servlets

EJB EJB

Conteneur d’EJB

Base de données

Partie 1

17

pages web dynamiques à partir d’un principe assez proche de celui dont nous avons parlé pour PHP. Nous reviendrons sur ces notions en partie 2. Les EJB (Entreprise Java Beans) sont le moyen d’implémenter les technologies composants pour J2EE. Un EJB est un composant Java. Il s’exécute dans un conteneur qui lui fournit des services tels que la persistance. L’utilisation des EJB n’est pas indispensable pour développer une application web avec J2EE. Il est possible d’utiliser un serveur d’application qui ne gère pas les EJB mais uniquement les Servlets (ex : Tomcat est un conteneur de Servlets). C’est le choix qui sera fait dans la suite de cette étude. Les EJB ne seront donc pas étudiés plus en détail dans ce mémoire. Des API (JDBC, JNDI, JTA, JavaMail, JMS, JAAS, …) sont employées pour fournir des fonctionnalités aux applications écrites en Java (connexion à une base de donnée, localisation et utilisation de ressources, utilisation de transactions, envoi et réception de courriel, envoi et réception de messages, gestion de l’accès aux ressources). La solution J2EE repose sur le langage java. Le code source java transformé en bytecode est interprété par une machine virtuelle (JVM : Java Vitual Machine) lors de l’utilisation de l’application. Ceci permet de créer des applications portables (indépendantes de toute plate-forme). Il est possible de développer une application web J2EE sous MS Windows puis de la déployer sur un autre système (linux par exemple). Définir un environnement complet de développement J2EE peut s’avérer complexe car il existe de nombreux outils et certaines versions de ces outils sont incompatibles entre elles. Il existe maintenant un grand nombre d’outils open source de bonne qualité. Dans ce mémoire, nous nous intéresserons uniquement au développement d’application web en environnement J2EE sous MS Windows avec des outils open source.

2.2.5. .NET Créée en 2000, ASP.NET est la technologie de développement Internet du framework 7 .NET (plate-forme de développement d'application). C’est la solution propriétaire de Microsoft pour le développement d’applications web. L’ensemble des technologies de base de la plate-forme .NET sont regroupées au sein du .NET framework. Les principaux composants de .NET Framework sont le Common Language Runtime (CLR) et la bibliothèque de classes .NET Framework, qui contient ADO.NET, ASP.NET et Windows Forms.

7 Framework : Bibliothèque de classes fournissant une ossature générale pour le développement d'une application. Struts est un exemple de framework en Open Source, basé sur l'architecture MVC. Struts, MVC : Ces notions sont définies plus loin.

Partie 1

18

Le CLR est essentiellement une machine virtuelle permettant d’exécuter des programmes compilés dans un code intermédiaire. Le CLR se propose d’abstraire la plupart des concepts objet de sorte qu’ils puissent être utilisés par plusieurs langages de programmation. Plusieurs langages sont supportés dont Visual Basic, et C#. Le langage de programmation C# créé par Microsoft est adapté au développement .NET. Ce langage correspond à une version simplifiée du langage C++ qui le fait ressembler à Java. Grâce au CLR, un programme réalisé dans un langage X peut créer des objets qui héritent d’objets créés dans un langage Y (différent de X). Pour qu’un programme soit exécutable par CLR il ne doit pas être compilé en code natif exécutable mais en un code intermédiaire appelé MSIL pour MicroSoft Intermediate Langage.

Figure 8 : Le Common Runtime Langage

La bibliothèque de classes .NET Framework contient ADO.NET (ADO pour ActiveX Data Object) dont la vocation est de fournir un accès orienté objet aux sources de données et ASP.NET (ASP pour Active serveur Pages) qui peut être comparé à ce qui est offert par JSP dans la technologie J2EE. .NET contient encore d’autres outils qui peuvent être comparés avec ce qui existe dans le monde Java (ex : les « assemblies » sont des fichiers d’archive destinés à simplifier le déploiement. Il sont équivalents aux fichiers jar du langage java). La mise en œuvre de ASP.NET nécessite des notions en programmation orientée objet et la maîtrise d’un langage objet tel que C# ou VB.NET. L’utilisation d’ASP.NET nécessite également la maîtrise d’outils de développement tel que Microsoft Visual studio .NET (environnement de développement visuel commercial). Il est possible de développer une application ASP.NET avec des outils gratuits tels

Compilateur Code source

MSIL

MSIL Class Loader

Compilateur JIT + vérificateur de code MSIL

Code natif « approuvé »

Exécution

CLR

Bibliothèques de base

Partie 1

19

que Web Matrix et le framework SDK (environnement de développement en ligne de commande), mais la productivité du développeur est alors moins élevée. Le projet open source Mono a pour objectif de réaliser une implémentation multiplateforme du framework .NET.

2.2.6. Ruby on Rails (RoR) Une nouvelle technologie permettant de construire des applications web, rapidement et proprement fait actuellement beaucoup parler d’elle sur Internet : Ruby on Rails. Ruby on Rails, également appelé RoR ou Rails est un framework écrit en Ruby dont la première version est apparue en 2004. Ruby est un langage de programmation objet disponible depuis 1995. Il s'agit d'un langage interprété dont la syntaxe est relativement proche de Perl. Ruby se veut être un langage simple (grâce à une syntaxe cohérente) et surtout puissant. Cette puissance vient notamment du fait que tout est objet en Ruby, même les entiers ou les chaînes de caractères par exemple. En outre, le langage comprend aussi la notion d’héritage (mais pas multiple), un ramasse-miettes pour la gestion de la mémoire (comme en Java), les gestion des exceptions, des expressions régulières, etc. Rails fonctionne selon deux grands principes qui sont ‘ne pas se répéter’ et ’convention plutôt que configuration’. Le premier signifie que chaque déclaration ne doit être faite qu’une seule fois. Comme il s’agit d’un framework en couches complet, la plupart des composants sont liés entre eux. Par exemple, ActiveRecord n’a pas besoin qu’on lui fournisse les colonnes des tables de la base de données. Il les trouve tout seul. Le second, lui, explique que le programmeur ne doit programmer que ce qui n’est pas conventionnel. Par exemple, les noms de contrôleurs sont associés automatiquement à la table ayant le même nom qu’eux au pluriel. Si la table ne porte pas ce nom, il faut le spécifier au contrôleur. Rails est basé sur une architecture MVC (Modèle Vue Contrôleur) 8 . Les modèles Ils maintiennent l’état de l’application et imposent toutes les règles métier qui s’appliquent aux données. Ce sont, en quelque sorte, les gardiens de l’intégrité des données.

8 MVC (Model View Controller) : Ce pattern architectural est recommandé pour la conception des applications web dynamiques. Il propose d’organiser l’application en 3 couches séparées. Le but est de séparer, lors de la conception, l’accès à la base de données (M), la partie visible par l’utilisateur (V) et la distribution des requêtes aux composants appropriés en fonction de la logique de l’application (C).

Partie 1

20

Dans Rails, c’est ActiveRecord qui gère les modèles et regroupe les classes assurant la gestion des données, venant des bases de données. Il suffit donc de créer un contrôleur héritant de ActiveRecord pour que Rails détecte automatiquement les tables a utiliser et les gérer avec des commandes simples. Les vues C’est la partie concernant l’IHM de l’application. Dans le cas de Rails, il s’agit de fichiers .rhtml contenant du code html ainsi que du script Ruby afin de les lier à l’application. Les contrôleurs Ils reçoivent des éléments du monde extérieur, interagissent avec le modèle et affichent ensuite une vue appropriée. Rails offre un système appelé scaffolding (que l’on peut traduire par échafaudage ou structure en français). Cette baguette magique permet de générer très rapidement les éléments Vue et Contrôleur nécessaires à la gestion courante des données issues du Modèle (Ajout, Affichage, Modification, Suppression), sans avoir à écrire une seule ligne de code. Il est bien entendu possible d’étendre ce fonctionnement, ou tout simplement de tout construire manuellement. Bases de données Rails supporte plusieurs bases de données DB2, MySQL, Oracle, PostgreSQL, SQLServer, SQLite. Serveur HTTP Rails est installé avec WEBrick (serveur http écrit en Ruby). Idéal pour une petite structure car très simple d’utilisation. Si le serveur doit accueillir beaucoup de demandes, l’utilisation de serveurs plus puissant comme Apache est recommandée. Rails et Ajax Rails implémente une bibliothèque de fonctions rendant l’utilisation de AJAX beaucoup plus facile.

Partie 1

21

AJAX (Asynchronous JavaScript and XML) est une méthode apparue en 2005 pour développer des applications web. AJAX est basée sur un ensemble de technologies couramment utilisées sur le web :

� HTML ou XHTML pour la structure sémantique, � CSS pour la présentation, � DOM (Document Object Model) et JavaScript pour manipuler la page en

cours, � Enfin, XML, XSLT et l’objet XMLHttpRequest pour dialoguer de façon

asynchrone avec le serveur web. AJAX permet de charger l’essentiel de la page une seule fois (les données variables de la page sont mises à jour de façon asynchrone sans avoir à recharger la page complète à chaque fois). Modules De nombreux modules sont dores et déjà disponibles, comme par exemple celui permettant de gérer l’authentification d’un utilisateur.

2.2.7. Quelle solution utiliser ? Pour le moment le marché de l’emploi se concentre essentiellement sur deux technologies ; J2EE et ASP.NET 9 ; avec une préférence pour J2EE. La solution PHP est très utilisée en raison de sa simplicité de mise en œuvre, mais souvent pour des sites personnels ou pour des sites de petite envergure car jugée moins professionnelle. ASP.NET est une solution propriétaire proposée par Microsoft. Cette solution est considérée comme étant moins portable que la solution J2EE. La solution Ruby on Rails saura-t-elle s’imposer ? Seul l’avenir permettra de répondre à cette question. L’utilisation de la technologie CGI pour développer de nouveaux sites ne se justifie plus vraiment car il existe des solutions plus performantes. Il est cependant possible d’utiliser CGI pour des sites simples sans grands trafics. Dans ce mémoire nous étudierons plus en détail la solution J2EE.

2.3. Méthodes pour la création d’applications web La problématique d’industrialisation des développements d’applications web devient une préoccupation majeure des responsables informatiques. CLOUX (2003) présente les solutions qui peuvent être adoptées pour tenter de répondre à ce problème complexe en s’appuyant sur deux visions majeures : RUP (Rational Unified Process) et XP (extreme programming).

9 Le comptage des offres parues dans les numéros de juin 2006 de l’hebdomadaire courrier cadres fait ressortir nettement cette tendance. Cet indicateur est cependant à prendre avec précaution en raison de l’effet amplificateur de l’offre par rapport au marché réel.

Partie 1

22

Il n’existe pas de solution miraculeuse adaptée à toutes les entreprises pour optimiser la production d’application web ou garantir à coût sûr le succès d’un projet. Chaque projet est unique et il faut mettre toutes les chances de son côté en insistant sur les axes suivants :

� Méthodes, � Choix technologiques, � Formation, cohésion et motivation de l’équipe de développement.

Le CMMI (Capability Maturity Model Intégration) est un référentiel qui permet d’identifier pour une entreprise à quelle niveau elle se situe en ce qui concerne le processus de développement d’application. CMMI comporte cinq étages qui correspondent à des stades croissants de maturité du processus de développement (1 Initial, 2 Reproductible, 3 Défini, 4 Maîtrisé, 5 Optimisation). Les résultats disponibles fin mars 2002 montrent que parmi 1158 organismes s’étant auto-évalués :

� 24,8 % étaient au niveau 1, � 39,9 % étaient au niveau 2, � 23,6 % étaient au niveau 3, � 6, 0 % étaient au niveau 4 et � 5,5 % étaient au niveau 5.

Même si ces chiffres sont relativement anciens, il existe probablement encore aujourd’hui pour bon nombre d’entreprises une large place pour l’amélioration du processus de développement.

2.3.1. Rational Unified Process (RUP) CLOUX (2003) présente UP (Unified Process) et son implémentation commerciale RUP. Promu par Rational, RUP propose à la fois une méthodologie (UP) issue des meilleures pratiques en génie logiciel et un outil constitué essentiellement de documents types (modèles de documents, canevas de projets). Vocabulaire et concepts : Artefacts : Eléments produit pour la gestion de projet (ex : planning) ou pour la fabrication du logiciel (ex : code source). RUP prend en charge le cycle de vie de la deuxième catégorie d’artefacts. Rôles : Un individu peut assumer plusieurs rôles (analyste, développeur, testeur, manager, etc.). Disciplines : 9 disciplines sont définies dans RUP (Expression des besoins, Spécifications, Analyse & Conception, Mise en oeuvre, Tests, Déploiement, Gestion

Partie 1

23

de configuration, Conduite de projet, Logistique). Pour chaque discipline les activités à réaliser et les artefacts à produire sont précisés sur un diagramme UML. Fondements de RUP : RUP découpe les projets de développement de logiciels en processus et documente pour chaque processus les bonnes pratiques que doivent respecter les acteurs. RUP peut théoriquement s’adapter à la taille du projet et au niveau de compétence des acteurs mais non sans difficultés. RUP est :

� Piloté par les cas d’utilisations (ceux-ci doivent être élaborés avec précision le plus en amont possible);

� Centré sur l’architecture (la description du système fait partie du processus et doit être réalisée selon différents points de vue : celui de l’analyste, du développeur, … );

� Itératif et incrémental (itératif pour faire diminuer les risques dès le début du projet et incrémental car chaque itération doit enrichir le résultat final).

Les itérations en nombre variables s’inscrivent dans 4 phases successives. Chaque phase se termine par un jalon :

Figure 9 : Itérations, phases RUP et jalons princip aux

Inception

Viabilité de l’application (coût, risques, délais, périmètre, etc.)

Elaboration Construction Transition

Architecture stable + planning d’itération de construction

Premières versions complètes exécutables de l’application

Version complète de l’application + guides d’utilisation et d’installation

Partie 1

24

Le cycle de développement est itératif avec un nombre variable d’itérations dont les terminaisons correspondent à des livrables. Au fil de l’avancement du projet, les poids respectifs des différentes activités vont évoluer (voir la figure ci-dessous).

Figure 10 : L'approche matricielle d'Unified Proces s

(source http://www.jerome.capirossi.org/prj_mgt/cycle_10.htm) Bonnes pratiques RUP

� Développer itérativement comme expliqué précédemment � Gérer les exigences du client (Les fonctionnalités attendues sont exprimées

par des cas d’utilisation, un document de spécifications consigne toutes les exigences, les différentes versions de ces artefacts sont conservées).

� Utiliser une architecture à base de composants pour augmenter la réutilisation et faciliter les tests

� Modéliser avec UML � Vérifier continuellement la qualité (conformité aux exigences du client) � Gérer les changements avec des outils appropriés :

o Par exemple CVS pour la gestion des versions et du contrôle d’accès des artefacts,

o Ant et Junit pour déployer et tester les différentes versions, o Bugzilla pour la gestion des requêtes de changement et des rapports

d’incidents.

Partie 1

25

Les outils de RUP Le support principal de RUP est un Intranet composé d’environ 3000 fichiers :

� Pages HTML ; � Modèles HTML, Word ; � Modèles MS-Project ; � Modèles SoDA (outil de génération de documentation de projet de Rational).

Conclusion Pour BENARD et MERAND (2005), UP est une approche conceptuellement séduisante. L’une des difficultés d’UP reste sa complexité : difficile pour un individu d’être au cœur d’une matrice (allusion à la figure précédente). L’individu a besoin pour avancer qu’on lui esquisse un chemin, et l’expression du cheminement dans UP n’est pas simple à appréhender. Il faut pratiquement avoir un œil en permanence sur le guide méthodologique pour savoir ce que l’on doit faire, tant les étapes et sous-étapes sont nombreuses. Difficile aussi de mettre en œuvre UP sans le support d’outils spécifiquement orientés sur la méthode (RUP par exemple). L’un des reproches fait à UP tient de ce fait à l’investissement formation très important avant d’avoir des équipes opérationnelles. Au final les équipes qui disent appliquer UP n’en retiennent généralement que les grandes lignes. UP nécessite une bonne maîtrise d’UML. Cette méthodologie très codifiée est davantage concentrée sur l’analyse et la conception que sur le code et les technologies mises en œuvre pour réaliser un logiciel. Elle est destinée à des projets stratégiques ou sollicitant un nombre important d’interlocuteurs.

2.3.2. Extreme Programming (XP) XP appartient à la catégorie des méthodes agiles qui prennent en compte le fait que les besoins sont susceptibles d’évoluer pendant le projet. XP est axé davantage sur l’activité de production (développement, prototypage rapide, tests) que sur les phases d’analyse et de conception. Il est constitué d’un ensemble de meilleures pratiques de développement concernant le travail en équipe, le transfert de compétences, les règles de développement et les tests pour fournir des livrables de qualité. Il s’agit d’un processus relativement innovant, basé sur un cycle itératif et incrémental simple à mettre en œuvre et adapté à de petites équipes de développement. RETAILLE (2005) donne une traduction des principes directeurs du manifeste qui définit les bases des méthodes agiles. Les méthodes agiles privilégient :

� Les individus et les interactions par rapport aux processus et aux outils, � Les logiciels qui fonctionnent par rapport à une documentation complète, � La collaboration avec les utilisateurs par rapport à une négociation

contractuelle, � La réponse aux changements par rapport au respect d'un plan.

Partie 1

26

Soyez extrêmement vigilant quand quelqu’un vous annonce que le projet doit être développé avec « agilité ». Pour MANGOLD (2005) il faut comprendre « Nous ne savons pas trop comment nous y prendre, mais l’important est de commencer. En cas de problème, nous procèderons autrement ».

2.3.3. Quelle méthode utiliser ? Dans MANGOLD (2005) nous trouvons une définition originale de la notion de projet : « Un projet est un dialogue continu entre le fournisseur et le client, afin d’atteindre le résultat souhaité. Ce n’est que lorsque le dialogue est maintenu qu’un projet peut réellement être mené à bien ». Pour BENARD et MERAND (2005), si une méthode garantissait le succès d’un projet, cela se saurait. La bonne méthode est celle qui permet au projet de réussir. BENARD (2005) recommande de construire sa propre méthode en s’inspirant des différentes méthodes existantes, en intégrant la culture d’entreprise et en s’aidant d’un référentiel de bonnes pratiques tel que CMMI. Au cours d’un entretien, François Mérand (coauteur de BENARD et MERAND 2005) m’a confié que pour lui le respect d’une méthode tel que RUP nécessite d’utiliser des outils dédiés. Or pour MANGOLD (2005) on ne produit pas de la qualité en achetant ou en utilisant des outils. Pour tirer de réels bénéfices d’une méthode comme RUP il faut être en mesure d’investir à la fois dans les outils et dans la formation (sur la méthode et les outils). La méthode RUP est plutôt destinée aux grandes entreprises pour gérer des projets complexes ayant une importance stratégique. Comme nous le verrons plus loin, le Ministère des affaires étrangères (MAE) a défini sa propre méthode. C’est une méthode itérative et incrémentale inspirée de UP. Dans la pratique, il est tout de même nécessaire de s’assurer que tous les participants ont bel et bien compris les principes de la méthode à appliquer et que celle-ci peut véritablement être appliquée au cas présent. Au final, c’est bien souvent l’expérience du chef de projet qui fait la différence. La méthode doit s’adapter au projet et non l’inverse.

Partie 1

27

2.4. Organisation du MAE Le Service des Systèmes d’information et de Communication de Ministère des affaires étrangères (MAE) est rattaché à la Direction Générale de l’administration.

Figure 11 : Organisation du MAE

La division des Projets du Système d’Information (PSI) est l’une des 5 divisions opérationnelles du Service des Systèmes d’Information et de Communication (95 agents dont 70 % à Paris et 30 % à Nantes). Le projet « rendez-vous » appartient au domaine de compétence du département « Applications Diplomatiques et Consulaires » (DC) de PSI.

Partie 1

28

Le système d’information du MAE est utilisé par des agents consulaires (personnel d’un consulat français à l’étranger) pour gérer des informations concernant les usagers (individus qui s’adressent aux consulats pour obtenir un service). Il existe deux types d’usagers :

• Français à l’étranger o Français résidant à l’étranger

� Ils effectuent des demandes administratives (ex : demande de passeport)

� Les consulats jouent auprès d’eux le rôle d’une • mairie (état civil) et d’une • préfecture (affaires électorales, …)

o Français de passage à l’étranger (touristes) � Ils contactent généralement le consulat uniquement lors d’une

situation d’urgence (perte de documents, papiers provisoires, …). Cette population n’est pas concernée par le projet « rendez-vous ».

• Etranger à l’étranger o Ils réalisent des demandes de visa (plusieurs types de visa existent :

visa de touriste pour venir en France ou entrer dans l’espace Schengen)

Caractéristiques des consulats :

• Ils jouent un rôle politique et un rôle administratif (les ambassades jouent un rôle politique mais pas administratif).

• Il existe 250 consulats français dans le monde répartis dans 180 pays (certains pays n’ont pas de relations diplomatiques avec la France). Dans certains pays il existe plusieurs consulats (ex : le Maroc).

• Il existe 3 types de consulats : o Consulats généraux (Celui de la capitale en général) o Consulat simple (Situé généralement en province) o Section consulaire (très petite unité)

Tous les consulats ont un site Internet. Chaque consulat est responsable du contenu de son site. Créé en octobre 1995, le Site Internet France-Diplomatie du ministère des affaires étrangères (http://www.diplomatie.gouv.fr/fr/) qui enregistre près de 3 millions de consultations mensuelles, est hébergé au sein du centre d’exploitation du Service des Systèmes d’information et de Communication (CXI). Ce site donne accès aux sites Internet des différents consulats de France à l’étranger. Les consulats confient généralement l’hébergement de leur site à un spécialiste local. L’appel de l’application « rendez-vous » sera réalisé à partir de ces sites.

Partie 1

29

Le système d’information consulaire repose actuellement sur les applications RMV2 et Racine.

2.4.1. RMV2 RMV2 (Réseau Mondial Visa) permet la gestion des demandes de visa effectuées par les étrangers (ex : visa Schengen) :

� Il est utilisé par le secteur étranger de tous les consulats. � Dans chaque consulat, il existe une base RMV2 locale qui échange des

informations avec la base RMV2 centrale située à Nantes à la SDCE (Sous Direction de la Circulation des Etrangers).

2.4.2. Racine RACINE (Réseau d’Administration Consulaire INformatiquE) permet la gestion administrative des français à l’étranger :

� Ce système est en cours de développement. � Actuellement, il existe une base de données appelée AFE2 dans chaque

consulat. L’objectif de RACINE est de remplacer ces 250 bases par une base de données centrale accessible à partir d’un client léger, ce qui impliquera une bonne disponibilité réseau ou des procédures de repli efficaces. La migration vers RACINE doit s’effectuer progressivement à partir de 2007.

2.5. Solutions existantes pour la prise de rendez-v ous Les consulats de Londres et Toronto possèdent déjà une solution de prise de rendez-vous sur leur site internet. Ces solutions ne peuvent pas être généralisées dans l’état pour tous les consulats (autant pour des raisons techniques que fonctionnelles). Une solution Acube 10 centralisée et paramétrable pour tous les consulats est préférable. Il est donc nécessaire de faire une nouvelle analyse du besoin et d’effectuer un nouveau développement. C’est l’objet du projet « rendez-vous ». Les solutions de Londres et Toronto sont présentées brièvement ci-dessous :

2.5.1. Solution du consulat de Londres Le site du consulat général de France à Londres ( http://www.consulfrance-londres.org/) permet de prendre un rendez-vous avec le consulat pour les demandes de visa et pour les démarches administratives des français vivant à l’étranger.

10 Acube : Méthodologie du MAE utilisée pour le développement des applications web de l’administration.

Partie 1

30

La prise de rendez-vous est :

• Personnelle : la personne attendue est la personne au nom de laquelle le rendez-vous a été pris.

• Individuelle : un rendez-vous, une personne. • Limitée à la démarche pour laquelle le rendez-vous a été pris. Dans certains

cas particuliers, des options de démarches combinées peuvent être proposées.

RDV pour les démarches administratives des français Cette fonction permet aux français à l’étranger de prendre un rendez-vous avec l’ambassade de France de Londres via Internet afin d’effectuer une ou plusieurs des démarches suivantes :

• Demande ou renouvellement de passeport ; • Demande de carte nationale d’identité ; • Inscription au registre des Français établis hors de France • Transcription d’une naissance, d’un mariage ou d’un décès et délivrance d’un

acte d’état civil ; • Demande de bourse scolaire.

Certaines combinaisons sont possibles (ex : inscription au registre et renouvellement de passeport). Les fonctions mises à la disposition de l’usager sont les suivantes :

• Création de rendez-vous • Vérification de la date du rendez-vous • Annulation du rendez-vous

Dans le cas d’une demande d'inscription au registre des français établis hors de France, le déroulement de l’application est le suivant :

• Présentation de la liste des pièces justificatives à présenter le jour du rendez-vous (photographies, passeport ou carte nationale d'identité, justificatif de domicile, …)

• Sélection du jour du rendez-vous parmi ceux proposés. • Sélection d’un créneau horaire parmi ceux disponibles • Affichage du formulaire « fiche de renseignement » :

o Nom, prénoms, Nom marital, civilité, date de naissance, lieu et ville de naissance, situation de famille, département ou pays

o Français(e) par (naissance, filiation, décret, …) o E-mail, autre nationalité, personne à prévenir en cas d’urgence,

informations sur le père et la mère • Confirmation de la saisie

Remarque : Il existe actuellement une interface permettant de remonter dans l’application AFE2 du consulat de Londres, l’état civil des français ayant effectué une prise de rendez-vous sur le site Internet du consulat de Londres pour une demande de passeport. Cette interface est lancée par un agent du consulat de Londres.

Partie 1

31

RDV pour les demandes de visa La prise de rendez-vous concerne 3 types de populations :

• Conjoints/enfants de ressortissants français • Conjoints/enfants de ressortissants européens (non français) • Toutes autres personnes.

La prise de « rendez-vous » est possible soit par Internet sur le site, soit par téléphone (service payant). La procédure diffère en fonction du type de visa (visas de "long séjour", visas pour un autre pays représentés par la France). L’adresse du lieu du rendez-vous est précisée à l’usager lors de la prise du rendez-vous. Une convocation est imprimée à la fin du processus de prise de rendez-vous pour permettre un accès prioritaire aux locaux du consulat.

2.5.2. Solution du consulat de Toronto Le site du consulat général de France à Toronto (http://www.consulfrance-toronto.org/) permet aux usagers de prendre rendez-vous avec le consulat pour les demandes concernant les types de visas suivants (la prise de rendez-vous pour les démarches administratives des français à l’étranger n’est possible que par téléphone) :

• Airport Transit visa, • Transit visa (maximum 5 days) • Short Stay Schengen • Short Stay DOM | TOM | CTOM • Long stay student (less than 6 months) • Long stay student (more than 6 months) • Long stay au Pair • Long stay minor attending school • Long stay teaching assistant • Long stay scientist • Long stay visitor • Long stay through OMI • Professional long stay

Pour ces types de visa, la prise de rendez-vous est obligatoire et s’effectue uniquement sur Internet. Pour les autres types de visas, les demandes doivent être envoyées par la poste (Visas 2A, 2B, 2C, 2D et 2E). La liste des documents à présenter le jour du rendez-vous sont précisés sur le site Internet du consulat, mais pas dans le module de prise de rendez-vous.

Partie 1

32

La prise de rendez-vous se déroule de la façon suivante :

• Créer un compte personnel en remplissant une fiche de renseignements (Nom, prénom, e-mail, téléphone, nationalité, nationalité sur le passeport, statut au Canada, date d’expiration du visa, type de visa, date de départ)

• Lire le mot de passe reçu par mail. • Utiliser le compte et le mot de passe pour accéder au module de prise de

rendez-vous • Sélectionner une date et un créneau horaire sur le calendrier parmi ceux

proposés (toutes les 10 minutes de 9h30 à 12h10). • Préciser le nombre de personnes (1 personne : 10 min, 2 personnes : 20 min,

3 personnes : 30 min, 4 personnes : 40 min) • Confirmer le rendez-vous (réserver la plage horaire) • Le système informe l’usager que le rendez-vous est confirmé

Liste des fonctions disponibles après la création d’un compte personnel :

• Créer un rendez-vous (mail de confirmation de création) • Visualiser mon compte • Voir mes rendez-vous, voir le détail d’un rendez-vous • Supprimer un rendez-vous (mail de confirmation de suppression) • Afficher l’aide en ligne

Contraintes et remarques :

• Un seul rendez-vous actif par compte • Un rendez-vous peut concerner plusieurs personnes

Les comptes des personnes qui ne se présentent pas sont effacés.

2.6. Outils Acube En 2004, le MAE a mis en place une filière de développement appelée Acube (Architecture Applicative de l’Avenir) basée sur les technologies :

� J2EE, � XML, � Client riche, � Architecture multi-niveaux, � XHTML, � CSS, � JavaScript, � DOM.

Acube fournit un cadre méthodologique et les outils nécessaires pour la réalisation des applications web du MAE. Le projet « rendez-vous » appartient à cette filière.

Partie 1

33

L’architecture technique multi-niveaux du Ministère des Affaires Etrangères repose sur les standards Internet (W3C/J2EE), le respect de la charte graphique du ministère et l’offre Open Source. Pour développer les applications Acube, les outils suivants sont utilisés :

• Serveur Web avec Apache 2.0.52 et Serveur d’application avec Tomcat 5 (Servlet Container),

• Environnement de développement Eclipse 3.0 + Plugins, • Base de données relationnelle SQL Server • Outil de modélisation UML et Conceptuel de données avec Power AMC 10. • Gestion des anomalies avec Mantis , • Gestion de configuration sous CVS, • Déploiement de l’application Acube avec ANT ou Marven • Automatisation des tests avec JUNIT (en cours d’étude)

2.6.1. Tomcat Tout serveur d’application revendiquant la compatibilité J2EE doit respecter les spécifications de la norme J2EE définie par Sun (support multi-plate-formes, répartition de charges, reprise sur incident, pooling de connexions, contexte multi-utilisateurs, sécurité etc, …). Un serveur d’application J2EE est un logiciel qui met en œuvre l’API J2EE fournie par SUN. Il existe de nombreuses solutions propriétaires (Webshere d’IBM, Weblogic de BEA …) ou open source (Jboss, tomcat …). Tomcat fonctionne sur la plupart des systèmes d’exploitations (windows, linux, …). C’est un moteur de servlet. Il permet de développer des sites dynamiques en Java, mais ne supporte pas les EJB 11 . Les EJB ne seront pas étudiés dans ce mémoire. Tomcat contient un serveur HTTP (apache).

2.6.2. Eclipse Il est possible de développer des applications java avec un simple éditeur de texte, mais en pratique, l’utilisation d’un IDE (Integrated Developpement Environnement) java est indispensable pour gagner en productivité. Eclipse est un IDE Open Source qui permet de développer notamment en java. Il fonctionne sur les plate-formes Windows 98/NT/2000/XP et Linux. Jbuilder de Borland est une alternative intéressante mais c’est une solution propriétaire. La version de base de Jbuider est gratuite (même pour une utilisation commerciale).

11 EJB : La technologie Enterprise JavaBeans est une architecture de composants logiciels côté serveur pour la plate-forme de développement J2EE.

Partie 1

34

2.6.3. Microsoft SQL Server SQL Server est une base de données relationnelle distribuée par Microsoft. Il existe des alternatives Open Source. Les plus connues sont PostgreSQL et MySQL.

2.6.4. Power AMC Power AMC est un outil de modélisation graphique payant distribué par Sybase qui permet de réaliser les 9 diagrammes UML en plus de ceux de la méthodologie Merise (modèle conceptuel de données, …). Il n’existe pas d’outil aussi puissant et polyvalent dans le monde Open Source mais l’on peut citer ArgoUML pour la modélisation UML et Dbdesigner pour la représentation de la base de données.

2.6.5. Mantis Mantis est un outil Open Source de gestion de bugs consultable via le web. Il peut être installé sur Windows, Mac ou Linux. Bugzilla (qui est présenté dans ZELLER 2005) est également un Gestionnaire de bugs Open Source reconnu, mais après avoir comparé les deux outils le MAE a retenu Mantis

2.6.6. CVS HOLZNER (2004) définit CVS (Concurrent Versions System) comme un outil Open Source permettant de développer en équipe (gestion des accès concurrents sur les fichiers d’un projet) et de conserver un historique des différentes versions.

2.6.7. ANT ou Marven Pour automatiser le déploiement des applications Acube, le MAE utilise ANT ou MARVEN. Selon FELICITE (2006), ANT est un outil Open Source qui utilise un fichier XML contenant des instructions permettant par exemple de créer un répertoire puis de compiler une application J2EE dans ce répertoire. Le principe de Marven est également expliqué dans FELICITE (2006). La finalité est la même.

2.6.8. Junit FELICITE (2006) précise qu’Eclipse incorpore Junit. Pour utiliser ce framework de test il faut créer des classes qui contiennent une description des opérations à tester. Il est ensuite possible de lancer régulièrement une batterie de tests, ce qui permet d’améliorer le code et notamment d’éviter (si les bons tests ont été effectués) des problèmes de régression. Il est à noter que l’écriture des classes de test a un coût et qu’il faut par conséquent décider si les tests unitaires doivent être réalisés ou non et si oui lesquels. Le MAE envisage d’utiliser prochainement Junit pour réaliser des tests unitaires.

Partie 1

35

2.7. Normes Acube Acube respecte les principes suivants : 1). Le standard XML comme format d’échange de l’information est utilisé dans les différentes logiques de programmation. 2). Une ergonomie complexe basée sur les principes du client riche est appliquée de préférence. Ainsi, une seule page HTML statique est nécessaire pour gérer un métier ou un cas d’utilisation. Seuls les flux de contenu informatif sont générés par le serveur. Ce type d’ergonomie a pour avantage :

• Des flux d’échange de taille plus faible et une plus grande capacité de montée en charge du fait d’une sollicitation moindre du serveur.

• Une souplesse ergonomique plus importante par l’utilisation de zones dynamiques et une garantie de cohérence avec la charte graphique du MAE par l’utilisation des APIs de génération d’éléments constitutifs d’une page.

3). L’architecture technique du MAE repose sur plusieurs Design Patterns 12 reconnus, permettant d’accélérer les développements et de faciliter la maintenance des applications :

• « Data Access Object » (DAO) 13 • « Modèle, Vue, Contrôleur » (MVC)

4). Les Logs permettent de résoudre et de corriger un grand nombre de problèmes, aussi bien lors de la phase de développement que dans la phase de maintenance des applications de la filière Acube. Une attention particulière doit donc être portée sur la gestion des logs. Les règles suivantes doivent être respectées :

• Utilisation d’un framework de gestion des logs (log4J 14 ) et récupération systématique de toutes les exceptions Java.

• Les données contenues dans les logs doivent être pertinentes (le plus lisible possible et fournir un niveau d’information suffisamment détaillé pour faciliter l’analyse du problème et sa résolution).

• Les logs doivent permettre d’assurer une traçabilité applicative. • Les messages contenus dans la log doivent respecter le format recommandé

par le MAE (date de l’évènement, code de l’application, code du site, type d’évènement, code évènement, identifiant utilisateur, commentaire).

12 Un design pattern est la description d’une solution classique à un problème récurrent, que l’on peut rencontrer généralement à un niveau conceptuel, architectural ou technique. En adaptant un design pattern au contexte d’un projet il est possible de bénéficier de l’expérience d’experts et donc d’améliorer la qualité ou la maintenabilité d’une application. 13 DAO : design pattern dédié à la persistance détaillé sur le site http://java.sun.com/blueprints/corej2eepatterns/Patterns/DataAccessObject.html 14 Log4j : C’est l’outil Open Source de traçage d’application le plus utilisé (source FELICITE 2006)

Partie 1

36

2.8. Méthodologie de projet Acube

Elle est basée sur le principe itératif (Unified Process) avec pour objectif :

• De paralléliser les tâches associées à un lotissement fonctionnel et technique • De présenter une version applicative enrichie au fur et à mesure de

l’avancement des travaux pour multiplier les points de contrôle et itérer la documentation correspondante.

• De démarrer au plus tôt la phase de recette dans le cycle de vie du projet. • D’identifier et limiter les risques inhérents au projet.

Acube décrit pour chaque phase du projet la démarche à adopter : • Phase d’étude : Analyse du besoin, identification des risques, planning des

itérations de développement du projet. • Phase d’implémentation : Itérations de développement • Phase de recette (recette technique et recette fonctionnelle) : La méthodologie

de test Acube décrit précisément pour chaque itération les différents types de tests à effectuer (Tests unitaires, Tests d’intégration, Tests de performance)

• Phase de déploiement : Mise en production Pour les trois premières phases, Acube décrit également la démarche à adopter lors :

• De l’analyse technique • De l’analyse fonctionnelle • De l’analyse SGBD • De la Modélisation UML et Merise • De la réalisation de la Maquette

La méthodologie Acube impose de décrire précisément la composition de l’équipe projet en nommant les participants et en précisant leur rôle :

• Architecte • Chef de projet interne et externe • Responsable fonctionnel • Responsable homologation • Responsable technique • Responsable fonctionnel

Ces compétences peuvent être réparties sur une ou plusieurs personnes physiques. La composition du comité de projet et du comité de pilotage ainsi que la fréquence des réunions de ces comités est précisée dans Acube. Deux comités évènementiels sont également à prévoir lors d’une réunion de lancement et une réunion de bilan de projet pour ouvrir et clôturer le projet.

Partie 1

37

Les livrables à produire impérativement sont les suivants : • Dossier d’architecture applicative (DA) : il présente l’ensemble des solutions

techniques retenues, les flux à générer et l’emplacement des composants à développer ainsi qu’une étude sur la sécurité.

• Spécifications fonctionnelles générales (SFG) : Description des cas d’utilisation à mettre en œuvre, recensement des acteurs et des habilitations, fonctions à maquetter.

• Maquette Acube : Elle permet de valider la bonne compréhension du besoin fonctionnel et l’ergonomie. Elle permet également de présenter une solution réalisable avec les composants du framework Acube.

• Modélisation UML des cas d’utilisation . • Modèle conceptuel de données (MCD) • Modèle physique de données (MPD) • Modélisation UML des diagrammes de classe et des diagrammes de

séquence essentiels. • Spécifications fonctionnelles et techniques détaillées (SFTD) : Elles

contiennent une description détaillée des cas d’utilisation et des règles de gestion associées. Les composants applicatifs mis en œuvre sont également détaillés dans ces spécifications.

Livrables

Phase d’étude Phase d’implémentation Analyse technique DA SFDT Analyse fonctionnelle

SFG

Maquettage Maquette Modélisation UML Cas

d’utilisation Diagrammes de classe et de séquence

Analyse SGBD MCD MPD

Figure 12 : Récapitulatif des livrables

Il est nécessaire de recueillir le plus finement possible, les besoins du client, au travers du cahier des charges. Dans le cas du MAE celui-ci est le plus souvent rédigé au sein de la cellule informatique et non par la maîtrise d’ouvrage. Ce cahier des charges est accompagné d’une maquette de l’application réalisée avec les outils de développement de la filière Acube et respectant la charte graphique. Ces éléments sont ensuite montrés à la maîtrise d’ouvrage qui approuve la solution, ou précise les améliorations à apporter. La méthodologie Acube donne également des recommandations en ce qui concerne :

� La rédaction de fiches anomalies (anomalies majeures et mineures) � Les opérations de vérification du code source � Les opérations de vérification documentaire � Les contraintes de performance et de sécurité

Partie 1

38

Le référentiel documentaire projet est stocké sur un serveur de fichiers. Il est organisé en suivant les recommandations AFNOR Z-67-100. L’arborescence de niveau 1 est donc la suivante (les autres niveaux sont libres) :

� 1-Contrat (documents contractuels qui définissent la relation client - fournisseur)

� 2-Projet (documents prévisionnels, de pilotage et de suivi de projet) � 3-Etude (documents d’étude et de développement) � 4-Qualité (modèles de documents, de fiches, de procédures de tests et

validation et d’organisation générale) � 5-Support (documents de référence, guides et manuels, utilitaires, documents

de formation dont le transfert de compétences et de communication)

2.9. UML dans Acube Dans le cadre du développement d’une application web, la notation UML (langage de modélisation unifié) peut être utilisée pour modéliser les besoins des utilisateurs, appréhender les processus métiers de l’entreprise et expliciter la façon de réaliser le logiciel. UML est une notation et ne définit aucune méthodologie pour modéliser. RUP de Rational Software est la méthodologie la plus connue mais convient plutôt aux grosses organisations (en raison de sa lourdeur). Un ouvrage comme ROQUES (2004) explique comment utiliser UML lors des différentes étapes d’un projet. Il existe généralement un fossé entre les outils utilisés pour réaliser la modélisation UML et les outils utilisés pour le développement de l’application. Ceci débouche le plus souvent sur un décalage entre la modélisation et le système réel. Le maintien de la cohérence a un coût. De plus les maîtrises d’ouvrages rencontrent souvent des difficultés pour comprendre la notation UML (il s’avère nécessaire d’y adjoindre systématiquement une description textuelle). Ceci explique sans doute pourquoi parmi les neuf diagrammes définis dans la notation UML, seuls deux sont couramment utilisés au MAE, et la modélisation est le plus souvent créée par et pour la maîtrise d’œuvre alors que les développements sont déjà bien avancés (les diagrammes font partie de la documentation technique de l’application). Les diagrammes UML les plus utilisés au MAE sont : . Les cas d’utilisation : Ce diagramme fournit une description du système du point de vue des utilisateurs. Il permet d’identifier les acteurs (personnes disposant d’un rôle ou autres systèmes logiciels) et les interactions entre ces acteurs et le système.

Partie 1

39

. Les diagrammes de classe : Permettent de représenter graphiquement les classes présentes dans l’application et les liens entre ces différentes classes.

2.10. Présentation du projet Rendez-vous du MAE Le lancement de ce projet a été effectué début septembre 2005 lors de mes premiers contacts avec le MAE. Malgré une attente forte de la part de la maîtrise d’ouvrage, il n’existait aucune étude sur le sujet ni cahier des charges. Il a donc été nécessaire de réaliser une étude préalable pour déterminer le besoin cible, puis de rédiger un cahier des charges sur un périmètre fonctionnel réduit.

2.10.1. Objectifs du projet rendez-vous et démarche à adopter L’étude préalable a permis de définir les objectifs du projet global. L’application de gestion des rendez-vous doit permettre :

1. A un usager de prendre un rendez-vous avec un poste sur Internet afin de mieux gérer le flux des demandes.

L’usager est soit : • Un étranger s’adressant au secteur Visa pour :

o Une demande de visa (l’usager devra pouvoir consulter sur Internet l’avancement de son dossier).

o Retirer son passeport avec ou sans visa. Prise de rendez-vous possible uniquement si le dossier visa a été traité.

• Un Français expatrié s’adressant au Secteur Français pour l’un des services

suivants : o Demande ou renouvellement de passeport, o Demande de carte nationale d’identité, o Inscription au registre des Français établis hors de France, o Transcription d’une naissance, d’un mariage ou d’un décès et

délivrance d’une copie d’ acte d’état civil, o Demande de bourse scolaire, o Inscription sur les listes électorales, o Autres prestations administratives

• Un poste est soit :

o Un consulat o Un consulat général o Une section consulaire

Partie 1

40

2. Aux postes consulaires, (secteur visa et secteur Français), de définir leurs capacités d’accueil et de faire évoluer celle-ci au cours du temps (semaines types, calendrier). Pour un jour donné, la capacité d’accueil sera rattachée à des créneaux horaires (à définir par le poste) et à des services. Les rendez-vous pris par les usagers s’appuient sur le calendrier défini par le poste. Le nombre de rendez-vous est limité par la capacité d’accueil.

3. La récupération des informations saisies par l’usager dans RMV2 ou dans les

applications métiers du système Racine. Le principe de récupération des données dans RMV2 à partir d’une application web Acube centralisée a déjà été mis en œuvre dans le projet VISANET15. Un principe similaire sera adopté, garantissant la sécurité et la cohérence des données importées.

L’objectif du projet est de bâtir une solution pouvant être utilisée par tous les postes, dans tous les pays où la France est représentée. Une maquette exhaustive sera présentée à l’ensemble des postes consulaires via l’intranet pour obtenir la plus grande adhésion avant la réalisation proprement dite. Le projet rendez-vous doit prendre en compte les enjeux suivants :

• Développer une application de gestion des rendez-vous utilisable par tous les postes (certaines fonctions devront être multilingues. Les postes ne sont pas tous organisés de la même façon).

• Réaliser le développement dans le respect de l’architecture Acube.

2.10.2. Présentation de l’équipe projet L’équipe du Ministère des Affaires Etrangères assure la maîtrise d’ouvrage. Elle est composée de la façon suivante :

• 1 Directeur de projet

• 1 Chef de projet

• 3 Responsables fonctionnels pour la partie Visa (RMV2)

• 2 Responsables fonctionnels pour la partie Racine

• 1 Responsable méthodologie Acube

• 1 Architecte logiciel La maîtrise d’œuvre sera sous-traitée auprès d’une société de service en informatique qui désignera un Directeur de projet, un Chef de projet J2EE, un Développeur client et un Développeur serveur. L’application « rendez-vous » est une application stratégique et concerne de multiples décideurs. Durant la phase d’étude une maquette sera réalisée avec les outils Acube. Celle-ci respectera la charte graphique définie par le Framework Acube

15 VISANET est un projet Acube permettant d'externaliser la saisie de certaines demandes de visa.

Partie 1

41

et permettra d’illustrer le fonctionnement des principales fonctions de l’application rendez-vous. La maquette, sera soumise à la validation de l’ensemble des acteurs concernés. Elle permettra notamment de valider le contenu des fonctions de paramètrage qui doivent autoriser une représentation appropriée de l’organisation des postes et des types d’usager.

2.11. Ma contribution au projet rendez-vous du MAE Pour plusieurs raisons je ne suis pas en mesure de présenter en détail la solution adoptée par le MAE :

� Les documents que j’ai rédigés ne m’appartiennent pas � Ces documents sont très volumineux � L’intérêt est limité car il s’agit de documents fonctionnels � Certains documents restaient à produire lorsque j’ai quitté le projet (Use

cases, MCD, SFG, …) et la rédaction de ces documents n’était pas de ma responsabilité

La fin de la première partie devrait cependant vous permettre de vous faire une idée assez précise du travail accompli et de la démarche adoptée.

2.11.1. Etude préalable

Après une réunion de lancement, j’ai rencontré différents interlocuteurs de la maîtrise d’ouvrage et du pôle DC de PSI afin de mieux comprendre le besoin. J’ai étudié la solution existante sur le site de l’ambassade de France à Londres (http://www.consulfrance-londres.org/article.php3?id_article=282) ainsi que celle disponible sur le site du Consulat Général de France à Toronto (https://www.consulfrance.net/toronto/). J’ai ensuite rédigé un document décrivant les principales fonctionnalités attendues dans la cible. Plusieurs réunions ont été nécessaires pour améliorer ce document et parvenir à un consensus.

2.11.2. Définition du périmètre du premier lot Le projet global étant relativement important, il était nécessaire de réduire le périmètre avant de poursuivre. La détermination du périmètre du premier lot et des fonctions à étudier en priorité a été réalisée en comité de pilotage. Comme le montre le tableau ci-dessous, RMV2 gère un flot de demandes plus important que RACINE : RMV2 RACINE 3 millions de demandes de visa par an 1 million de français résident depuis plus

de 6 mois à l’étranger. 300 000 nouveaux français à l’étranger par an

Il a donc été décidé de développer en priorité la prise de rendez-vous pour le secteur des visas. Le premier lot concerne la prise de rendez-vous Visas et plus précisément les fonctions d’administration.

Partie 1

42

Les contraintes du secteur français 16 n’ont cependant pas été ignorées totalement durant la phase de conception du premier lot car il fallait bâtir une application la plus générique et la plus souple possible (adaptable à toutes les organisations susceptibles de gérer des rendez-vous).

2.11.3. Phase d’étude du premier lot

En collaboration avec différents acteurs du MAE, j’ai participé à l’élaboration du cahier des charges du premier lot. Il a ensuite été décidé en comité de pilotage de confier la maîtrise d’œuvre à une société de service en informatique. Celle-ci s’est vu remettre une copie du cahier des charges pendant la réunion de lancement. Lors de la rédaction de l’étude préalable et du cahier des charges du premier lot, j’avais réalisé sous PowerPoint une maquette complète de l’application rendez-vous, mais si celle-ci permettait de préciser les objectifs fonctionnels à atteindre, elle ne respectait pas l’ergonomie Acube. J’ai donc ensuite animé plusieurs réunions destinées à piloter la création par la société de service en informatique responsable de la maîtrise d’œuvre d’une maquette Acube (prototype opérationnel) pour le premier lot. Enfin j’ai organisé une réunion destinée à identifier les risques du projet et à y apporter des solutions. Les discussions ont porté principalement sur la sécurité des données. Il a été décidé de créer une base de données unique pour gérer les données saisies par les usagers et celles saisies par le personnel du ministère des affaires étrangères, mais d’attribuer les droits séparément pour ces deux types de données (les usagers ne doivent pas être autorisés à mettre à jour les données de paramétrage saisies par le personnel du MAE). La rédaction des documents suivants a été confiée à la société de service en informatique responsable de la maîtrise d’œuvre du projet rendez-vous :

• Dossier d’architecture (description des serveurs et de tous les choix techniques)

• Spécifications Fonctionnelles Générales (contient notamment la description des cas d’utilisation)

• Présentation des données gérées par l’application et création du Modèle Conceptuel des Données

16 Secteur français : Personnel du Ministère des affaires étrangères qui répond aux demandes des français. Le secteur français utilise RACINE.

Partie 1

43

Maquette du premier lot

Figure 13 : Maquette - Gestion des semaines types

La maquette peut être manipulée comme si l’application fonctionnait réellement. Elle permet de simuler le fonctionnement des options suivantes : Fonction But de la fonction

Ecran de connexion Saisie du login et du mot de passe de l’utilisateur Gestion des Agents En dehors des usagers, tous les utilisateurs

doivent posséder un compte pour accéder à l'application rendez-vous. Cette fonction permet de créer, modifier ou supprimer ces comptes.

Gestion des services du poste

Permet de définir pour un poste, à partir des services de base des différents secteurs, les services offerts aux usagers.

Gestion des jours de fermeture

L'objet de cette fonction est d'éviter de proposer des rendez-vous aux usagers lorsque le poste est fermé.

Gestion des semaines types

Cette fonction est destinée à simplifier le paramétrage du calendrier.

Partie 1

44

Gestion du calendrier Cette fonction permet de définir sur un calendrier pour chaque service du poste des créneaux horaires et pour chaque créneau une capacité d'accueil.

Gestion des paramètres généraux

Cette fonction permet de définir pour un poste les paramètres suivants :

� nombre de jours de rétention des rendez-vous après la date du rendez-vous,

� nombre de jours de rétention des informations du calendrier pour les jours écoulés,

� langue par défaut pour les usagers, � rendez-vous futur le plus éloigné en

nombre de jours accessible par l'usager Le menu de la maquette affiche seulement les commandes autorisées pour l’utilisateur connecté.

2.11.4. Phase d’implémentation du premier lot Je n’ai pas participé aux développements, la maîtrise d’œuvre ayant été confiée à une société de service en informatique, ni à la recette ni même au déploiement. En parallèle de la réalisation du premier lot de l’application rendez-vous, la société de service en informatique responsable de la maîtrise d’œuvre devait rédiger les documents suivants :

• Spécifications Fonctionnelles et Techniques Détaillées • Diagrammes de classe et diagrammes de séquence • Modèle physique de données

Partie 1

45

2.12. Conclusion Ces 4 mois auront été l’occasion pour moi :

• De découvrir l’organisation du pôle informatique du ministère des affaires étrangères.

• D’animer des réunions afin de définir les objectifs du projet, de recueillir les différents souhaits, de proposer une solution réunissant un consensus maximum.

• De rédiger divers documents en vue de constituer un cahier des charges et de tracer les décisions prises.

• De participer à l’élaboration d’une maquette de l’application (réalisée par une société de service en informatique).

• De découvrir le framework Acube Lors de mon passage au MAE j’ai été invité à une réunion de retour d’expérience destinée à identifier les points d’amélioration à envisager pour la filière Acube. Cette réunion s’est déroulée alors que le premier projet de la filière (VISANET) touchait à sa fin. Les points suivants ont été abordés :

• Déploiement complexe car peu automatisé (beaucoup de travaux répétitifs sont réalisés manuellement ce qui entraîne des risques d’erreur).

• Le document des SFTD 17 mélange des spécifications fonctionnelles et des éléments techniques très pointus. Ceci rend quasiment impossible la validation de ce document sur le plan fonctionnel car les spécifications sont noyées dans un document très complexe que les personnes chargées de la validation ont du mal à appréhender.

• Le framework Acube ne permet pas de répondre à tous les besoins. De nouveaux composants devront être développés.

• Lors de la mise en production de l’application VISANET des temps de réponse élevés ont été constatés. Un effort devra être réalisé pour améliorer ce point.

• Définir une solution commune à toutes les applications Acube pour gérer l’identification de l’utilisateur afin d’augmenter la sécurité.

17 SFTD : Spécifications Fonctionnelles et Techniques Détaillées

Partie 2

46

3. PARTIE 2 : CREATION D’UNE VERSION SIMPLIFIEE DE L’APPLICATION « RENDEZ-VOUS » AVEC J2EE

Partie 2

47

3.1. Introduction Cette partie se rapporte à l’expérience acquise au cours de la période de fin décembre 2005 à juin 2006. L’objectif principal pour cette période était de réaliser seul une application simplifiée de prise de rendez-vous avec les technologies J2EE. Pour atteindre cet objectif j’ai du :

� Adapter et simplifier l’application de prise de rendez-vous du MAE pour la sortir de son contexte.

� Sélectionner les outils et versions nécessaires à la réalisation de l’application � Me former à ces outils � Réaliser le développement

3.2. Cahier des charges de l’application « rendez-v ous » simplifiée

Dans un premier temps, je me suis inspiré des spécifications du projet décrit en première partie pour concevoir une application centralisée de prise de rendez-vous qui puisse permettre à différents professionnels de proposer des rendez-vous à leurs clients en partageant une base de données unique. Cette application pourrait être utilisée par plusieurs sociétés souhaitant mettre à la disposition du public des rendez-vous de différentes natures (exemple : un garagiste propose des rendez-vous pour changer les pneumatiques et d’autres rendez-vous pour faire une vidange. Un salon de beauté propose des rendez-vous pour une séance de bronzage et d’autres pour une épilation). Chaque société pourrait gérer plusieurs bureaux mais n’aurait accès qu’aux données de sa société. Une société pourrait créer des types de rendez-vous et mettre à jour le calendrier des jours ouvrés. Chaque société aurait une page d’accueil spécifique sur laquelle un client pourrait s’identifier ou s’enregistrer. Le client pourrait alors choisir un rendez-vous et le confirmer. Il aurait également la possibilité de visualiser ses rendez-vous ou d’annuler un rendez-vous.

Partie 2

48

Voici une représentation possible de la base de données :

Figure 14 : Modélisation des données réalisée avec Dbdesigner

Partie 2

49

Dans un second temps, mon but dans cette deuxième partie étant de me former aux technologies J2EE, d’expérimenter un certain nombre d’outils et non de bâtir une application commercialisable, j’ai simplifié radicalement l’application rendez-vous pour ne garder que l’essentiel. La représentation de la base de données qui sera réellement utilisée dans la suite de ce document pour bâtir l’application simplifiée de prise de rendez-vous est la suivante :

Figure 15 : Modélisation des données simplifiée

Dictionnaire des données : Table Champ Type Description Personnes person_id entier Incrémenté automatiquement, permet

d’identifier une personne Personnes Nom Caractères Nom Personnes Prénom Caractères Prénom Personnes Téléphone Caractères Téléphone Personnes Courriel Caractères Courriel Personnes Login Caractères Login Personnes Motdepasse Caractères Mot de passe Personnes administrateur Booléen Vrai pour l’administrateur Créneaux creneaux_id entier Incrémenté automatiquement, permet

d’identifier un créneau Créneaux DateHeureDebut Datetime Date et heure de début d’un créneau

pour un service donné Créneaux ServiceProposé Caractères Service proposé Créneaux RdvAutorisé Booléen Vrai si le créneau peut faire l’objet

d’une prise de rendez-vous Si un même service est proposé sur plusieurs créneaux il faudra saisir le même libellé plusieurs fois ce qui est un inconvénient du modèle simplifié. Cette solution ne serait pas acceptable dans le cadre du développement d’une application professionnelle. Définissons maintenant le fonctionnement attendu.

Rendez-vous --------------- creneaux_id * person_id *

Personnes ------------- person_id * nom prénom téléphone courriel login motdepasse administrateur

Creneaux ------------- creneaux_id * DateHeureDebut ServiceProposé RdvAutorisé

Partie 2

50

3.2.1. Acteurs Il existe deux types d’acteurs :

� L’Administrateur qui accède à toutes les fonctions du système � Le Client qui peut prendre ou annuler un rendez-vous

Le champ « administrateur » de la table « Personnes » permet de déterminer le rôle attribué lors de la connexion au système.

3.2.2. Les cas d’utilisation Les cas d’utilisation suivants sont réservés à l’administrateur :

� Création / Mise à jour / Suppression d’une personne, liste des personnes � Création / Mise à jour / Suppression d’un créneau pour un service donné, liste

des créneaux. Possibilité d’associer un créneau de la liste à un rendez-vous en sélectionnant une personne. Possibilité pour un créneau de la liste de voir s’il est associé à un rendez-vous (afficher le prénom et le nom de la personne). Possibilité pour un créneau de la liste associé à une personne de le libérer.

Les cas d’utilisation suivants sont réservés aux autres utilisateurs (clients) :

� Prise d’un rendez-vous parmi les créneaux non encore affectés à un rendez-vous qui sont ouverts à la prise de rendez-vous

� Liste des rendez-vous de la personne connectée avec possibilité de détruire un rendez-vous

� Modification des champs Prénom, Nom, Téléphone, Courriel, Login et Mot de passe de la personne connectée.

Figure 16 : Diagramme des cas d'utilisation réalisé avec ArgoUml

Partie 2

51

3.2.3. Règles de gestion et contraintes

� La suppression d’un créneau entraîne la suppression du rendez-vous associé s’il existe.

� La suppression d’une personne entraîne la suppression des rendez-vous associés à cette personne.

� Les champs Nom, Prénom, Login et Motdepasse sont obligatoires en saisie ou modification d’une personne

� Les champs DateHeureDebut et ServiceProposé sont obligatoires en saisie ou modification d’un créneau. DateHeureDebut doit respecter le format dd/MM/yyyy HH:mm.

� L’application doit être multilingue (Anglais et Français pour commencer). � Il peut y avoir plusieurs administrateurs

3.2.4. Navigation Une page d’accueil permet d’afficher l’écran de connexion. Après l’écran de connexion (saisie du login et du mot de passe) un menu est affiché. La navigation est réalisée à partir de ce menu. Pour l’administrateur le menu contient les options suivantes :

� Gestion des personnes (administrateur uniquement) � Gestion des créneaux (administrateur uniquement)

Pour les autres utilisateurs le menu contient :

� Prendre un rendez-vous � Gestion de mes rendez-vous � Gérer mon profil

3.3. Sélection et installation de l’outillage Nous parlons ici des logiciels utilisés pour l’application rendez-vous :

� Lors du développement � En production � Lors de la conception ou documentation

L’architecture proposée s’inspire des choix réalisés par le MAE pour la filière Acube en remplaçant les solutions propriétaires ou maison par des solutions open source reconnues et adaptées :

� La base de données relationnelle Microsoft SQL Server est remplacée par MySQL .

� Pour créer les diagrammes UML, Power AMC est remplacé par ArgoUML � Pour Le Modèle Conceptuel des Données, Power AMC est remplacé par

DBDesigner � Acube pour sa partie technique est remplacé par des frameworks J2EE plus

populaires (Struts et hibernate )

Partie 2

52

Les développements et les tests sont réalisés sous MS Windows XP.

Partie 2

53

Après avoir tâtonné longtemps pour savoir précisément quels outils et quelles versions utiliser pour développer l’application simplifiée de prise de rendez-vous, j’en suis arrivé à la conclusion que la solution suivante était un bon compromis :

Figure 17 : Architecture retenue pour l’application rendez-vous

(1) MS Internet Explorer 6 (2) J2SE 1.5.0 contenant le runtime et le kit de développement java 2 (3) Tomcat 5.5.15 (4) Struts 1.2.8 (5) Implémentation de la logique métier développée spécifiquement pour l’application

rendez-vous (6) Hibernate 3.0 (7) Driver JDBC 3.1.12 pour MySQL (8) MySQL 4.1.9 (9) Eclipse 3.1.1 (10) Plugin Tomcat sysdeo 3.1 (11) ArgoUML v0.20 (12) DbDesigner 4 +

MySQL Administrator 1.1.7 + MySQL Query Browser 1.1.19

Serveur d’application (3)

HTTP

Navigateur (1)

Base de données relationnelle (8)

Couche présentation (4)

Couche traitements (5)

Couche persistance (6)

JDBC (7)

Application rendez-vous

Outillage pour créer, administrer et consulter la base de données (12)

Modélisation UML (11)

Environnement de développement intégré (9)

JAVA (2)

Plugin (10)

Déploiement

Conception et développement Environnement de production

Partie 2

54

Pour chacun de ces outils, voici quelques conseils pour l’installation, une définition et la justification du choix.

� J2SE J2SE (plate-forme Java 2, Standard Edition) est la base indispensable pour réaliser un développement J2EE. J’ai téléchargé le fichier jdk-1_5_0_06-windows-i586-p.exe sur le site http://java.sun.com/j2se/1.5.0/download.jsp. Ce fichier permet d’installer le JDK (Java Development Kit) maintenant appelé aussi SDK (Standard Development Kit) qui contient notamment le compilateur java (le compilateur permet de créer les fichiers d’extension .class à partir des fichiers d’extension java) et une JRE (Java Runtime Environment) pour interpréter les fichiers d’extension .java qui contiennent du byte-code. Le JDK n'est pas un logiciel libre. Il est gratuit, mais son usage est régi par une licence qui protège les droits du propriétaire (Sun).

� Eclipse Pour installer Eclipse sur Windows XP j'ai téléchargé à partir du site www.Eclipse.org dans la section downloads le fichier Eclipse-sdk-3.1.2-win32.zip. J'ai également téléchargé les fichiers nlpack1_featureoverlay-Eclipse-sdk-3.1.1.zip et nlpack1-Eclipse-sdk-3.1.1a-win32.zip pour permettre un affichage des écrans en français. Nous avons déjà vu dans la première partie qu’Eclipse est un IDE java Open Source. Je présenterai quelques fonctions de base d’Eclipse dans le chapitre consacré à l’auto formation J2EE. Le choix d’Eclipse s’est imposé naturellement puisqu’il fait partie de l’outillage Acube.

� Tomcat La version 5.5.15 de Tomcat que j’ai utilisée est téléchargeable sur le site http://tomcat.apache.org/ (fichier apache-tomcat-5.5.15.exe). Le serveur d’application Open Source Tomcat dont nous avons déjà parlé dans la première partie a été choisi car il fait partie de l’outillage Acube.

� MySQL BORDAGE et DAVY (2005), indiquent que parmi les SGBD (Système de gestion de Bases de Données) open source, MySQL est utilisé dans 86% des cas et PostgreSQL dans 10% des cas (plusieurs solutions se partagent les 4% restant). 48 % des utilisateurs sont prêts à basculer sur une base open source pour leurs nouveaux projets. Microsoft propose gratuitement une version allégée de SQL Serveur 2005 (baptisée « SQL Server Express ») pour offrir une alternative à MySQL.

Partie 2

55

J’ai décidé d’utiliser MySQL en raison de sa notoriété et téléchargé le fichier MySQL-essential-4.1.9-win32.msi à partir de l’adresse http://dev.MySQL.com qui permet d’installer MySQL sous Windows. La version 5 de MySQL permet de créer des procédures stockées, des déclencheurs, des transactions et devient un concurrent sérieux pour les systèmes propriétaires.

� MySQL Administrator SARRION (2005b) recommande d’utiliser MySQL Administrator. Cet outil permet notamment de sauvegarder ou restaurer facilement une base de données MySQL en créant ou utilisant un fichier de script SQL. Il est également possible d’administrer les profils des utilisateurs et de définir les autorisations à l’aide de l’interface graphique de MySQL Administrator. MySQL Administrator a été installé à partir du fichier MySQL-administrator-1.1.7-win.msi téléchargé à partir de http://www.MySQL.com .

� MySQL Query Browser SARRION (2005b) recommande également l’utilisation de l’outil MySQL Query Browser qui permet d’interroger ou de mettre à jour facilement les tables d’une base de données MySQL à l’aide de Query et de Scripts SQL. Le fichier MySQL-query-browser-1.1.19-win.msi téléchargé sur http://www.MySQL.com a permis d’installer MySQL Query Browser.

� Dbdesigner C’est en recherchant sur Google un outil pour modéliser la base de données de l’application rendez-vous que j’ai découvert Dbdesigner sur le site http://www.fabforce.net/dbdesigner4/. Ce produit m’ayant donné satisfaction, je l’ai adopté. DBDesigner est un outil graphique de conception de base de données. Il permet de créer graphiquement une base de données ou d’importer les schémas d’une base existante pour la modéliser et la faire évoluer. Cette solution Open Source s’interface facilement avec MySQL. L’installation de Dbdesigner a été réalisée à partir du fichier DBDesigner4.0.5.6_Setup.exe téléchargé sur http://www.fabforce.net/downloads.php

� Driver JDBC JDBC (Java DataBase Connectivity) fournit une interface standardisée permettant à une application cliente sous Java d’accéder à une base de données relationnelle. Pour accéder à la base de données de l’application « rendez-vous » avec JDBC, nous utiliserons un pilote compatible avec MySQL. Le rôle de ce pilote est de

Partie 2

56

traduire les requêtes SQL de l’application rendez-vous, au format spécifique de la base MySQL. Le fichier MySQL-connector-java-3.1.12.zip téléchargé sur le site de MySQL a permis d’installer un pilote JDBC compatible avec notre projet.

� Plugin Tomcat sysdeo Plusieurs plugins peuvent être ajoutés à Eclipse pour étendre ses capacités. Le seul qui me semble indispensable lorsque l’on utilise à la fois Eclipse et Tomcat est celui téléchargeable gratuitement sur le site www.sysdeo.fr (j’ai téléchargé le fichier de la version 3.1 tomcatpluginv31.zip pour réaliser l’installation). Le plug-in Tomcat de Sysdeo possède de nombreux atouts. Il facilite notamment le démarrage et l'arrêt de Tomcat ainsi que le déploiement dans Tomcat. Avant de découvrir le plug-in Tomcat de Sysdeo (son installation est recommandée par FELICITE 2006) j’ai testé le plug-in Lomboz recommandé par SARRION (2005b). Lomboz simplifie également le déploiement des applications J2EE sur Tomcat mais dans une moindre mesure car les manipulations à réaliser lors de chaque déploiement sont plus nombreuses (sélection du serveur d’application, suppression du déploiement précédent, déploiement). Lomboz possède l’avantage de pouvoir simplifier le déploiement sur plusieurs serveurs d’applications (tomcat, Jonas, Jboss, …). Eclipse Web Tools Platform (WTP) est un plugin Open-Source pour Eclipse particulièrement adapté au développement d'applications web J2EE. WTP (disponible sur http://www.eclipse.org/webtools/) est composé de nombreux outils (éditeur JSP, éditeur XML, etc.) et exemples de programmes. Je n’ai pas testé personnellement WTP, mais les développeurs J2EE si intéressent beaucoup actuellement.

� Struts Après avoir étudié le HTML, CSS, JavaScript, Java et MySQL. Après avoir créé mes premières Servlets et JSP avec Eclipse puis déployé le tout sur tomcat avec lomboz j’étais en mesure de commencer le développement de l’application de prise de rendez-vous. Je me suis alors posé plusieurs questions :

� Comment implémenter au mieux le design pattern MVC ? � Quelle méthode utiliser pour que les valeurs entrées sur un formulaire soient

conservées lors du réaffichage de celui-ci ? � Comment faire pour vérifier la validité des données entrées sur un

formulaire ? � Quelle méthode utiliser pour créer une application multilingue ? � Comment faire pour développer une application, en évitant, tant que faire ce

peut, la duplication de code (pour faciliter la maintenance) ? SARRION (2005b) propose une solution basée sur des JSP et une Servlet unique pour implémenter le design pattern MVC 2 sans avoir recours à un framework tel que struts. Il propose également une solution permettant, lorsqu’un formulaire est réaffiché, de conserver les données saisies. Il est possible de créer soi-même une méthode permettant d’afficher des messages d’erreurs ou de gérer l’affichage

Partie 2

57

multilingue. Des instructions « includes » peuvent être utilisées pour limiter la duplication de code. De nombreux framewoks Open Source implémentent MCV. L’étude de Struts m’a semblée particulièrement intéressante car c’est le framework MVC le plus utilisé par la communauté J2EE et il répond, comme nous le verrons dans le chapitre consacré à la formation, à toutes les questions posées plus haut. Struts est composé d'un ensemble de classes java, de librairies de tag JSP et de servlets. Il sera décrit plus en détail dans le chapitre consacré à la formation. J’ai installé Struts à partir du fichier struts-1.2.8-bin.zip téléchargé sur http://www.jakarta.struts.com en suivant les conseils de FELICITE (2006).

� Hibernate Hibernate est un framework open source qui permet de « mapper » une base de données relationnelle en objets (POJO 18). Il propose un accès orienté objet aux données. Au cours de mon apprentissage de J2EE et de Struts j’ai été amené à faire fonctionner des exemples qui réalisaient des interactions avec une base de données MySQL en utilisant JDBC directement. Cette solution n’est pas mauvaise en soit, mais il existe aujourd’hui plusieurs frameworks objet / relationnel dont l’avantage principal est de permettre de créer des applications indépendantes de la source de données. Hibernate et Ibatis sont les plus communément utilisés en complément de struts. La communauté Hibernate est actuellement la plus importante et il existe de nombreux livres sur hibernate. J’ai donc décidé d’étudier hibernate avant de développer l’application de prise de rendez-vous. Le fichier ayant servi à installer hibernate (hibernate-3.1.3.zip) a été téléchargé sur http://www.hibernate.org/

� Spring Avant d’arrêter l’architecture utilisée pour développer l’application rendez-vous, je me suis posé la question de savoir s’il était judicieux d’avoir recours au framework Spring puisque ce dernier peut être utilisé avec Struts ainsi qu’avec Hibernate et qu’il commence à se diffuser au sein des sociétés de service en informatique et des entreprises françaises. Le framework Open Source Spring (http://www.springframework.org) comme indiqué dans DUBOIS (2006) est un cadre de travail. Sont objectif est d’améliorer l’architecture des applications Java/J2EE en les rendant à la fois plus souples, plus agiles et plus facilement testables. Spring fournit une couche d’abstraction destinée à

18 POJO (Plain Old Java Object) : Un POJO est un objet java. Cet acronyme est principalement utilisé pour faire référence à la simplicité d'utilisation d'un Objet Java en comparaison à la lourdeur d'utilisation d'un composant EJB.

Partie 2

58

simplifier et structurer les développements J2EE de manière à respecter les meilleures pratiques d’architecture logicielle. L’architecture de Spring peut être représentée de la façon suivante :

Figure 18 : Architecture de Spring

POA : La Programmation Orientée Aspect est utilisée par Spring pour offrir des

services similaires à ceux des conteneurs EJB, mais sans leur lourdeur, car ils sont applicables à de simples JavaBeans, ou POJO.

MOR : Mapping Objet / Relationnel DAO : Objets d'Accès aux Données Spring Web : Module d’intégration de frameworks Web MVC : Modèle Vue Contrôleur SPRING s'appuie sur les principes du design pattern IoC (Inversion Of Control ou Injection de dépendance) et sur la programmation Orientée Aspect (POA). L'idée du pattern IoC consiste, lorsqu'un objet A à besoin d'un objet B, à déléguer à un objet C la mise en relation de A avec B. Les notions d’injection de dépendance et de programmation orientée aspect ne seront pas étudiées dans ce mémoire. La figure ci-dessous montre grossièrement comment combiner les frameworks Struts (pour la couche présentation), Spring (pour la couche Métier) et Hibernate (pour la couche persistance) :

Figure 19: Architecture combinant les frameworks St ruts, Spring et Hibernate

RAIBLE (2005) permet de construire une petite application web (CRUD ou Create Retrieve Update Delete) utilisant Struts, Spring et hibernate. J’ai testé l’exemple afin

POA Spring

AspectJ

MOR Ibatis – hibernate - JDO

DAO Spring JDBC - LDAP

Spring Web JSP – PDF – Excel

Tiles - Velocity

MVC Spring Struts JSF

Tapesty

Noyau Spring

Partie 2

59

de voir si cette combinaison pouvait avoir un intérêt. Je suis parvenu à faire fonctionner l’exemple, mais mes connaissances de Struts et d’Hibernate étaient trop minces pour me permettre de comprendre vraiment l’intérêt d’y associer Spring. J’ai donc décidé de ne pas utiliser Spring pour développer l’application rendez-vous afin de consacrer plus de temps à l’étude de Struts et d’Hibernate.

� ArgoUml ArgoUML peut être téléchargé à partir de l’adresse http://argouml.tigris.org/ . Sur ce site, ArgoUML est présenté comme étant l’outil de modélisation UML open source le plus utilisé. Il gère les 9 diagrammes UML. Développé en java, il peut être utilisé sur tous les systèmes supportant java. Il existe des extensions commerciales basées sur ArgoUML (Poseidon de Gentleware, plugin MyEclipse pour Eclipse).

Figure 20 : Création d'un diagramme de classes avec ArgoUml

Partie 2

60

3.3.1. Conclusion Pour développer une application web, il n’est pas indispensable d’utiliser des frameworks tel que Struts ou hibernate. L’utilisation de ces frameworks dans le cadre de ce mémoire a pour but d’en mesurer l’intérêt. Afin de développer une application web, il est également possible de créer son propre framework. Cette démarche nécessite d’avoir un grand nombre d’applications à développer pour amortir la création du framework. Ceci est donc réservée à de grosses structures (trois ans ont été nécessaires au MAE pour bâtir le framework Acube). Pour créer un framework « maison », on part généralement d’un framework tel que Struts que l’on étend. C’est le cas pour Acube qui est basé sur StrutsCX et Struts. Le framework StrutsCX (http://it.cappuccinonet.com/strutscx/index.php ) s'utilise avec Struts et permet de renvoyer du XML à la place des JSP.

3.4. Formation J2EE Cette section résume quelques points importants concernant les outils, langages, frameworks ou concepts qu’il m’a fallu maîtriser avant de commencer le développement de l’application de gestion des rendez-vous. Il faut savoir qu’avant d’entamer ce mémoire je n’ai jamais participé moi-même au développement d’une application web en tant que développeur et qu’il m’était donc indispensable de consacrer le temps nécessaire pour me former. La présentation suit, si possible, un ordre logique pour l’apprentissage et traite en premier des compétences devant être possédées pour le développement côté client. Généralement les développeurs possèdent à la fois des compétences sur la programmation côté client et côté serveur. Certaines organisations préfèrent cependant définir des profils spécialisés.

3.4.1. Langage de description des pages Web Le HTML permet de structurer et d’afficher différents objets sur un écran (page HTML). Ces objets peuvent être du texte, des tableaux, des images, de la vidéo ou des sons. Ils peuvent être aussi les éléments devenus classiques des environnements graphiques, à savoir les boutons, listes, barres de défilement, cases à cocher, … Sur la plupart de ces objets, il est possible de placer des liens qui vont permettre de se connecter à d’autres pages. Le langage HTML, à l’origine, est essentiellement statique. Pour développer une application web il est nécessaire de connaître le HTML. Ceci ne représente pas une difficulté majeure. Il existe de nombreux ouvrages consacrés au HTML et plusieurs outils de conception de site web commerciaux (ex : frontpage de Microsoft) ou open source (ex : NVU) qui permettent de générer du code HTML au travers d’une interface graphique. Après avoir téléchargé le fichier nvu-1.0-win32-installer-fr.exe sur le site http://www.nvu.com/ et installé NVU, j’ai suivi la formation disponible à l’adresse

Partie 2

61

http://info.sio2.be/ pour évaluer NVU. NVU comme ses concurrents a tendance à générer beaucoup plus de code que nécessaire et ne permet pas toujours de réaliser exactement ce que l’on veut. Dans la pratique le programmeur devra donc généralement créer le code HTML « à la main ». LANCKER L.V., 2003 m’a permis d’affiner mes connaissances du HTML à l’aide d’exemples. Les balises HTML ne sont pas décrites dans ce mémoire. Exemple de page HTML : La sauvegarde du texte suivant dans un fichier texte d’extension html <HTML> <HEAD> <TITLE>PAGE DE LOGIN - GESTION DES RENDEZ-VOUS</TITLE> </HEAD> <BODY BGCOLOR="white"> <H1>Veuillez vous identifier</H1> <FORM name="login"> <TABLE> <TR> <TD> Login </TD> <TD> <INPUT type="text" value="" name="login"/></TD> </TR> <TR> <TD> Mot de passe </TD> <TD> <INPUT type="text" value="" name="motdepasse"/></TD> </TR> </TABLE> <INPUT type="submit"/> </FORM> </BODY> </HTML>

Partie 2

62

Puis l’ouverture de ce fichier dans un navigateur donne le résultat suivant :

Figure 21 : Exemple HTML

L’utilisation de pages HTML implique l’utilisation du protocole http (HyperText Transfert Protocol). En effet, le serveur et le client web communiquent grâce au protocole http. Apache est un serveur http Open Source. Tomcat intègre son propre serveur http (coyote).

3.4.2. Code exécuté par le navigateur Créé à l’origine par Netscape, le langage de programmation JavaScript est conçu pour traiter localement des évènements provoqués par l’utilisateur (ex : événement lié au positionnement de la souris). C’est un langage interprété, c’est à dire que le texte contenant le programme est analysé au fur et à mesure par l’interprète, partie intégrante du navigateur, qui va exécuter les instructions. SARRION (2005a) m’a permis de m’initier à ce langage. L’exemple ci-dessous permet d’afficher la date actuelle dans une page HTML avec un format personnalisé (« 02/07/2006 » devient «Dimanche 2 juillet 2006, 17H10 »).

Partie 2

63

Contenu du fichier date.html : <HTML> <HEAD> <TITLE>AFFICHER LA DATE</TITLE> </HEAD> <BODY BGCOLOR="white"> <H1>Voici la Date</H1> <SCRIPT src = "dateheure.js"> </SCRIPT> <SCRIPT LANGUAGE = "JavaScript"> document.write (AffichageDateConvi viale (Aujourdhui) ) </SCRIPT> </BODY> </HTML>

Le premier script permet du charger le contenu du fichier dataheure.js. Le second affiche la date au format attendu en passant la date du jour à la fonction AffichageDateConviviale. Contenu du fichier dataheure.js : var Aujourdhui = new Date() function NomDuJour (QuelleDate) {switch (QuelleDate.getDay()) {case 1 : return "Lundi" break …. case 0 : return "Dimanche" break}} function NomDuMois (QuelleDate) {switch (QuelleDate.getMonth()) {case 0 : return ("janvier") break … case 11 : return ("décembre") break}} function AffichageDateConviviale (QuelleDate) {var T T = (" ") + (NomDuJour (QuelleDate) ) + (" ") + (QuelleDate.getDate()) + (" ") + (NomDuMois (QuelleDate) ) + (" ") + (QuelleDate.getFullYear() ) + (", ") + (QuelleDate.getHours()) + ("H") if (Aujourdhui.getMinutes() < 10 ) T = T + ("0") T = T + (QuelleDate.getMinutes()) return T}

3.4.3. Feuilles de styles pour l'affichage des page s html Je me suis formé à CSS 2 (Cascading Styles Sheets) en lisant SARRION (2005a). L’utilisation des feuilles de style CSS permet d’améliorer l’ergonomie des pages Web en séparant contenu et présentation. CSS permet notamment de découper la page en plusieurs blocs, sans avoir recours a la balise html <TABLE>.

Partie 2

64

Si l’on souhaite découper la page en 6 blocs de la façon suivante :

entete entete2 entete3 menu

texte

pied Il est possible de créer la page HTML suivante : <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <meta content="text/html; charset=ISO-8859-1" http-equiv="content-type"> <title>mise en page css</title> <style title="Styles" media="all" type="text/css" > #conteneur { border: 1px solid rgb(0, 0, 102); width: 90%; margin-left: 5px; background-color: rgb(230, 230, 230); font-family: Arial,Helvetica,sans-serif; color: rgb(0, 0, 0); font-weight: normal; font-style: normal; font-size: 11px; } #entete { border: 1px solid rgb(0, 0, 0); width: 100%; opacity: 1; height: 50px; background-image: url(file:///C:/aphilippe/2006/mon sitenvu/images/degrademauv.jpg); background-position: left top; font-family: Comic Sans MS; font-weight: bold; color: rgb(0, 0, 0); font-size: 25px; text-align: center; padding-top: 10px; } #menu { background-color: rgb(153, 255, 255); float: left; width: 150px; } #texte { background-color: rgb(204, 255, 255); margin-left: 150px; } #pied { background-color: rgb(255, 204, 204); clear: left; } #entete2 { width: 100%; background-color: rgb(0, 0, 0); color: rgb(255, 255, 255); } #entete3 { margin: 0px; padding: 0px;

Partie 2

65

width: 100%; background-color: rgb(204, 204, 204); } .texte10 { font-family: Arial,Helvetica,sans-serif; font-size: 50px; } </style> </head> <body> <div id="conteneur"> <div id="entete">Garage Belle Auto - Prise de rendez-vous</div> <div id="entete2">&nbsp;Aide I Contact I Mot de Passe&nbsp;</div> <div id="entete3"> <table style="text-align: left; width: 100%;" border="0" cellpadding="0" cellspacing="0"> <tbody> <tr> <td style="text-align: left;">Texte aligné à gauche (bloc n° 3)</td> <td style="text-align: right;">Texte aligné à droite (bloc n° 3)</td> </tr> </tbody> </table> </div> <div id="menu">Emplacement du menu javasript</div> <div class="texte10" id="texte">Contenu de la page. <BR><BR><BR> </div> <div id="pied">pied de page</div> </div> </body> </html>

Remarque : Les styles qui apparaissent en gras ci-dessus peuvent être placés dans un fichier externe d’extension CSS et importés dans la page HTML avec la balise <link …>. Le résultat est le suivant :

Partie 2

66

Après avoir ajouté un menu JavaScript à deux niveaux dans le bloc « menu », la date du jour formatée avec l’exemple JavaScript donné plus haut dans le bloc entete3 et amélioré l’ergonomie, nous obtenons le résultat suivant :

3.4.4. Structurer des données Il est aujourd’hui indispensable pour un développeur d’application web de posséder des notions de base sur le formalisme XML (eXtensible Markup Language) car cette technologie est largement exploitée par J2EE. Si un document textuel respecte un ensemble de règles (une balise de fin pour chaque balise de début et inversement, ordre des balises, … ) il est au format XML. Les 2 exemples ci-dessous sont des documents XML bien formés : <Personne nom=’’MARTIN’’ titre=’’DIRECTEUR’’> </Personne>

<Personne>

<Nom>MARTIN</Nom> <Titre>DIRECTEUR</Titre>

</Personne>

3.4.5. Langage de développement Pour développer une application web J2EE, il est bien sûr nécessaire de connaître le langage java . Il existe de nombreux ouvrages sur java. J’ai utilisé HUBBARD (2005) pour me former car c’est un ouvrage récent, peu volumineux, qui s’adresse à des débutants et permet d’apprendre le langage java à partir d’exemples simples. Java est un langage qui a été défini à partir de 1990, dans le cadre d’un projet de recherche, par Sun Microsystems. C’est un langage objet de haut niveau qui évite au programmeur les difficultés d’un langage comme C++. Contrairement aux langages

Partie 2

67

plus anciens qui séparaient les données et les traitements, un langage objet comme java permet de définir pour une classe, à la fois des données (variables d’instance) et des traitements (méthodes). A partir d’une classe, on peut créer autant d’objets que nécessaire (instances de classe). Les instances de classe sont créées à l’aide d’un constructeur (unité de code contenu dans la classe définissant comment instancier un objet). Une classe peut contenir plusieurs constructeurs (c’est la liste des paramètres qui permet de les différencier). Pour créer un programme java, il faut créer un fichier ayant l’extension « .java », puis compiler ce programme pour générer du code interprétable (bytecode). Cette opération permet la création d’un ou plusieurs fichiers d’extension « .class ». Il est ensuite possible d’exécuter le programme java à l’aide d’une machine virtuelle capable d’interpréter le bytecode. On reproche souvent aux programmes java d’être plus lents que des programmes compilés directement en langage machine. Ceci est vrai lorsque le bytecode Java est interprété, mais l’est moins lorsque celui-ci est converti à la volée en code natif par un compilateur « juste à temps » lors de l’exécution. Les applications développées avec Java ont cependant l’avantage d’être portables grâce aux machines virtuelles. Dans les langages objet et donc dans le langage Java, il est possible de définir une classe par héritage d’une autre classe et de spécialiser la nouvelle classe (il est possible de redéfinir une méthode de la classe d’origine). Avec le langage Java, la gestion du polymorphisme (Choix dynamique de la méthode à exécuter en fonction du contexte) est assurée par la machine virtuelle et est plus simple à mettre en œuvre qu’avec C++. Exemple de programme java : Le fichier Bonjour.java qui contient le code suivant : package test; public class Bonjour { public static void main(String[] args) { System.out.println("Bonjour"); } }

Affiche « Bonjour » sur la console lors de son exécution (après compilation). Nous verrons un peu plus loin comment créer ce programme avec Eclipse.

Partie 2

68

3.4.6. Plate-forme architecturale CLAVEL (2003) indique que l’architecture J2EE (Java 2 Entreprise Edition) est aujourd’hui le modèle le plus utilisé pour les applications web Intranet et Internet. Les applications Intranet reposent sur les mêmes principes qu’Internet (HTML, client léger, protocole http … ) mais accessibles uniquement par les membres de l’entreprise. La tendance actuelle pour beaucoup d’entreprises est d’utiliser les technologies Web pour faire évoluer leur système d’information (y compris les applications critiques) et non plus uniquement de créer des applications périphériques (ex : présentation de la société, postes à pourvoir, …). Une application informatique est composée de 3 couches fondamentales :

� Couche de présentation (affichage des données pour l’utilisateur) � Logique métier (ex : le montant TTC d’une facture est lié au taux de TVA) � Couche d’accès aux données ou couche de persistance

Il existe plusieurs types d’architectures :

� Simple tiers : les 3 couches sont sur l’ordinateur de l’utilisateur � Architecture client serveur ou 2 tiers : la base de données est partagée entre

plusieurs utilisateurs et située sur un serveur dédié. Les 2 autres couches (couche de présentation et logique métier) sont sur le poste de l’utilisateur. L’accès aux données est généralement réalisé à l’aide de commandes SQL.

� Architecture 3 tiers : Le poste client gère uniquement la couche de présentation. La logique métier est définie sur un serveur accessible par tous les utilisateurs. La couche d’accès aux données est également située sur un serveur partagé entre tous les utilisateurs.

� Architecture n-tiers (ex : interface utilisateur, modèle métier, règles métiers, correspondances entre objets métiers et sources de données, accès aux données).

L’architecture J2EE est basée sur la notion d’application n-tiers (certaines couches peuvent se situer physiquement sur le même serveur). On identifie quatre couches implémentables indépendamment les unes des autres :

� Présentation côté client (pas de traitement métier, uniquement l’affichage des informations fournies par le serveur au format HTML sur le navigateur).

� Présentation côté serveur. � Logique métier côté serveur. � Système d’information de l’entreprise.

Les principaux avantages des architectures 3-tiers et n-tiers sont :

� De pouvoir faire évoluer la logique métier sans avoir à effectuer un déploiement sur chaque poste client.

� De partager des données entre plusieurs utilisateurs L’architecture J2EE est censée mieux supporter la montée en charge et permettre de développer des applications web plus faciles à maintenir et avec une interface utilisateur plus élaborée que ce qui était possible avec les premières applications web dynamiques qui utilisaient des scripts CGI.

Partie 2

69

J2EE regroupe à la fois un ensemble de bibliothèques et une plate-forme logicielle. C’est une version de la plate-forme java spécialement étudiée pour les problèmes des applications d’entreprise. J2EE est destiné aux gros systèmes d’entreprises. Avec J2EE, il est possible de construire des applications indépendantes de toute plate-forme matériel. L’architecture J2EE inclut principalement 4 types de composants :

� Les EJB (Entreprises JavaBeans) ; � Les Web services ; � Les servlets ; � Les JSP (JavaServer Pages).

Les EJB et Web services ne seront pas étudiés dans ce mémoire. Les servlets et les JSP sont chargés côté serveur du traitement de la requête et de la mise en page du document HTML. Une servlet est une classe Java qui réalise des traitements et inscrit le résultat dans un flux en direction du client. Une JSP est une page HTML qui invoque des traitements et insère les données récupérées en son sein.

3.4.7. Programme Java s'exécutant sur un serveur SARRION (2005b) explique qu’une Servlet est une classe Java implémentant l’interface javax.servlet.Servlet qui est stockée et contrôlée par un serveur d’application J2EE (Tomcat dans notre cas). Son invocation est la conséquence de la requête du client, dirigée vers cette servlet. Le serveur Web reçoit une demande adressée à une servlet sous la forme d’une requête http. Il transmet la requête à la servlet concernée. La servlet reçoit les paramètres de la requête envoyée par le client. Elle peut alors effectuer toutes les opérations nécessaires pour construire de manière dynamique la réponse avant de renvoyer celle-ci sous forme de code HTML au client.

Partie 2

70

La servlet suivante renvoie au client une page HTML qui affiche « Bonjour ». Fichier servlet1.java package testservlet; import java.io.IOException; import java.io.PrintWriter; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class servlet1 extends HttpServlet { protected void doGet( HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { /* obtention de l'ecrivain */ PrintWriter out = response.getWriter(); /* indiquer que le type de sortie dans la réponse doit être interprété en HTML */ response.setContentType("text/html"); /* envoyer du HTML sur le flux de sortie */ out.println ("<h1>Bonjour </h1>"); } } Avant de pouvoir appeler cette servlet, il faut la compiler afin de créer le fichier servlet1.class. Ce fichier servlet1.class peut alors être copié dans l’arborescence du serveur d’application (certaines règles propres aux serveurs d’application sont à respecter). Après avoir mis à jour le fichier web.xml dans la même arborescence, il est alors possible d’appeler la servlet. Fichier web.xml <?xml version="1.0" encoding="ISO-8859-1"?> <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN" "web-app_2_2.dtd"> <web-app> <servlet> <servlet-name>servlet1</servlet-name> <servlet-class>testservlet.servlet1</servlet-class> </servlet> <servlet-mapping> <servlet-name>servlet1</servlet-name> <url-pattern>/servlet1.html</url-pattern> </servlet-mapping> </web-app>

Pour appeler la servlet, si elle a été installée sur Tomcat, il faut taper «http://localhost :8080/ testservlet/servlet1.html » dans le navigateur. Pour développer l’application de prise de rendez-vous, l’utilisation de Struts nous dispense d’avoir à créer des servlets. Nous aurons par contre à créer des pages JSP.

Partie 2

71

3.4.8. Création de pages dynamique en HTML Les JSP (Java Server Page) sont très proches des servlets (elles servent également à créer du contenu Web de manière dynamique), mais en diffèrent par le fait qu’elles sont constituées de code Java inséré dans des documents HTML. Le serveur J2EE compile ces documents pour en faire des servlets qui renvoient aux clients du contenu HTML. Fichier nombres.jsp <%@ page language="java" %> <!DOCTYPE HTML PUBLIC "-//w3c//dtd html 4.0 transitional//en"> <html> <head> <title>Lomboz JSP</title> </head> <body bgcolor="#FFFFFF"> <h1>Nombres de 1 à 10</h1> <% int i; for (i = 1; i <= 10; i++) { out.println(i + "<br>"); } %> </body> </html>

Après avoir créé cette JSP dans l’arborescence du serveur d’application, il est possible de l’appeler à partir du navigateur.

3.4.9. Environnement de développement La lecture du livre HOLZNER (2004) m’a apporté une bonne maîtrise d’Eclipse . Ce livre est très bien écrit et les exemples sont simples et faciles à mettre en œuvre.

Partie 2

72

Eclipse est un environnement de développement très complet, utilisé principalement pour développer en java. Eclipse permet de développer dans d’autres langages en installant les plug-ins adaptés. On peut personnaliser l’interface utilisateur d’Eclipse (Choix des vues à afficher). Par défaut l’affichage est le suivant :

Pour créer le programme Java qui affiche « bonjour » sur la console dont nous avons déjà parlé, voici les étapes à suivre :

� Créer un projet (fichier / nouveau / projet). Le nouveau projet apparaît dans la fenêtre « explorateur de packages » ;

� Créer une classe java et un package (fichier / nouveau / classe) ; � Compléter le code de la classe au centre de l’écran et sauvegarder (fichier /

sauvegarder tout) ; � Compiler (projet / générer tout) ; � Redémarrer Tomcat avec l’icône du plugin sysdeo la plus à droite

; � Lancer l’exécution (Clic droit sur la classe / exécuter en tant que / application

java).

Partie 2

73

Pour passer en mode débogage, il suffit de double cliquer à gauche de la ligne de code sur laquelle on souhaite placer un point d’arrêt puis de lancer l’exécution dans le mode approprié (Clic droit sur la classe / Déboguer en tant que / application java). L’écran suivant est affiché (il permet d’exécuter le programme pas à pas) :

Une fois le débogage terminé, l’utilisateur peut revenir au mode d’affichage classique (fenêtre / ouvrir la perspective / java). Eclipse permet d’utiliser Junit (librairie open source pour les tests unitaires). Vous pouvez créer des classes basées sur l’outil Junit et des classes normales dans le même projet. Le code Junit sert à tester les autres classes du projet. Junit permet de construire un ensemble de jeux de tests. Après chaque modification de code, quelques clics suffisent pour vérifier si l’application passe avec succès les jeux de tests. Dans la classe basée sur JUnit (créée par : Fichier / nouveau / scénario de test Junit) on peut utiliser plusieurs types d’assertion pour effectuer les tests (ex : assertFalse(a) permet de tester si le booléen a est faux). Il est ensuite possible avec un clic droit sur la classe de test de sélectionner l’option « exécuter en tant que / test Junit » pour lancer le test. DJAAFAR (2005) explique que sous Eclipse la gestion du travail en équipe repose sur l’outil CVS (Concurrent Versions System – logiciel open source de gestion de version). Pour travailler avec CVS, il est nécessaire d’avoir accès à un serveur CVS. Sous Windows, c’est couramment CVSNT (disponible gratuitement sur le site http://www.cvsnt.org) qui est utilisé. Après avoir créé un référentiel pour le code source du projet au moyen du serveur CVS et lancé CVSNT Eclipse permet d’ajouter un projet et des sources dans le référentiel CVS. Le référentiel CVS est généralement situé sur un serveur partagé entre tous les développeurs. CVS gère et

Partie 2

74

stocke toutes les modifications effectuées sur un code source en suivant par défaut les règles du verrouillage optimiste. Le verrouillage optimiste autorise différents programmeurs à modifier simultanément un même code source (chacun travaillant sur sa propre version). Les différentes versions sont si possible fusionnées automatiquement lors de la validation des modifications. En cas de conflits, le programmeur est informé et il doit les résoudre manuellement. Ant, dont nous avons déjà parlé, est directement installé et opérationnel dans Eclipse. Ant peut automatiser plusieurs dizaines de tâches qu’il aurait fallu réaliser manuellement. Pour travailler avec Ant il faut créer dans le projet un fichier build.xml. Eclipse reconnaît ce fichier comme un fichier Ant. Le fichier build.xml suivant affiche « Bonjour » sur la console <?xml version="1.0" encoding="ISO-8859-1" ?> <project name="TestAnt" default="Affichermessage"> <target name="Affichermessage"> <echo message = “Bonjour”/> </target> </project> Plusieurs blocs <target> </target> peuvent figurer dans build.xml. Chaque bloc permet de réaliser une action (ex : créer ou détruire un répertoire, compiler l’application, créer un fichier JAR ou WAR, créer la documentation javadoc, déplacer des fichiers, lancer les tests unitaires, …). Les fichiers JAR et WAR sont des conteneurs de fichiers (comme tar ou zip).

3.4.10. Bien concevoir l’architecture globale de l’ application Le design pattern MVC (Modèle Vue Contrôleur) est présenté dans DUBOIS (2006). Ce pattern est communément utilisé dans les applications Java/J2EE pour réaliser la couche de présentation des données. MVC favorise la séparation entre la présentation de l’application, les interactions avec l’utilisateur et des modèles de données. Il existe deux types de patterns MVC, le pattern MVC dit de type 1, qui possède un contrôleur par action, et le pattern MVC dit de type 2, plus récent, qui possède un contrôleur unique. Nous nous concentrerons sur ce dernier, puisque c’est celui sur lequel s’appuie Struts.

Partie 2

75

La figure ci-dessous illustre les différentes entités du type 2 du pattern MVC ainsi que leurs interactions lors du traitement d’une requête.

Figure 22 : Composants du pattern MVC type 2

Les caractéristiques des composants de ce pattern sont les suivantes :

� Modèle : Gestion des données de l’application (lien avec la base de données) ;

� Vue : Présentation des données à l’utilisateur (sorties graphiques et textuelles sur l’écran) ;

� Contrôleur : Comportement de l’application en fonction des actions de l’utilisateur (clavier, souris). Lors de la mise en œuvre du type 2 du pattern MVC, cette partie se compose d’un point d’entrée unique pour toute l’application. Ce point d’entrée unique traite la requête et dirige les traitements vers l’entité Worker appropriée. Le Front Controller est intégré au framework MVC, et seuls les workers sont spécifiques à l’application.

Un framework MVC implémente le contrôleur façade, les mécanismes de gestion du modèle ainsi que ceux de sélection et de construction de la vue. L’utilisateur d’un tel framework a en charge le développement et la configuration des workers. Une application mettant en œuvre le design pattern MVC est généralement mieux structurée et donc plus facile à maintenir. Les données d’un seul modèle peuvent être affichées dans plusieurs vues qui disposent de logiques de présentation différentes.

3.4.11. Un framework basé sur l'approche MVC Struts est un framework de développement apparu en 2000 qui permet de créer des applications web. C'est une solution open source qui implémente le design pattern MVC de type 2. Struts est de loin le framework le plus utilisé pour le développement d’application web J2EE. Il est facile de trouver des sites ou des livres traitant de struts. Struts est particulièrement adapté pour la création de sites ayant une taille conséquente.

Contrôleur

Front Controller

Aiguille les requêtes vers le bon worker

Worker

Réalise le traitement de la

requête

Modèle

Contient les données à présenter

Vue

Construit la vue en affichant les données à

présenter

Partie 2

76

L’utilisation de Struts pour des sites ne comportant que quelques pages alourdit inutilement l’application et n’est donc pas justifiée. Struts facilite la maintenance de l’application et la rend plus évolutive. Plusieurs personnes m’ont découragées de « m’attaquer » à struts. Pour Eric Sarrion (auteur de deux ouvrages cités dans ce mémoire) Struts est une « usine à gaz » et il n’existe pas de bons livres sur le sujet. François Merand (coauteur d’un ouvrage cité dans ce mémoire) a également utilisé le terme d’ « usine à gaz » pour décrire Struts, mais il a ajouté que l’étude de Struts aurait au moins le mérite de me permettre de me familiariser avec le modèle MVC. Il est vrai que l’utilisation de struts n’est pas triviale au premier abord. Après l’avoir pratiqué quelque peu, on finit généralement par acquérir certains réflexes et les choses qui paraissaient embrouillées au départ finissent par devenir claires. Struts n’est justifié que pour des projets d’une certaine taille. Il existe plusieurs livres en français sur struts. J’ai entrepris la lecture de plusieurs d’entre eux en testant une partie des exemples proposés. Vous trouverez en bibliographie les livres consacrés à struts que j’ai consultés. Certains sont assez anciens, d’autres destinés à être utilisés comme aide-mémoire pour des personnes connaissant déjà struts. Parmi ces livres, j’ai étudié en détail ceux de CEKVENICH & GEHNER (2005) et FELICITE (2006) :

� Le premier ne permet pas un apprentissage approfondi de struts car le fonctionnement de ce dernier n’est pas décrit en détail. Cet ouvrage est cependant très intéressant car les auteurs nous font part de leur expérience sur des projets réels et délivrent de nombreux conseils.

� Le deuxième est très récent et recommande l’adoption d’un environnement stable basé sur les dernières versions du JDK et d’Eclipse. Ce livre m’a permis de valider les choix techniques que j’avais effectués précédemment et d’écarter des outils comme Easystruts et MyEclipse.

Easystruts est un plugin Eclipse censé simplifier la création d’applications struts. Les tests que j’ai effectué ne m’ont pas semblé concluant et de plus easystruts n’est pour le moment compatible qu’avec la version 2 d’Eclipse.

Le plugin MyEclipse pour Eclipse semble pouvoir rendre de nombreux services, notamment pour créer des applications struts. Malheureusement il n’est pas gratuit et je ne l’ai donc pas testé moi-même. Dans le cadre d’une utilisation professionnelle, je pense que cet outil est probablement à retenir.

Partie 2

77

Architecture et concepts de struts Struts implémente le pattern MVC de façon classique :

� Modèle : Constitué de JavaBeans standards ; � Vue : Constituée de pages JSP ; � Contrôleur : Constitué de la servlet Struts principale, appelée ActionServlet.

Figure 23 : Struts et le modèle MVC

Dans son implémentation, Struts utilise deux notions principales, qui sont représentées par les classes :

� Action : Représente une action de l’utilisateur, telle que valider une sélection. Cette classe proche du contrôleur sert de liant entre le formulaire envoyé par l’utilisateur, l’exécution de traitements et l’affichage d’une page Web résultant de l’opération. Elle représente le worker introduit à la section précédente.

� Formulaire : Représente un formulaire HTML, tel qu’il a été rempli par l’utilisateur.

L’ensemble formé par les actions, formulaires et JSP est relié via le fichier de configuration de Struts, Struts-config.xml. Toute application Web J2EE doit respecter certaines règles au niveau de son arborescence afin de pouvoir fonctionner sur un serveur d’application. Le répertoire WEB-INF doit figurer dans cette arborescence. Le fichier Struts-config.xml doit être stocké dans ce répertoire.

Partie 2

78

Configuration de Struts Struts se fonde sur une servlet très évoluée pour assurer sa fonction de contrôleur générique. Comme pour toute servlet, il faut la configurer dans le fichier web.xml : (…) <servlet> <servlet-name>action</servlet-name> <servlet-class>org.apache.struts.action.ActionS ervlet</servlet-class> <load-on-startup>2</load-on-startup> </servlet> (…) <servlet-mapping> <servlet-name>action</servlet-name> <url-pattern>*.do</url-pattern> </servlet-mapping> (…)

Cette configuration permet d’envoyer à la servlet ActionServlet de Struts les URL se terminant par *.do. Le fichier struts-config de l’application rendez-vous amputé de certains formulaires et de certaines actions, pour une présentation plus lisible, se présente de la façon suivante : <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" "http://struts.apache.org/dt ds/struts-config_1_2.dtd"> <struts-config> <form-beans > <form-bean name="personneEditForm" type="de.laliluna.library.struts.form.PersonneEditF orm" /> (…) </form-beans> <global-exceptions /> <global-forwards /> <action-mappings > <action attribute="personneEditForm" input="/jsp/MajMonProfil.jsp" name="personneEditForm" parameter="do" path="/MajMonProfil" scope="request" type="de.laliluna.library.struts.action.Ma jMonProfilAction" validate="false"> <forward name="menuClient" path="/jsp/menu Client.jsp" /> <forward name="editPersonne" path="/jsp/Ma jMonProfil.jsp" /> </action> <action attribute="personneEditForm" input="/jsp/MajMonProfil.jsp" name="personneEditForm" parameter="do" path="/SaveMonProfil" scope="request" type="de.laliluna.library.struts.action.Ma jMonProfilAction"

Partie 2

79

validate="true"> <forward name="menuClient" path="/jsp/menu Client.jsp" /> <forward name="editPersonne" path="/jsp/Ma jMonProfil.jsp" /> </action> (…) </action-mappings> <message-resources parameter="de.laliluna.library.struts.ApplicationRe sources" /> <plug-in className="org.apache.struts.validator.V alidatorPlugIn"> <set-property property="pathnames" value="/WEB-INF/validator-rules.xml,/WEB-IN F/validation.xml"/> </plug-in> </struts-config> Ce fichier comporte les grandes parties suivantes :

� <form-bean> : Contient la liste des formulaires Struts. On associe à chaque formulaire, un nom et une classe Java. La classe représente un Javabean.

� <global-exceptions> : Cette partie est facultative. Elle permet de gérer certaines exceptions.

� <global-forwards> : Cette partie est facultative. Elle permet à partir de toutes les actions de pouvoir renvoyer certaines pages en simplifiant le paramétrage dans struts-config.xml.

� <action-mappings> : Cette partie est la plus importante et la plus complexe. Elle permet de lier une URL à une action. Dans notre exemple le menu client permet d’afficher la page de mise à jour du profil de la personne connectée (réalisé avec le lien <html:link action="MajMonProfil.do?do=prepareEdit"> Modifier mon profil</html:link>). L’aiguillage est réalisé dans le fichier struts-config.xml avec l’action dont path="/MajMonProfil". Lorsque l’utilisateur clique sur le bouton pour enregistrer sa saisie, la page est réaffichée si la saisie est incorrecte, sinon, le menu client est affiché. La page de mise à jour du profil contient une instruction (<html:form action="/SaveMonProfil">) qui permet dans le fichier struts-config.xml de savoir quelle action effectuer (celle dont path="/SaveMonProfil"). On peut voir que dans cette action la validation de la saisie est activée (validate="true ) alors qu’elle ne l’est pas dans l’action identifiée par /MajMonProfil.

� <message-resources> : Définit un fichier de propriétés, dans notre cas ApplicationResources.properties. Ce fichier contient les messages utilisés dans les pages JSP et les actions.

Le fichier Struts-config.xml est relativement complexe. Il peut être intéressant d’utiliser un utilitaire (comme Struts Console) pour visualiser son contenu graphiquement. Je n’ai pas testé cette possibilité, mais DUBOIS (2006) la recommande.

Partie 2

80

Actions et formulaires Les actions et les formulaires sont les classes de base utilisées dans Struts. Les actions Struts héritent toutes de la classe Action ou de la classe DispatchAction (il faut utiliser DispatchAction lorsque l’on fait appel à la validation de la saisie à l’aide de validators). Voici un exemple d’action, provenant du projet rendez-vous : package de.laliluna.library.struts.action; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionForward; import org.apache.struts.action.ActionMapping; import org.apache.struts.actions.DispatchAction; import de.laliluna.library.bl.LibraryManager; import de.laliluna.library.struts.form.PersonneEditForm; public class MajMonProfilAction extends DispatchAction { /** Préparer Mise à jour */ public ActionForward prepareEdit(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) { PersonneEditForm personneEditForm = (PersonneEditForm) form; LibraryManager libraryManager = new LibraryManager(); HttpSession s = request.getSession(); String p5="MonId" ; System.out.println("prepareEdit Dans MajMonProfilAction"); String p6 = s.getAttribute(p5).toString(); Integer id = Integer.valueOf(p6); personneEditForm.setPersonne(libraryManager.getPersonneByPrimaryKey (id)); return mapping.findForward("editPersonne "); } /** Sauvegarde */ public ActionForward savePersonne(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) { System.out.println("savePersonne Dans MajMonProfilAction"); PersonneEditForm personneEditForm = (PersonneEditForm) form; LibraryManager libraryManager = new LibraryManager(); libraryManager.savePersonne (personneEditForm.getPersonne()); return mapping.findForward("menuClient "); } }

Cette classe est utilisée par le client lorsqu’il appelle la fonction de mise à jour de son profil à partir du menu client et lorsqu’il valide sa saisie sur l’écran de mise à jour de son profil. Dans les deux cas une méthode de la classe libraryManager est appelée (La classe LibraryManager contient toutes les méthodes nécessitant d’accéder à la base de données). Dans le premier cas la méthode de libraryManager permet de charger dans le formulaire les informations du client à modifier. Dans le deuxième cas la méthode de libraryManager permet de savegarder les éléments saisis dans la base de données. Ces méthodes seront décrites plus en détail dans la partie consacrée à Hibernate. L’objectif de l’action est d’effectuer un traitement, puis de renvoyer l’utilisateur vers une nouvelle page Web. Cette page est représentée par l’objet ActionForward, que retourne l’action.

Partie 2

81

Dans notre exemple, la méthode prepareEdit renvoie sur la page de mise à jour du profil alors que la méthode savePersonne renvoie sur le menu client. Les formulaires Struts sont des JavaBeans standards qui héritent tous de la classe ActionForm ou de la classe ValidatorForm (il faut utiliser ValidatorForm lorsque l’on fait appel à la validation de la saisie à l’aide de validators). Les formulaires Struts correspondent à une page Web. Lors de la validation de la page par l’utilisateur, Struts transforme la requête http envoyée en un objet formulaire que nous pouvons ensuite plus facilement manipuler. Chaque paramètre de la requête http est renseigné dans l’attribut du formulaire qui porte son nom. Voici un exemple de formulaire, provenant du projet rendez-vous : ValidatorForm package de.laliluna.library.struts.form; import java.util.List; import java.util.Set; import javax.servlet.http.HttpServletRequest; import org.apache.struts.action.ActionErrors; import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionMapping; import de.laliluna.library.Personne; import org.apache.struts.validator.ValidatorForm; public class PersonneEditForm extends ValidatorForm { private Personne personne; public Personne getPersonne() { return personne; } public void setPersonne(Personne personne) { this.personne = personne; } public boolean equals(Object rhs) { return personne.equals(rhs); } public String getTelephone() { return personne.getTelephone(); } public Integer getId() { return personne.getId(); } public String getLastname() { return personne.getLastname(); } public String getFirstname() { return personne.getFirstname(); } public String getCourriel() {

Partie 2

82

return personne.getCourriel(); } public void setCourriel(String courriel) { personne.setCourriel(courriel); } public String getLogin() { return personne.getLogin(); } public void setLogin(String login) { personne.setLogin(login); } public String getMotdepasse() { return personne.getMotdepasse(); } public void setMotdepasse(String motdepasse) { personne.setMotdepasse(motdepasse); } public java.lang.Boolean getAdministrateur() { return personne.getAdministrateur(); } public void setAdministrateur(java.lang.Boolean administrateur) { personne.setAdministrateur(administrateur); } public int hashCode() { return personne.hashCode(); } public void setTelephone(String telephone) { personne.setTelephone(telephone); } public void setId(Integer id) { personne.setId(id); } public void setLastname(String lastname) { personne.setLastname(lastname); } public void setFirstname(String firstName) { personne.setFirstname(firstName); } public String toString() { return personne.toString(); } public void reset(ActionMapping mapping, HttpServletRequest request) { personne = new Personne(); } }

Lorsque le client est sur la page de mise à jour de son profil et qu’il clique sur le bouton qui permet d’enregistrer sa saisie, les données présentes sur la page sont

Partie 2

83

transmises aux attributs du formulaire ci-dessus à l’aide des méthodes set (setFirstname, etc.). Nous pouvons ensuite utiliser les méthodes get (getFirstname, etc. ) pour accéder à ces valeurs. Les balises Struts et les pages JSP Les balises Struts évitent l’insertion de code Java dans les pages JSP. Elles ressemblent à des balises HTML. Struts propose en standard de nombreuses balises. Il existe d’autres bibliothèques de balises que celle proposée par Struts (ex : JSLT). La page JSP suivante est extraite du projet rendez-vous : Page MajMonProfil.JSP <%@ page language="java"%> <%@ taglib uri="http://jakarta.apache.org/struts/tags-bean" prefix="bean"%> <%@ taglib uri="http://jakarta.apache.org/struts/tags-html" prefix="html"%> <html> <head> <title>Modifier mon profil - MajMonProfil.jsp </title> </head> <body> <h1>Modifier mon profil</h1> <html:form action="/SaveMonProfil"> <html:hidden property="id"/> <html:hidden property="do" value="savePersonne"/> <html:errors/> <table border="1"> <tbody> <tr> <td> <bean:message key="personne.prenom" /> </td> <td> <html:text property="firstname"/> &nbsp; * <html:errors property="firstname" header="errors.en tete" footer="errors.pied" prefix="" suffix=""/> </td> </tr> <tr> <td> Nom </td> <td> <html:text property="lastname"/> </td> </tr> <tr> <td> T&eacute;l&eacute;phone </td> <td> <html:text property="telephone"/> </td> </tr> <tr> <td> Courriel </td> <td>

Partie 2

84

<html:text property="courriel"/> </td> </tr> <tr> <td> Login </td> <td> <html:text property="login"/> </td> </tr> <tr> <td> Mot de passe </td> <td> <html:text property="motdepasse"/> </td> </tr> </tbody> </table> <br> <html:submit>Valider</html:submit>&nbsp; <html:cancel>Menu</html:cancel> </html:form> </body> </html> Sur cette page, lorsque l’utilisateur clique sur le bouton Valider, L’action à appeler est identifiée dans le fichier struts-config.xml à l’aide du contenu de la balise suivante :

<html:form action="/SaveMonProfil">

Les balises Struts sont très nombreuses et bien documentées par les ouvrages consacrés à Struts.

Partie 2

85

Affichage en plusieurs langues La Balise <bean:message key="personne.prenom" /> permet d’afficher le texte contenu dans le fichier des propriétés à l’aide de la clef personne.prenom. Cette balise permet en utilisant plusieurs fichiers de propriétés, d’afficher les pages d’une application Web dans plusieurs langues. Dans l’application rendez-vous, il existe deux fichiers de propriétés. L’un contient les libellés en français, l’autre les libellés en anglais. Extrait du fichier des propriétés en anglais ApplicationResources_en.properties : # -- Libelles -- personne.prenom=Firstname Extrait du fichier des propriétés en français ApplicationResources_fr.properties : # -- Libelles -- personne.prenom= Pr&eacute;nom Si les règles de nommage des fichiers de propriétés ont été respectées (ex : ajouter « en » devant « .properties » pour le fichier en Anglais), il suffit alors à l’utilisateur d’ajouter et d’ordonner les langues préférées dans les paramètres de son navigateur (ex : menu outil puis langue avec Internet Explorer) pour que l’application s’affiche dans la langue souhaitée. Validation des formulaires Struts offre une solution appelée « Validators » qui permet de valider les données saisies par l’utilisateur sur une page Web. Pour mettre en œuvre cette solution, les fichiers validators-rules.xml et validation.xml doivent être présent dans le répertoire WEB-INF de l’application et contenir les informations de validation existantes dans le projet modèle struts-blank.war fourni avec struts. Le fichier validation.xml doit être complété avec les règles de validation que l’on souhaite mettre en place. Dans le projet rendez-vous, pour rendre obligatoire la saisie du champ prénom sur la page qui permet au client de mettre à jour son profil, les lignes suivantes ont été ajoutées dans validation.xml : <form name="personneEditForm"> <field property="firstname" depends="required" page="0"> <arg key="personne.errors.prenom"/> </field> </form>

Ces lignes rendent obligatoire la saisie de l’attribut firstname du formulaire personneEditForm dont nous avons déjà vu le source (rappel : ActionForm a été remplacé par ValidatorForm dans ce formulaire pour pouvoir utiliser les validators). Le texte du message affiché pour l’utilisateur en cas d’erreur est chargé à partir du fichier des propriétés à l’aide de la clef « personne.errors.prenom ». L’utilisation de

Partie 2

86

plusieurs fichiers de propriétés permet d’afficher le message d’erreur dans la langue attendue. Extrait du fichier des propriétés en anglais ApplicationResources_en.properties : # -- Personne Errors -- personne.errors.prenom=Firstname Extrait du fichier des propriétés en français ApplicationResources_fr.properties : # -- Personne Errors -- personne.errors.prenom=Pr&eacute;nom Pour afficher le message d’erreur dans la page JSP nous avons ajouté le code suivant dans la page MajMonProfil.JSP : (..) <html:errors/> (..) <html:errors property="firstname" header="errors.entete" footer="errors.pied" prefix="" suffix=""/> (..)

Le code complet de cette page a été donné dans les pages précédentes. Le code suivant doit être ajouté dans le fichier Struts-config.xml juste avant la dernière balise : <plug-in className="org.apache.struts.validator.ValidatorPlugIn"> <set-property property="pathnames" value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/> </plug-in>

Partie 2

87

Enfin, pour que la validation soit activée sur le formulaire personneEditForm uniquement lorsqu’il le faut, nous avons déjà vu qu’il fallait utiliser le paramètre validate dans les actions du fichier struts-config.xml. Dans l’exemple ci-dessous, la validation est activée uniquement lorsque l’utilisateur clique sur le bouton d’enregistrement de la page de modification du profil de l’utilisateur courant. Struts-config.xml (..) <action attribute="personneEditForm" input="/jsp/MajMonProfil.jsp" name="personneEditForm " parameter="do" path="/MajMonProfil" scope="request" type="de.laliluna.library.struts.action.MajMonProfilAction" validate="false"> <forward name="menuClient" path="/jsp/menuClient.jsp" /> <forward name="editPersonne" path="/jsp/MajMonProfil.jsp" /> </action> <action attribute="personneEditForm" input="/jsp/MajMonProfil.jsp" name="personneEditForm " parameter="do" path="/SaveMonProfil" scope="request" type="de.laliluna.library.struts.action.MajMonProfilAction" validate="true"> <forward name="menuClient" path="/jsp/menuClient.jsp" /> <forward name="editPersonne" path="/jsp/MajMonProfil.jsp" /> </action> (..)

La méthode de validation présentée ci-dessus s’exécute sur le serveur. Struts propose une autre méthode qui s’appuie sur JavaScript pour effectuer les contrôles coté client. La technologie Tiles Tiles est une technologie de découpage de pages JSP qui s’appuie sur les includes des JSP en les améliorant significativement. En particulier, Tiles permet d’effectuer les tâches suivantes :

� Créer aisément des modèles de pages réutilisables, avec un support de l’héritage entre différents modèles.

� Nommer les pages au lieu de donner leur chemin complet, dans l’esprit des tags <forwards>.

� Réutiliser des composants de présentation, y compris des composants internationalisés.

Afin de montrer le fonctionnement de tiles, nous allons créer un exemple avec une page contenant 4 parties (entête, menu, cœur de page et pied de page) et une autre

Partie 2

88

page identique à la première, mais avec un cœur de page spécifique (le titre de la barre de titre sera également spécifique). Pour rendre possible l’utilisation des taglib de tiles, nous devons commencer par ajouter ce qui suit dans le fichier WEB-INF/web.xml : <taglib> <taglib-uri>/tags/struts-tiles</taglib-uri> <taglib-location>/WEB-INF/struts-tiles.tld</taglib-location> </taglib>

Nous devons également indiquer à la fin du fichier struts-config.xml le nom et l’emplacement du fichier de configuration de tiles : <plug-in className="org.apache.struts.tiles.TilesPlugin"> <set-property property="definitions-config" value="/WEB-INF/tiles-defs.xml "/> <set-property property="moduleAware" value="true" /> </plug-in> Les deux pages appelées à partir du navigateur internet (unepage00.jsp et unepage01.jsp ) sont créées respectivement à l’aide des morceaux de code suivant : <%@ taglib uri="http://jakarta.apache.org/struts/tags-tiles" prefix="tiles" %> <tiles:insert definition="page00" flush="true"/>

<%@ taglib uri="http://jakarta.apache.org/struts/tags-tiles" prefix="tiles" %> <tiles:insert definition="page01" flush="true"/>

La première ligne est identique pour les deux pages et est indispensable pour permettre une interprétation correcte de la balise de la deuxième ligne. La deuxième ligne indique le nom de la page correspondante dans le fichier tiles-defs.xml. Pour notre exemple le fichier tiles-defs.xml contiendra : <?xml version="1.0" encoding="ISO-8859-1" ?> <!DOCTYPE tiles-definitions PUBLIC "-//Apache Software Foundation//DTD Tiles Configuration 1.1//EN" "http://jakarta.apache.org/struts/dtds/tiles-config_1_1.dtd"> <!--Utilisation de Tiles pour l'application rendez-vous--> <tiles-definitions> <definition name="page00 " template="/jsp/myLayout.jsp "> <put name="title " value="Application Rendez-vous" /> <put name="header " value="/jsp/header.jsp" /> <put name="menu " value="/jsp/menu.jsp" /> <put name="footer " value="/jsp/footer.jsp" /> <put name="body " value="/jsp/body.jsp" /> </definition> <definition name="page01 " extends="page00"> <put name="title " value="titre page 1" /> <put name="body " value="/jsp/body01.jsp" /> </definition> </tiles-definitions>

Partie 2

89

La page nommée page00 contient 4 parties et le titre à afficher dans la barre de titre. La page nommée page01 est identique à page00 à l’exception du cœur de la page (body) et du titre (title).Page00 et par extension page01 dépendent du modèle (template en anglais) /jsp/myLayout.jsp dont le code suit : <%@ taglib uri="http://jakarta.apache.org/struts/tags-tiles" prefix="tiles" %> <html> <head> <title><tiles:getAsString name="title "/></title> </head> <body> <table width="100%" border="0" cellspacing="5"> <tr bgcolor="#00CCFF"> <td colspan="2"> <tiles:insert attribute="header "/> </td> </tr> <tr> <td width="140" valign="top" bgcolor="#FFCC99"> <tiles:insert attribute="menu "/> </td> <td valign="top" align="left"> <tiles:insert attribute="body "/> </td> </tr> <tr bgcolor="#CCCCCC"> <td colspan="2"> <tiles:insert attribute="footer "/> </td> </tr> </table> </body> </html>

Ce modèle indique comment créer la page HTML qui doit être montrée à l’utilisateur. Cette page rassemble et met en forme les différentes parties de la page (titre, entête, menu, etc.).

Partie 2

90

Après avoir créé le contenu des pages header.jsp, menu.jsp, body.jsp, body01.jsp et footer.jsp, nous pouvons afficher unepage00.jsp dans le navigateur :

Figure 24 : Page créée avec la technologie tiles

Affichons maintenant unepage01.jsp :

Partie 2

91

Le résultat est identique, à l’exception de la barre de titre et du cœur de la page. Comme précisé dans CEKVENICH (2005), pour une application Struts, il est inutile de créer les pages unepage00.jsp et unepage01.jsp car il est possible d’appeler directement le pages page00 et page01 (noms utilisés dans tiles-defs.xml) à partir du fichier struts-config.xml. <forward name=’’success’’ path=’’page01’’> Une alternative à tiles est SiteMesh. SiteMesh permet d'enrichir la réponse d'une requête HTTP à l'aide de décorateurs. Cet outil permet par exemple de rajouter facilement des en-têtes et des pieds de page sur des pages web. L’avenir de struts Pour rester compétitif face aux nouveaux frameworks MVC (Spring MVC , Tapestry Webwork , etc.), les concepteurs de Struts ont lancé le projet Shale . Shale est un nouveau framework qui intègre des fonctionnalités éprouvées de Struts tout en corrigeant la majorité des problèmes soulevés à l’encontre de Struts (difficultés pour effectuer les tests, gestion insuffisante de la sécurité et des loggings, mauvaise gestion des types autre que string, etc.). Transformer une application Struts en application Shale nécessite des adaptations. La version standard de Struts qui continue à évoluer en assurant une compatibilité ascendante reste cependant de loin la solution MVC la plus utilisée pour java. Pour étendre les possibilités de la partie présentation de Struts, il est fréquent d’utiliser la bibliothèque de tags HTML de JSF (Java Server Faces). Pour DUBOIS (2006) l’accès à la couche métier d’une application peut être rendue plus performante en intégrant Struts à Spring .

3.4.12. Persistance des objets dans une base de don nées relationnelle

DUBOIS (2006) et PATRICIO (2005) rappellent que la principale technologie de persistance utilisée est celle des bases de données relationnelles. Les rares solutions concurrentes, comme les bases de données orientées objet, sont peu utilisées. Le programmeur java est donc contraint de faire cohabiter deux mondes conceptuellement différents, le monde objet et le monde relationnel. Les applications Java s’appuyant sur des bases de données relationnelles sont très souvent lourdes à coder, difficiles à faire évoluer et peu performantes. Des solutions de mapping objet / relationnel (MOR) existent aujourd’hui pour palier à ces problèmes. Ces dernières proposent une couche d’abstraction supérieure à JDBC (Java DataBase Connectivity), sur laquelle elles reposent. JDBC est une API fournie avec Java permettant de développer des applications capables de se connecter à des bases de données relationnelles. Le terme mapping objet / relationnel décrit la technique consistant à faire le lien entre la représentation objet des données et une représentation relationnelle basée sur un schéma SQL.

Partie 2

92

Hibernate étant en ce moment la solution de mapping la plus utilisée dans le monde Java, vous trouverez ci-dessous une présentation de ses concepts fondamentaux. Hibernate est une solution Open Source qui bénéficie d’une documentation abondante. Non seulement, Hibernate s'occupe du transfert des objets Java dans les tables de la base de données (et des types de données Java dans les types de données SQL), mais il permet de requêter les données et propose des moyens de les récupérer. Il peut donc réduire de manière significative le temps de développement qui aurait été autrement perdu dans une manipulation manuelle des données via SQL et JDBC. On peut voir Hibernate comme une fine surcouche de JDBC qui lui ajouterait une dimension objet. Hibernate est surtout utile pour les applications dont la logique métier est implémentée dans la couche Java et non dans des procédures stockées. Les applications qui utilisent Hibernate peuvent facilement migrer vers une autre base de données. Théoriquement il suffit de modifier le fichier de configuration d’hibernate pour remplacer une base de données Oracle par MySQL par exemple. Hibernate utilise des objets persistants (JavaBeans simples) communément appelés POJO (Plain Old Java Object) avec des fichiers de mapping XML pour assurer la persistance d’objets dans une base de données. Avec Hibernate, Il est possible d’utiliser des fonctionnalités objet complexes (héritage, polymorphisme). Hibernate étant un framework très riche, il est impossible de présenter dans ce mémoire toutes les possibilités qu’il offre. Nous nous concentrerons donc uniquement sur les concepts les plus simples et les plus couramment utilisés. L’architecture d’Hibernate peut être représentée de cette manière :

Figure 25 : Architecture d’hibernate

Base de données relationnelle

Fichier de configuration Fichier de mapping

HIBERNATE

Application

Objet persistant

Partie 2

93

Les étapes suivantes présentent hibernate à l’aide du code créé pour le projet rendez-vous. Ajout d’Hibernate dans le projet : Après avoir téléchargé et installé hibernate 3 dans le projet rendez-vous d’eclipse, la bibliothèque hibernate3.jar et quelques autres fichiers jar doivent apparaître dans l’arborescence du projet. Base de données : La base de donnée de l’application rendez-vous sera créée dans MySQL à l’aide des fichiers de mapping d’hibernate. Elle devra contenir une table personnes et une table creneaux . Les rendez-vous pris par une personne seront enregistrés dans une table intermédiaire.

Classes persistantes Pour créer une classe persistante (exemple : la classe personne ) dans le projet rendez-vous, il faut créer un JavaBean personne. Celui-ci contient le type java de tout les attributs de la classe et les méthodes get et set classiques. personne.java : package de.laliluna.library; import ... public class Personne { private java.lang.Integer id; private java.lang.String firstname; private java.lang.String lastname; private java.lang.String courriel; private java.lang.String login; private java.lang.String motdepasse; private java.lang.String telephone; private java.lang.Boolean administrateur; ... public java.lang.Integer getId() { return id; } public void setId(java.lang.Integer id)

Rendez-vous --------------- creneaux_id * person_id *

Personnes ------------- person_id * nom prénom téléphone courriel login motdepasse administrateur

Creneaux ------------- creneaux_id * DateHeureDebut ServiceProposé RdvAutorisé

Partie 2

94

{ this.hashValue = 0; this.id = id; } ... public java.lang.Boolean getAdministrateur() { return this.administrateur; } public void setAdministrateur(java.lang.Boolean administrateur) { this.administrateur = administrateur; } ... } creneaux.java : package de.laliluna.library; import … public class creneaux { … private java.lang.Integer id; private java.util.Date debut; … public java.lang.Integer getId() { return id; } public void setId(java.lang.Integer id) { this.hashValue = 0; this.id = id; } public java.util.Date getDebut() { return this.dateheuredebut; } public void setDebut(java.util.Date debut) { this.debut = debut; } … }

Fichiers de mapping : Il faut ensuite créer pour chaque classe java persistante un fichier de mapping (fichier XML). Celui-ci réalise une correspondance entre une table de la base de données et une classe java (entre les champs de la table personnes et le JavaBean personne par exemple). Le fichier de mapping permet également de décrire les associations (exemple : association many to many entre personnes et creneaux). Plusieurs types d’associations existent dans Hibernate. Les fichiers de mapping sont lus lorsque l’application démarre.

Partie 2

95

Dans l’application de prise de rendez-vous, les fichiers de mapping contiennent les informations suivantes : personne.hbm.xml : <?xml version="1.0" encoding='UTF-8'?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" > <hibernate-mapping package="de.laliluna.library"> <class name="Personne" table="personne"> <id name="id" column="person_id" type="java.lang.Integer"> <generator class="increment"/> </id> <property name="firstname" column="firstname" type="java.lang.String" /> <property name="lastname" column="lastname" type="java.lang.String" /> <property name="telephone" column="telephone" type="java.lang.String" /> <property name="courriel" column="courriel" type="java.lang.String" /> <property name="login" column="login" type="java.lang.String" /> <property name="motdepasse" column="motdepasse" type="java.lang.String" /> <property name="administrateur" column="administrateur" type="java.lang.Boolean" /> <set name="creneaux" table="rendez_vous" > <key column="person_id"/> <many-to-many column="creneau_id" class="Creneau"/> </set> </class> </hibernate-mapping>

creneaux.hbm.xml <?xml version="1.0" encoding='UTF-8'?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" > <hibernate-mapping package="de.laliluna.library"> <class name="Creneau" table="creneau"> <id name="id" column="creneau_id" type="java.lang.Integer"> <generator class="increment"/> </id> <property name="dateheuredebut" column="dateheuredebut" type="timestamp" /> <property name="servicepropose" column="servicepropose" type="java.lang.String" /> <property name="rdvautorise" column="rdvautorise" type="java.lang.Boolean" /> <set name="participants" table="rendez_vous" inverse="true" > <key column="creneau_id"/> <many-to-many column="person_id" class="Personne"/> </set> </class> </hibernate-mapping>

Lorsque les informations à mapper sont nombreuses, le programmeur peut s’appuyer sur des outils pour accélérer la création de ces documents XML (ex : Hibernate Tools est un outil graphique, XDoclet un générateur de code). Pour l’application rendez-vous, les fichiers ont été créés avec un simple éditeur de texte.

Partie 2

96

Configuration d’Hibernate : Pour se connecter à la base de donnée bd_rdv4 de MySQL qui contient les tables de l’application rendez-vous, Hibernate a besoin d’informations de connexion. Ces connexions sont établies à travers un pool de connexions JDBC, que nous devons aussi configurer. Cette configuration est réalisée à l’aide du fichier hibernate.cfg.xml qui pour l’application rendez-vous contient les informations suivantes : <?xml version='1.0' encoding='utf-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <property name="connection.url">jdbc:mysql://localhost/bd_rdv4 </property> <property name="connection.username">root </property> <property name="connection.password"></property> <property name="connection.driver_class">com.mysql.jdbc.Driver </property> <property name="dialect">org.hibernate.dialect.MySQLDialect </property> <property name="connection.pool_size">1</property> <property name="current_session_context_class">thread</property> <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property> <property name="show_sql">true</property> <!-- <property name="hbm2ddl.auto">create </property> --> <mapping resource="de/laliluna/library/Creneau.hbm.xml" /> <mapping resource="de/laliluna/library/Personne.hbm.xml" /> </session-factory> </hibernate-configuration> La configuration ci-dessus permet à hibernate de se connecter avec le profil root sans mot de passe. L'option hbm2ddl.auto active la génération automatique des schémas de base de données (création automatique de la base à partir des fichiers de mapping). Dans le fichier xml ci-dessus, cette option est mise en commentaire pour être utilisée uniquement si nécessaire et éviter la destruction accidentelle des jeux de test. Session Hibernate : Pour accéder aux données de la base à l’aide d’hibernate, l’application rendez-vous doit premièrement récupérer une session Hibernate. Cette dernière est l’interface principale entre l’application java et Hibernate et correspond à une unité de travail. La classe HibernateSessionFactory.java dont le code est listé plus loin permet à l’application rendez-vous de créer une session hibernate (ou de la clôturer) en lisant le fichier de configuration hibernate hibernate.cfg.xml. Après la création d’une transaction, l’application peut utiliser les objets persistant java et utiliser la session pour rendre des objets persistants. package de.laliluna.library; import org.hibernate.HibernateException; import org.hibernate.Session; import org.hibernate.cfg.Configuration; public class HibernateSessionFactory { private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";

Partie 2

97

private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>(); private static final Configuration cfg = new Configuration(); private static org.hibernate.SessionFactory sessionFactory; public static Session currentSession() throws HibernateException { Session session = (Session) threadLocal.get(); if (session != null && ! session.isOpen()) session = null; if (session == null) { if (sessionFactory == null) { try { cfg.configure(CONFIG_FILE_LOCATION); sessionFactory = cfg.buildSessionFactory(); } catch (Exception e) { System.err.println("%%%% Error Creating SessionFactory %%%%"); e.printStackTrace(); } } session = sessionFactory.openSession(); threadLocal.set(session); } return session; } public static void closeSession() throws HibernateException { Session session = (Session) threadLocal.get(); threadLocal.set(null); if (session != null) { session.close(); } } private HibernateSessionFactory() { } } Charger et stocker des objets : Hibernate propose plusieurs techniques de récupération d’objets :

• HQL (Hibernate Query Language), un puissant langage de requête orienté objet ;

• L’API Criteria (non étudiée dans ce mémoire) ; • Le mapping de résultats de requêtes en SQL natif aussi appelé SQLQuery

(dans cette technique, les objets sont chargés depuis le résultat d’une requête écrite en SQL. Ceci est surtout utilisé pour introduire hibernate au sein d’une application déjà existante afin d’éviter la réécriture des requêtes SQL. Cette technique est moins intéressante en ce qui concerne la portabilité de l’application vers une autre base de données).

Le HQL est le moyen le plus utilisé. Il consiste en une encapsulation du SQL selon une logique orientée objet et permet de créer des requêtes complexes. Les requêtes HQL s’utilisent directement dans le code Java, elles s’appuient sur les noms des objets Java, mais leur syntaxe reste malgré tout très proche du SQL.

Partie 2

98

Dans l’application rendez-vous la classe LibraryManager.java listée en partie ci-dessous contient toutes les méthodes d’accès aux données. package de.laliluna.library.bl; import ... import de.laliluna.library.Creneau; import de.laliluna.library.Personne; import de.laliluna.library.HibernateSessionFactory; public class LibraryManager { ... public void savePersonne (Personne personne) { Session session = null; Transaction tx = null; session = HibernateSessionFactory.currentSession(); tx = session.beginTransaction(); if (personne.getId() == null || personne.getId().intValue() == 0) session.save(personne); else { Personne toBeUpdated = (Personne) session.get(Personne.class, personne.getId()); toBeUpdated.setTelephone(personne.getTelephone()); toBeUpdated.setLastname(personne.getLastname()); toBeUpdated.setFirstname(personne.getFirstname()); toBeUpdated.setCourriel(personne.getCourriel()); toBeUpdated.setLogin(personne.getLogin()); toBeUpdated.setMotdepasse(personne.getMotdepasse()); toBeUpdated.setAdministrateur(personne.getAdministrateur()); session.update(toBeUpdated); } tx.commit(); } ...

public Personne[] getAllPersonnes () { List personnes = new ArrayList(); Session session = null; Transaction tx = null; session = HibernateSessionFactory.currentSession(); tx = session.beginTransaction(); List tmpPersonne = session.createQuery ( "select c from Personne as c order by c.lastname ").list(); for (Iterator iter = tmpPersonne.iterator(); iter.hasNext();) { personnes.add((Personne) iter.next()); } tx.commit(); return (Personne[]) personnes.toArray(new Personne[0]); } … } La méthode savePersonne permet d’ajouter une personne dans la table de même nom. La méthode getAllPersonnes utilise une requête HQL (Hibernate Query Language) pour lister toutes les personnes présentes dans la table personne.

Partie 2

99

3.4.13. Tracer une application Java Pour MOLIERE (2005), Log4J (Log for Java) est une API de journalisation open source couramment utilisée dans le monde Java (téléchargeable sur http://logging.apache.org/ log4j/docs/download.html). Log4j s’appuie sur un fichier de configuration (généralement appelé log4j.properties) pouvant contenir les lignes suivantes : log4j.rootLogger=DEBUG, A log4j.appender.A=org.apache.log4j.ConsoleAppender log4j.appender.A.layout=org.apache.log4j.PatternLayout log4j.appender.A.layout.ConversionPattern=%d %-5p - %m%n

Les messages sont classés par niveau de gravité (DEBUG, INFO, WARN, ERROR, et FATAL). La première ligne du fichier de configuration présenté ci-dessus indique que les messages de niveau DEBUG et supérieurs seront ajoutés à la log. Cette option est souvent utilisée pendant la phase de développement. Lors de la mise en production de l’application, la première ligne pourra être modifiée pour indiquer que l’on ne souhaite afficher dans la log que les messages de niveau WARN et supérieurs. Sur la deuxième ligne « ConsoleAppender » indique que les messages seront affichés sur la console. Nous aurions pu diriger les messages vers un fichier. La troisième et la quatrième ligne permettent de définir le format d’affichage des messages (date et heure, niveau sur 5 caractères, un tiret, le message, un retour chariot). Les lignes suivantes peuvent être ajoutées dans l’application pour vérifier le fonctionnement de log4j : import org.apache.log4j.*; … Logger log = Logger.getLogger(…) ; … log.debug("Premier message"); … log.info("Deuxieme message"); …

Lors de l’exécution de cette portion de code, le résultat sur la console est le suivant : 2006-10-25 10:00:01,511 DEBUG - Premier message 2006-10-25 10:01:001,111 INFO - Deuxieme message

Si nous remplaçons DEBUG par INFO dans le fichier de configuration, seule la deuxième ligne apparaît sur la console.

Partie 2

100

3.5. Présentation de l’application rendez-vous réal isée Présentation de l’application créée Vous trouvez ci-dessous une représentation graphique des règles de navigation puis les images écran des principales fonctions de l'application de prise de rendez-vous développée avec struts et hibernate. L’application rendez-vous permet la navigation suivante :

Figure 26 : Règles de navigation

Les images ont été nommées de la façon suivante :

• P01 : Page d'accueil • P02 : Page de Login • P03 : Menu administrateur • P04 : Identification incorrecte • P05 : Menu client • P06 : Gestion des créneaux • P07 : Nouveau créneau • P08 : Associer un client

• P09 : Modifier créneau • P10 : Gestion personnes • P11 : Ajouter / Modifier personne • P12 : Prendre un rendez-vous (1/2) • P13 : Prendre un rendez-vous (2/2) • P14 : Mes rendez-vous • P15 : Modifier mon profil

Partie 2

101

P01 : Page d'accueil

P02 : Page de Login

P03 : Menu administrateur

P04 : Identification incorrecte

Partie 2

102

P05 : Menu client

P06 : Gestion des créneaux

P07 : Nouveau créneau

Partie 2

103

P08 : Associer un client

P09 : Modifier créneau

P10 : Gestion personnes

Partie 2

104

P11 : Ajouter / Modifier personne

P12 : Prendre un rendez-vous (1/2)

P13 : Prendre un rendez-vous (2/2)

Partie 2

105

P14 : Mes rendez-vous

P15 : Modifier mon profil

3.6. Conclusion Etudier et mettre en œuvre les technologies J2EE en étant livré à moi même aura été un véritable chalenge. Il est en effet nécessaire de maîtriser de nombreux outils et d’éviter de se disperser tant il en existe. Je pense avoir atteint les objectifs que je m’étais fixés car j’ai réussi à créer une application J2EE et beaucoup de notions qui me paraissaient obscures, avant de débuter ce travail, me sont aujourd’hui familières. Cela ne se sera cependant pas fait sans difficultés, car même s’il existe de très bons ouvrages sur le domaine, il m’est arrivé fréquemment de rester bloqué sur des problèmes qu’un développeur confirmé contourne rapidement pour y avoir déjà été confronté. Avec l’aide des auteurs, d’internautes ou de recherches approfondies je suis toujours parvenu à résoudre les problèmes rencontrés. Je dois avouer être cependant impatient de travailler à nouveau en équipe pour le plaisir et l’efficacité que cela apporte.

106

4. CONCLUSION La panoplie du parfait développeur d’application J2EE est aujourd’hui mature. Les outils Open Source étudiés donnent de bons résultats. Il est cependant important de garder à l’esprit que la gratuité des licences n’entraîne pas nécessairement une réduction du coût des applications développées et qu’il reste indispensable de bien former et encadrer l’équipe de développement en appliquant des méthodes adaptées. J2EE connaît aujourd’hui un franc succès pour le développement d’applications web notamment dans les grandes entreprises. Il reste cependant encore une place pour des solutions qui permettrons de simplifier et d’industrialiser le processus de développement, pour permettre de développer ou faire évoluer toujours plus vite des applications dont le cycle de vie se raccourcit, alors que leur complexité augmente. La solution se trouve peut-être en partie dans l’utilisation de nouveaux frameworks (JSF, Spring, …) ou langages (RoR) Open Source. Ou pourquoi pas, dans l’utilisation de solutions intégrées comme Visual Studio Team System de Microsoft qui couvre tout le cycle de vie des logiciels et s'adresse à l'équipe de développement toute entière (chefs de projets, architecte, développeurs et testeurs). L’offshore va t-il se développer ? On le voit, l’histoire de l’informatique n’est pas prête de s’arrêter et il est important de rester informé sur ce que propose le marché pour rester concurrentiel. Ce mémoire m’aura permis d’acquérir une vision plus claire sur le développement d’applications web avec J2EE et de mieux appréhender les problèmes que peut rencontrer un développeur. Bien des domaines restent à étudier. Ce n’est donc pas la fin.

107

5. GLOSSAIRE Acube Acube ou A 3 est le nom de la filière de développement J2EE au

MAE Application web

Application à laquelle on accède avec un simple navigateur

CCTP Cahier des Clauses Techniques Particulières CMMI CMMI (Capability Maturity Model Intégration) est un modèle

d'évaluation des processus de conception d'un logiciel. CRASIC Centres Régionaux d’Assistance des Systèmes d’information et de

Communication (Ministère des affaires étrangères) CXI Service des Systèmes d’information et de Communication du

ministère des affaires étrangères DC Département des applications diplomatiques et consulaires rattaché

à PSI (Ministère des affaires étrangères) Design Pattern

Un design pattern est la description d’une solution classique à un problème récurrent, que l’on peut rencontrer généralement à un niveau conceptuel, architectural ou technique. En adaptant un design pattern au contexte d’un projet il est possible de bénéficier de l’expérience d’experts et donc d’améliorer la qualité ou la maintenabilité d’une application.

Framework Bibliothèque de classes fournissant une ossature générale pour le développement d'une application (ex : Struts est un exemple de framework en Open Source, basé sur l'architecture MVC).

Hibernate Hibernate est un framework open source gérant la persistance des objets en base de données relationnelle.

J2EE J2EE (Java 2 Entreprise Edition) est une norme qui définit une infrastructure pour l’exécution des applications java et les API des services utilisés pour concevoir ces applications.

MAE Ministère des affaires étrangères MVC (Model View Controller)

Ce pattern architectural est recommandé pour la conception des applications web dynamiques. Il propose d’organiser l’application en 3 couches séparées. Le but est de séparer, lors de la conception, l’accès à la base de données (M), la partie visible par l’utilisateur (V) et la distribution des requêtes aux composants appropriés en fonction de la logique de l’application (C).

Open Source FONTAINE (2003) donne une définition précise des logiciels Open Source en s’appuyant sur celle donnée par les membres de la FSF (Free Software Foundation). Nous retiendrons que les logiciels Open Source doivent être distribués gratuitement et que le code source complet doit être disponible. Enfin il est possible de modifier un logiciel Open Source, de distribuer la version modifiée et de l’exécuter pour n'importe quel usage.

Poste Agence consulaire ou Ambassade ou Antenne consulaire ou Consulat général (poste consulaire) au Ministère des affaires étrangères

PSI Division Projets du Système d’information du Ministère des affaires

108

étrangères Racine Ensemble des applications du MAE permettant de gérer les services

offerts aux français à l’étranger. RMV2 Application du MAE permettant de gérer les demandes de visa

émanant des étrangers souhaitant venir en France. RUP RUP (Rational Unified Process) est l’une des plus célèbres

implémentations de la méthode UP. Struts Struts est un Framework Open Source utilisé pour développer des

applications WEB J2EE. Il s’agit d’un squelette d’application s’appuyant sur le MVC et fournissant des outils supplémentaires pour aider le développeur à réaliser ses applications.

UP Le Processus Unifié (UP) est un processus de développement logiciel « itératif et incrémental, centré sur l’architecture, conduit par les cas d’utilisation et piloté par les risques ».

URL Une URL (Uniform Resource Locator) est l’adresse d’une ressource sur Internet. Pour une page par exemple, son url est composée du protocole http:// suivi du nom de domaine du serveur, puis du chemin d’accès à la page.

Visanet Projet Acube permettant d'externaliser la saisie de certaines demandes de visa.

XP L'Extreme Programming (XP) est une méthode agile de gestion de projet informatique adaptée aux équipes réduites avec des besoins changeants. Elle pousse à l'extrême des principes simples.

109

6. BIBLIOGRAPHIE BENARD J.L., BOSSAVIT L., 2002. Gestion de projet eXtreme Programming,

Eyrolles, Paris, 316 p.

BENARD J.L., MERAND F., 2005. Approches pragmatiques pour industrialiser le développement d’applications, BrainSonic, Paris, 88 p.

BORDAGE F., DAVY P., PARPINELLI S., 2005, MySQL aux trousses des géants du SGBD, 01 informatique du 21/10/2005, 6-8.

CEKVENICH V., GEHNER W., 2005. Struts, Dunod, Paris, 219 p.

CLAVEL G., 2003. Java la synthèse, Dunod, Liège, 403 p.

CLOUX P.Y., DOUSSOT D., 2002. Technologies et architectures Internet, Dunod, Paris, 254 p.

CLOUX P.Y., 2003. RUP XP, Dunod, Paris, 277 p.

DJAAFAR K., 2005. Eclipse et Jboss : Développement d’applications J2EE professionnelles, de la conception au déploiement, Eyrolles, Paris, 627 p.

DUBOIS J., 2006. Spring par la pratique, Eyrolles, Paris, 517 p.

FELICITE J.C., 2006. Développement java sous struts, Eni éditions, Nantes, 415 p.

FONTAINE A., 2003. Développement open source avec Windows, Dunod, Paris, 320 p.

GOODWILL J., 2003. Jakarta Struts par la pratique, Eyrolles, Paris, 330 p.

HOLZNER S., 2004. Eclipse, O’Reilly, Paris, 324 p.

HUBBARD J., 2005. Programmation java, EdiScience, Baume les dames, 388 p.

LANCKER L.V., 2003. HTML Entraînez-vous à maîtriser le code source, Eni éditions, Nantes, 295 p.

MANGOLD P., 2005. Gestion de projet informatique, Eyrolles, Marsat, 120 p

MOLIERE J., 2005. J2EE, Eyrolles, Paris, 220 p

PATRICIO A., 2005. Hibernate 3.0, Eyrolles, Paris, 317 p.

RAIBLE M., 2005. Spring live, SourceBeat, 13-57, http://www.sourcebeat.com/TitleAction.do?id=7

RETAILLE J.P., 2005. Refactoring des applications Java/J2EE, Eyrolles, Paris, 390 p.

ROQUES P., 2002. UML - Modéliser un site e-commerce, Eyrolles. Paris, 152 P.

ROQUES P., VALLEE F., 2004. UML 2 en action de l’analyse des besoins à la conception J2EE, Eyrolles, Paris, 385 p.

SARRION E., 2005a. CSS et JavaScript, O’Reilly, Paris, 305 p.

SARRION E., 2005b. J2EE, O’Reilly, Paris, 235 p.

TURNER J., BEDELL K., 2003. Struts, CampusPress, Paris, 407 p.

ZELLER A., KRINKE J., 2005. Essential open source toolset, Wiley, Heidelberg, 392 p.

110

7. ANNEXES Les outils présentés ci-dessous ont été testés sous Windows XP durant mon mémoire et peuvent être utiles pour développer une application J2EE.

7.1. Filezilla FileZilla est un logiciel open source permettant de se connecter à distance (en FTP) sur un serveur pour y télécharger des fichiers. http://filezilla.sourceforge.net/

7.2. GIMP Le logiciel GIMP est un puissant outil de manipulation d'images. C'est un logiciel libre et gratuit, développé par la communauté du logiciel libre. Ses spécialités vont de la retouche de photographies numériques à la création d'images. http://gimp-win.sourceforge.net/stable.html

7.3. Irfanview Irfanview = outil de retouche d'image gratuit (pour retouches ultra rapide *) Ce logiciel de retouche d’images gratuit ne permet pas de tout faire (dessiner, faire des dégradés, ...) mais il est très pratique pour changer la dimension d'une image, recadrer une image, changer le type de fichier " image ", corriger les couleurs d'une image. http://info.sio2.be/divers/irfanview/index.php

7.4. JarsBrowser 3.0 Cet outil gratuit permet de trouver dans un ensemble de fichiers jar ou war celui qui contient une classe donnée. http://cmarton.free.fr/jarsbrowser/

7.5. FreeDiff FreeDiff est un logiciel gratuit qui permet de visualiser les différences entre deux fichiers.

111

http://www.freediff.com/

7.6. JDecompiler Cet utilitaire permet de décompiler une classe java (création du fichier d'extension java à partir de celui d'extension class). Il est utilisable pendant 15 jours gratuitement. Il existe des équivalents comme JCavaj (gratuit) ou DJ Java Decompiler (10 essais gratuits). http://www.shareup.com/JDecompiler-download-43149.html

OLLIVIER Philippe Participation à la conception d’une application J2EE d’entreprise. Développement d’une application web de prise de rendez-vous avec les frameworks Struts et Hibernate

Mémoire d’ingénieur C.N.A.M., Nantes 2006

RÉSUMÉ Aujourd’hui, les concepteurs d’applications estampillées « nouvelles technologies » à base de serveur d’application, sont confrontés à ce que le Gartner Group nomme « l’explosion de la complexité ». Les développeurs doivent avoir recours à un panel d’outils et de technologies toujours plus larges. Mon objectif lors du choix du sujet de mon mémoire était de participer au développement d’une application J2EE en m’intéressant aux aspects fonctionnels et organisationnels mais également techniques. Ce mémoire CNAM a été réalisé en deux phases. La première phase (4 mois) s’est déroulée au MAE à Nantes. Elle m’a permis de réaliser une étude et de participer à l’écriture du cahier des charges ainsi qu’à l’élaboration d’une maquette pour une application de gestion des rendez-vous. La seconde phase (5 mois ½) réalisée à l’école polytechnique de l’université de Nantes m’a permis de me former aux technologies J2EE et de développer une application simplifiée de gestion des rendez-vous. De plus en plus d’applications informatiques sont développées avec des technologies N-tiers. Devant le nombre important d’outils disponibles sur le marché (libres ou non) pouvant être utilisés pour développer des applications de ce type, les entreprises doivent aujourd’hui adopter une stratégie claire. Le Ministère des affaires étrangères a créé une filière de développement Acube en 2004 avec pour objectif de définir les outils, les méthodes et les normes à appliquer, lors des développements faisant appel à la technologie J2EE. La première partie de ce mémoire présente ces notions et explique comment le projet rendez-vous du MAE a été conduit. La deuxième partie de ce mémoire présente la démarche que j’ai adoptée pour développer seul une application J2EE s’appuyant sur les frameworks struts et hibernate : définition de l’architecture, formation sur les outils retenus, cahier des charges de l’application rendez-vous et présentation de l’application développée. Mots-clefs : J2EE, MVC, UP, UML, XML, Normes, Méthodes, Outils, Java, HTML, Struts, Hibernate, application Web, Open Source