Génie logiciel. Intranet Ressources Humaines. Dossier de conception. François COJEAN Alexandre JARNOUX EPSI CSII 2 1

Transcription

1 Génielogiciel IntranetRessources Humaines Dossierdeconception AlexandreJARNOUX EPSI CSII2 1

2 Sommaire 1.Lesgrandschoixd architecture LeframeworkSpring:Lesgrandsconcepts IntroductionàSpring Ledesignpattern:InversionOfControlIOC) Lefichierdeconfiguration ArchitectureMVCavecSpring MVC Pagesimple Pageavecformulaireetvalidationdedonnées AccèsauxdonnéesavecJPAencapsuléparSpring Créationd'unEJBentity LacoucheDAODataAccessObject) Lacoucheservice Architecturephysique Diagrammededéploiement Architectureinterne Descriptiongénériquedespackages Schémadelabasededonnées Modèlelogiquedesdonnées ScriptSQLdecréationdelabase Lesfonctionnementsgénériques Listerdeséléments Ajouterunélément Modifierunélément Supprimerunélément...37 AlexandreJARNOUX EPSI CSII2 2

3 1.Lesgrandschoixd architecture 1.1.LeframeworkSpring:Lesgrandsconcepts IntroductionàSpring ToutepersonneayantabordéledéveloppementJEEdansuneapplicationn tierss'estvite rendu compte de la rapide complexité de ce genre de développement. Le jonglage permanent entre les différentes technologies, telles que servlet, conteneur d'application, EJB, contexte de persistence,jsp,...,nerendpaslaviefacileauprogrammeur. LebutduframeworkSpringestdesimplifierlavieduprogrammeurJEE,enapportantun framework open source, spécialisé pour le développement d'applications 3 tiers et simple à utiliser.uneautregrandequalitédespringestd'êtrenonimmersif.springsedéfinitcommeun conteneur dit "léger". Il se compose d'une infrastructure similaire à celle d'un conteneur d'applications. Il prend donc en charge la création d'objets et la mise en relation d'objets par l'intermédiaired'unfichierdeconfigurationquidécritlesobjetsàfabriqueretlesrelationsde dépendances entre ces objets. Le gros avantage par rapport aux serveurs d'applications est qu'avecspring,lesclassescréées,n'ontpasbesoind'implémenterunequelconqueinterfacepour êtreprisesenchargeparleframework. Pourarriveràcerésultat,Springreposesurtroisconcepts: LedesignpatternInversiondecontrôleIOC:InversionOfControl) LaprogrammationorientéaspectPOA) Une couche d'abstraction permettant l'intégration aisée d'autres framework dans le framework. Spring agit un peu à la manière d'un chef d'orchestre dans le projet en permettant d'encadrer,decontrôleretdefairecohabiterlesdifférentescoucheslogiciellesd'uneapplication JEE Ledesignpattern:InversionOfControlIOC) L'inversion de contrôle repose sur le principe que l'application n'appelle pas le framework mais que le framework appelle l'application. Le framework devient donc le chef d'orchestreetencadrecomplètementl'application. LeframeworkSpringestbâtisurceconcept.Etnotammentsurledesignpatterndérivé de l'inversion de contrôle qui est l'injection de dépendances. Il s'agit de diminuer les dépendancesentrelesobjets. Prenonsunexempleconcret: Imaginons que l'on conçoit un objet voiture de type Voiture. Cette voiture dépend d'un objetklaxondetypeklaxon. Dans la pratique pour construire notre voiture, on n'aura pas toujours un Klaxon à disposition.l'idéedel'injectiondedépendancesestd'avoiruneusineàpièceprêteafournirdes objets de type Klaxon pour être injecter dans notre objet de type Voiture. Il est possible d'injecterlesobjetsàl'instanciationd'unobjetougrâceàunmodificateurgetter,setter). AlexandreJARNOUX EPSI CSII2 3

4 Springmetàdispositioncemécanismedefabriqued'objets.Lesobjetssontsoitdetype singletonuneseuleetmêmeinstancedanstoutel'application),soitdetypeprototypemultiple instancesdansl'application).cettefabriqued'objetestdécritesouslaformed'unouplusieurs fichiersxml,chargésparleframeworkaudémarragedel'application.danslasuitedudocument onappelleracefichier:lefichierdeconfigurationdespring Lefichierdeconfiguration VoyonsàquoiressembleunexempletrèssimpledefichierdeconfigurationpourSpring, surnotreexempleprécédent:lavoiture. <beans> <bean id="klaxon" class="klaxon" scope="prototype" /> <bean id="voiture" class="voiture" scope="prototype" <property name="leklaxon" ref="klaxon" /> <bean/> </beans> Spring,configuréaveclefichierprécédent,seraitenmesured'injecteruneinstanced'un objet de type Klaxon dans la propriété leklaxon, ce dans un objet de type Voiture dont l applicationauraitbesoin. LaclasseVoitureressembleraitàquelquechoseprochedececi: class Voiture { private Klaxon leklaxon; public Klaxon getleklaxon) { return this.leklaxon; public void setleklaxonklanxon k) { this.leklaxon = k Spring, à l'aide du modificateur sur l'attribut leklaxon de la classe Voiture et de la fabrique d'objet qu'il met à disposition, est en mesure d'injecter directement un objet de type Klaxon dans une instance de Voiture. Ce concept d'injection de dépendance peut-être mis en pratique sur énormément de cas pratique, et montre notamment sa puissance sur les objets qui doivent exister dans l'application sous la forme de singleton. Ainsi, le code source de l'application sera complètement débarrassé des fioritures qui le rendent compliqué et se résumera simplement à récupérer le singleton à partir de la fabrique d'objet de Spring. Dans une application 3-tiers MVC), le fichier de configuration de Spring rassemble : Les références aux actions Classe implémentant Controller) soumises au contrôleur. Les références aux objets de service accédant à la couche métier de l'application. Les références aux objets DAO accédant directement à la couche métier de l'application. Les références aux objets permettant l'accès aux sources de données de l'application. Les références aux objets permettant l'accès à la couche de persistance de l'application. Les références aux objets permettant d'automatiser la gestion des transactions de la couche de persistance. Et plus généralement, les références aux objets devant être gérés par Spring. AlexandreJARNOUX EPSI CSII2 4

5 La configuration de Spring peut être repartie dans plusieurs fichiers XML. Dans notre projet, la configuration de la couche MVC du projet se trouve dans le fichier '/WEB- INF/spring-servlet.xml' alors que la configuration de la couche applicative se trouve dans le fichier '/WEB-INF/applicationContext.xml'. AlexandreJARNOUX EPSI CSII2 5

6 1.2.ArchitectureMVCavecSpring MVC Pagesimple Figure : Cheminement d'une requête HTTP d'accès à une page simple dans l'architecture MVC Commentaires des étapes numérotées : 1) Le navigateur du client envoie une requête HTTP pour accéder à une page nommée 'helloworld.htm'. L'adresseHTTPdemandéeestlasuivante:' 2) Le serveur web Apache Tomcat) reçoit la requête HTTP et passe la main à la servlet désignéecommecontrôleurprincipaldanslefichier'/web INF/web.xml'. Extraitdufichier'/WEB INF/web.xml': <-- La servlet repond aux requete HTTP se terminant par.htm --> <servlet-mapping> <servlet-name>spring</servlet-name> <url-pattern>*.htm</url-pattern> </servlet-mapping> <-- La servlet principale est de type DispatcherServlet --> <servlet> <servlet-name>spring</servlet-name> <servlet-class>org.springframework.web.servlet.dispatcherservlet </servlet-class> <load-on-startup>1</load-on-startup> </servlet> Ici,laservletdésignéeestlaclasseDispatcherServletfourniparleframeworkSpring. AlexandreJARNOUX EPSI CSII2 6

7 Le contrôleur principal analyse URL de la requête HTTP et découpe la partie finale : 'helloworld.htm'. A partir du fichier de configuration de Spring, il va instancier la classe implémentantl'interfacecontrollerassociéàcetteaction. Extraitdufichier'/WEB INF/spring servlet.xml': <!-- couches MVC --> <bean name="/helloworld.htm" class="helloworldcontroller"> Le controleur principal va automatiquement appeler la méthode handlerequest), définie dans l'interface Controller de Spring, de la classe HelloWorldController. 3) L'instance de la classe HelloWorldController va si nécessaire faire appel à la couche service pour récupérer des données dans la couche métier. 4) La couche service fait appel à la couche DAO. 5) La couche DAO accède à la source de données et récupère les données demandées. 6) La source de données renvoie les données demandées à la couche DAO. 7) La couche DAO renvoie les données demandées à la couche service. 8) La couche service renvoie les données demandées à l'instance de la classe HelloWorldControler. 9) L'instance de la classe HelloWorldController prépare la vue. Elle instancie un objet implémentant l'interface ModelAndView. Elle y insere les données précédement récupérées dans le modèle et renvoie cet objet au contrôleur principal. Celui-ci appelle automatiquement la méthode render) de l'instance de ModelAndView. 10) Le viewresolver définit dans le fichier de configuration de Spring va ensuite renvoyer la page JSP approprié avec les données du modéle. Extrait du fichier '/WEB-INF/spring-servlet.xml' : <-- Resolveur de vue --> <bean id="viewresolver" class="org.springframework.web.servlet.view.internalresourceviewresolver"> <property name="viewclass" value="org.springframework.web.servlet.view.jstlview"/> <property name="prefix" value="/web-inf/jsp/"/> <property name="suffix" value=".jsp"/> </bean> Avec cette configuration, le resolveur de vue, va automatiquement renvoyer la JstlView présente dans le fichier '/WEB-INF/jsp/helloworld.jsp' à l'aide du préfixe et du suffixe définit dans la configuration XML. 11) Le navigateur du client interprète le code JSP et affiche la page JSP helloworld.jsp. Pour le client, tout est transparent et l'adresse dans la barre d'adresse de son navigateur est toujours ' AlexandreJARNOUX EPSI CSII2 7

8 1.2.2.Pageavecformulaireetvalidationdedonnées Le framework Spring met à disposition plusieurs types de contrôleurs spécialement dédiés pour la gestion des formulaires. Ils permettent d'injecter et de contrôler les données du formulaire avant et après sa soumission. Un mécanisme de validation des champs est aussi disponible et permet d'afficher les erreurs de saisie sur le formulaire. Nous allons illustrer le fonctionnement de ces mécanismes sur l'exemple d'un formulaire d'authentification avec gestion de validation des données saisies. Figure : Cheminement d'une requête HTTP d'accès à une page avec un formulaire et validation des données dans l'architecture MVC. Commentaires des étapes numérotées : 1) L'URL appelée par le navigateur client est ' 2) Le serveur web Apache Tomcat) reçoit la requête HTTP et passe la main à la servlet désignée comme contrôleur principal Spring RequestDispatcher) dans le fichier '/WEB-INF/web.xml'. Le contrôleur principal analyse URL de la requête HTTP et découpe la partie finale : 'identification.htm'. A partir du fichier de configuration de Spring, il va instancier la classe implémentant l'interface Controller associée à cette action. Extrait du fichier '/WEB-INF/spring-servlet.xml' : <!-- Controllers --> <bean name="/identification.htm" class="identificationcontroller"> <property name="commandclass" value="utilisateur" /> <property name="formview" value="identification" /> <property name="successview" value="accueil_rh.htm" /> <property name="validator" ref="identificationvalidator" /> </bean> AlexandreJARNOUX EPSI CSII2 8

9 <!-- Validadors --> <bean name="identificationvalidator" class="identificationvalidator"> <property name="su" ref="serviceutilisateur" /> </bean> Ici, la classe associée est IdentificationController. Cette classe hérite de la classe fournie par le framework Spring SimpleFormController, qui elle-même implémente l'interface Controller. On remarque que plusieurs propriétés sont associées au contrôleur IdentificationController : CommandClass : Désigne le type d'objet qui servira pour stocker les données du formulaire. Ici, cela sera la classe Utilisateur qui est un POJO avec au moins les attributs login et pass de type String. FormView : Désigne le nom de la vue contenant le code du formulaire d'identification affiché sur le navigateur client. SuccessView : Désigne le nom de la vue vers laquelle sera dirigé le client en cas de validation complète des données du formulaire. Validator : Désigne la classe de validation, implémentant l'interface Validator, associé au formulaire. 3) Le contrôleur principal va automatiquement appeler la méthode handlerequest), définit dans l'interface Controller de Spring, de la classe IdentificationController. Le Validator associé au contrôleur est instancié au même moment. Lors du premier appel au formulaire, le validator est inactif. Il s'activera lors d'une tentative de soumission du formulaire par le client. Dans ce cas, on se rend directement à l'étape 11 pour renvoyer la vue de formulaire au client, le processus s'effectue comme le cas d'une page simple. Dans le cas où le formulaire a déjà été affiché sur le navigateur et que le client tente de valider le formulaire, le processus continue en étape 4. 4) Le validator exécute sa méthode validate) avec les données passées dans le formulaire. Pendant cette méthode, le validator peut si nécessaire accéder au modèle pour récupérer des données depuis la source de données. Le validator effectue généralement les contrôles suivants : Vérifie les champs vides ou requis. Vérifie la validité des informations saisies. Notre formulaire d'authentification vérifie que le champ login et le champ password sont non vides. Il vérifie aussi que le login et le password fournit correspondent à un utilisateur connu dans le modèle. AlexandreJARNOUX EPSI CSII2 9

10 Extrait du fichier 'src/identificationvalidator.java' : public class IdentificationValidator implements Validator { public void validateobject arg0, Errors arg1) { Utilisateur user = Utilisateur)arg0; /* Verifie que les champs sont remplis */ // Champs login ValidationUtils.rejectIfEmptyOrWhitespacearg1,"login", "field.required", "Ne doit pas etre vide"); // Champs password ValidationUtils.rejectIfEmptyOrWhitespacearg1,"pass", "field.required", "Ne doit pas etre vide"); /* Si pas d'erreur de saisie, on verifie que le login * et le mot de passe sont correct */ if!arg1.haserrors)) { if!su.existeutilisateuruser)) { arg1.rejectvalue"login", "bad.user", "Login ou password incorrect"); 5) La couche service fait appel à la couche DAO. 6) La couche DAO accède à la source de données et récupère les données demandées. 7) La source de données renvoie les données demandées à la couche DAO. 8) La couche DAO renvoie les données demandées à la couche service. 9) La couche service renvoie les données demandées à l'instance de la classe IdentificationValidator. 10) Le validator remplit un objet avec les erreurs, si des erreurs ont été détectées, et le renvoi à l'instance de type IdentificationController. 11) Le contrôleur IdentificationController prépare la vue. Il instancie un objet implémentant l'interface ModelAndView. Si des erreurs ont été détectées, Il prépare une vue pointant sur le formulaire, avec les données saisies dans le formulaire et les messages d'erreurs correspondants aux erreurs détectées. Sinon, il prépare une vue pointant sur la vue définie dans la propriétés 'successview' de l'identificationcontroller, ou bien la vue définie dans la propiétés 'formview' si c'est le premier affichage. Dans les trois cas, la vue générée est renvoyée au contrôleur principal. Celui-ci appelle automatiquement la méthode render) de l'instance de ModelAndView. AlexandreJARNOUX EPSI CSII2 10

11 12) Le viewresolver, défini dans le fichier de configuration de Spring, va ensuite renvoyer la page JSP approprié. Le formulaire écrit sous la forme d'une JSP, utilise une syntaxe particulière. Le framework Spring fournit une librairie de tags spécifiques pour les formulaires qui permet de réafficher facilement les messages d'erreurs. Extrait du fichier '/WEB-INF/jsp/identification.jsp' : <%@ taglib prefix="form" uri=" %> <form:form method="post"> Identification RH<br/> Login : <form:input path="login" /> <form:errors path="login" cssclass="error"/> Password : <form:password path="pass" /> <form:errors path="pass" cssclass="error"/> <input type="submit" value="valider" /> </form:form> On note que le code du formulaire est légèrement différent du code HTML classique. Les balise 'form:errors' vont permettrent d'afficher les erreurs concernant le champs désigné dans l'attribut 'path'. 13) Le navigateur du client interprète le code de la JSP renvoyée. Si le formulaire contenait des erreurs, le formulaire d'identification est affiché, dans le navigateur du client, avec les messages d'erreurs. Il peut, de nouveau, saisir les champs du formulaire et tenter de le soumettre une nouvelle fois. Sinon, la page affichée est la page désignée par l'attribut 'successview', dans notre exemple, cela sera la page d'accueil des ressources humaines. AlexandreJARNOUX EPSI CSII2 11

12 1.3.AccèsauxdonnéesavecJPAencapsuléparSpring L accès aux données dans un environnement JEE est une tâche compliquée pour le développeur. En effet, plusieurs technologies peuvent ici être mises en œuvre, et il faudra au préalablechoisircellesquel onsouhaiteutiliser,selonnosbesoins. Pourceprojetnousavonschoisid utiliserjpajavapersistenceapi),carspringoffrela possibilité de manipuler très facilement un contexte de persistance et les transactions en utilisantcettetechnologie.jpapermetdemanipulerdesejbentity,quisontdesobjetsmétiers contenant les informations de mapping objet relationnel. L association de JPA + EJB entity, encapsuléparleframeworkspring,permetdonclamiseenœuvredel'accèsauxdonnéesbasée sur le mapping objet relationnel, c est à dire que l on peut manipuler à sa guise les données métiersousformed objetsquiserontenregistrésdanslabasededonnéesparjpa Créationd'unEJBentity Un EJB entity est un Entreprise Java Bean contenant les informations de mapping sous forme d annotations Prenons pour exemple un EJB entity représentant un utilisateur : public class Utilisateur implements Serializable { generator = "SEQ_UTILISATEUR") sequencename = "SEQ_UTILISATEUR") private int private String private String private String pass; private Droit droit; private static final long serialversionuid = 1L; public Utilisateur) { super); public int getid) { return this.id; public void setidint id) { this.id = id; public String getnom) { return this.nom; AlexandreJARNOUX EPSI CSII2 12

13 public void setnomstring nom) { this.nom = nom; public String getlogin) { return this.login; public void setloginstring login) { this.login = login; public String getpass) { return this.pass; public void setpassstring pass) { this.pass = pass; public Droit getdroit) { return this.droit; public void setdroitdroit iddroit) { this.droit = iddroit; Commentaire des lignes numérotées : 1) est la première annotation indispensable. Elle se place avant la ligne qui déclare la classe et indique que la classe en question doit être gérée par la couche de persistancejpa.enl'absencedecetteannotation,touteslesautresannotationsjpaseraient ignorées. 2) désigne la table de la base de données dont la classe est une représentation. 3) l'annotation@idsertàdésignerlechampdanslaclassequiestimagedelacléprimairedela table. 4) l'annotation@columnsertàfairelelienentreunchampdelaclasseetlacolonnedelatable dontlechampestl'image. 5) l'annotation@generatedvaluesertàdéfinierlastratégiedegénérationdel id,dansnotre casonutilisedesséquencesoracle. 6) l'annotation@sequencegeneratorsertàdésignerlasequencequiserautilisée. 7) sert à désigner la relation plusieurs à un qui relie l'@entity Utilisateuràl'@EntityDroitquireprésenteledroitd accèsdel utilisateuràl application). 8) l'annotation@joincolumnsertàdésignerlechampàréférencerencléétrangère. AlexandreJARNOUX EPSI CSII2 13

14 Il convient de préalablement indiquer au serveur Tomcat, les entités à charger lors de son initialisation. Extraitdufichier'/src/META INF/persistence.xml': <persistence-unit name="irh"> <class>entities.droit</class> <class>entities.utilisateur</class> </persistence-unit> AlexandreJARNOUX EPSI CSII2 14

15 1.3.2.LacoucheDAODataAccessObject) La fonction de cette couche est de gérer les entités dans le contexte de persistance. Cela va nous permettre ensuite d effectuer toutes les actions liées L interface EntityManager permet de gérer des entités dans un contexte de persistance. Il ne faut pas la confondre avec le contexte de persistance, elle permet seulement de le manipuler. Cette interface fournit comme méthodes principales : find : qui permet de recherche une entité à partir de sa clé primaire. persist : qui permet d attacher une nouvelle entité au contexte de persistance. merge : qui permet de mettre à jour une entité détachée du contexte à jour dans le contexte de persistance remove : qui permet de supprimer une entité du contexte de persistance. flush : qui permet de synchroniser le contexte de persistance avec la base de données. createquery : qui permet de récupérer les entités d une requête. Voici un schéma récapitulatif du fonctionnement de ces méthodes : AlexandreJARNOUX EPSI CSII2 15

16 Il convient de préalablement indiquer à Spring la configuration du contexte de persistance. Extraitdufichier'/WEB INF/applicationContext.xml': <!-- couche de persistance JPA --> 1.<bean id="entitymanagerfactory" class="org.springframework.orm.jpa.localcontainerentitymanagerfactorybean"> 2. <property name="datasource" ref="datasource" /> <property name="jpavendoradapter"> 3. <bean class="org.springframework.orm.jpa.vendor.hibernatejpavendoradapter"> <property name="databaseplatform" value="org.hibernate.dialect.oracle10gdialect" /> </bean> </property> 4. <property name="loadtimeweaver"> <bean class="org.springframework.instrument.classloading.instrumentationloadtimeweaver" /> </property> </bean> Commentaire des lignes numérotées : 1) Nomdubean. 2) SourcededonnéesàutiliserpourobtenirlaconnexionauSGBD. 3) Cette section définie l implémentation JPA à utiliser. On choisi ici de prendre Hibernate commeimplémentation.onfourniaussiledialectesqlquejpadevrautilisericiceluide Oracle10g. ExempledecoucheDAO: Lacouchedaoprésentel'interfaceIDaoUtilisateursuivante: public interface IDaoUtilisateur { Utilisateur getoneint id); void addoneutilisateur user); void updateoneutilisateur user); void deleteoneutilisateur user); List<Utilisateur> listall); boolean existeutilisateur user); L implémentationdecetteinterfaceestlasuivante: public class DaoUtilisateur implements IDaoUtilisateur { 2. private EntityManager public void addoneutilisateur user) { 3. em.persistuser); AlexandreJARNOUX EPSI CSII2 16

17 @Override public void deleteoneutilisateur user) { Utilisateur u = em.findutilisateur.class, user.getid)); if u!= null) 4. public Utilisateur getoneint id) { 5. return em.findutilisateur.class, public void updateoneutilisateur user) { 6. public boolean existeutilisateur user) { boolean existe = true; Query q = em.createquery"from Utilisateur u " + "where u.login = :login " + "and u.pass = :pass "); q.setparameter"login", user.getlogin)); q.setparameter"pass", user.getpass)); try { q.getsingleresult); catch NoResultException e) { existe = false; public List<Utilisateur> listall) { 7. Query q = em.createquery"from Utilisateur"); return List<Utilisateur>) q.getresultlist); Commentaire des lignes numérotées : 1) l'annotation demande à Spring d'injecter dans em, un gestionnairedecontextedepersistance.springgèrecelui ciàl aided unsingleton. 2) Lʼattribut em est permet de gérer le contexte de persistance. Il est instancié par lʼannotation vue plus haut. 3) Ajoute lʼutilisateur au contexte de persistance 4) Supprime lʼutilisateur du contexte de persistance. 5) Recherche une entité de type Utilsateur, selon son Id. AlexandreJARNOUX EPSI CSII2 17

18 6) Met à jour une entité dans le contexte de persistance. 7) Permet de récupérer la liste des utilisateurs. On utilise ici JPQL Java Persistence Query Language) qui permet de manipuler les objets et non les tables. AlexandreJARNOUX EPSI CSII2 18

19 1.3.3.Lacoucheservice Lafonctiondecettecoucheestd effectuerlagestiondelatransaction.seulecettecouche seraappeléeparl applicationpourgérerlesdonnées. Une transaction sera commencée avant le début d'exécution de la méthode et fermée après exécution. Si une exception, de type RuntimeException ou autre, se produit au cours de l'exécution de la méthode, un rollback automatique annule toute la transaction, sinon un commit automatique la valide. On retiendra que le code Java n'a pas besoin de se soucier des transactions.ellessontgéréesparspring. Il convient de préalablement indiquer à Spring comment effectuer la gestion des transactions. Extraitdufichier'/WEB INF/applicationContext.xml': <!-- le gestionnaire de transactions --> 1.<tx:annotation-driven transaction-manager="txmanager" /> 2.<bean id="txmanager" class="org.springframework.orm.jpa.jpatransactionmanager"> 3. <property name="entitymanagerfactory" ref="entitymanagerfactory" /> </bean> Commentaire des lignes numérotées : 1) On indique que les transactions seront définies par des annotations. Cela sert principalementpourl utilisationdel annotation@transactionalvoirplusloin). 2) Onindiquelegestionnairedetransactionquel onsouhaiteutiliser,iciungestionnairede transactionjpa. 3) Ondonnelaréférencedel entitymanagerfactoryàutiliser. Exemple de couche service: Lacoucheserviceprésentel'interfaceIServiceUtilisateursuivante: public interface IServiceUtilisateur { Utilisateur getutilisateurint id); void addutilisateurutilisateur user); void updateutilisateurutilisateur user); void deleteutilisateurutilisateur user); List<Utilisateur> listutilisateurs); boolean existeutilisateurutilisateur user); L public class ServiceUtilisateur implements IServiceUtilisateur { // Couche dao private IDaoUtilisateur daoutilisateur; public IDaoUtilisateur getdaoutilisateur) { return daoutilisateur; AlexandreJARNOUX EPSI CSII2 19

20 public void setdaoutilisateuridaoutilisateur daoutilisateur) { this.daoutilisateur = public void addutilisateurutilisateur user) { public void deleteutilisateurutilisateur user) { public Utilisateur getutilisateurint id) { return public void updateutilisateurutilisateur user) { public boolean existeutilisateurutilisateur user) { return public List<Utilisateur> listutilisateurs) { return this.daoutilisateur.listall); 1) l annotationspring@transactionalindiquequetouteslesméthodesdelaclassedoivent s'exécuterauseind'unetransaction. On peut remarque la simplicité de l implémentation de la couche service, cela grâce au FrameworkSpring. SansleFrameworkSpring,voiciunexempleducodeàécrirepourl ajoutd unutilisateur: public void addutlisateurutlisateur user) { EntityTransaction transaction = null ; try { transaction = em.gettransaction); transaction.begin this.daoutlisateur.addoneuser); transaction.commit); catch RuntimeException e) { if transaction!= null && transaction.isactive) ) transaction.rollback); AlexandreJARNOUX EPSI CSII2 20

21 2.Architecturephysique 2.1.Diagrammededéploiement AlexandreJARNOUX EPSI CSII2 21

22 3.Architectureinterne 3.1.Descriptiongénériquedespackages Commentaires: L applicationestscindéeen4packages. Lepackage«entities»regroupetouteslesEJBentitymétier. Le package «dao» regroupe tous les interfaces et implémentation DAOs Accès aux données) Le package «services» regroupe tous les interfaces et implémentation des services gestiondeservicestransactionnels) Le package «web» regroupe les contrôleurs et les validateurs associés aux différentes fonctionnalitésapplicatives.unvalidateurestassociéàcontrôleurlorsqueceluicigèreun formulairedesaisie. Note: se est le diminutif de«service Element» et de est le dimintif de«dao Element». Dans unevisionconcrèteleterme«element»serasubstituéparlesdifférentsnomsd objetsmétiers induiteparlalogiqueapplicativeex:employé,utilisateur,formation...). AlexandreJARNOUX EPSI CSII2 22

23 3.2.Schémadelabasededonnées Modèlelogiquedesdonnées AlexandreJARNOUX EPSI CSII2 23

24 3.2.2.ScriptSQLdecréationdelabase -- TABLE : DROIT CREATE TABLE DROIT ID NUMBER2) NOT NULL, LIBELLE VARCHAR2128) NOT NULL, CONSTRAINT PK_DROIT PRIMARY KEY ID) -- TABLE : UTILISATEUR CREATE TABLE UTILISATEUR ID NUMBER2) NOT NULL, ID_DROIT NUMBER2) NOT NULL, NOM VARCHAR2128) NOT NULL, LOGIN VARCHAR2128) NOT NULL, PASS VARCHAR232) NOT NULL, CONSTRAINT PK_UTILISATEUR PRIMARY KEY ID) -- TABLE : PLAN_FORMATION CREATE TABLE PLAN_FORMATION ANNEE NUMBER4) NOT NULL, CONSTRAINT PK_PLAN_FORMATION PRIMARY KEY ANNEE) -- TABLE : CIVILITE CREATE TABLE CIVILITE ID NUMBER2) NOT NULL, LIBELLE VARCHAR2128) NOT NULL, CONSTRAINT PK_CIVILITE PRIMARY KEY ID) -- TABLE : SITUATION_FAMILIALE CREATE TABLE SITUATION_FAMILIALE ID NUMBER2) NOT NULL, LIBELLE VARCHAR2128) NOT NULL, CONSTRAINT PK_SITUATION_FAMILIALE PRIMARY KEY ID) AlexandreJARNOUX EPSI CSII2 24

25 -- TABLE : SESSION CREATE TABLE SESSION ID NUMBER2) NOT NULL, ANNEE NUMBER4) NOT NULL, DATE_DEBUT DATE NOT NULL, DATE_FIN DATE NOT NULL, CONSTRAINT PK_SESSION PRIMARY KEY ID) -- TABLE : COMPETENCE CREATE TABLE COMPETENCE ID NUMBER2) NOT NULL, LIBELLE VARCHAR2128) NOT NULL, CONSTRAINT PK_COMPETENCE PRIMARY KEY ID) -- TABLE : NIVEAU_ETUDE CREATE TABLE NIVEAU_ETUDE ID NUMBER2) NOT NULL, LIBELLE VARCHAR2128) NOT NULL, CONSTRAINT PK_NIVEAU_ETUDE PRIMARY KEY ID) -- TABLE : CONTRAT CREATE TABLE CONTRAT ID NUMBER2) NOT NULL, LIBELLE VARCHAR2128) NOT NULL, CONSTRAINT PK_CONTRAT PRIMARY KEY ID) -- TABLE : FORMATION CREATE TABLE FORMATION ID NUMBER2) NOT NULL, ID_ORGANISME CHAR32) NOT NULL, ID_SESSION NUMBER2) NOT NULL, LIBELLE VARCHAR2128) NOT NULL, PRIX_PAR_PERSONNE NUMBER7,2) NOT NULL, DUREE CHAR32) NOT NULL, CONSTRAINT PK_FORMATION PRIMARY KEY ID) AlexandreJARNOUX EPSI CSII2 25

26 -- TABLE : METIER CREATE TABLE METIER ID NUMBER2) NOT NULL, ID_CATEGORIE NUMBER2) NOT NULL, LIBELLE VARCHAR2128) NOT NULL, CONSTRAINT PK_METIER PRIMARY KEY ID) -- TABLE : ORGANISME CREATE TABLE ORGANISME ID CHAR32) NOT NULL, NOM VARCHAR2128) NOT NULL, DESCRIPTION VARCHAR2255) NULL, CONSTRAINT PK_ORGANISME PRIMARY KEY ID) -- TABLE : POSTE CREATE TABLE POSTE ID NUMBER2) NOT NULL, ID_METIER NUMBER2) NOT NULL, LIBELLE VARCHAR2128) NOT NULL, ESTOCCUPE NUMBER1) NOT NULL, CONSTRAINT PK_POSTE PRIMARY KEY ID) -- TABLE : DIPLOME CREATE TABLE DIPLOME ID NUMBER2) NOT NULL, ID_NIVEAU NUMBER2) NOT NULL, ID_EMPLOYE NUMBER2) NOT NULL, DENOMINATION VARCHAR2128) NOT NULL, ETABLISSEMENT VARCHAR2128) NULL, ANNEE NUMBER4) NULL, CONSTRAINT PK_DIPLOME PRIMARY KEY ID) AlexandreJARNOUX EPSI CSII2 26

27 -- TABLE : EVALUATION CREATE TABLE EVALUATION ID NUMBER2) NOT NULL, ID_EMPLOYE NUMBER2) NOT NULL, DATE DATE NOT NULL, COMMENTAIRE VARCHAR2255) NULL, CONSTRAINT PK_EVALUATION PRIMARY KEY ID) -- TABLE : CATEGORIE CREATE TABLE CATEGORIE ID NUMBER2) NOT NULL, ID_THEME NUMBER2) NOT NULL, LIBELLE VARCHAR2128) NOT NULL, CONSTRAINT PK_CATEGORIE PRIMARY KEY ID) -- TABLE : EMPLOYE CREATE TABLE EMPLOYE ID NUMBER2) NOT NULL, ID_CIVILITE NUMBER2) NOT NULL, ID_SITUATION_FAMILIALE NUMBER2) NOT NULL, ID_POSTE NUMBER2) NOT NULL, NOM VARCHAR2128) NOT NULL, PRENOM VARCHAR2128) NOT NULL, TELEPHONE_PRO VARCHAR220) NULL, TELEPHONE_MOBILE VARCHAR220) NULL, TELEPHONE_PERSO VARCHAR220) NULL, FAX VARCHAR220) NULL, DATE_NAISSANCE DATE NOT NULL, VARCHAR2128) NULL, ADR_RUE VARCHAR2255) NOT NULL, ADR_CP VARCHAR210) NOT NULL, ADR_VILLE VARCHAR2128) NOT NULL, DESCRIPTION VARCHAR2255) NULL, NB_ENFANTS NUMBER2) NULL, CONSTRAINT PK_EMPLOYE PRIMARY KEY ID) -- TABLE : THEME CREATE TABLE THEME ID NUMBER2) NOT NULL, LIBELLE VARCHAR2128) NOT NULL, CONSTRAINT PK_THEME PRIMARY KEY ID) AlexandreJARNOUX EPSI CSII2 27

28 -- TABLE : NIVEAU_REQUIS CREATE TABLE NIVEAU_REQUIS ID_POSTE NUMBER2) NOT NULL, ID_COMPETENCE NUMBER2) NOT NULL, NIVEAU NUMBER1) NOT NULL, CONSTRAINT PK_NIVEAU_REQUIS PRIMARY KEY ID_POSTE, ID_COMPETENCE) -- TABLE : NIVEAU_EVAL CREATE TABLE NIVEAU_EVAL ID_EVALUATION NUMBER2) NOT NULL, ID_COMPETENCE NUMBER2) NOT NULL, NIVEAU NUMBER1) NOT NULL, CONSTRAINT PK_NIVEAU_EVAL PRIMARY KEY ID_EVALUATION, ID_COMPETENCE) -- TABLE : INSCRIPTION CREATE TABLE INSCRIPTION ID_EMPLOYE NUMBER2) NOT NULL, ID_SESSION NUMBER2) NOT NULL, ETAT VARCHAR2128) NULL, PRESENCE NUMBER1) NULL, CONSTRAINT PK_INSCRIPTION PRIMARY KEY ID_EMPLOYE, ID_SESSION) -- TABLE : NIVEAU_FORM CREATE TABLE NIVEAU_FORM ID_COMPETENCE NUMBER2) NOT NULL, ID_FORMATION NUMBER2) NOT NULL, NIVEAU NUMBER1) NOT NULL, CONSTRAINT PK_NIVEAU_FORM PRIMARY KEY ID_COMPETENCE, ID_FORMATION) AlexandreJARNOUX EPSI CSII2 28

29 -- CREATION DES REFERENCES DE TABLE ALTER TABLE EMPLOI_PRECEDENT ADD CONSTRAINT FK_EMPLOI_PRECEDENT_CONTRAT FOREIGN KEY ID_CONTRAT) REFERENCES CONTRAT ID) ALTER TABLE EMPLOI_PRECEDENT ADD CONSTRAINT FK_EMPLOI_PRECEDENT_EMPLOYE FOREIGN KEY ID_EMPLOYE) REFERENCES EMPLOYE ID) ALTER TABLE UTILISATEUR ADD CONSTRAINT FK_UTILISATEUR_DROIT FOREIGN KEY ID_DROIT) REFERENCES DROIT ID) ALTER TABLE SESSION ADD CONSTRAINT FK_SESSION_PLAN_FORMATION FOREIGN KEY ANNEE) REFERENCES PLAN_FORMATION ANNEE) ALTER TABLE FORMATION ADD CONSTRAINT FK_FORMATION_ORGANISME FOREIGN KEY ID_ORGANISME) REFERENCES ORGANISME ID) ALTER TABLE FORMATION ADD CONSTRAINT FK_FORMATION_SESSION FOREIGN KEY ID_SESSION) REFERENCES SESSION ID) ALTER TABLE METIER ADD CONSTRAINT FK_METIER_CATEGORIE FOREIGN KEY ID_CATEGORIE) REFERENCES CATEGORIE ID) ALTER TABLE POSTE ADD CONSTRAINT FK_POSTE_METIER FOREIGN KEY ID_METIER) REFERENCES METIER ID) ALTER TABLE DIPLOME ADD CONSTRAINT FK_DIPLOME_NIVEAU_ETUDE FOREIGN KEY ID_NIVEAU) REFERENCES NIVEAU_ETUDE ID) ALTER TABLE DIPLOME ADD CONSTRAINT FK_DIPLOME_EMPLOYE FOREIGN KEY ID_EMPLOYE) REFERENCES EMPLOYE ID) ALTER TABLE EVALUATION ADD CONSTRAINT FK_EVALUATION_EMPLOYE FOREIGN KEY ID_EMPLOYE) REFERENCES EMPLOYE ID) AlexandreJARNOUX EPSI CSII2 29

30 ALTER TABLE CATEGORIE ADD CONSTRAINT FK_CATEGORIE_THEME FOREIGN KEY ID_THEME) REFERENCES THEME ID) ALTER TABLE EMPLOYE ADD CONSTRAINT FK_EMPLOYE_CIVILITE FOREIGN KEY ID_CIVILITE) REFERENCES CIVILITE ID) ALTER TABLE EMPLOYE ADD CONSTRAINT FK_EMPLOYE_SITUATION_FAMILIALE FOREIGN KEY ID_SITUATION_FAMILIALE) REFERENCES SITUATION_FAMILIALE ID) ALTER TABLE EMPLOYE ADD CONSTRAINT FK_EMPLOYE_POSTE FOREIGN KEY ID_POSTE) REFERENCES POSTE ID) ALTER TABLE NIVEAU_REQUIS ADD CONSTRAINT FK_NIVEAU_REQUIS_POSTE FOREIGN KEY ID_POSTE) REFERENCES POSTE ID) ALTER TABLE NIVEAU_REQUIS ADD CONSTRAINT FK_NIVEAU_REQUIS_COMPETENCE FOREIGN KEY ID_COMPETENCE) REFERENCES COMPETENCE ID) ALTER TABLE NIVEAU_EVAL ADD CONSTRAINT FK_NIVEAU_EVAL_EVALUATION FOREIGN KEY ID_EVALUATION) REFERENCES EVALUATION ID) ALTER TABLE NIVEAU_EVAL ADD CONSTRAINT FK_NIVEAU_EVAL_COMPETENCE FOREIGN KEY ID_COMPETENCE) REFERENCES COMPETENCE ID) ALTER TABLE INSCRIPTION ADD CONSTRAINT FK_INSCRIPTION_EMPLOYE FOREIGN KEY ID_EMPLOYE) REFERENCES EMPLOYE ID) ALTER TABLE INSCRIPTION ADD CONSTRAINT FK_INSCRIPTION_SESSION FOREIGN KEY ID_SESSION) REFERENCES SESSION ID) ALTER TABLE NIVEAU_FORM ADD CONSTRAINT FK_NIVEAU_FORM_COMPETENCE FOREIGN KEY ID_COMPETENCE) REFERENCES COMPETENCE ID) ALTER TABLE NIVEAU_FORM ADD CONSTRAINT FK_NIVEAU_FORM_FORMATION FOREIGN KEY ID_FORMATION) REFERENCES FORMATION ID) AlexandreJARNOUX EPSI CSII2 30

31 3.3.Lesfonctionnementsgénériques Ce projet est composé d'une multitude d'entités métier qui reposent sur la même logique de gestion. Toutes ces entités nécessitent d'être listées, ajoutées, modifiées et supprimées. Nous allons décrire, en détail, le fonctionnement générique de ces 4 comportements Listerdeséléments AlexandreJARNOUX EPSI CSII2 31

32 Commentaires : Le client accède à une liste d'éléments à partir d'un lien dans son navigateur de ce type : ' Le serveur Tomcat reçoit la requête et passe la main à la servlet Spring. Celle-ci instancie un objet de type ListeElementController et appelle la méthode handlerequest). Cette méthode se sert du singleton IServiceElement pour demander la liste des éléments aux modèle listelement)). Ce même singleton fait appel au singleton DAO IDaoElement pour aller chercher les données dans le contexte de persistance JPA. Le DAO effectue une requête objet createquery"from Element") )pour récupérer les enregistrements de type Element par le biais de l'entity manager. Celui-ci, va interroger la base de données et injecter dans le contexte de persistance les enregistrements demandés, sous la forme d' EJBs. La liste d'enregistrement est récupérée sous la forme d'un objet Java.util.List d'element List<Element>). Cette liste est ensuite renvoyée au travers des couches DAO et service pour être récupérée dans l'objet ListeElementController. Ensuite, un nouvel objet de type ModelAndView est créé. Celui-ci sert à définir une vue View) et y attaché des données sous la forme d'une table de hachage Java.util.Map) de données Model). Cet objet ModelAndView est ensuite retourner à Spring, qui va automatiquement appelé la méthode render). Cette méthode permet de définir le type de vue généré. Dans notre cas, ce sera une JSTLView. Enfin, la JSTLView retournée est résolue par le ViewResolver de Spring qui fera correspondre la JSTLView et ses données avec la JSP associée. La JSP est finalement retournée au client. AlexandreJARNOUX EPSI CSII2 32

33 3.3.2.Ajouterunélément AlexandreJARNOUX EPSI CSII2 33

34 Commentaires : A partir d'une liste d'éléments le client possède un lien pour ajouter un élément dans la liste. Ce lien l'amène vers un formulaire composé des champs qui définissent l'élément. Le client accède à ce formulaire à partir d'un lien dans son navigateur de ce type : ' Le serveur Tomcat reçoit la requête et passe la main à la servlet Spring. Celle-ci instancie un objet de type AddElementController et appelle la méthode handlerequest). Spring appelle aussi la méthode referencedata) qui permet d'initialiser des champs de formulaire avant l'affichage de celui-ci. Par exemple, Spring peut charger les données d'une liste déroulante par le biais de cette méthode. Le formulaire est ensuite affiché, remplit et soumis par le client. La soumission d'un formulaire entraine l'exécution de la méthode validate) du Validator associé au formulaire Ce validator est facultatif). Cette méthode permet de vérifier les données et éventuellement réafficher le formulaire si des erreurs de saisie sont détectées. Tant que le validator renvoi des erreurs le formulaire n'est pas soumis. Lorsque le validator renvoie null, le formulaire est correctement rempli et est prêt à être soumis. A ce moment précis, Spring propose la méthode initbinder) pour effectuer des opérations sur l'objet renvoyé par le formulaire. On effectue généralement du transtypage sur certaines valeurs des champs du formulaire. Finalement, le code de la méthode onsubmit) est exécuté. Cette méthode définit le traitement associé au formulaire. L'objet AddElementController va par l'intermédiaire du singleton IServiceElement, du singleton DAO et de la couche JPA effectué l'ajout de l'élément dans la base de données. L'ajout de l'élément grâce à l'entity manager se traduit par un appelle à la méthode persistelem) qui va introduire l'élément dans le contexte de persistance et indirectement en base de données. Ensuite, le cheminement habituel pour retourner une vue de la liste des éléments est déroulé. AlexandreJARNOUX EPSI CSII2 34

35 3.3.3.Modifierunélément AlexandreJARNOUX EPSI CSII2 35

36 Commentaires : La modification d'un élément est très similaire au mécanisme d'ajout. La seule différence intervient juste avant l'appel à la méthode referencedata) pour initialiser le formulaire. Spring propose d'appeler la méthode formbackingobject) qui permet de récupérer dans le modèle une instance de l'objet associé au formulaire et ainsi automatiquement remplir les champs avec les précédentes valeur de l'objet à modifier. Pour que le bindage soit automatique et transparent, il faut que l'objet associé au formulaire propose des getters et setters, sur ses attributs, avec les mêmes noms que les champs de formulaire. Ensuite, le ModifElementController effectue le même type d'opération que pour l'ajout. Il intéragit avec le contexte de persistance, et effectue un mergeelem), pour mettre à jour l objet ayant la même clé id) que l objet passé en paramètre, au lieu du persistelem) dans le cas de l'ajout. Finalement, le cheminement habituel pour retourner une vue de la liste des éléments est déroulé. AlexandreJARNOUX EPSI CSII2 36

37 3.3.4.Supprimerunélément AlexandreJARNOUX EPSI CSII2 37

38 Commentaires : A partir d'une liste d'éléments le client possède un lien pour supprimer un élément de la liste. Le client donne l'ordre de suppression à partir d'un lien dans son navigateur de ce type : ' Le serveur Tomcat reçoit la requête et passe la main à la servlet Spring. Celle-ci instancie un objet de type SupprElementController et appelle la méthode handlerequest). Cette méthode prend en argument un objet de type HttpRequest et un autre de type HttpResponse. Bizarrement, pour supprimer l'élément nous allons créer un objet de type Element en mémoire et initialisé son id avec l'id de l'élément à supprimer que l'on recupére dans les paramètres GET de l'objet HttpRequest. Ensuite, On utilise la couche service, puis DAO, puis JPA pour supprimer l'élément du contexte de persistence et indirectement de la base de données. Après l'appel à removeelem) à partir de l'entity manager, il faut retourner vers la liste des éléments. On utilise la méthode sendredirect de l'objet HttpResponse pour rediriger le client sur la liste des éléments. AlexandreJARNOUX EPSI CSII2 38