Rapport de Projet J2EE Site de E-Commerce

Hibernate - Struts - Spring

Olivier Ferran Guillaume Papon 08/01/2008

Rapport de Projet J2EE Site de E-Commerce

janv. 8

I. II. 1. 2. 3. III. 1. 2. 3.

Introduction ..................................................................................................................................... 3 Lenvironnement de dveloppement .............................................................................................. 3 Eclipse Europa ............................................................................................................................. 3 Apache Tomcat ............................................................................................................................ 4 SVN .............................................................................................................................................. 4 Le modle MVC ........................................................................................................................... 5 Spring : Faciliter le dveloppement et les tests .......................................................................... 5 Struts : Mettre en place le MVC .................................................................................................. 5 Hibernate : La persistance des objets ......................................................................................... 6 a. b. c. Pourquoi Hibernate ? .............................................................................................................. 6 Configuration dHibernate....................................................................................................... 7 Utilisation dHibernate ............................................................................................................ 7 Le site de E-Commerce ................................................................................................................ 8

IV.

1. Architecture 3-tier et mise en place du modle MVC ..................................................................... 8 2. 3. 4. a. b. 5. a. b. 6. a. b. V. Configuration de lapplication ..................................................................................................... 9 Les contrleurs ......................................................................................................................... 10 La couche Web .......................................................................................................................... 13 JSTL ........................................................................................................................................ 13 Ajax ........................................................................................................................................ 17 La couche service....................................................................................................................... 19 Synchronisation ..................................................................................................................... 19 Le framework Spring ............................................................................................................. 20 La couche daccs aux donnes (DAO) ...................................................................................... 21 La persistance des objets en via Object/Relational Mapping (ORM) .................................... 21 Hibernate ............................................................................................................................... 22

Conclusion ..................................................................................................................................... 27

Rapport de Projet J2EE Site de E-Commerce

janv. 8

I. Introduction
Notre objectif en choisissant ce projet tait de se familiariser avec toute larchitecture J2EE et de dcouvrir les frameworks les plus couramment dans le dveloppement web en java. Pour ce faire, nous avons choisi de les mettre en uvre dans un site de type e-commerce. Nanmoins, le vritable objectif reste la manipulation de toutes ces technologies en vue de nous futurs stages.

II. Lenvironnement de dveloppement

1. Eclipse Europa
Eclipse Europa (Ex Callisto) est une version de lIDE dIBM auquel ont t ajouts plus de 21 projets pour un total de plus de 500 plugins, allant de ldition de fichier xml la gestion de serveurs dapplications en passant par la cration de JSP, dEJB, de JSF et bien dautres. Nous avons choisi cette distribution car son projet Web Tools (WTP) permet de grer lintrieur de lIDE toutes les tapes du dveloppement, notamment tout ce qui concerne la publication automatique du projet web sur le serveur dapplication.

Rapport de Projet J2EE Site de E-Commerce

janv. 8

2. Apache Tomcat
Tomcat est un conteneur de Servlet J2EE issu du projet Jakarta, Tomcat et est dsormais un projet principal de la fondation Apache. Cest un conteneur de Servlet J2EE qui implmente la spcification des Servlets et des JSP de Sun Microsystems. Tomcat est en fait charg de compiler les pages JSP avec Jasper pour en faire des Servlets (une servlet tant une application Java qui permet de gnrer dynamiquement des donnes au sein dun serveur http). Gnralement, ces donnes sont prsentes sous forme de page HTML cot client.

3. SVN
Subversion est un systme de gestion de version, conu pour remplacer CVS. Concrtement, ce systme permet aux membres dune quipe de dveloppeur de modifier le code du projet quasiment en mme temps. Le projet est en effet enregistr sur un serveur SVN (le notre sur https://opensvn.csie.org/) et tout moment, le dveloppeur peut mettre jour une classe avant de faire des modifications pour bnficier de la dernire version et a la possibilit de comparer deux versions d'un mme fichier. Le principe de fonctionnement est le suivant :

Rapport de Projet J2EE Site de E-Commerce

janv. 8

III. Le modle MVC

1. Spring : Faciliter le dveloppement et les tests
Le framework Spring est un conteneur dit lger , c'est--dire une infrastructure similaire un serveur d'application J2EE. Il prend donc en charge la cration d'objets et la mise en relation d'objets par l'intermdiaire d'un fichier de configuration qui dcrit les objets fabriquer et les relations de dpendances entre ces objets (IoC Inversion of Control). Le gros avantage par rapport aux serveurs d'application est qu'avec SPRING, les classes n'ont pas besoin d'implmenter une quelconque interface pour tre prises en charge par le framework. C'est en ce sens que SPRING est qualifi de conteneur lger . L'ide du pattern IoC est trs simple, elle consiste, lorsqu'un objet A besoin d'un objet B, dlguer un objet C la mise en relation de A avec B.

2. Struts : Mettre en place le MVC

Apache Struts est un framework libre pour dvelopper des applications web J2EE. Il utilise et tend l'API Servlet Java afin d'encourager les dveloppeurs adopter l'architecture Modle-VueContrleur. Struts permet la structuration d'une application Java sous forme d'un ensemble d'actions reprsentant des vnements dclenchs par les utilisateurs de l'application. Ces actions sont dcrites dans un fichier de configuration de type XML dcrivant les cheminements possibles entre les diffrentes actions. En plus de cela, Struts permet d'automatiser la gestion de certains aspects comme par exemple la validation des donnes entres par les utilisateurs via l'interface de l'application. Ainsi, il nest plus besoin de venir coder le contrle de chaque donne fournie par un utilisateur, il suffit de dcrire les vrifications effectuer dans un fichier XML ddi cette tche.

Rapport de Projet J2EE Site de E-Commerce

janv. 8

Le contrleur est le cur de l'application. Toutes les demandes du client transitent par lui. C'est une servlet gnrique fournie par STRUTS. Cette servlet gnrique prend les informations dont elle a besoin dans un fichier le plus souvent appel struts-config.xml. Si la requte du client contient des paramtres de formulaire, ceux-ci sont mis par le contrleur dans un objet javaBean hritant de la classe ActionForm. Dans le fichier de configuration struts-config.xml, chaque URL devant tre traite par programme on associe certaines informations : Le nom de la classe tendant Action charge de traiter la requte. Si l'URL demande est paramtre (cas de l'envoi d'un formulaire au contrleur), le nom du bean charg de mmoriser les informations du formulaire est indiqu. Muni de ces informations fournies par son fichier de configuration, la rception d'une demande d'URL par un client, le contrleur est capable de dterminer s'il y a un bean crer et lequel. Une fois instanci, le bean peut vrifier que les donnes qu'il a stockes et qui proviennent du formulaire, sont valides ou non. Pour cela, une mthode du bean appele validate est appele automatiquement (si le dveloppeur le souhaite et la dfinie) par le contrleur et renvoie ventuellement une liste des erreurs. Dans ce cas l, le contrleur n'ira pas plus loin et passera la main une vue dtermine dans son fichier de configuration pour informer lutilisateur des erreurs quil a commis lors de la saisie de son formulaire. Si les donnes du bean sont correctes, ou s'il n'y a pas de vrification ou s'il n'y a pas de bean, le contrleur passe la main l'objet de type Action associ l'URL. Il le fait en demandant l'excution de la mthode execute de cet objet laquelle il transmet la rfrence du bean qu'il a ventuellement construit. C'est ici que le dveloppeur fait ce qu'il a faire : il devra ventuellement faire appel des classes mtier ou des classes d'accs aux donnes. A la fin du traitement, l'objet Action rend au contrleur le nom de la vue qu'il doit envoyer en rponse au client. Le contrleur envoie cette rponse. L'change avec le client est termin.

3. Hibernate : La persistance des objets

a. Pourquoi Hibernate ? Hibernate est un framework open source grant la persistance des objets en base de donnes relationnelle. La manipulation de SQL dans le langage de programmation JAVA est rendue possible par lutilisation du JDBC. Puisque, chaque requte est effectue sur le modle logique de la base de donnes, cette approche prsente linconvnient de lier trs fortement le code de lapplication au schma de la base de donnes. En consquence, toute volution apporte au modle logique doit tre rpercute sur le code de lapplication. Loutil Hibernate propose une solution ce problme. Celleci consiste dfinir, dans des fichiers de configurations, le lien entre le diagramme de classes de lapplication qui exploite une base de donnes et le modle logique de cette base de donnes. Il permet ensuite de manipuler les donnes de la base de donnes sans faire la moindre rfrence au schma de la base de donnes en utilisant lAPI fournie par cet outil grce au lien tabli dans les fichiers de configuration.

Rapport de Projet J2EE Site de E-Commerce

janv. 8

b. Configuration dHibernate Hibernate est conu pour pouvoir tre utilise dans diffrents types darchitectures dapplication. Pour cela, chaque application doit indiquer Hibernate comment celui-ci peut accder et manipuler la source de donnes dans un fichier de configuration nomm hibernate.cfg.xml. Les principaux lments paramtrer sont les suivantes : Le SGDB utilis. Chaque SGBD propose une implmentation du langage SQL qui diffre souvent de la norme SQL. Hibernate doit connaitre le type de SQL quil doit gnrer. La Connexion la base de donnes. Si la connexion la base de donnes se fait en utilisant JDBC, il faut indiquer Hibernate, le driver JDBC, lurl de connexion ainsi quun nom dutilisateur et un mot de passe permettant de se connecter `a la base de donnes. Les connexions peuvent galement tre gres par un serveur dapplication. Dans ce cas, il faut indiquer Hibernate comment il peut accder aux connexions cres par ce serveur (Annuaire JNDI). Les Services tiers. Hibernate a besoin de grer un ensemble (pool) de connexions la base de donnes et un cache de donnes. Pour cela, Hibernate propose une implmentation rudimentaire de ces services mais peut aussi utiliser des services tiers plus performants.

Pour rsumer, le paramtrage de Hibernate ncessite : La dfinition du modle de classes exploitant la base de donnes ; Une correspondance (mapping) entre le modle de classes et la base de donnes ; Une configuration au niveau systme de laccs. c. Utilisation dHibernate Lutilisation de Hibernate se fait principalement au travers de la classe Session quil fournit. Un objet session offre les fonctionnalits suivantes : Rendre persistant un objet dune classe. Cest la mthode save qui offre cette fonctionnalit. Elle prend en paramtre lobjet rendre persistant. Charger un objet dune classe partir de la base de donnes. La mthode load est utilise cette fin. Elle prend en paramtre la classe de lobjet charger ainsi que la valeur de lidentifiant (cl primaire) de cet objet. Modification dun objet persistant. Il suffit pour cela de modifier la valeur des proprits dun objet puis dappeler la mthode flush de lobjet session. Suppression dun objet persistant. Lappel de la mthode delete avec en paramtre un objet persistant se charge deffectuer la suppression dans la base de donnes. Rechercher des objets. Hibernate propose un langage de requte orient objets nomm HQL dont la syntaxe est similaire au SQL et qui permet deffectuer des requtes sur le modle objet.

Rapport de Projet J2EE Site de E-Commerce

janv. 8

IV. Le site de E-Commerce

1. Architecture 3-tier et mise en place du modle MVC
Une application web possde souvent une architecture 3-tier : la couche dao s'occupe de l'accs aux donnes, le plus souvent des donnes persistantes au sein d'un SGBD. la couche mtier implmente les algorithmes " mtier " de l'application. Cette couche est indpendante de toute forme d'interface avec l'utilisateur. Ainsi elle doit tre utilisable aussi bien avec une interface console, une interface web, une interface de client riche. Elle doit ainsi pouvoir tre teste en-dehors de l'interface web et notamment avec une interface console. C'est gnralement la couche la plus stable de l'architecture. Elle ne change pas si on change l'interface utilisateur ou la faon d'accder aux donnes ncessaires au fonctionnement de l'application. la couche interface utilisateur qui est l'interface (graphique souvent) qui permet l'utilisateur de piloter l'application et d'en recevoir des informations. Les couches mtier et dao sont normalement utilises via des interfaces Java. Ainsi la couche mtier ne connat de la couche dao que son ou ses interfaces et ne connat pas les classes les implmentant. C'est ce qui assure l'indpendance des couches entre-elles : changer l'implmentation de la couche dao n'a aucune incidence sur la couche mtier tant qu'on ne touche pas la dfinition de l'interface de la couche dao. Il en est de mme entre les couches interface utilisateur et mtier. L'architecture MVC prend place dans la couche interface utilisateur lorsque celle-ci est une interface web

Le traitement d'une demande d'un client se droule selon les tapes suivantes : 1. Le client fait une demande au contrleur. Celui-ci voit passer toutes les demandes des clients. C'est la porte d'entre de l'application. C'est le C de MVC. 2. Le contrleur C traite cette demande. Pour ce faire, il peut avoir besoin de l'aide de la couche mtier. Une fois la demande du client traite, celle-ci peut appeler diverses rponses. Un exemple classique est : une page d'erreurs si la demande n'a pu tre traite correctement une page de confirmation sinon

Rapport de Projet J2EE Site de E-Commerce

janv. 8

3. Le contrleur choisit la rponse (une vue) envoyer au client. Choisir la rponse envoyer au client ncessite plusieurs tapes: choisir l'objet qui va gnrer la rponse. C'est ce qu'on appelle la vue V, le V de MVC. Ce choix dpend en gnral du rsultat de l'excution de l'action demande par l'utilisateur. lui fournir les donnes dont il a besoin pour gnrer cette rponse. En effet, celle-ci contient le plus souvent des informations calcules par le contrleur. Ces informations forment ce qu'on appelle le modle M de la vue, le M de MVC. L'tape 3 consiste donc en le choix d'une vue V et en la construction du modle M ncessaire celle-ci. 4. Le contrleur C demande la vue choisie de s'afficher. Il s'agit le plus souvent de faire excuter une mthode particulire de la vue V charge de gnrer la rponse au client. 5. Le gnrateur de vue V utilise le modle M prpar par le contrleur C pour initialiser les parties dynamiques de la rponse qu'il doit envoyer au client. 6. la rponse est envoye au client. La forme exacte de celle-ci dpend du gnrateur de vue. Ce peut tre un flux HTML, PDF, Excel... Dans notre application, et pour plus de simplicit, la couche mtier est intgre au gnrateur de vue.

2. Configuration de lapplication
Chacun des frameworks que nous avons utiliss ncessite sa propre configuration, en plus de celle requise par le moteur de servlet. Gnralement, cette configuration se fait via lutilisation de fichiers XML, bien quil soit galement possible dutiliser dautres types de fichiers ou de leffectuer par programmation. Cest nanmoins la premire solution que nous avons retenu. Globalement, larchitecture dun projet web Java EE dans eclipse est la suivante : On trouve dabord le repertoire src, qui contient les packages et les sources java de lapplication ainsi que certains fichiers de configuration, dont ceux dhibernate (hibernate.cfg.xml) et de spring (springconfig.xml). Ensuite, on a le rpertoire build, qui correspond la version compile du rpertoire src . En J2EE, quand une page est demande par lutilisateur, le moteur de servlet regarde la version compile de la servlet quil possde pour cette page et dtermine sil a besoin ou non de recompiler une version plus rcente de la source correspondant. Cest dans ce rpertoire build que vont toutes ces classes une fois compiles, ainsi que les copies des fichiers de configuration prsent dans le rpertoire src. Le rpertoire WebContent contient quant lui toutes les donnes relatives une application web classique, c'est--dire que cest ici que lon va retrouver nottament les images, les feuilles de style, les jsp , etc

Rapport de Projet J2EE Site de E-Commerce

janv. 8

On y trouve galement contenu dans le rpertoire WEB-INF , plusieurs lments importants : Un rpertoire classes, qui correspond au rpertoire build prcdent. Un rpertoire lib, qui contient tous les jar ncessaires lexcution de lapplication. Dans notre cas, entre les frameworks que nous utilisions et leur dpendances, le nombre darchives sleve plus de 40, pour un taille de 10Mo. Le fichier de configuration de struts (struts-config.xml) Le fichier de configuration de lapplication, ncessaire pour le fonctionnement du moteur de serlet (web.xml) En fait, le rpertoire WebContent reprsente, comme son nom lindique, le contenu complet ncessaire pour faire tourner le site web sur un serveur dapplication. On se rend plus facilement compte de cela si lon exporte notre projet dans un fichier WAR (pour Web Archive) afin de le mettre en production sur notre serveur Tomcat ou sur un autre serveur compatible J2EE, tels que Glassfish, le serveur utilis par Sun, ou dautres tels que JBoss, Jonas ou autres. Cette archive ne comporte ds lors plus que le contenu du rpertoire WebContent, le rpertoire classes contenant toutes la partie applicative crite en java.

3. Les contrleurs
Notre contrleur est le point dentre dans notre application. Cest un des premiers modules que nous avons dvelopp car il a t ncessaire ds le dbut de trouver une mthode unifie pour dispatcher les requtes (les pages demandes) des utilisateurs vers les servlets traitant ces demandes. Dans le but de nous familiariser avec larchitecture et pour apprhender son fonctionnement, nous avons dcid de coder notre propre moteur. Comme dans les frameworks rcents, nous avons dvelopp une servlet unique (architecture de type MVC-2) qui rceptionne toutes les requtes et qui, suivant luri demande, transmet la vue une classe qui soccupe de lui renvoyer la jsp correspondante. Nous avons choisi de grer tout le paramtrage dans un fichier xml nomm config-servlet.xml dont le contenu est de la forme suivante :
<delegate id="main" uri="/main" jsp="/WEB-INF/vues/main.jsp" spring-id="delegate-main" default="true" />

Ainsi, chaque page peut possder son lment delegate qui permet, grce Spring, de charger automatiquement le gnrateur de vue appropri pour retourner la page au client. Ce systme permet galement dutiliser le mme gnrateur de vue pour plusieurs pages. Ensuite, dans le fichier spring-config-servlet.xml, on trouve la correspondance entre lidentifiant pass dans llment delegate prcdent et la classe faire instancier Spring.
<bean id=" delegate-main" class="yaz.ecommerce.controleur.delegate.DelegateMain"/>

10

Rapport de Projet J2EE Site de E-Commerce

janv. 8

Cette classe est limplmentation dune interface (IDelegate) possdant une mthode process appele par notre contrleur pour gnrer la vue renvoyer lutilisateur
void process( HttpServletRequest request, HttpServletResponse response, ServletContext context, ServletConfig config, String jsp) throws AccesNonAuthoriseException, ServletConfigInitialisationException;.

Lintrt de notre contrleur est quil permet au gnrateur de vue de lancer des exceptions correspondant la logique mtier de notre application. Ainsi, une page ncessitant que lutilisateur soit identifi va lancer une exception de type AccesNonAuthoriseException pour signifier que lutilisateur na pas le droit daccder cette page. Le contrleur se chargera alors de transmettre le traitement la delegate approprie pour ce genre de cas, ce qui au final, enrichie notre contrleur de nombreuses possibilits dextensions. Nous avons galement utilis le contrleur de servlet de Struts pour grer tous les formulaires prsent dans notre application. Pour ce faire, pour chaque formulaire, nous dfinissions dans le fichier struts-config.xml les paramtres suivant :
<form-beans> <form-bean name="formInscription" type="yaz.ecommerce.formulaire.bean.InscriptionBean" /> <form-beans> <action name="formInscription" path="/inscription" scope="request" type="yaz.ecommerce.formulaire.action.InscriptionAction" validate="true" input="/WEB-INF/vues/inscription.jsp" parameter="/WEB-INF/vues/main.jsp"> <forward name="success" path="/WEB-INF/vues/main.jsp"/> </action>

Tout dabord, on dfinit le form-bean . Lattribut name donne le nom du bean et type le bean tendant ActionForm contenant les membres correspondant aux lments du formulaire. Ensuite, on dfinit laction appliquer une fois le formulaire valid. On retrouve le paramtre name prcdent, pour faire la correspondance entre lActionForm (le bean contenant les donnes du formulaire) et la classe Action (la classe contenant les actions effectuer une fois le bean correctement rempli). Viennent ensuite luri laquelle on trouve le formulaire (attribut path ), la porte dans laquelle sont transmises les donnes entre le formulaire et lActionForm (attribut scope , pouvant prendre les valeurs de application , session , ou request ), la classe

11

Rapport de Projet J2EE Site de E-Commerce

janv. 8

Action (proprit type ), la demande de valider ou non les donnes du formulaire en appelant la fonction validate ,la page vers laquelle rediriger lutilisateur en cas derreur dans la valorisation de lActionForm (attribut input ) et enfin un ou plusieurs forwards permettant de dterminer quelle va tre la jsp afficher. Ainsi, au bean InscriptionBean correspond le formulaire suivant :
public class InscriptionBean extends ActionForm{ private String civilite; private String nom; private String prenom; public String getCivilite(){ return this.civilite; }

<html:form action="/inscription" > <html:select property="civilite"> <html:option value="Monsieur"></html:option> <html:option value="Madame"></html:option> <html:option value="Madamoiselle"></html:option> </html:select><br/> <html:text property="nom" maxlength="20"/><br/> <html:text property="prenom" maxlength="20"/><br/> <html:submit value="Soumettre" > <html:reset value="Reset" > </html:form>

Il est intressant de noter que dans la jsp, il est obligatoire dutiliser les balises de la taglib html de Struts et non pas les lments html classiques (input*text+ input*submit+, select, etc) afin que le contrleur de Struts puisse correctement rcuprer les valeurs des champs afin de valoriser les membres correspondant dans lActionForm. Une fois valides par le client, les donnes sont transmises lActionForm qui, avant de rendre la main la classe Action, va tenter de vrifier si elles sont bien valides. Dans le cas contraire, la fonction validate retourne un objet de type ActionErrors contenant la liste des erreurs et redirige vers la jsp spcifie par lattribut input dans son fichier de configuration. Ce mcanisme est trs puissant et trs simple utiliser car le framework Struts propose dans sa taglib html un tag nomm html:errors quil suffit dappeler pour afficher la liste des erreurs. On lutilise simplement comme suit :
<div id="inscriptionErreurs"> <html:errors /> </div>

En ralit, en appelant ce tag, le contrleur de Struts va analyser le contenu de lobjet ActionErrors et pour chaque erreur dsigne par un ActionMessage, va aller chercher le code html afficher correspondant dans le fichier /classes/erreur.properties.

12

Rapport de Projet J2EE Site de E-Commerce

janv. 8 errors.header=<h1>Erreurs</h1><ul> errors.footer=</ul> inscription.nom.vide=<li>Veuillez renseigner votre nom</li> inscription.nom.long=<li>Le nom ne doit pas excder 20 caractres</li> inscription.prenom.vide=<li>Veuillez renseigner votre prnom</li> inscription.prenom.long=<li>Le prnom ne doit pas excder 20 caractres</li>

Ainsi, une erreur dans la saisie gnrera automatiquement le code html suivant :
<div id="inscriptionErreurs"> <h1>Erreurs</h1> <ul> <li>Veuillez renseigner votre nom</li> </ul> </div>

De plus, la classe ActionForm possde une deuxime mthode intressante, la mthode reset. Cette mthode est appele chaque fois avant que le formulaire ne soit affich dans la page web, do son utilisation pour pr-remplir les champs. Par exemple, nous proposons nos utilisateurs une page (/ECommerce/editInfos) leur permettant de modifier leurs coordonnes personnelles. Ds laccs cette page, et puisquils sont identifis nous savons qui ils sont, nous pouvons afficher leurs informations compltes grce cette mthode afin de leur faciliter la saisie. La mthode reset est galement appele lorsque lutilisateur clique sur un bouton de type input*reset+.

4. La couche Web
La couche web est compose de tout le cot html de lapplication, c'est--dire les Jsp, les feuilles de style css, le javascript, ainsi que des contrles ncessaires charger le modle de chaque page afficher. a. JSTL Le but de la JSTL est de simplifier le travail des auteurs de page JSP, c'est dire la personne responsable de la couche prsentation d'une application web J2EE. En effet, un web designer peut avoir des problmes pour la conception de pages JSP du fait qu'il est confront un langage de script complexe qu'il ne matrise pas forcment. La JSTL permet de dvelopper des pages JSP en utilisant des balises XML, donc avec une syntaxe proche des langages utiliss par les web designers, et leur permet donc de concevoir des pages dynamiques complexes sans connaissances du langage Java. Sun a donc propos une spcification pour une librairie de tags standards : la Java Standard Tag Library (JSTL). C'est dire qu'il spcifie les bases de cette librairie, mais qu'il laisse l'implmentation libre (de la mme manire que pour les serveurs J2EE qui sont des implmentations de la spcification J2EE). La JSTL se base sur l'utilisation des Expressions Languages (EL) en remplacement des scriptlets Java. Lexemple suivant tir de la page de commandes permet de se rendre compte de la puissance des Expressions Languages :

13

Rapport de Projet J2EE Site de E-Commerce

janv. 8 <c:forEach var="item" varStatus="iter" items="${facture.pannier.contenu}"> <td>${item.portable.stockage.taille}Go (${item.portable.stockage.rotation}tr/min) </td> </c:forEach>

Tout dabord, on remarque quune EL commence par un $ et que le contenu de lexpression doit se trouver lintrieur daccolades. La page JSP va chercher un attribut s'appelant "item" successivement et dans l'ordre dans : l'objet request qui reprsente la requte transmise par le contrleur request.getAttribute("item") l'objet session qui reprsente la session du client : session.getAttribute("item") l'objet application qui reprsente le contexte de l'application web application.getAttribute("item") :

Puisque lexpression fait rfrence un attribut compos, JSTL va chercher un membre de lobjet item qui sappellerait portable (un membre public, ou accessible par un getter), puis va faire de mme en cherchant un membre stockage du type de lobjet portable , puis de mme avec taille . Une fois lobjet dextrmit trouv, la JSP laffiche en utilisant la mthode toString de cet objet. Ainsi, on aura parcouru toute larborescence de lobjet trs simplement, sans surcharge de code. Dans le code prcdent, on peut galement observer lutilisation dun tag <c :forEach>.Ce tag fait partie dune des quatre taglibs que propose JSTL, la taglib Core (les trois autres tant Format, XML, SQL), et propose de nombreuses actions de base tels que laffichage de variables, la cration ou la modification de variables de scope, la gestion dexceptions, etc Une taglib intressante que nous avons galement teste est la taglib Format (fmt) qui permet de simplifier la localisation et le formatage des donnes. La premire utilisation que nous en avons faite concerne la gestion des dates, dans notre module de news. En effet, les dates tant enregistres dans notre base de donnes de faon non formate, il nous faut les traiter avant leur affichage. Pour cela, la taglig Format propose deux tags :
<fmt:parseDate value="${news.date}" pattern="yyyy-MM-dd" var="date"/> <fmt:formatDate value="${date}" dateStyle="full"/>

Le premier permet de construire le modle daffichage de la date, en utilisant un pattern personnalis. Il prend en paramtre la date parser, le pattern suivre, et le nom de la variable dans laquelle il placera le rsultat. Le tag formatDate nas plus alors qu afficher le rsultat contenu dans la variable date . Mais la principale utilit de cette taglib rside dans sa facult dinternationaliser une application, c'est--dire dafficher indiffremment tous les messages contenus sur un site dans diffrentes langues. Nous avons mis en place ce concept sur les premires tapes dune commande.

14

Rapport de Projet J2EE Site de E-Commerce

janv. 8

La JSTL utilise les classes standards de Java pour la gestion de l'internationalisation. Ainsi la classe java.util.Locale permet de reprsenter les spcificits rgionales, ainsi que la classe java.util.ResourceBundle pour accder aux donnes des fichiers de localisation. Un ResourceBundle permet de grer un ensemble de fichier *.properties contenant les ressources localises. Par exemple pour grer les langues franaises et anglaises, nous avons les fichiers suivants: messages_fr_FR.properties messages_en_US.properties Les fichiers *.properties comportent un ensemble de couples clef/valeur contenant lensemble des messages possibles afficher. On accde aux donnes localises grce aux diffrentes clefs. Par exemple, le fichier messages_fr_FR.properties contient :
pannierVide=Il n'y a pas d'items dans votre pannier quantite=Quantite prixTTC=Prix TTC

Alors que le fichier message_en_US.properties contient pour sa part :

pannierVide=There is no item in your cart quantite=Quantity prixTTC=IAT Price

Ds lors, lutilisation est trs simple puisquil suffit de choisir un moment quelle est la langue utiliser et de placer cette locale dans un objet de la session :
String langue = request.getParameter("langue"); if (langue != null){ if (langue.equals("FR")) request.getSession().setAttribute("langue","fr_FR"); if (langue.equals("EN")) request.getSession().setAttribute("langue","en_US"); }

Puis de rajouter dans les jsp concernes les deux lignes suivantes:
<fmt:setLocale value="${sessionScope.langue}"/> <fmt:setBundle basename="messages" var="maLocale" scope="session"/>

Le tag setLocale permet daller chercher dans le scope session la variable reprsentant la langue utiliser, celle que nous lui avons donn prcdemment, et le tag setBundle spcifie le nom du fichier de base contenant les messages (on ajoute basename + locale pour construire messages_fr_FR.properties ). Il ne suffit plus alors qu accder nos messages en utilisant le tag message en spcifiant la cl voulue.
<fmt:message bundle="${maLocale}" key="pannierVide"/>

15

Rapport de Projet J2EE Site de E-Commerce

janv. 8

Pour avoir mis en place ce mcanisme, nous nous sommes rendus compte de la puissance de la JSTL, et notamment de la taglib Format car en peine plus dune demi heure, il est possible de rendre son site compltement multilingue, ce qui cre une forte valeur ajoute une application. Il est galement possible de crer sa propre bibliothque de tags. Nous avons galement test cette possibilit en crant plusieurs tags que nous avons runis dans une customTag. Par exemple, nous avons cr un tag nomm PromoTag dont le rsultat est reprsent par la capture suivante.

La construction dun tel tag se fait en deux tapes. Tout dabord, il faut dcrire les paramtres de ce tag dans une tld.

<tag> <name>promo</name> <tag-class>yaz.ecommerce.taglib.PromoTag</tag-class> <bodycontent>scriptless</bodycontent> <description> Utilis pour afficher une offre spciale </description> <attribute> <name>image</name> <required>true</required>

16

Rapport de Projet J2EE Site de E-Commerce

janv. 8 <rtexprvalue>false</rtexprvalue> </attribute> <attribute> <name>titre</name> <required>true</required> <rtexprvalue>false</rtexprvalue> </attribute> </tag>

On y trouve le nom du tag, le chemin vers la classe qui correspond au code du tag, un paramtre spcifiant si le tag accepte ou nom des expression language ainsi que la liste complete des attributs du tag. Lcriture du code du tag est trs simple, il sufit de crer une classe hritant de javax.servlet.jsp.tagext.SimpleTagSupport, contenant un membre par proprit spcifie avec ses setters puis de se servir du lobjet JSPWriter qui reprsente le flux de sortie de la jsp pour crire le code html du tag.
public void doTag() throws JspException, IOException{ JspWriter writer = getJspContext().getOut(); writer.println ("<div class=\"produit1\">"); writer.println (" <div class=\"caracteristiques\">"); writer.println (" <div class=\"photo\"><img src=\"images/"+image+"\" alt=\""+altImage+"\"/></div>"); writer.println (" <div class=\"description\">"); writer.println (" <h1>"+titre+"</h1>");

Mme si dans notre cas, les tags que nous avons crs ont plus une vise pdagogique que pratique, on peut quand mme entrapercevoir de nombreuses utilisations de ce mcanisme. Par exemple, les taglibs de Struts sont construites de cette faon.

b. Ajax De toutes les technologies en vogue en ce moment, Ajax est sans doute lune des plus prometteuses. Nous navons pas drog cette mode et avons test son implmentation dans un site en java. Puisqutant dj familiers du concept et de son implmentation en php, la retranscription en java est assez rapide. Nous avons plac notre requte aprs laffichage des rsultats dune recherche de produits, afin dajouter un produit au panier.

17

Rapport de Projet J2EE Site de E-Commerce

janv. 8

Dans un premier temps (1), lutilisateur demande la page /recherche. Le conteneur de servlet donne la main au contrleur pour traiter la demande et renvoie finalement le code html de la page dsir que le navigateur web affiche au client (2). Alors que cette premire partie de lchange est termin, lutilisateur va dclencher une fonction javascript qui, via une requte http sur une url bien prcise, constituera la demande dajout dun item dans son pannier (3). Le serveur traitera cette requte http et retournera non pas une page afficher, mais du code javascript (4) que le navigateur pourra excuter. Dans notre cas, quand lutilisateur clique sur le lien pour ajouter un objet son panier, il dclenche en fond une requte vers luri AddItemAjax avec deux paramtres : lidentifiant du produit et la quantit ajouter.
function doAjouterPannier(id, qte){ var xhr = getXHR(); if (xhr){ // true : requte asynchrone xhr.open( "POST", "./addItemAjax?portable="+id+"&quantite="+qte, true); xhr.onreadystatechange = function() { if (xhr.readyState == 4){ eval(xhr.responseText); } } // envoie la requete au serveur xhr.send(null); } }

Cot serveur, une fois la requte reue les paramtres rcuprs, on se contente dexcuter les fonctions ncessaires lajout du produit au panier et on retourne quelques lignes de javascript que le client excutera pour signifier lutilisateur que sa requte sest droule avec succs en crivant dans le flux de sortie de la servlet.
/* ajoute le portable au panier */ pannier.ajouterProduit(idPortable, quantite); try{ PrintWriter pw = response.getWriter(); pw.println("var p = document.getElementById('ajoutPannierResponse"+idPortable+"');");

18

Rapport de Projet J2EE Site de E-Commerce

janv. 8 pw.println("p.innerHTML = '(" + quantite + " Article ajout&eacute; au pannier)'"); } catch(IOException ex){ ex.printStackTrace(); }

5. La couche service
a. Synchronisation La couche service est une couche cl de lapplication puisque cest par elle que transitent les informations entre la couche contrleur et la couche daccs aux donnes (dao). Son existence provient dun constat simple : il est ncessaire de protger la couche dao de possibles accs concurrentiels sur la base de donnes. Considrons la situation suivante. Imaginons que nous possdions dans notre module de news une partie administration qui permettrait dditer le contenu dune news, ou de la supprimer compltement. Imaginons maintenant que nous avons deux administrateurs qui tentent de modifier la mme news en mme temps. On sent bien quil peut arriver un problme entre le moment o la premire personne commence lexcution de la fonction ddition et le moment ou lexcution se termine. Si la news a t supprime par le deuxime administrateur entre temps, le programme va tenter de modifier un objet qui nexiste plus. Pour rsoudre ce problme, on a besoin de synchroniser laccs aux mthodes de la couche dao afin de sassurer quun seul thread les excute la fois. Pour cela, les classes du package dao ne sont instancies quun un seul exemplaire. Cest ce que lon appelle des singletons . Ces singletons sont rpartis sur plusieurs classes, chacune dentre elle grant une seule table en base de donnes, ce qui rend possible un tel dcoupage. Puisque pendant le droulement normal de lapplication, il existe de nombreux threads lancs en mme temps et potentiellement concurrents, il faut trouver un moment o il ny a quun seul thread de lanc pour instancier nos objets dao. Cet instant lieu pendant la phase dinitialisation de la servlet, lors de lappel la mthode init. Chacune de nos classes dao est alors instancie une seule fois et la rfrence ainsi cre est stocke en mmoire dans un objet accessible depuis le scope application .
/* construit une hashmap qui va contenir toutes les instances de la couche service */ HashMap<String,Object> mapService = new HashMap<String,Object>(); /* met la hashmap dans le scope de l'application */ getServletContext().setAttribute("mapService", mapService);

19

Rapport de Projet J2EE Site de E-Commerce

janv. 8

Nous mettons ainsi dans cette HashMap tous nos objets de la couche service dont les mthodes synchronises permettent daccder la couche dao.
public class LivraisonServiceImpl implements ILivraisonService{ private ILivraisonDao dao; public LivraisonServiceImpl(){} public synchronized void ajouterLivraison(Livraison livraison){ dao.ajouterLivraison(livraison); } public synchronized ArrayList<Livraison> getAllLivraisons(Integer id){ return dao.getAllLivraisons(id); } public synchronized Livraison getDefaultLivraison(Integer id){ return dao.getDefaultLivraison(id); } public ILivraisonDao getDao() { return dao; } public void setDao(ILivraisonDao dao) { this.dao = dao; } }

b. Le framework Spring Lorsque nous ajoutons des objets dans la HashMap prcdente, ce sont toujours des objets implmentant une interface contenant le prototype des mthodes proposes. Considrons la classe LivraisonServiceImpl en la modifiant comme suit :
public LivraisonServiceImpl(){ dao = new LivraisonDaoImpl(); }

Si nous avions crit ceci, notre classe LivraisonServiceImpl aurait t dpendante de la classe LivraisonDaoImpl puisque pour utiliser une autre classe implmentant linterface ILivraisonDao, nous aurions du modifier lobjet la main et recompiler la classe. Pour remdier ce problme, nous avons choisi dutiliser le framework Spring notamment pour ses fonctions dInversion of Control (Injection de Dpendance en franais). Spring IoC nous permet de crer une application 3tier o les couches sont indpendantes des autres, cest dire que changer l'une ne ncessite pas de changer les autres. Cela apporte une grande souplesse dans l'volution de l'application. Avec Spring IoC, la classe LivraisonServiceImpl va obtenir la rfrence dont il a besoin sur la couche dao de la faon suivante :

20

Rapport de Projet J2EE Site de E-Commerce

janv. 8

1. Ds que besoin, nous demandons Spring IoC de nous donner une rfrence vers un objet implmentant linterface ILivraisonService. 2. Spring va alors exploiter un fichier XML de configuration qui lui indique quelle classe doit tre instancie et comment elle doit tre initialise. 3. Spring IoC nous rends alors la rfrence de la couche ainsi cre. L'avantage de cette solution est que dsormais le nom des classes instanciant les diffrentes couches n'est plus cod en dur mais simplement prsent dans un fichier de configuration. Changer l'implmentation d'une couche induira un changement dans ce fichier de configuration mais pas dans les classes appelantes. Linstanciation des beans lors de linitialisation se fait ds lors de la faon suivante :
/* charge toutes les instances de la couche service dans la hashmap */ mapService.put("LivraisonServiceImpl", (ILivraisonService)new XmlBeanFactory( new ClassPathResource("spring-config.xml")) .getBean("livraison-service"));

La configuration de Spring seffectue dans le fichier spring-config.xml de la faon suivante :

<bean id="livraison-dao" class="yaz.ecommerce.dao.LivraisonDaoImpl" init-method="init" destroy-method="close"/> <bean id="livraison-service" class="yaz.ecommerce.service.LivraisonServiceImpl"> <property name="dao"> <ref local="livraison-dao" /> </property> </bean>

Le premier bean dfinit un objet de type LivraisonDapImpl. Cest lobjet que nous allons passer comme rfrence de la couche dao la couche service. Les attributs init-method et destroymethod spcifient respectivement la mthode appeler la cration du bean et sa destruction. Le deuxime bean est celui de notre couche service. Nous lui donnons la classe instancier et dfinissons comment valoriser le membre dao en lui disant de prendre le bean local cr juste avant, dont lid est livraison-dao . De cette faon, nous obtenons automatiquement un objet java prt lemploi dont la configuration est aisment modifiable par simple modification dun fichier xml.

6. La couche daccs aux donnes (DAO)

a. La persistance des objets en via Object/Relational Mapping (ORM) Pour faire court, la notion dORM est le fait dautomatiser la persistance des objets java dans les tables dune base de donnes relationnelle, ainsi que son contraire, rcuprer les donnes des tables directement dans des objets java.

21

Rapport de Projet J2EE Site de E-Commerce

janv. 8

Pour implmenter ce concept, un framework doit tre compos des quatre lments suivants : Une api pour effectuer les oprations CRUD (Create, Retrieve, Update, Delete) de base sur les objets des classes persistantes Un langage ou une api pour crer des requtes qui se rfrent aux classes et leurs proprits. Un moyen simple de spcifier les mtadonnes pour le mapping Limplmentation de concepts tels que lautomatic dirty checking (mise jour automatique des tables quand les objets java correspondants sont modifis), le lazy loading (chargement des proprits des objets uniquement des quils sont accds) ainsi que dautres fonctions doptimisation.

b. Hibernate Parmi de nombreuses solutions rpondant cette attente (EJB, iBatis, JDO, Cayenne, Castor, etc..), nous avons choisi dutiliser le framework Hibernate car cest lheure actuelle le framework le plus puissant, le plus complet, et surtout le plus utilis dans le monde professionnel. Nanmoins, son utilisation est assez complexe malgr le grand nombre de documentations disponibles sur internet. Dans notre cas, nous nous sommes contenter dutiliser les fonctions de bases ncessaires pour la persistance de nos donnes, sans nous proccuper de toute la problmatique concernant les performances. Tout dabord, avant dutiliser Hibernate, il est ncessaire de modliser les donnes que lon va vouloir stocker. Cette tape consiste construire des objets java dont les membres seront porteurs des informations stocker. Chaque membre doit possder un getter et un setter.
public class Commande { private private private private private private private private Integer id; Date dateCommande; Date datePreparation; Date dateExpedition; Integer client; Livraison livraison; Float port; Float tva;

public Commande(){} /* getters, setters */

} On peut noter en regardant cette simple entit quoutre les types primitifs (ou les wrappers), il est galement possible de mapper des types complexes (des objets de la classe Livraison). De plus, Hibernate est non intrusif, c'est--dire quil ne ncessite pas limplmentation dune quelconque interface ou hritage. La deuxime tape consiste mapper nos entits dans les tables de la base de donnes. Pour cela, Hibernate utilise deux types de fichiers de configuration.

22

Rapport de Projet J2EE Site de E-Commerce

janv. 8

Le premier, hibernate.cfg.xml, regroupe les paramtres ayant trait la base de donnes elle-mme (son type, comment y accder, etc).
<hibernate-configuration> <session-factory> <property name="hibernate.dialect"> org.hibernate.dialect.PostgreSQLDialect </property> <property name="hibernate.connection.driver_class"> org.postgresql.Driver </property> <property name="hibernate.connection.url"> jdbc:postgresql://localhost/e-commerce </property> <property name="hibernate.connection.username"> Postgres </property> <property name="hibernate.connection.password"> Administrateur </property> <property name="show_sql">true</property> <property name="hibernate.jdbc.batch_size">0</property> <mapping resource="yaz/ecommerce/entite/commande.hbm.xml"/> </session-factory> </hibernate-configuration>

La proprit hibernate.dialect sert configurer le dialecte SQL de la base de donnes. Ce dialecte va servir Hibernate pour optimiser certaines parties de l'excution en utilisant les proprits spcifiques la base. Cela se rvle trs utile pour la gnration de cl primaire et la gestion de concurrence. Chaque base de donnes son dialecte propre. La proprit hibernate.connection.driver_class permet de renseigner quel est le driver jdbc utiliser. Ce driver est fournit par lditeur de la base de donnes. La proprit hibernate.connection.url renseigne sur ladresse de la base de donnes. Les proprits hibernate.connection.username et hibernate.connection.pasword correspondent aux identifiants du compte avec lequel Hibernate va accder la base de donnes. Les deux proprits suivantes sont optionnelles, le premire permettant dafficher les requtes cres par Hibernate dans la console au moment de lexcution, et la deuxime dsactive les traitements par batch. Ensuite, il faut ajouter tous les mappings des entits dont nous avons besoin grce aux balises mapping ressource . En gnral, chaque objet persistant possde son fichier de mapping. Le contenu dun tel fichier pour la classe Commande est le suivant :
<hibernate-mapping package="yaz.ecommerce.entite"> <class name="Commande" table="commandes"> <id name="id" type="integer"> <generator class="sequence"> <param name="sequence">commandes_id_seq</param> </generator> </id>

23

Rapport de Projet J2EE Site de E-Commerce

janv. 8 <property name="dateCommande" column="date_commande" type="date" /> <property name="datePreparation" column="date_preparation" type="date" /> <property name="dateExpedition" column="date_expedition" type="date" /> <property name="client" type="integer" /> <component name="livraison" class="yaz.ecommerce.entite.Livraison"> <property name="civilite" column="livraison_civilite" type="string" /> <property name="nom" column="livraison_nom" type="string" /> <property name="prenom" column="livraison_prenom" type="string" /> <property name="adresse" column="livraison_adresse" type="string" /> <property name="cp" column="livraison_cp" type="integer" /> <property name="ville" column="livraison_ville" type="string" /> </component> <property name="port" type="float" /> <property name="tva" type="float" /> </class> </hibernate-mapping>

La balise class dfinit le mapping de la classe Commande (lattribut package sert de raccourci pour le package de cette classe) et lattribut table donne la table dans la base de donne qui va tre concerne par cette classe. On doit ensuite mapper tous les champs de la classe un par un, avec certaines spcificits. Les classes mappes doivent dclarer la cl primaire de la table en base de donnes. Toutes nos classes ont ainsi une proprit prsentant l'identifiant unique d'une instance. L'lment <id> sert dfinir le mapping entre cette proprit et la clef primaire en base. L'lment fils <generator> nomme une classe Java utilise pour gnrer les identifiants uniques pour les instances des classes persistantes. Certaines applications peuvent proposer leurs propres implmentations spcialises pour le gnrateur de cls mais pour notre utilisation, nous nous servons dune des implmentations intgres Hibernate. Il est bien sr galement possible dutiliser des cls composes en mappant plusieurs attributs de la classe comme proprits identifiantes mais nous ne les avons pas utilises. Toutes les proprits simples se mappent aisment en spcifiant dun cot le nom de la proprit dans la classe java et de lautre le nom de la colonne dans la base de donnes. Pour les proprits complexes, on utilise llment <component> en lui passant en paramtre le nom de la proprit java dans lobjet et le chemin vers la classe correspondant cet objet. Les paramtres sont alors mapps de la mme faon que pour la classe englobante. Lutilisation que nous avons faite dHibernate est assez rudimentaire puisque globalement, tous nos objets sont mapps de cette faon. Nanmoins, aprs avoir commenc la lecture du livre Hibernate in Action, nous nous sommes aperus que la meilleure faon de modliser les classes tait diffrente de la notre, et quelle impliquait de nombreux autres lments dans les fichiers de configuration.

24

Rapport de Projet J2EE Site de E-Commerce

janv. 8

Ainsi, mme si notre mapping est fonctionnel, nous nous sommes rendu compte sur le tard de ses limites lorsque nous avons eu besoin de mapper des objets plus complexes quune simple classe contenant uniquement des types simples. Ce fut notamment le cas pour mapper les objets reprsentant les commandes, puisque ceux-ci comportaient des tableaux dobjets complexes reprsentant le contenu de la commande. Nanmoins, cest une fois le mapping effectu que lon se rend compte de la puissance dHibernate. Pour manipuler les objets persistants, tout passe par lobjet Hibernate Session.
public void enregistrerCommande( Integer idClient, Livraison livraison, Double tva, Double port, ArrayList<PannierItem> listePortables){ (1) Transaction tx = null; session = sessionFactory.openSession(); Commande commande = new Commande(idClient, livraison, 25.0f , 19.6f); try { tx = session.beginTransaction(); session.save(commande); for (Iterator it = listePortables.iterator(); it.hasNext();){ CommandeContenu contenu = new CommandeContenu((PannierItem)it.next()); contenu.setCommande(commande.getId()); session.save(contenu); } tx.commit(); } catch (HibernateException e) { e.printStackTrace(); if (tx != null && tx.isActive()) tx.rollback(); } finally { session.close(); sessionFactory.close(); } }

(2) (3)

(4)

(5)

Tout dabord, on rcupre une session Hibernate (1) grce une fabrique qui analyse les fichiers xml de configuration et qui retourne un objet prt lemploi. Ensuite, on dbute une transaction (2), qui reprsente une unit de travail, c'est--dire toutes les instructions raliser pour complter une tche. En (3), nous constatons quil suffit dune simple ligne pour insrer notre objet java dans la base de donnes ! En (4), nous flushons la session et terminons notre unit de travail. Il est remarquable de voir que si une exception sest produite pendante la dure de la transaction, lapi Hibernate est capable dannuler toutes les modifications qui se sont droul durant cette priode (5). Ds lors, on se rend bien compte des raisons qui ont mens au succs dHibernate par ce simple exemple.

25

Rapport de Projet J2EE Site de E-Commerce

janv. 8

De la mme faon, pour rcuprer un objet persistant, on utilisera la fonction suivante :

tx = session.beginTransaction(); Commande commande = (Commande)session.get(yaz.ecommerce.entite.Commande.class,id); tx.commit();

Un simple appel la fonction get avec en paramtre la classe de lobjet persistant et la cl primaire de lobjet en base permet de rcuprer une instance persistance java. De mme que si lon utilise le code suivant durant une session:
tx = session.beginTransaction(); Commande commande = (Commande)session.get(yaz.ecommerce.entite.Commande.class,id) Commande.setPort(12f); tx.commit();

Lapi Hibernate va dtecter le changement dune des proprits de lobjet commande et va mettre jour automatiquement lenregistrement correspondant en base de donnes. En ce qui concerne le requtage, Hibernate est aussi bien capable dutiliser le langage SQL
tx = session.beginTransaction(); Query q = session.createQuery("select * from commandes_contenu where commande=:id"); q.setInteger("id",id); contenu = (ArrayList<CommandeContenu>)q.list(); tx.commit();

Que le langage HQL (Hibernate Query Language). Ce dialecte orient objet a t dvelopp au dessus du langage SQL afin de rcuprer des objets en base de donnes (le R de CRUD).
tx = session.beginTransaction(); Query q = session.createQuery("from Commande as c where c.client = ?").setInteger(0, id); liste = q.list(); tx.commit();

La diffrence entre les deux prcdentes requtes est quen HQL, la requte retourne une liste non pas dObject mais de Commande. Hibernate propose mme un autre type de requtage, via lapi Query By Criteria (QBC) qui permet de construire ses requtes en spcifiant les contraintes dynamiquement sans manipulation de chaines de caractres comme on serait oblig de le faire en HQL ou en SQL.
Criteria crit = session.createCriteria(yaz.ecommerce.entite.News.class); crit.addOrder(Order.desc("date")); crit.setMaxResults(10); liste = (ArrayList)crit.list();

26

Rapport de Projet J2EE Site de E-Commerce

janv. 8

V. Conclusion
Ce projet, malgr la courte dur dont nous avons dispos, nous a t dun grand bnfice. En effet, lorsquau mois de Septembre nous avons choisi comme sujet le dveloppement J2EE, lun des principaux objectifs tait de proposer un profil extrmement attractif sur nos CV puisque le march de lemploi dans le domaine de linformatique est aujourdhui domin par le dveloppement Java/J2EE. La facilit avec laquelle nous avons tous les deux trouv notre stage confirme que ce choix tait pertinent. Sur un plan plus technique, nous avons dcouvert le monde du dveloppement web dans un langage que nous connaissions dj. Nanmoins, la spcificit de J2EE fait que nous avons du apprendre toutes les bases de cette nouvelle architecture ce qui nous a pris plus de temps que nous ne lescomptions. Finalement, une fois maitris, nous nous sommes rendu compte de la puissance de loutil et avons compris pourquoi, pour des sites de grosse audience ncessitant de frquentes mises jour et proposant des services complexes, le mode est aujourdhui au J2EE plutt qua un langage comme PHP. Nous avons pu apprendre les bases des frameworks les plus couramment utiliss tels que Struts, Spring et Hibernate. Compte tenu de la complexit de ces APIs, et du peu de temps dont nous disposions, nous navons pas pu pousser notre approche trop loin mais nous avons quand mme eu le temps de juger de leur utilit. Struts est aujourdhui lun des frameworks incontournables dans le monde J2EE, comme peut ltre Hibernate (et dans une moindre mesure Spring) et son utilisation, relativement aise, amliore grandement la facilit de dveloppement. Sa gestion faon MVC 2 avec un contrleur unique et ses taglibs utilises pour la gestion des formulaires en font un alli presque indispensable pour une application de grande envergure. Hibernate quant lui est beaucoup plus complexe maitriser et ncessiterait un projet complet pour en maitriser toutes les facettes. Malgr cela, il nous est apparu comme tant une alternative extrmement puissante au requtage classique en SQL comme on le connait en PHP par exemple. Son efficacit est dailleurs reconnue tel point que le framework a t port en C# pour tre utilis dans lenvironnement .NET (tout comme la t Spring IoC). Avec un peu plus de temps, nous aurions galement aim tester des frameworks comme Tiles pour ajouter notre application un systme de template ou JSF, le futur standard proposant un modle bas sur les composants graphiques et non plus sur le paradigme MVC.

27