MVC2 avec Struts Version 1.

Prpar par F. BERNA

MVC2 avec Struts

INTRODUCTION........................................................................................................................................................ 3 DECOMPOSITION DU MODELE-VUE-CONTROLEUR .................................................................................... 3 LES TROIS COMPOSANTS MVC DUNE APPLICATION WEB ........................................................................................... 4 LES AVANTAGES D'UNE TELLE DECOMPOSITION.......................................................................................................... 5 TRAITEMENT DUNE REQUETE PAR LE MODELE MVC ................................................................................................. 5 LE MODELE 1.............................................................................................................................................................. 3 LE MODELE 2.............................................................................................................................................................. 4 STRUTS ........................................................................................................................................................................ 7 INTRODUCTION ........................................................................................................................................................... 7 ARCHITECTURE STRUTS MVC2.................................................................................................................................. 8 CONSTRUCTION DES COMPOSANTS DE MODELE .......................................................................................................... 8 Prsentation ........................................................................................................................................................... 8 Porte des JavaBeans ............................................................................................................................................ 9 Beans de Formulaire (ActionForm) ....................................................................................................................... 9 Les beans Action .................................................................................................................................................. 10 CONSTRUCTION DES COMPOSANTS DE VUE .............................................................................................................. 11 Prsentation ......................................................................................................................................................... 11 Gestion des messages........................................................................................................................................... 11 Interaction Formulaires/FormBean ..................................................................................................................... 12 Construction de formulaires avec Struts .............................................................................................................. 12 Types de champs supports .................................................................................................................................. 14 Autres tags utiles.................................................................................................................................................. 14 Validation automatique de formulaires................................................................................................................ 14 CONSTRUIRE LE COMPOSANT DE CONTROLE ............................................................................................................. 15 Introduction.......................................................................................................................................................... 15 Fichier [Link] ...................................................................................................................................... 15 Dploiement de lApplication Web ...................................................................................................................... 16 ASPECTS TECHNIQUES IMPORTANTS ............................................................................................................ 19 GESTION DES VARIABLES .......................................................................................................................................... 19 CONCLUSION........................................................................................................................................................... 19

MVC2 avec Struts

Introduction
Struts est un FrameWork de dveloppement dapplication web, bas sur le pattern de conception ModleVue-Contrleur (MVC). Il est compos dun contrleur (un servlet), de la vue (des pages JSP), et de la logique mtier (le modle). Struts fait partie du groupe ouvert Jakarta Project dont le but est de fournir des outils orients Application Web, bass sur la technologie Java .

Dcomposition du Modle-Vue-Contrleur

Le Modle 1
Le premier modle consiste en une collection de pages JSP. La programmation d'un site de type Modle 1 est facile. Il est notamment possible de mixer des routines en script. Ainsi, la logique mtier (javaBeans), le traitement ct serveur (JSP et Java), et les scripts clients (HTML, JavaScript) sont mlangs dans une seule page excutable. Alors le conteneur JSP fait tout le travail. Trs facile mettre en oeuvre, le modle 1 ne permet pas la construction de grosses applications web, la logique tant mlange dans toutes les pages JSP. Les tches complexes sont difficilement implantes dans ce modle qui tend a produire du code difficile tendre et maintenir. Les grosses pages JSP sont difficilement rutilisables. Le code gnr n'est pas modulable. Une mise jour met en branle l'ensemble du projet plutt qu'un seul point prcis. Autant le modle 1 est trs apprciable par sa simplicit d'application, autant la gestion dun grand nombre de pages JSP est laborieux. Dans le cas de l'implantation d'une grosse application web que l'on veut plus facile maintenir, on utilisera plutt une conception de type modle 2 (bas sur le paradigme MVC).

Figure 1. Architecture de type Modle 1. Les composants sont indpendants

MVC2 avec Struts

Le Modle 2
La principale caractristique du Modle 2 est dtre compos dun seul servlet de contrle linverse du modle 1 qui associe un servelt chaque vue. Le modle 2 est un framework de dveloppement bas sur le pattern de conception modle-vuecontrleur MVC. Le "modle" contient la logique mtier et l'tat du systme. La "vue" est gnre par les pages JSP. Le "contrleur", implant dans un servlet, apporte une gestion centralise du traitement. Le pattern MVC rend le code plus propre et spare la logique mtier, le traitement ct serveur et l'affichage dans des composants distincts. Chaque composant est ainsi rutilisable et remplaable. Par contre, un framework complexe est ncessaire pour assembler ces diffrents composants.

Figure 2. Architecture de type MVC

Les trois composants MVC dune application web

Larchitecture MVC comprend trois classes dobjets : - Le modle : ce document contient les donnes et la logique mtier - La vue : il sagit du composant prsentation, ou IHM. Plusieurs vues peuvent fournir diffrentes prsentations dun modle unique - Le contrleur : Il sagit du composant qui rpond la saisie utilisateur. Le contrleur traduit les vnements de lIHM en modifications du modle, puis dfinit la manire dont lIHM ragit ces vnements Ces trois classes sont des divisions logiques de fonctionnalits utilises pour sparer la logique mtier, la logique de prsentation et la conception du site web.

MVC2 avec Struts

Les avantages d'une telle dcomposition

Cette architecture rend les trois parties de lapplication : la logique de prsentation, la logique mtier et la structure du site web parfaitement indpendantes. Ainsi, la programmation de chacune peut tre distribue des quipes diffrentes. La maintenance de lapplication est plus souple. En effet, le partitionnement de lapplication permet de modifier la prsentation, les pages web, sans toucher la structure du site et la logique mtier. De mme, les composants implmentant la logique mtier peuvent tre remplacs et la structure du site modifie.

Traitement dune requte par le modle MVC

Figure 3. Cheminement dune requte 1. Lutilisateur manipule linterface homme/machine. Un vnement est envoy. Cet vnement est rcupr par le contrleur. 2. Le contrleur effectue laction demande par lutilisateur en appelant les mthodes ncessaires sur le modle 3. Le contrleur informe la vue dun changement dtat du modle 4. La vue interroge le modle afin de connatre son tat 5. Lutilisateur voit le rsultat de son action

MVC2 avec Struts

MVC2
La construction d'un systme MVC2 est complexe. Toutes les pages et les composants doivent tre inscrits dans le framework, ce qui produit un surcot de travail. Chaque page HTML ne peut plus tre conue indpendamment des autres. Elle fait partie d'un processus plus large, contenant : - le modle : deux types de JavaBeans pour la logique mtier (Action) et pour l'tat de l'application (FormBean) - la vue : des pages JSP qui fournissent au client la rponse ses requtes - le contrleur : une servlet qui gre les transactions. Il excute le code ncessaire une requte, et en coordonne la rponse

Figure 4. Architecture de type MVC2. Le navigateur agit sur un seul composant, le contrleur

Struts est un framework de type modle 2. Il permet de simplifier la construction d'un systme MVC qui a l'avantage de fournir du code propre et rutilisable. Le temps pass apprhender cette conception est rattrap dans les phases de maintenance et de mise jour.

MVC2 avec Struts

Struts

Introduction
Struts est un framework en open source, utilis pour dvelopper des applications web bases sur les technologies Servlet et JSP, et sur une architecture de type MVC2. Il permet notamment de sparer la partie Modle (programmation, traitement des informations) de la partie Prsentation (affichage) Il est compos de : - Un contrleur : un servlet - La vue : des pages JSP, avec des librairies de tag struts pour assister le dveloppeur - La logique mtier : le modle. Pour expliquer le fonctionnement de Struts, nous utiliserons un exemple trs simple : - Un utilisateur saisit son nom et son prnom dans un formulaire dune page JSP. - Sil na pas saisi les deux informations, un message derreur est affich et il est invit recommencer sa saisie - Si la saisie est correcte, la classe user est instancie, des traitements (calcul des initiales) sont effectus. - Une page JSP affiche les informations saisies ainsi que les initiales de la personne. Pour ce faire, nous utiliserons la classe user :

public class User{ protected String nom; protected String prenom; protected String initiales; public void setNom(String nom) {[Link] = nom;} public String getNom() {return nom;} public void setPrenom(String prenom) {[Link] = prenom ;} public String getPrenom () {return prenom;} public void setInitiales(String initiales) {[Link] = initiales;} public String getInitiales () {return initiales;} }

MVC2 avec Struts

Architecture Struts MVC2

[Link]

[Link]

Contrleur
[Link]

[Link] 5. Redirige [Link]

Action
[Link]

Client
[Link]

Page JSP

[Link]

FormAction

Fonctionnement global de Struts : 1. Le client effectue une requte (via un formulaire par exemple) 2. Le contrleur, configur par le fichier [Link] affecte le FormAction avec les donnes saisies dans le formulaire 3. Le contrle donne la main Action 4. Action effectue des traitements sur le FormAction ou sur autre source de donnes 5. Action rend la main au contrleur en lui spcifiant la russite ou non de ses traitements et la page de prsentation appeler 6. Le contrleur appelle la page de prsentation JSP 7. La page JSP consulte les donnes du FormAction et les formate 8. La page JSP envoie une rponse au client.

Construction des composants de modle

Prsentation
Le composant de modle se concentre sur la cration de classes JavaBeans qui supportent toutes les fonctions requises pour effectuer les traitements (comme la gestion dune Bases de donnes, ou lidentification des utilisateurs). On distinguera sous Struts deux type de JavaBeans : - Les Beans FormAction : Beans de formulaires, destins rcuprer et effectuer des traitements de validit sur les donnes postes par un formulaire. - Les Beans Action : Beans daction, destins aussi effectuer des traitements. Ils informent le contrleur quelle page JSP appeler en fonction du rsultat des traitements.

MVC2 avec Struts

Porte des JavaBeans

Dans une application web, les JavaBeans peuvent avoir diffrentes portes (dfinissant la dure de vie et la visibilit des Beans). Dans chaque porte, on trouvera une collection dattributs. La spcification JSP dfinit la porte en utilisant les termes suivants : - page : Beans qui sont visibles par une seule page JSP, pour la dure de vie de la requte - request : Beans qui sont visibles par une seule page JSP, ainsi que par toutes les pages ou servlet inclus dans cette page - session : Beans visibles par toutes les pages JSP et servlets dune session utilisateur - application : Beans visibles par toutes les pages JSP et servlets dune application web Il est important de rappeler que les Servlets et pages JSP dune application web partagent les mmes collections dattributs pour une porte donne. Par exemple, un Bean stock comme attribut de requte dans un servlet comme suit : MyCart mycart = new MyCart() ; [Link]( cart , mycart) ;

Est immdiatement visible par une page JSP appele par ce servlet, en utilisant le tag action : <jsp:useBean id=cart scope=request class=[Link]/>

Beans de Formulaire (ActionForm)

Le Framework Struts gre des beans ActionForm (qui hritent de la classe ActionForm) pour chaque formulaire de lapplication. Pour tre fonctionnel, chaque Bean devra tre dfini dans le fichier de configuration [Link]. (voir section Composant de contrle). Lors de la validation dun formulaire, le contrleur Struts cr le ActionForm associ dans la session utilisateur (pour que ses donnes soient accessibles par les pages JSP), affecte toutes les variables avec les donnes du formulaire, et passe le bean en paramtre la mthode Perform() du Bean Action associ. Principes respecter pour coder les beans ActionForm : - Ce sont des classes qui ne requirent pas de mthodes spcifiques. Ils ne possdent que des mthodes getter et setter. - La mthode validate() permet de contrler la validit des donnes reues du formulaire (ex. : age dune personne) et dinformer le contrleur si les donnes saisies sont valides ou non. Cette mthode nest pas obligatoire, la validation peut tre effectue dans le bean Action associ. - Chaque proprit de la classe doit avoir ses propres accesseurs de la forme getMaproprit() et setMaproprit(Maproprit). Les accesseurs permettent aux pages JSP de consulter le contenu des Beans, grce aux taglibs. Le Bean ActionForm est donc un Bean qui reprend toutes les donnes saisies dans un formulaire, effectue un contrle sur ces donnes, et sera utilis par le bean Action associ pour des traitements. Retour lexemple. Voici la classe UserForm, qui rcupre les informations saisies dans le formulaire, et qui vrifie que le nom et le prnom aient bien t saisis. Dans le cas contraire, elle retourne un message derreur.

MVC2 avec Struts

import import import import import

[Link]; [Link]; [Link]; [Link]; [Link];

public class UserForm extends ActionForm { protected String nom; protected String prenom; public void setNom(String nom) {[Link] = nom;} public String getNom() {return nom;} public void setPrenom(String prenom) {[Link] = prenom ;} public String getPrenom () {return prenom;} public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) { ActionErrors errors = new ActionErrors(); if ((nom == null) || ([Link]() < 1)) [Link]("nom", new ActionError("[Link]")); if ((prenom == null) || ([Link]() < 1)) [Link]("prenom", new ActionError("[Link]")); return errors; } }

Note : la classe UserForm doit tre dclare dans le fichier WEB-INF/[Link] pour tre excutable (voir section construire le composant de contrle) ;

Les beans Action

Lors de la rception dune requte utilisateur, le contrleur appelle le bean Action associ. Celui-ci va effectuer tous les traitements demands (Recherche dinformations dans une Base de donnes, validation dinformations postes). Puis, en fonction du rsultat, le bean Action rend la main au contrleur (par un ActionForward) en lui spcifiant la page JSP de prsentation appeler. Ces traitements se font dans la mthode perform() du bean Action. Retour lexemple. Voici lAction qui rcupre le nom et le prnom du Bean FormAction, Calcule les initiales, et rend la main au contrleur.

MVC2 avec Struts

public final class inscriptionAction extends DicoBaseOngletAction { public ActionForward perform(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException{ //Initialisation User user = null ; //Rcupration du nom saisi dans un formulaire associ la classe UserForm (voir section contrleur String usernom = ((UserForm) form).getNom(); String userprenom = ((UserForm) form).getPrenom() ; //Traitements [Link](usernom ); [Link](userprenom) ; [Link]([Link](0,1) + [Link](0,1)) ; // on sauve les informations dans la accessibles par les pages JSP HttpSession session = [Link](); [Link]("user", user); //On redonne la main au contrleur qui associe la cl "success" return([Link]("success")); session, pour tre

appelle

la

page

JSP

Note : la classe inscriptionAction doit tre dclare dans le fichier WEB-INF/[Link] pour tre excutable (voir section construire le composant de contrle) ;

Construction des Composants de Vue

Prsentation
Ce chapitre porte sur la construction des composants de vue dune application Struts. Les composants de vue sont bass sur des pages JSP, avec des tags spcifiques Struts. Les pages JSP utilisent des librairies de tags pour accder aux donnes des Beans (taglib bean), pour insrer des pages JSP (taglib template), pour crer des formulaires dont les donnes sont accessibles par les FormBean (taglib HTML), ou pour effectuer des traitements logiques comme les boucles, les test (taglib logic).

Gestion des messages

Struts permet dexternaliser tous les messages utiliss dans les pages JSP, comme dans les Beans (messages derreur par exemple). Ces messages sont stocks dans le fichier [Link] , et sont indexs sous la forme cl=valeur

MVC2 avec Struts Retour lexemple. Notre fichier [Link] possde les entres : [Link]=<LI>Vous devez saisir votre nom [Link]=<LI>Vous devez saisir votre prnom [Link]=Nom [Link]=Prnom [Link]=Envoyer [Link]=Effacer Les messages sont accessibles dans les pages JSP par le tag : <bean:message key="cl"/> Notes : - le fichier [Link] doit tre dclar dans le fichier WEB-INF/[Link] (voir section construire le composant de contrle) - linstallation de ce fichier sur serveur WebSphere doit respecter certaines contraintes (voir document Ajouter Struts une application Web sous WebSphere 3.5

Interaction Formulaires/FormBean
Dans un systme de dveloppement traditionnel, des contrles sont effectus sur les donnes saisies dans les formulaires, directement sur le client (JavaScritpts de contrle). Ainsi, le client na pas ressaisir toutes les autres informations. Dans le cas o les contrles sont effectus sur le serveur (le formulaire est post), il faudra rafficher toutes les informations. Ceci peut savrer laborieux. En effet, pour notre exemple, il faudrait entrer la ligne : <input type="text" name="prenom" value="<%= [Link]()%>"/> Struts fourni des outils simples dutilisation pour construire des formulaires qui respectent ces contraintes. Ainsi le code prcdent deviendra sous Struts : <html:text property="nom"/> Il nest pas ncessaire de prciser le Bean associ. Il est retrouv automatiquement (celui utilis pour poster le formulaire).

Construction de formulaires avec Struts

Voici un exemple de formulaire qui illustre comment Struts fonctionne avec les formulaires. Les fonctionnalits Struts : - Appel des librairies de Tag en dbut de page - Utilisation des messages du fichier [Link]. Pour afficher les intituls Nom utilise la cl [Link] et pour Prnom la cl [Link]. De mme pour les boutons valider et recommencer. - Le tag errors affiche les messages derreur en cas de saisie errone - Le tag form cr un formulaire coupl avec le FormBean inscription. Ce bean est dabord utilis pour initialiser la valeur de chacun des champs, puis pour recueillir les informations postes par le formulaire. - Le tag text cr un champ <input> de type text .

MVC2 avec Struts Les tag submit et reset crent des boutons denvoi et de remise zro.

<%@ page language="java" %> <%@ taglib uri="/WEB-INF/[Link]" prefix="html" %> <%@ taglib uri="/WEB-INF/[Link]" prefix="bean" %> <html:html> <head> <body bgcolor="white"> <!-- la balise suivante rcupre les messages derreurs gnres par les FormAction et Action --> <html:errors/> <html:form action="/inscription" focus="username"> <table border="0" width="100%"> <tr> <th align="right"> <html:message key="[Link]"/> </th> <td align="left"> <html:text property="nom" size="16"/> </td> </tr> <tr> <th align="right"> <html:message key="[Link]"/> </th> <td align="left"> <html:text property="prenom" size="16"/> </td> </tr> <tr> <td align="right"> <html:submit> <bean:message key="[Link]"/> </html:submit> </td> <td align="right"> <html:reset> <bean:message key="[Link]"/> </html:reset> </td> </tr> </table> </html:form> </body> </html:html>

Note : le fichier [Link] doit tre dclar dans le fichier WEB-INF/[Link] pour tre excutable (voir section construire le composant de contrle).

MVC2 avec Struts

Types de champs supports

Struts dfini des tags HTML pour tous les champs suivant : - checkbox - input de type password - champs de type hidden - boutons radio - boutons reset - boutons submit - listes select - options - champs input de type text - textareas Dans tous les cas, chacun de ces champs doit tre inclus dans un tag form. Ceci pour connatre le bean associ.

Autres tags utiles

Struts dfini aussi une liste de tags autre que ceux rservs aus formulaires : - <logic :iterate> pour rpter une boucle pour tous les lments dune collection (ex. : Vecteur, Hashtable, tableaux) - <html :link> pour gnrer une ancre ou un lien hypertexte (dont lURL peut tre directement modifie partir des informations contenues dans un Bean) - <html :img> pour insrer une image (dont lURL peut tre directement modifie partir des informations contenues dans un Bean) - <bean :parameter> pour rcuprer les paramtres envoys cette page.

Validation automatique de formulaires

En plus des interactions Formulaire/FormBean, Struts offre une mthode simple de validation des informations saisies : la mthode validate() dans le FormBean. Cette mthode est appele aprs que le formulaire ait t post, et avant que la mthode perform() du FormBean soit appele. On y effectue les divers contrles de saisie (donnes obligatoires). En cas de saisie errone, un message derreur doit tre ajout dans le conteneur ActionErrors. Une fois la mthode validate() excute, si le conteneur de messages derreur est vide, la mthode perform() est appele. Dans le cas contraire, le formulaire dappel est raffich, et le tag <html :errors> soccupe dafficher les diffrents messages derreur. Comme dit dans le chapitre FormBeans , cette mthode est optionnelle et doit tre configure dans le fichier [Link] pour tre excute.

MVC2 avec Struts

Construire le composant de contrle

Introduction
Struts inclut un servelt de contrle qui associe chaque requte une Action, un FormAction, ou une redirection. Pour fonctionner, ce servlet doit tre dclar dans le fichier [Link], et configur laide du fichier [Link].

Fichier [Link]
Le fichier [Link] permet de configurer les requtes, les actions, les formulaires, et les renvois vers les pages JSP. A lintrieur de la balise <struts-config>, on trouve essentiellement trois lments : - form-beans : contient la dfinition des FormAction. Il est ncessaire dutiliser un lment form-bean par ActionForm, en prcisant lURL de la requte (name) et la classe utilise pour cet ActionForm (type) - global-forwards : contient les dclarations de renvois dURL vers des pages JSP ou des Action. - action-mapping : contient la dfinition des Actions. Pour chaque Action, il faut dfinir : - le chemin de la requte associe (path) - la classe utiliser (type) - si ncessaire, le nom du FormAction utiliser (name) - la porte de la classe (scope) - si oui ou non la mthode validate() du FormBean doit tre appele (validate = true ou false)

MVC2 avec Struts Exemple dun fichier [Link] <struts-config> <!-- beans de formulaires --> <form-beans> <form-bean name="userForm" type="[Link]" /> </form-beans> <!-- redirections globales --> <global-forwards type="[Link]" /> <forward name="index" path="/[Link]" redirect="false" /> </global-forwards> <!--mapping des actions --> <action-mappings> <!-- Accueil --> <action path="/inscription" type="[Link]" scope="request" name="userForm" validate="true" unknown="true"> <forward name="success" path="/jsp/[Link]" redirect="false" /> <forward name="failure" path="/jsp/[Link]" redirect="false"/> </action> </action-mappings> </struts-config>

Dploiement de lApplication Web

La dernire tape est la configuration du descripteur de dploiement de lapplication Struts, pour intgrer tous les composants ncessaires. Sous Tomcat, ce descripteur est le fichier WEB-INF/[Link].

MVC2 avec Struts

Configuration du Servlet dAction

La dclaration du servlet de contrle Struts se fait comme lexemple suivant :

<!-- Configuration du servlet de contrle Struts --> <!-- Nom du servlet et classe associe --> <servlet> <servlet-name>action</servlet-name> <servlet-class>[Link]</servlet-class> <!--fichier contenant les messages utiliss dans les pages JSP et les beans-> <init-param> <param-name>application</param-name> <param-value>[Link]</param-value> </init-param> <load-on-startup>2</load-on-startup> </servlet>

Configuration du mapping du Servlet dAction

Le servlet daction Struts doit tre configur pour ne sappliquer que sur certaines URLs. Ainsi, on peut dcider que le contrleur sera appel pour toutes les URLs dextension .do : <servlet-mapping> <servlet-name>action</servlet-name> <url-pattern>*.do</url-pattern> </servlet-mapping>

Configuration des librairies de Tag de Struts

Ensuite, il faut dfinir les librairies de tag de Struts. Il en existe actuellement quatre fournies avec Struts : - La librairie struts-bean contient les tags utiliss pour accder aux Beans et leur proprits, aussi bien que pour crer des Beans. - La librairie struts-html contient les tags utiliss pour crer des formulaires Struts - La librairie struts-logic contient les tags utiliss pour grer les sorties texte, grer les flots de lapplication, les tests, les boucles itratives. - La librairie struts-template contient les tags utiliss pour importer une page JSP lintrieur dune autre

MVC2 avec Struts

<taglib> <taglib-uri> /WEB-INF/[Link] </taglib-uri> <taglib-location> /WEB-INF/[Link] </taglib-location> </taglib> <taglib> <taglib-uri> /WEB-INF/[Link] </taglib-uri> <taglib-location> /WEB-INF/[Link] </taglib-location> </taglib> <taglib> <taglib-uri> /WEB-INF/[Link] </taglib-uri> <taglib-location> /WEB-INF/[Link] </taglib-location> </taglib> <taglib> <taglib-uri> /WEB-INF/[Link] </taglib-uri> <taglib-location> /WEB-INF/[Link] </taglib-location> </taglib>

Ajouter des composants Struts votre application

Une fois les deux fichiers crs, il faut intgrer tous les composants Struts lapplication. Tlcharger le fichier dinstallation de Struts sur le site : [Link] Copier les fichiers commons-*.jar dans le rpertoire WEB-INF/lib de lapplication (fichiers communs tous les programmes du projet Jakarta (contient notamment un parseurs XML, des applicatif Java) Copier [Link] dans le rpertoire WEB-INF/lib de lapplication (contient les classes ncessaires au fonctionnement de Struts, comme les classes Action, FormAction et autres) Copier les fichiers struts-*.tld dans le rpertoire WEB-INF (contient les librairies de tag pour les pages JSP propres Struts ) Installer les classes de lapplication dans le rpertoire WEB-INF/classes

MVC2 avec Struts

Aspects techniques Importants

Gestion des variables

Pour une application Struts donne, chaque classe nest instancie quune seule fois. Tous les utilisateurs utilisent la mme instance. Toutes les classes Action de lapplication ne doivent utiliser que des variables locales. Struts soccupe dempiler ces variables pour viter tout conflit. En revanche, toute variable dinstance est partage entre tous les utilisateurs.

Echange de donnes
Toutes les donnes calcule dans les Beans, ou saisies dans les formulaires transitent par la session utilisateur. Ainsi, tout rsultat calcul dans une Action devra tre mont en session pour tre accessible par les pages JSP. Inversement, toute donne saisie dans un formulaire est accessible par les Beans dans la session.

Conclusion
Struts est un FrameWork qui permet de dvelopper des applications web en utilisant le modle MVC2. Il apporte de nombreux avantages : sparation des fonctions de modle, de contrle et de vue. Il permet ainsi de bien distinguer la partie programmation mtier de la partie affichage. Struts fournit les outils ncessaires pour que la conception de la vue ne fasse pas intervenir de comptences en programmation, et pour que la partie modle ne fasse pas intervenir de comptences en infographie et design. La prise en main de Struts est difficile : il faut se familiariser avec le concept MVC2 et apprendre utiliser las API et les tags Struts ; linstallation du Struts peut aussi savrer laborieuse (notamment sur le serveur WebSphere 3.5). Cependant, les gains de temps sont importants par la suite : facilit de maintenance (que ce soit du ct modle ou du ct vue), portions de code facilement rutilisables. On rservera donc lutilisation de Struts pour les grosses applications grant un grand nombre de pages.