I. Introduction

Struts est un framework proposant un cadre logiciel pour l'organisation des échanges avec l'utilisateur et la dynamique de l'application. Il promeut une structuration de la couche Servlet-JSP suivant le modèle MVC II. La définition de la dynamique de l'application est partiellement déclarative, via un fichier de configuration, partiellement implémentée, au sein des classes Action.

II. Présentation et modèles équivalents

Struts est un projet Open Source développé par la communauté Jakarta d'Apache. Il a débuté en mai 2000 sous la direction de Craig R Mc Clanahan, qui participe également au développement de Tomcat. Aujourd'hui, Struts est géré par plusieurs committers. Sa mailing-list comporte un millier de personnes. C'est un projet très actif. Expliquons tout d'abord ce qu'est un framework (lit. Structure) : architecture et ensemble d'outils de développement. J2EE est un Framework Java pour les développements web. Les Frameworks ont l'avantage de structurer, simplifier, segmenter les développements et donc les accélérer. Struts fournit un framework MVC comprenant les composants suivants :

  • un contrôleur facilement configurable permettant d'associer des actions (méthode d'un objet Java) à des requêtes HTTP ;
  • des bibliothèques de tags spécifiques pour créer facilement une vue ;
  • un Digester, permettant de parser un fichier XML et d'en récupérer seulement les informations voulues.

II-A. Le modèle

II-B. La vue


La vue sous Struts est constituée de pages JSP. Afin de rendre la création de ces pages aisées par un designer et d'y éviter l'introduction de code Java, Struts propose l'utilisation de quatre bibliothèques de tags ou taglib spécifiques : html, bean, logic et template.

II-C. Taglibs de Struts



Les taglibs de Struts sont très complètes et permettent de faire beaucoup de choses sans écrire de code Java. Des bibliothèques répondant à des besoins plus spécifiques - création de composants, accès à une base de données, mises en page - sont en projet pour les prochaines versions de Struts.

II-D. Le contrôleur



Le contrôleur est la partie du framework qui fait le lien entre la vue et le modèle. C'est elle qui permet de gérer l'enchaînement de la navigation. Dans Struts, le point central du contrôleur est un servlet de la classe ActionServlet. Toutes les requêtes y aboutissent. Du point de vue du développeur, la programmation du contrôleur passe par :

  • l'écriture d'un fichier de configuration : struts-config.xml. Ce fichier décrit en particulier quelles sont les actions possibles et à quelles classes Actions il faut les associer (mapping) ;
  • l'écriture des objets formulaires qui vont servir à la transmission des données de la vue au modèle. Ces objets étendent ActionForm. Ils contiennent toutes les propriétés des formulaires, ainsi qu'une méthode permettant de valider ou non les valeurs de ces propriétés. Lorsqu'un formulaire HTML est renvoyé, Struts instancie automatiquement l'ActionForm correspondant et initialise ses propriétés avant de les valider ;
    l'écriture des Actions à effectuer pour chaque requête.

    Une fois que Struts a validé les données envoyées, il appelle la méthode perform () de l'Action correspondante. Dans cette méthode, le développeur peut récupérer les données rentrées dans le formulaire via l'ActionForm, et effectuer les opérations nécessaires sur le modèle. Il peut pour cela s'aider des utilitaires de Struts permettant de recopier des propriétés d'un bean à un autre. Struts fournissant le servlet cœur du contrôleur et des classes Action et ActionForm qu'il n'y a plus qu'à étendre, la création d'actions est très rapide.

II-E. Le framework Struts

Celui-ci propose plusieurs taglibs, qui, combinées à des JavaBeans dédiés, les ActionForms, fournissent un support semi-automatisé à la manipulation de formulaires HTML (description, remplissage, validation côté client et serveur, remontée de message d'erreur…). Struts fournit par ailleurs quelques services techniques, tels qu'un support à l'externalisation de chaînes de caractères (messages) et à l'internationalisation de ces chaînes, une gestion de sources de données (DataSources), une interface de journalisation, ainsi que quelques Actions spécialisées.

II-E-1. Entités Struts


Struts s'appuie sur le modèle de conception des commandes : un discriminant, une chaîne de caractères en général, fait office de commande et indique le traitement à exécuter. Une table de correspondance permet de faire le lien entre commande et traitement à exécuter. Dans Struts, la commande est déterminée par une partie de l'URL transmise au servlet contrôleur, ActionServlet. Les traitements sont encapsulés dans les classes Actions. La correspondance (le « mapping ») entre la commande et le l'Action à exécuter est définie par les classes ActionMapping. Le contenu des classes ActionsMapping est déclaré au sein du fichier de configuration Struts et consiste à la base en un couple morceau d'URL/nom de la classe Action. Struts intègre un mécanisme d'automatisation des relations entre Actions et JSP par le biais des ActionForms. Ces classes sont des JavaBeans renseignés automatiquement à partir des paramètres des requêtes transmises au servlet contrôleur et transmises telles quelles aux Actions.

II-E-2. Taglibs


La manipulation des beans ActionForms au sein des JSP est grandement facilitée par l'emploi des taglibs Struts essentiellement dédiées à cet usage.
Struts fournit un peu plus d'une cinquantaine de tags personnalisés regroupés au sein de bibliothèques (taglibs) :

- la bibliothèque des tags bean pour la manipulation pure de beans ;
- la bibliothèque des tags HTML pour la manipulation des formulaires et éléments de formulaires HTML ;
- la bibliothèque des tags logiques pour la mise en place de traitements conditionnels et/ou itératifs ;
- la bibliothèque des tags template qui propose un mécanisme de gestion de modèles de JSP (les templates).

II-F. Les frameworks MVC2 les plus avancés


Il existe actuellement un certain nombre de projets plus ou moins avancés visant à la création de framework MVC2. Ces projets, tous basés sur les servlets progressent très vite. En voici une rapide présentation :

II-F-1. Barracuda


Ce framework qui se veut très complet est développé par la communauté Open Source Enhydra. Il est prévu qu'il comporte :
· un modèle événementiel complet ;
· un modèle et une bibliothèque de composants MVC pour l'interface utilisateur ;
· un système de validation des formulaires et de mappings avec des objets Java ;
· un contrôleur MVC2 ;
· une bibliothèque JavaScript.

II-F-2. Hammock


Ce framework permet de développer une application web de la même façon qu'une application Swing. Pour cela, Hammock utilise le même modèle : système d'événements identique, présence de composants IHM ‘Panel', et de layout ‘FlowLayout ‘ ou ‘TableLayout', etc. Ce système fonctionne sans JSP. Signalons qu'il n'est pas Open Source mais développé par OOP.

II-F-3. Tapestry


Ce framework est axé sur les composants : la création d'une page se fait par le développement de composants qui vont définir cette page. Il propose des concepts intéressants comme la séparation de l'état de la page et de la page elle-même afin de disposer d'un pool de pages ou encore des possibilités d'internationalisation via des templates. Tapestry facilite la gestion des erreurs et de la charge.
Tapestry a d'abord été développé par Primix et est maintenant disponible en Open source.

II-F-4. Webwork


Ce framework utilise le concept du Pull Hierarchical Model View Controller. Il est similaire techniquement au framework Struts dont la présentation suit, mais son API est plus réduite. Il pourrait être utilisé avec d'autres technologies que les servlets.

Nom Version url Puissance Complexité
Barracuda 1.1 http://barracuda.enhydra.org/ +++ +++
Hammock 1.0 n'existe plus +++ +++
Tapestry 2.1 http://sourceforge.net/projects/tapestry ++ +++
Webwork 0.95 délaissé au profit de Tapestry + +
Struts 1.0.2 http://jakarta.apache.org/struts ++ ++

II-F-5. Pourquoi choisir Struts comme framework MVC2


Struts fait partie du projet Apache. Or les projets Apache ont tendance à monopoliser toute l'attention des utilisateurs. Sachant que la qualité des projets Open Source est apportée par le nombre d'utilisateurs, on peut penser que Struts sera de meilleure qualité que les autres projets MVC2. Conclusion tirée il y a 18 mois. Depuis certains frameworks ont été abandonnés, alors que Struts continue son développement de manière certaine.

III. Description plus technique

Struts Struts est un Framework MVC pour développer des applications web, développé en Open Source dans le cadre du projet Jakarta de l'ASF ( Apache Software Foundation ).

Les framewoks sont des structures logicielles qui définissent des cadres dans lesquels viennent s'insérer les objets et concepts spécifiques à une application. En pratique, un framework (traduction littérale : squelette d'application) est un ensemble de classes et de mécanismes associés à une architecture logicielle qui fournissent un ou plusieurs services techniques ou métiers aux applications qui s'appuient dessus. Alors qu'un framework métier fournit des services à forte plus-value fonctionnelle (gestion de clients, d'abonnements, de news…) un framework technique apporte les concepts, entités et mécanismes qui permettent, dans le cadre d'une architecture logicielle retenue, de s'abstraire d'un certain nombre de problématiques conceptuelles et techniques récurrentes. J2EE est un Framework Java pour les développements web. Les Frameworks ont l'avantage de structurer, simplifier, segmenter les développements et donc les accélérer. Struts prend en compte les problématiques de performance, sécurité, multilangue…


Le MVC : acronyme synonyme de séparation des composants de type « Model » (logique métier et accès aux données), « View » (présentation des informations) et « Controller » (la gestion des interactions des utilisateurs).
Le modèle MVC s'appuie essentiellement sur la séparation en deux couches verticales regroupant d'un côté les objets métier (Modèle) et de l'autre les objets IHM, ces derniers étant eux-mêmes regroupés en objets chargés de l'acquisition d'informations, en provenance de l'utilisateur (contrôleur) et en objets chargés de la restitution d'informations vers l'utilisateur (Vue).

Image non disponible

Le modèle MCV II hérite des propriétés du modèle MVC. Son organisation cependant capitalise sur la longue expérience acquise avec MVC et s'adapte au contexte des applications Internet et de la plateforme J2EE.
Dans le modèle MVC II, le servlet est unique, en classe et en instance. Il garantit l'unicité du point d'entrée de l'application. Il prend en charge une partie du contrôle de l'application. Les contrôleurs MVC se retrouvent alors partiellement déportés dans l'entité dynamique de l'application qui assure le contrôle de la dynamique de l'application et qui gère les relations entre les objets métier et la présentation. Les contrôleurs deviennent essentiellement des contrôleurs du dialogue entre l'utilisateur et les objets métier.

Image non disponible
  • 1. Le client envoie une requête à l'application. La requête est prise en charge par le servlet d'entrée.
  • 2. Le servlet d'entrée analyse la requête et réoriente celle-ci vers un contrôleur adapté.
  • 3. Le contrôleur sélectionné par le servlet d'entrée est responsable de l'exécution des traitements nécessaires à la satisfaction de la requête. Il sollicite les objets métier lorsque nécessaire.
  • 4. Les objets métier fournissent des données au contrôleur.
  • 5. Le contrôleur encapsule les données métier dans des JavaBeans, sélectionne la JSP qui sera en charge de la construction de la réponse et lui transmet les JavaBeans contenant les données métier.
  • 6. La JSP construit la réponse en faisant appel aux JavaBeans qui lui ont été transmis et l'envoie au navigateur.
  • 7. Lorsque nécessaire, pour le traitement d'erreurs essentiellement, le servlet d'entrée traite la requête directement, sélectionne la JSP de sortie et lui transmet par JavaBean les informations dont elle a besoin.



    La taglib bean

    Les tags de cette bibliothèque peuvent être vus comme des améliorations des tags JSP <jsp :useBean> <jsp :getProperty> et <jsp :setProperty>. En effet, ils permettent de rendre accessibles des objets dans les contextes standards (page, session, application) via des variables de scripting. Il est ensuite possible de récupérer, de modifier ou d'afficher les valeurs des propriétés de ces objets.
    Par exemple si la session contient un objet nommé « item » disposant d'une méthode getPrize() et que l'on veut afficher son prix, il suffira d'écrire :
 
Sélectionnez
<bean:write name=’item’ property=’prize’/> 

Struts supporte également les nested et indexed properties. Par exemple si la session contient un objet nommé « items » et a une méthode getItem(int item) qui renvoie un item. il est possible d'écrire :

 
Sélectionnez
<bean:write name=’items’ property=’item[2].prize’/> 

La taglib bean propose également un tag permettant d'afficher un message en fonction de la langue de l'utilisateur. Dans l'optique de créer une application supportant plusieurs langues, les pages JSP ne doivent pas contenir de texte mais faire appel à ce tag. Dans Struts, les messages destinés à l'utilisateur sont associés à une clé et définis dans des fichiers spéciaux. Chaque fichier contient les messages dans une langue donnée. Le tag

 
Sélectionnez
<bean :message key=’titre.index’/> 

affichera le texte sous la clé titre.index dans la langue principale définie par le browser si disponible ou sinon dans la langue par défaut.


La taglib HTML
Cette bibliothèque contient les tags nécessaires à la création d'interfaces utilisateur dynamiques, et notamment des formulaires.

Les tags permettent de remplir automatiquement les champs à afficher et de retourner les valeurs en vue de leur gestion par le contrôleur. Ceci se fait en spécifiant dans le tag le nom de la propriété qui doit être affichée/modifiée. Cette propriété correspond à une propriété JavaBeans d'un objet Formulaire qui aura été spécialement écrit par le développeur pour servir d'interface entre la vue et le contrôleur.

Les autres tags de la bibliothèque permettent :

  • d'afficher les messages d'erreur relatifs à l'application ou au remplissage d'un champ donné ;
  • de gérer plus facilement les liens et les sessions.

    Voici par exemple comment créer un formulaire permettant de se loguer :
 
Sélectionnez
<html:form action=/logon’ focus=’username’>
Username : <HTML:text property=’username’/> <br>
Password: <html:password property=’password’/>
<HTML:submit property="submit" value="Submit"/>
</html:form> 

L'utilisation de ce formulaire est plus détaillée dans la section exemple.


La taglib logic


Cette bibliothèque définit un ensemble de tags permettant d'inclure ou de ne pas inclure le corps des tags en fonction de critères logiques portant sur la valeur des propriétés d'un objet. Il est également possible d'effectuer des itérations.
Par exemple, pour afficher un message en fonction de l'âge de l'utilisateur :

 
Sélectionnez
<logic:greaterThan name=’utilisateur’ property=’age’ value=17>
Vous êtes majeurs !
</logic:greaterThan> 

Ou pour afficher tous les prénoms des enfants d'une personne :

 
Sélectionnez
<logic:iterate name=’user’ property=’enfants’ id=’enfant’>
<bean:write name=’enfant’/><br> </logic :iterate> 

La taglib template


Cette dernière bibliothèque est destinée à faciliter la création de pages suivant un modèle. Pour un exemple courant, imaginons la barre de navigation en haut de la page, une zone centrale et un copyright en bas. Les templates permettent de définir la barre de navigation et le copyright, puis de les inclure aisément dans toutes les pages.

IV. Installation

IV-A. Easy Way to start

Essayer Struts

Essayer Struts est très facile : la distribution binaire de Struts est fournie avec des fichiers .war parmi lesquels une application exemple. Il suffit avec Tomcat de copier ses fichiers dans le répertoire webapps après avoir installé un parseur XML JAXP (l'implémentation de référence de Sun [ download ] ou Xerces par exemple) et de redémarrer le serveur pour faire fonctionner Struts.

Les personnes désirant recompiler Struts ou utiliser d'autres serveurs trouveront les informations nécessaires sur le site de Struts.

IV-B. Expert and Full installation

IV-B-1. Prérequis logiciel

Pour installer et utiliser Struts quelques opérations préliminaires sont nécessaires. Il faut télécharger et installer différents packages :

  • Java Development Kit - télécharger et installer une version de Java2 [java.sun.com/j2se] ;
  • Servlet Container - télécharger et installer un serveur pour les JSP, par exemple le serveur [Tomcat] (version 3.1 ou supérieure, version 3.2 ou plus recommandée) ;
  • Ant Build System - si vous compilez une version de Struts, il faudra utiliser, après l'avoir téléchargé une version de [Ant]. Ce package est aussi recommandé pour le développement de leurs applications web basées sur Struts.
    • Si c'est la version 1.3 de Ant que vous utilisez, vous devrez télécharger le fichier « optional.jar » qui contient l'implémentation de la commande <style> de Ant.
    • Vérifier que « Ant » et le script « ant.bat » peuvent s'exécuter en ajoutant le répertoire $ANT_HOME/bin à la variable environnement PATH ;
  • JDBC 2.0 Optional Package Classes - Struts supporte une implémentation optionnelle de javax.sql.DataSource, qui requiert une API pour être compilé. Pour le download [jdbc] ;
  • XML Parser - Struts nécessite la présence d'un parseur XML, compatible avec le parseur XML pour l'API JAVA (JAXP 1.0 ou plus). Télécharger et installer JAXP [ici], requis pour la compilation de Struts à partir des sources de Struts. Pour les applications webs liées à Struts vous pouvez utiliser JAXP ou tout autre parseur équivalent : [Xerces] ;
  • Xalan XSLT Processor - si vous compilez une version de Struts, vous devez télécharger et installer la version 1.2 de [ Xalan] XSLT processor (qui inclut le parseur XML Xerces) ou alors utiliser la version de Xalan incluse dans la version 1.1 de JAXP. Il est utilisé pour convertir la documentation interne de Struts basée sur du XML en HTML.

IV-B-2. Installer une distribution binaire de Struts

  • lib/struts.jar - le fichier JAR qui contient toutes les classes JAVA incluses dans Struts. Copiez-le dans le répertoire WEB-INF/lib de votre application web. Attention, si vous utilisez plusieurs applications basées sur Struts avec le même serveur au répertoire où vous placerez le fichier struts.jar au risque d'avoir une erreur : ClassNotFoundException ;
  • lib/struts*.tld - fichiers qui devront être copiés dans le répertoire WEB-INF. Ils constituent une description de la bibliothèque de tag de Struts ;
  • webapps/struts-blank.war - elle contient une archive d'une application web basique totalement vide qui servira de départ au développement d'une application Struts ;
  • webapps/struts-documentation.war - archive d'une application web basée sur Struts, elle constitue aussi à la fois toute la documentation de Struts ;
  • webapps/struts-example.war - exemple d'applications web qui utilisent un large pourcentage des possibilités de Struts. Il peut être installé avec un serveur Tomcat à partir de la version 3.1, et s'il ne contient pas de parseur XML, il faudra en rajouter un dans le répertoire WEB-INF/lib de l'application web ;
  • webapps/struts-exercise-taglib.war - application web contenant des pages mettant en valeur les différents tags de Struts ;
  • webapps/struts-template.war - exemple de mise en application des template tags de Struts ;
  • webapps/struts-upload.war - application utilisant le framework Struts pour réaliser un upload des fichiers.
    Pour utiliser Struts dans vos applications, observez les indications suivantes :
  • copiez le fichierlib/struts.jar à partir de la distribution de Struts dans le répertoire WEB-INF/lib de votre application web ;
  • copiez tous les ficheirslib/struts*.tld de la distribution de Struts dans le répertoire WEB-INF de votre application web ;
  • modifiez le fichier WEB-INF/web.xml de votre application web pour inclure la définition de l'élément <servlet>, et <servlet-mapping> pour établir le mapping des URL correspondant à cette servlet. Utilisez le fichier WEB-INF/web.xml de Struts pour vous aider dans la syntaxe ;
  • modifiez le fichier WEB-INF/web.xml de votre application en y introduisant les déclarations des bibliothèques de tags suivantes :
     
    Sélectionnez
    <taglib>
    
      <taglib-uri>/WEB-INF/struts-bean.tld</taglib-uri>
    
      <taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
    
    </taglib>
    
    
    
    <taglib>
    
      <taglib-uri>/WEB-INF/struts-html.tld</taglib-uri>
    
      <taglib-location>/WEB-INF/struts-html.tld</taglib-location>
    
    </taglib>
    
    
    
    <taglib>
    
      <taglib-uri>/WEB-INF/struts-logic.tld</taglib-uri>
    
      <taglib-location>/WEB-INF/struts-logic.tld</taglib-location>
    
    </taglib>
    
    
    
    <taglib>
    
      <taglib-uri>/WEB-INF/struts-template.tld</taglib-uri>
    
      <taglib-location>/WEB-INF/struts-template.tld</taglib-location>
    
    </taglib>
    
  • créez un fichier WEB-INF/struts-config.xml qui définit les actions de mapping et les autres caractéristiques de votre application. Vous pouvez utiliser votre fichier struts-config.xml provenant de la distribution de Struts pour vous aider au niveau de la syntaxe ;
  • au début de chaque JSP qui utilisera les tags de Struts, il faut quelques lignes de déclarations, par exemple :
     
    Sélectionnez
    <@ taglib uri="/WEB-INF/struts-bean.tld" prefix="struts-bean" %>
    
    <@ taglib uri="/WEB-INF/struts-html.tld" prefix="struts-html" %>
    
    <@ taglib uri="/WEB-INF/struts-logic.tld" prefix="struts-logic" %>
    
    <@ taglib uri="/WEB-INF/struts-template.tld" prefix="struts-template" %>
    
  • Lorsque vous compilez, soyez sûr d'inclure le fichierstruts.jar dans la variable d'environnement CLASSPATH.

V. Exemple d'application Struts


Struts est fourni avec une application exemple très simple. Celle-ci montre comment effectuer des tâches courantes comme afficher un formulaire, récupérer les données, les réafficher, afficher des listes dynamiques, etc.

Image non disponible

Fonctionnalités

L'application exemple permet à un utilisateur de s'enregistrer et de maintenir une liste des différents comptes mails qu'il a sur Internet. Les actions qu'il est possible d'effectuer avec cette application sont :

- se loguer (associé par le contrôleur à la classe Logon Action) ;
- se déloguer (classe LogoffAction) ;
- enregistrer ses coordonnées (classe SaveRegistrationAction) ;
- enregistrer les propriétés d'un compte mail (classe SaveSubscriptionAction) ;
- afficher ses coordonnées (classe EditRegistrationAction) ;
- afficher les propriétés d'un compte mail (classe EditSubscriptionAction).

L'application est composée de cinq pages :

- la page d'accueil, index.jsp ;
- la page de login, logon.jsp ;
- le menu principal, mainMenu.jsp ;
- la page permettant d'afficher les propriétés de l'utilisateur, registration.jsp ;
- la page permettant d'afficher la configuration d'un compte mail de l'utilisateur, subscription.jsp.

Grâce à l'emploi de la taglib logic, les pages servant à l'affichage des propriétés de l'utilisateur et de ses comptes servent aussi pour la création, la modification et la suppression. Les pages contenant des formulaires (logon.jsp, registration.jsp, subscription.jsp) sont chacune associées à un objet Form (on trouve respectivement les classes LogonForm, RegistrationForm et SubscriptionForm).


Ensemble des composants formant un traitement
Examinons en détail le processus permettant de se loguer.
La page logon.jsp contient les tags suivants :

 
Sélectionnez
<html:form action=/logon’ focus=’username’><HTML:text property=’username’/><HTML:password property=’password’/><HTML:submit property="submit" value="Submit"/></html:form>


ce qui provoque l'affichage d'un formulaire avec deux champs login/password et un bouton submit.

Voici ce qui se passe lorsqu'on clique sur submit :

1. La requête est envoyée à l'adresse logon.do à laquelle va répondre le contrôleur de Struts.
2. Le contrôleur utilise le fichier struts-config.xml pour déterminer quel est le formulaire qui va permettre la validation des données (dans notre exemple il s'agit de LogonForm) et quelle est l'action associée à cette requête (dans notre exemple il s'agit de LogonAction).

Extraits du fichier struts-config.xml  :

 
Sélectionnez
<!-- Logon form bean --> 
<form-bean name="logonForm"type="org.apache.struts.example.LogonForm"/><!-- Process a user logon -->
<action path="/logon" type="org.apache.struts.example.LogonAction" name="logonForm" 
scope="request" input="/logon.jsp">
</action>
3. Le servlet va donc instancier un LogonForm et l'initialiser avec les valeurs des attributs fournis dans la requête (password et username). Pour ce faire LogonForm propose les méthodes setUsername et setPassword :
 
Sélectionnez
public class LogonForm extends ActionForm {public void setPassword(String password) {} public void setUsername(String username) {} public String getUsername() {} public String getPassword() {}} 
4. Le servlet va ensuite appeler la méthode validate() de LogonForm. Celle-ci renvoie une erreur si au moins un des deux champs est vide.
 
Sélectionnez
public class LogonForm extends ActionForm {public ActionErrors validate( ActionMapping mapping, HttpServletRequest request) { ActionErrors errors = new ActionErrors(); 

if ((username == null) || (username.length() < 1)) errors.add("username", new 
ActionError("error.username.required")); 

if ((password == null) || (password.length() < 1)) errors.add("password", new ActionError( "error.password.required")); return errors; } } 
5. S'il n'y a pas d'erreur, le contrôleur va appeler la méthode perform() de LogonAction. Sinon il va renvoyer à la page de login.
6. La méthode perform() contient le code métier associé à une opération d'authentification.
 
Sélectionnez
public class LogonAction extends Action {public ActionForward perform( ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws{
// récupération des paramètres 
String username = ((LogonForm) form).getUsername(); 
String password = ((LogonForm) form).getPassword(); 
// récupération de la base de données 
Hashtable database = (Hashtable) servlet.getServletContext().getAttribute(..) ; 

// création de l’utilisateur // (utilisation du modèle) 
User user = (User) database.get(username); 
if (user!=null && (!user.getPassword().equals(password))) user=null; 
if (user==null) 
errors.add(ActionErrors.GLOBAL_ERROR, new ActionError("error.password.mismatch")); 

// si on a des erreurs, retour à la page de login 
if (!errors.empty()) { saveErrors(request, errors); 
return (new ActionForward(mapping.getInput())); } 

// OK, sauvegarde de l’utilisateur 
HttpSession session = request.getSession(); 
session.setAttribute(Constants.USER_KEY, user); … 
// renvoie à la page suivante 
return (mapping.findForward("success")); } 

Le code source complet de l'application est fourni avec Struts.

Extension du framework Struts a été conçu de façon à pouvoir être aisément modifié par les développeurs pour répondre à leurs besoins particuliers. Cela se voit dans l'application exemple, qui redéfinit la classe ActionMapping pour introduire la notion de « success » et de « failure » pour une action. Des tags spécifiques sont également introduits pour vérifier si un utilisateur est logué ou non et pour écrire plus facilement certains liens.

VI. Conclusion

Struts est un framework qui permet de développer des applications web en utilisant le modèle MVC2. Les applications conçues ainsi sont plus facilement maintenables et évolutives, de par la séparation des fonctionnalités du modèle, du contrôle, et de la vue. L'utilisation du framework permet au développeur de se concentrer sur le modèle, Struts fournissant le cadre nécessaire au contrôle et à l'interface de l'application, permettant un développement rapide de ces parties. Struts préfigure une nouvelle méthode de développement, succession de la programmation par servlets. Néanmoins, il convient d'ajouter que l'écriture d'une application utilisant Struts ne doit pas se décider à la légère : un certain temps est nécessaire pour prendre en main le concept et les API.

Le déploiement d'un servlet unique dont le comportement est configuré par fichier donne une grande flexibilité à la gestion de la navigation de l'application. Ce fonctionnement limite, par ailleurs, considérablement les adhérences entre les applications développées et les serveurs d'application sur lesquels elles sont déployées. Cet avantage est cependant estompé par la généralisation du support, par les différents serveurs d'application, des formats de déploiement standardisés (format WAR notamment).

La centralisation des accès à l'application permet un contrôle fin et personnalisé des accès aux traitements (Actions) et offre une grande marge de manœuvre pour la gestion des profils ou des rôles utilisateurs. L'abstraction des traitements et des ressources par le modèle des commandes, en occultant les informations relatives à la structuration de l'application, apporte une plus grande sécurité de cette dernière. Struts fait partie des projets Open Source Jakarta de l'ASF (Apache Software Foundation). À ce titre les sources du framework sont publiques. Le framework Struts en conséquence aisément adaptable et extensible. Son appartenance au projet Jakarta d'Apache garantit par ailleurs sa pérennité et la capacité importante de développement, dans un but opérationnel et non de recherche et développement, que la communauté Java lui consent.

Enfin, Struts suscitant un grand intérêt de la part de la communauté Java, de nombreux articles et exemples de mises en œuvre ainsi que diverses extensions sont aujourd'hui publiés sur divers sites Internet, que ce soit ou non sous l'égide du projet officiel.

VII. Liens