FaqStruts 2

La FAQ Struts
Date de publication : 17/05/2003
Dernière mise à jour : 22/12/2009
Cette faq a été réalisée à partir des questions fréquemment posées sur les forums de
www.developpez.com et de l'expérience personnelle des auteurs.
Nous tenons à souligner que cette faq ne garantit en aucun cas que les informations
qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est
humaine. Cette faq ne prétend pas non plus être complète. Si vous trouvez une erreur,
ou que vous souhaitez nous aider en devenant rédacteur, lisez ceci.
Sur ce, nous vous souhaitons une bonne lecture.
L'équipe Java
Ont contribué à cette FAQ :
OButterlin - dje_dje - mattheox - mezoo - blbird - L'équipe

Java - c_nvy - Alwin - Sniper37 - hipchic - jak0 - Jaxofun
- SEMPERE Benjamin - Lunatix - Ricky81 (http://
ricky81.developpez.com) - Lionel Roux (aka RanDomX) -
La FAQ Struts
1. Informations (5) ......................................................................................................................................................................... 4

2. Généralités (4) ........................................................................................................................................................................... 6
3. Configuration de l'application web (6) ..................................................................................................................................... 7
4. Bibliothèques de tags (2) .........................................................................................................................................................11
5. Configuration de l'application Struts (14) ............................................................................................................................... 12
5.1. Les ActionForms (2) .......................................................................................................................................................15
5.2. Les Exceptions (3) ..........................................................................................................................................................17
5.3. Les Datasources (3) ........................................................................................................................................................ 19
5.4. Divers (3) ........................................................................................................................................................................ 21
6. I18N (5) ................................................................................................................................................................................... 23
7. Formulaires (18) ...................................................................................................................................................................... 30
7.1. Validation (6) ..................................................................................................................................................................33
7.2. Checkbox et Radiobutton (2) ......................................................................................................................................... 37
7.3. Listes (3) ......................................................................................................................................................................... 39
7.4. Fichiers (3) ......................................................................................................................................................................42
8. Liens (5) ...................................................................................................................................................................................45
9. Erreurs (5) ................................................................................................................................................................................47
10. Messages (1) .......................................................................................................................................................................... 52
11. DataSource (2) ....................................................................................................................................................................... 53
12. Sécurité (2) .............................................................................................................................................................................54
13. Plug-ins (3) ............................................................................................................................................................................ 55
14. Trucs et Astuces (5) .............................................................................................................................................................. 56
-3-
Les sources présentées sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation de ces sources
constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2003 - 2009 Developpez LLC. Tout droits réservés Developpez LLC. Aucune
reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez
LLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://javaweb.developpez.com/faq/struts/
La FAQ Struts
Sommaire > Informations

Comment bien utiliser cette FAQ ?
Auteurs : L'équipe Java ,
Le but : Cette faq a été conçue pour être la plus simple possible d'utilisation. Elle tente d'apporter des réponses simples
et complètes aux questions auxquelles sont confrontés tous les débutants (et les autres).
L'organisation : Les questions sont organisées par thème, les thèmes pouvant eux-même contenir des sous-thèmes.
Lorsqu'une question porte sur plusieurs thèmes, celle-ci est insérée dans chacun des thèmes rendant la recherche plus
facile.
Les réponses : Les réponses contiennent des explications et des codes sources. Certaines sont complétées de fichier à
télécharger contenant un programme de démonstration. Ces programmes sont volontairement très simples afin qu'il
soit aisé de localiser le code intéressant. Les réponses peuvent également être complétées de liens vers d'autres réponses,
vers la documentation en ligne de Sun ou vers un autre site en rapport.
Nouveautés et mises à jour : Lors de l'ajout ou de la modification d'une question/réponse, un indicateur est placé à coté
du titre de la question. Cet indicateur reste visible pour une durée de 15 jours afin de vous permettre de voir rapidement
les modifications apportées.
J'espère que cette faq pourra répondre à vos questions. N'hésitez pas à nous faire part de tous commentaires/remarques/
critiques.
lien : Comment participer à cette FAQ ?
Comment participer à cette FAQ ?

Cette faq est ouverte à toute collaboration. Pour éviter la multiplication des versions, il serait préférable que toutes
collaborations soient transmises aux administrateurs de la faq.
Plusieurs compétences sont actuellement recherchées pour améliorer cette faq :
Rédacteur : Bien évidemment, toute nouvelle question/réponse est la bienvenue.
Web designer : Toute personne capable de faire une meilleure mise en page, une feuille de style ou de belles images...
Correcteur : Malgré nos efforts, des fautes d'orthographe ou de grammaire peuvent subsister. Merci de contacter les
responsables si vous en débusquez une... Idem pour les liens erronés.
lien : Quels sont les droits de reproduction de cette FAQ ?
Quels sont les droits de reproduction de cette FAQ ?

Les sources présentés sur cette pages sont libre de droits et vous pouvez les utiliser à votre convenance. Par contre
cette page de présentation de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright
©2004 Developpez LLC. Tout droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite
de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC.
-4-
La FAQ Struts
Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérets. Cette page est
déposée à la SACD.
lien : Licence en anglais

lien : Licence "non-officielle" en français
lien : Comment participer à cette FAQ ?
Où trouver d'autres sources d'information ?

•
Les cours et didacticiels de www.developpez.com
•
Les forums de la rubrique Java de www.developpez.com
• La FAQ Général Java
• La FAQ JDBC
• La FAQ Java EE
•
La Javadoc : toutes les informations utiles sur les classes, leurs méthodes ... à toujours avoir sous la main.
•
Le site officel du projet Struts
Remerciements
Un grand merci à tous ceux qui ont pris de leur temps pour la réalisation de cette FAQ.
Aux rédacteurs :
Remerciements tout d'abord à tous ceux qui ont rédigé les questions et les réponses.
Aux correcteurs :
Remerciements également aux personnes qui ont relu les textes pour supprimer un maximum de fautes de français.
A l'équipe Java :
Remerciements tous particuliers aux membres de la rubrique Java pour leurs conseils, corrections, relectures, idées,
etc. Bref, merci pour leur travail d'équipe qui a permis de faire aboutir ce projet.
Aux visiteurs et membres de DVP :
Remerciements enfin à tous ceux qui ont consulté cette FAQ, et qui, par leurs remarques, nous ont aidé à la
perfectionner.
Remerciements particuliers à Cyberzoide, Braim, babylone07 et Clément Cunin
-5-
La FAQ Struts
Sommaire > Généralités

Qu'est-ce que Struts?
Auteurs : Lionel Roux (aka RanDomX) ,
Selon la définition des auteurs, Struts est un framework Open Source écrit entièrement en JAVA qui permet de
construire des applications Web.
Struts est construit autour de technologies qui ont fait leurs preuves comme les servlets JAVA, les JavaBeans, le
formalisme XML, ... .
Struts implémente le design pattern MVC Model 2.
Le framework Struts fournit le minimum vital pour construire une application Web professionnelle.
Struts est un projet soutenu par l'Apache Software Foundation. La page officelle se trouve à cette adresse: http://
struts.apache.org/.
Struts est-il le meilleur choix pour construire mes applications Web?

Disons le tout de suite, Struts n'est pas la panacée !
Pour écrire une application Web très simple, Struts introduit un niveau de complexité et de mise en route trop important.
En revanche, dès qu'une application prends de l'importance, Struts peut rapidement simplifier les choses.
Qui a écrit Struts ?

Struts a été crée par Craig R. McClanahan, puis offert à la fondation Apache en Mai 2000.
Craig Mc Clanahan a aussi été à l'origine de Tomcat 4, l'implémentation officielle de référence des conteneurs Servlet
2.3 et JSP 1.2.
Il est aujourd'hui le lead manager du projet Java Server Faces (JSR-127) et l'architecte de la couche de presentation
Web de la plateforme J2EE chez Sun.
17 autres personnes contribuent activement au développement de ce projet.
Struts peut-il être utilisé dans une application commerciale ?

Struts est distribué sous licence ASF.
Struts peut donc être utilisé dans des applications commerciales dans le respect de ce qui est inscrit dans cette licence.
-6-
La FAQ Struts
Sommaire > Configuration de l'application web

Comment configurer la servlet ActionServlet dans le fichier web.xml?
Auteurs : Lionel Roux (aka RanDomX) , Alwin ,
Le framework Struts consiste en une application web classique, dont le point d'entrée unique (MVC model 2 oblige)
est une servlet appelée ActionServlet.
Pour configurer l'ActionServlet, vous devez dans un premier temps déclarer la servlet et lui attribuer un alias:
<web-app>
<servlet>
<servlet-name>action<servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
...
</web-app>
<servlet-name> définit l'alias dont vous devez vous servir dans le reste du descripteur de déploiement web.xml.
<servlet-class> définit le nom entièrement qualifié de la servlet ActionServlet.
<load-on-startup> (entier positif) sert à attribuer une priorité de chargement de la servlet par le conteneur, 1 étant la
priorité la plus élevée.
Pour définir quelles sont les requêtes que la servlet ActionServletdoit intercepter, il faut configurer le mapping de celle-ci:
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
Dans cet exemple, toutes les requêtes qui finissent par *.do sont interceptés et traités par la servlet ActionServlet.
Il est d'usage d'utiliser *.do ou /do/* comme expression régulière pour définir le mapping.
Comment changer le nom ou l'emplacement du fichier struts-config.xml ?

Auteurs : Lionel Roux (aka RanDomX) , Alwin , Ricky81 ,
Le nom et l'emplacement du fichier struts-config.xml est spécifié par le paramètre d'initialisation config dans la
déclaration de la servlet ActionServlet.
Le chemin vers ce fichier est donné relativement au contexte. L'exemple suivant est identique à une déclaration sans
section <init-param> (valeur par défaut) :
<web-app>
<servlet>
<init-param>
<param-name>config<param-name>
<param-value>/WEB-INF/struts-config.xml<param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
...
-7-
La FAQ Struts
</web-app>
Vous pouvez changer cette valeur pour faire pointer le paramètre vers le fichier de votre choix.
Vous pouvez déclarer plusieurs fichiers de configuration en les séparant par des virgules.
Comment déclarer le fichier de configuration d'un module Struts ?

Auteurs : Lionel Roux (aka RanDomX) , Ricky81 ,
La configuration se fait comme pour une application mono-module, à la différence près que le nom du paramètre
d'initialisation est suffixé par le nom du module :
<web-app>
<servlet>
<init-param>
<param-name>config/moduleXXX<param-name>
<param-value>/WEB-INF/struts-config_moduleXXX.xml<param-value>
</init-param>
</servlet>
...
</web-app>
Vous pouvez changer cette valeur pour faire pointer le paramètre vers le fichier de votre choix.
Vous pouvez déclarer plusieurs fichiers de configuration en les séparant par des virgules.
Vous pouvez répéter le paramètre pour chaque module de votre application.
lien : Comment changer le nom ou l'emplacement du fichier struts-config.xml ?
Comment utiliser plusieurs fichiers de configuration pour un module Struts ?

Auteurs : Lionel Roux (aka RanDomX) , Lunatix ,
Pour utiliser plusieurs fichiers de configuration pour un seul module Struts, il suffit de les déclarer dans le paramètre
d'initialisation config, séparés par une virgule.
Par exemple, pour le module par défaut :
<init-param>
<param-name>config</param-name>
<param-value>
/WEB-INF/struts-config.xml,/WEB-INF/struts-config2.xml
</param-value>
</init-param>
Ceci peut s'avérer très intéressant lorsque les fichiers de configurations prennent de l'importance.
Cela peut permetre de séparer les différentes parties de ces fichiers.
-8-
La FAQ Struts
Attention cependant par la suite aux collisions de noms de formBean et d'actions plus difficiles à éviter lorsqu'on utilise
plusieurs fichiers.
lien : Comment déclarer le fichier de configuration d'un module Struts ?
Comment configurer les fichiers de bienvenue ?

La ou les pages d'accueil d'une application web est configurée par le paramètre welcome-file-list.
Par exemple si vous souhaitez afficher la page monindex.jsp comme page d'entrée de l'application, il faut le déclarer
comme ceci:
<web-app>
<welcome-file-list>
<welcome-file>monindex.jsp</welcome-file>
</welcome-file-list>
</web-app>
Vous pouvez spécifier plusieurs éléments <welcome-file>
lien : Comment définir une Action comme une page d'accueil d'une application ?
Comment configurer les taglibs de Struts pour l'application web ?

Struts est livré avec des bibliothèques de balises standards.
Pour pouvoir les utiliser dans les pages JSP, il faut les déclarer leurs descripteurs dans le fichier de configuration
web.xml.
Quelle que soit la taglib, sa déclaration prends la forme suivante:
<web-app>
...
<taglib>
<taglib-uri>AliasTaglib;</taglib-uri>
<taglib-location>CheminRelatifAuContexte/NomDuDescripteur</taglib-location>
</taglib>
</web-app>
Par exemple pour la taglib html de Struts:
<web-app>
...
<taglib>
<taglib-uri>StrutsHtml</taglib-uri>
<taglib-location>/WEB-INF/struts-html.tld</taglib-location>
</taglib>
</web-app>
-9-
La FAQ Struts
Dans la JSP, il faut ensuite faire référence à la taglib:
<%@ taglib uri="StrutsHtml" prefix="html" %>

<html:html>
...
</html:html>
On notera qu'il est d'usage de déclarer le chemin relatif comme alias.
Attention, les exigences de la déclaration varient en fonction de l'implémentation de J2EE/Java EE. A partir de J2EE
1.4 il n'est plus nécessaire de déclarer les taglibs dans le web.xml.
lien : Pour plus de détails, consultez la FAQ Java EE.

lien : Qu'apportent les bibliothèques de tags de Struts par rapport à la JSTL ?
- 10 -
La FAQ Struts
Sommaire > Bibliothèques de tags

Qu'apportent les bibliothèques de tags de Struts par rapport à la JSTL ?
Auteurs : Alwin , Ricky81 ,
Les bibliothèques bean et logic proposent à peu de choses près des fonctionnalités identiques à la JSTL.
On entend parfois dire qu'elle sont plus intuitives et plus faciles à comprendre par des designers n'ayant cure de Java.
Cependant, la tendance (et c'est ce qui est préconisé par l'auteur de Struts) est à l'utilisation massive de la JSTL
(si possible combinée à EL) en remplaçement des balises Struts (hors bibliothèque html et ses extensions dans la
bibliothèque nested).
Un exemple :
<html:select property="position">
<c:forEach begin="1" end="20" var="i">
<html:option value="${i}">${i}</html:option>
</c:forEach>
</html:select>
Cette directive n'est pas pas toujours appliquée dans cette FAQ pour des raisons historiques et de compréhension.
lien : Que sont les JSP Taglibs ?

lien : Quels sont les objectifs de la JSTL ?
Comment permettre/empêcher l'encodage en HTML dans un bean:write ?

L'attribut filter du tag <bean:write> permet d'echapper l'encodage.
Si il est renseigné à la valeur "true" (valeur par défaut), les éléments seront remplaçés par leur équivalent HTML.
exemple :
<bean:define id="test">
<br/>
</bean:define>
<%-- génère <br> pour afficher <br/> --%>
<bean:write name="test" filter="true" />
<%-- génère <br/> pour générer un saut de ligne --%>
<bean:write name="test" filter="false" />
- 11 -
La FAQ Struts
Sommaire > Configuration de l'application Struts

Comment exécuter un traitement avant le contrôleur Struts ?
Struts ne fournit pas de mécanisme pour réaliser cela.
Cependant ceci peut fait simplement en suivant l'une des techniques suivantes:
• Avec un conteneur compatible avec les spécification Servlet 2.3, vous pouvez implémenter un filtre de
prétraitement.
• Avec une application compatible Struts 1.1 et plus, vous pouvez redéfinir le RequestProcessor et y intégrer les
prétraitements .
• Avec une application compatible Struts 1.0, vous pouvez redéfinir l'ActionServlet et y intégrer les prétraitements
lien : Comment vérifier si l'utilisateur est identifié et si sa session n'a pas expiré?
Comment vérifier si l'utilisateur est identifié et si sa session n'a pas expiré?

Auteurs : Sniper37 ,
Une manière de faire est d'étendre la classe org.apache.struts.action.RequestProcessor qui réalise un certain nombre
de traitements en amont de l'exécution du code d'une action.
Cette solution est d'autant plus intéressante si vous utilisez des actions variées dans votre application (Action,
DispatchAction, ...).
Pour que Struts prenne en compte la nouvelle classe, modifier le struts-config.xml :
<controller>
<set-property property="processorClass"value="com.developpez.faq.struts.FaqRequestProcessor"/>
</controller>
Dans notre nouvelle classe, il nous faudra écrire le code suivant :
// On verifie si l'utilsateur est bien connecté

protected boolean isUserConnected(HttpServletRequest request) {
if (request != null) {
HttpSession session = request.getSession(false);
if (session != null) {
User user = (User) session.getAttribute("user");
}
return user != null;

}
return false;
}
// On vérifie si la session a expirée : la session expire si l'id de la session n'est pas valide
protected boolean isSessionValid(HttpServletRequest request) throws ServletException {
if (request != null) {
return request.isRequestedSessionIdValid();
}
return false;
}
protected boolean processRoles(HttpServletRequest request, HttpServletResponse response,

ActionMapping mapping)
throws java.io.IOException, javax.servlet.ServletException {
- 12 -
La FAQ Struts
ActionMessages messages = new ActionMessages();

if (isSessionValid(request)) {
if (isUserConnected(request)) {
return true;
} else {
messages.add(ActionMessages.GLOBAL_MESSAGE, new
ActionMessage("erreurs.connection.required"));
}
} else {
messages.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage("erreurs.session.expired"));
}
// rediriger vers une page d'erreur
request.getRequestDispatcher ("/error.jsp").forward(request,response);
return false;
}
Comment rajouter des éléments de configuration aux actions ?

Auteurs : blbird ,
Il vous suffit de créer une classe héritant de ActionMapping, et y rajouter les paramètres voulus. Ici par exemple le
paramètre level est déclaré :
public class MonActionMapping extends ActionMapping {

private String level = null;
public MonActionMapping() {
super();
}
public String getLevel() {

return level;
}
public void setLevel(String level) {

this.level = level;
}
}
Ensuite, dans votre fichier struts-config.xml, dans une action quelconque, par exemple ici TitreSecondaireInit, vous la
déclarez en rajoutant le paramètre className :
<action path="/titresecondaireinit" name="titreSecondaireBean" scope="session"

type="fr.appli.actions.TitreSecondaireInit" className="fr.appli.struts.MonActionMapping">
<set-property property="level" value="160" />
<forward name="ok" path="/vues/titresecondaire.jsp"/>
</action>
Ensuite, dans l'implémentation de l'action, ici fr.appli.actions.TitreSecondaireInit, il ne vous reste plus qu'à récupérer
le paramètre level comme ceci :
package fr.appli.actions;
// Imports à faire
public class TitreSecondaireInit extends Action {
- 13 -
La FAQ Struts
public TitreSecondaireInit() {
super();
}
public ActionForward execute(ActionMapping mapping, ActionForm form,

HttpServletRequest request, HttpServletResponse response)
throws Exception {
TitreSecondaireBean titre = (TitreSecondaireBean) form;
MonActionMapping am = (MonActionMapping) mapping;
String level = am.getLevel();
// ...
}
}
- 14 -
La FAQ Struts
Sommaire > Configuration de l'application Struts > Les ActionForms

Comment configurer un ActionForm ?
Pour déclarer un ActionForm dans le fichier de configuration struts-config.xml, il suffit d'ajouter un noeud de type
<form-bean> à ce dernier.
<form-beans>
<form-bean name="monBean" type="com.developpez.form.MonActionForm" />
...
</form-beans>
L'attribut name désigne l'alias que vous utiliserez dans vos formulaires JSP et/ou HTML.
L'attribut type désigne le nom qualifié de la classe d'implémentation de votre ActionForm.
Comment configurer un DynaActionForm (ActionForm dynamique) ?

Pour déclarer un DynaActionForm dans le fichier de configuration struts-config.xml, il suffit d'ajouter un noeud de type
<form-bean> à ce dernier.
<form-beans>
<form-bean name="monDynaBean" type="org.apache.struts.action.DynaActionForm">
</form-bean>
...
</form-beans>
L'attribut name désigne l'alias que vous utiliserez dans vos formulaires JSP et/ou HTML.
L'attribut type désigne le nom complètement qualifié de la classe d'implémentation de votre DynaActionForm.
De plus, il faut spécifier un certain nombre de propriétés qui seront les attributs de votre DynaActionForm grâce aux
éléments de types <form-property>
Chaque élément <form-property> possède un certain nombre d'attributs parmi lesquels:
• initial qui représente la valeur par défaut de la propriété selon son type.
• name qui représente le nom de la propriété du dynabean.
• size qui représente le nombre d'élément si la propriété est un tableau.
• type qui représente le nom entièrement qualifié du type de la propriété, suivi de [] si c'est un tableau.
<form-beans>
<form-bean name="personDynaBean" type=" org.apache.struts.action.DynaActionForm">
<form-property name="name" type="java.lang.String" />
<form-property name="firstname" type="java.lang.String" />
<form-property name="birthDate" type="java.util.Date" />
</form-bean>
...
- 15 -
La FAQ Struts
</form-beans>
- 16 -
La FAQ Struts
Sommaire > Configuration de l'application Struts > Les Exceptions

Comment configurer la gestion des exceptions dans Struts ?
Struts permet de gérer les exceptions de manière déclarative. Dans vos classes Action, si une exception est levée, elle
sera propagée jusqu'à la super classe Action, qui ira chercher si une exception est déclarée pour le mapping de ladite
Action. Si ce n'est pas le cas, elle ira ensuite chercher si une exception est déclarée en tant qu'exception globale dans
le fichier struts-config.xml.
La gestion déclarative des exceptions crée aussi un message de type ActionMessage (ActionError pour les premières
versions de Struts) à partir de la clé de ResourceBundle indiquée. Ce message est alors utilisé par la page jsp spécifiée
pour l'affichage d'un message d'erreur.
Le plus grand avantage de ce type de déclaration, outre le fait de centraliser les exceptions, est sans doute de permettre
de ne pas polluer le code source des classes Actions avec des blocs try/catch redondants dans plusieurs classes.
Pour déclarer une exception , il suffit de créer un noeud de type <exception> au fichier struts-config.xml :
<exception
key="error.message.key"
path="/page.jsp"
scope="request"
type="java.handled.exception.type" />
Conmment configurer la gestion d'une exception globale ?

Pour déclarer une exception en tant qu'exception globale dans le fichier struts-config.xml, il faut ajouter un noeud
<exception> au noeud <global-exceptions> :
<global-exceptions>
<exception
key="error.database.failure"
path="/dbfailure.jsp"
scope="request"
type="com.developpez.DatabaseException" />
</global-exceptions>
Si une exception de type DatabaseException est levée, le framework Struts redirigera la requête vers la page dbfailure.jsp
et affichera dans celle-ci le message dont la clé est error.database.failure.
lien : Comment configurer la gestion des exceptions dans Struts ?
Comment configurer une exception spécifique à une Action ?

Pour déclarer une exception en tant qu'exception spécifique à une action dans le fichier struts-config.xml, il faut ajouter
un noeud <exception> au noeud <action> :
- 17 -
La FAQ Struts
<action>
...
<exception
key="error.database.failure"
path="/myactionerror.jsp"
scope="request"
type="com.developpez.DatabaseException" />
</action>
Si une exception de type DatabaseException est levée, le framework Struts redirigera la requête vers la page
myactionerror.jsp et affichera dans celle-ci le message dont la clé est error.database.failure.
lien : Comment configurer la gestion des exceptions dans Struts ?
- 18 -
La FAQ Struts
Sommaire > Configuration de l'application Struts > Les Datasources

Comment configurer un datasource utilisable directement par Struts ?
Bien qu'il ne soit pas recommandé de gérer la persistence des données dans la couche de présentation, il peut être utile
d'accéder aux datasources directement.
Le DataSource manager de Struts est le composant en charge de la gestion des DataSources; il est configuré directement
dans le fichier de configuration struts-config.xml. Il peut être utilisé pour déployer n'importe quel pool de connections
qui implémente l'interface javax.sql.DataSource.
Si aucun composant natif n'est livré, vous pouvez aussi utiliser le Jakarta Commons dbcp's BasicDataSource
[org.apache.commons.dbcp.BasicDataSource] disponible dans le projet Commons chez Jakarta.
Vous devez configurer votre source de données (exemple pour PostgreSQL) dans struts-config.xml :
<data-sources>

<data-source type="org.apache.commons.dbcp.BasicDataSource">
<set-property property="driverClassName" value="org.postgresql.Driver" />
<set-property property="url" value="jdbc:postgresql://localhost/mydatabase" />
<set-property property="username" value="me" />
<set-property property="password" value="test" />
<set-property property="maxActive" value="10" />
<set-property property="maxWait" value="5000" />
<set-property property="defaultAutoCommit" value="false" />
<set-property property="defaultReadOnly" value="false" />
<set-property property="validationQuery" value="SELECT COUNT(*) FROM users" />
</data-source>
</data-sources>
Note: la requête de la propriété validationQuery doit retourner au moins une ligne.

Vous pouvez ensuite utiliser directement cette connexion dans vos Actions.
lien : Comment utiliser un DataSource directement avec Struts ?
Comment configurer plusieurs datasources utilisables par Struts ?

Si vous avez besoin d'utiliser plusieurs DataSources dans votre application Struts, vous pouvez utiliser l'attribut key
du noeud <data-source>, comme ceci:
<data-sources>
<data-source key="FirstDataSource" type="org.apache.commons.dbcp.BasicDataSource">
...  ...
</data-source>
<data-source key="SecondDataSource" type="org.apache.commons.dbcp.BasicDataSource">
...  ...
</data-source>
...
- 19 -
La FAQ Struts
</data-sources>
lien : Comment utiliser plusieurs DataSources avec Struts?
Comment changer la classe d'implémentation du pool de connection d'une datasource ?

Par défaut, Struts utilise la classe org.apache.struts.util.GenericDataSource comme implémentation de l'interface
javax.sql.Datasource.
Il est cependant possible de changer cette implémentation par une autre, comme par exemple celle fournie avec Oracle.
Pour ce faire, il suffit de spécifier le nom qualifié de cette classe comme valeur de l'attribut type dans le noeud <data-
source>
<data-sources>
<data-source type="oracle.jdbc.pool.OracleDataSource">
...
</data-source>
</data-sources>
- 20 -
La FAQ Struts
Sommaire > Configuration de l'application Struts > Divers

Comment utiliser plusieurs ResourceBundle avec Struts ?
Struts 1.1 (et plus) supporte cette fonctionalité.
Il permet de définir un ResourceBundle par défaut et des ResourceBundles personnalisés.
Chaque ResourceBundle personalisé doit être identifié par une clé dans le fichier struts-config.xml :
<message-resources parameter="application.resources"/>
<message-resources parameter="foo.bar.custom.myCustomResource" key="Custom"/>
Pour faire référence à ce dernier, vous devez spécifier une valeur pour l'attribut bundle :
<bean:write bundle="Custom" ...>
lien : Comment charger plusieurs fichiers de ressources (bundles) sans avoir à utiliser les clés des bundles ?
lien : Comment définir les fichiers de localisation en dehors du classpath ?
Comment accéder au ResourceBundle à partir d'une action Struts ?

Auteurs : SEMPERE Benjamin ,
L'ensemble des messages est stocké dans un objet MessageResources disponible dans le scope request. Une fois cet objet
récupéré, on accède à un message particulier via la méthode getMessage() avec en paramètres la locale et la clé du
message à récupérer.
Un extrait de code à titre d'exemple :
I18NHelper
/**
* Return the message resources for localization
*/
private static MessageResources getMessageResources(HttpServletRequest request) {
return (MessageResources) request.getAttribute(Globals.MESSAGES_KEY);

}
/**
* Get the localized message
*/
public static String getLocalizedMessage(HttpServletRequest request, String messageKey) {
MessageResources messageResources = getMessageResources(request);

String localizedMessage = null;
if(messageResources != null) {
localizedMessage = messageResources.getMessage(request.getLocale(), messageKey);

}
if(localizedMessage == null) {
localizedMessage = "N/A";
}
- 21 -
La FAQ Struts
I18NHelper
return localizedMessage;
}
Ainsi, imaginons que dans notre fichier de localisation, nous avons un message de ce style :
prompt.hello=Bonjour
Alors dans l'action struts, pour recupérer le message dans la bonne locale, il faut faire:
String msg = I18NHelper.getLocalizedMessage(request, "prompt.hello");
lien : Comment gérer l'internationalisation (I18N) et/ou la localisation avec Struts ? : Le ResourceBundle
Comment définir une action qui n'a pas besoin de

traitements particuliers; seulement une page JSP à afficher ?
Auteurs : Sniper37 , c_nvy ,
C'est un cas rarement utile, mais qui mérite d'être signalé.
Il peut être utilisé dans les cas suivants :

• Nous avons notre propre ActionMapping, et que nous voulons faire un forward en passant par une action et sans
traitement particulier ou sans répétition de traitement.
• Nous avons un autre moyen pour faire le traitement métier.
<action path="/BasicAction"
type="org.apache.struts.actions.ForwardAction"
parameter="/WEB-INF/jsp/resultats.jsp"
/>
A partir de la version 1.2, on peut faire directement :
<action path="/BasicAction"
forward="/WEB-INF/jsp/resultats.jsp"
/>
- 22 -
La FAQ Struts
Sommaire > I18N

Comment gérer l'internationalisation (I18N) et/ou la localisation avec Struts ? : Le ResourceBundle
Struts supporte nativement le mécanisme d'internationalisation et de localisation offert par la plateforme Java : Le
ResourceBundle et la Locale.
Pour obtenir un ResourceBundle foo.bar.MyResourceBundle, il suffit de créer un ou plusieurs fichiers dans le

répertoire /foo/bar/ :
• MyResourceBundle.properties : ce fichier contient les messages de la langue par défaut pour votre application.
• MyResourceBundle_XX.properties : ce fichier contient les mêmes messages dans la langue dont le code ISO est XX
Ex : si votre langue par défaut est l'anglais, vous aurez dans MyResourceBundle.properties une entrée du type :
default.welcome=hello
Si vous souhaitez supporter le francais, vous aurez dans le fichier MyResourceBundle_fr.properties la mème entrée :
default.welcome=bonjour
Il en sera de même pour toutes les langues et vous aurez autant de fichiers .properties que de langues que vous
supporterez.
Il vous faudra ensuite déclarer ces ressources dans le descripteur de configuration de votre application (struts-
config.xml) :
<message-resources parameter="foo.bar.MyResourceBundle" />
Attention: il ne faut pas préciser l'extension du fichier (.properties) et ne pas spécifier les codes ISO.
Il faut aussi absolument veiller à ce que le fichier soit accessible dans le CLASSPATH.
Dans les pages JSP, il faut déclarer l'internationalisation avec l'attribut locale du tag <html:html> :
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html"%>

<html:html locale="true">
.. page content ...
</html:html >
Comment changer de langue à la demande avec Struts ?

Auteurs : Lionel Roux (aka RanDomX) , hipchic ,
Pour changer la langue à la demande, il faut créer une action qui va mettre à jour la locale dans l'objet request.
La locale fait partie des attributs d'une requête http et est donc conservée durant la navigation.
De plus, la JVM charge tous les bundles au démarrage. Toutes les langues définies sont donc accessibles.
Imaginons trois liens :
<html:link page='/switch.do?lang=fr&cty=FR'>FR</html:link>
- 23 -
La FAQ Struts
<html:link page='/switch.do?lang=en&cty=EN'>EN</html:link>
<html:link page='/switch.do?lang=en&cty=US'>US</html:link>
Ces liens pointent sur une Action "SwitchAction" définie dans le mapping par l'alias "switch".
public class SwithLangAction extends Action

{
public ActionForward execute(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException
{
//récupération des paramètres passés et de l'url du referer
String country = request.getParameter("cty");
String language = request.getParameter("lang");
String referer = request.getHeader("referer");
HttpSession session = request.getSession();
ActionForward forward = null;
// définition de la locale
setLocale( request, new Locale( language, country ) );
// redirection vers une page définie par défaut

if( referer==null )
{
forward = (mapping.findForward("success"));
}
// redirection vers l'url du referrer.
else
{
forward = new RedirectingActionForward();
forward.setPath( referer );
}
return forward;
}
}
Attention: certains serveurs ne transmettent pas le referer. Il faut donc explicitement le récupérer (dans un ActionForm
par exemple).
Comment formater une valeur d'un bean avec Struts ? : Les attributs "format" et "formatkey"
Il faut utiliser l'attribut format du tag <bean:write>.
<bean:write name='mybean' property='number' format='#,##0.00' />
Ainsi, si la valeur numérique de la variable number de l'ActionForm référencé par "mybean" vaut 123456789, elle sera
affichée 123,456,789.00, conformément au pattern #,##0.00 .
Vous pouvez aussi localiser les patterns de formatage, pour différencier ceux-ci en fonction de la langue. Pour ce faire,
il faut embarquer ceux-ci dans les bundles de ressources.
Ex :
- 24 -
La FAQ Struts
number.format=#,##0.00
il faut ensuite utiliser:
<bean:write name='mybean' property='number' formatkey='number.format'/>
Attention: le pattern utilisé doit être compatible avec la langue. Par exemple, '#,##0.00' ne fonctionnera pas avec la
locale 'fr', puisque c'est un pattern anglais.
Comment charger plusieurs fichiers de ressources (bundles) sans avoir à utiliser les clés des bundles ?
Auteurs : Alwin ,
Le principe consiste à fusionner les resources-bundles au chargement.
Voici la classe qui se charge de le faire (l'API commons Logging est utilisée dans cet exemple pour la journalisation) :
package bla.bla.bla.struts;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.Properties;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.struts.util.MessageResourcesFactory;
import org.apache.struts.util.PropertyMessageResources;
public class MultiPropertyMessageResources extends PropertyMessageResources

{
protected static final Log log;
public MultiPropertyMessageResources(MessageResourcesFactory factory, String config)

{
super(factory, config);
log.info("Initializing, config='" + config + "'");
}
public MultiPropertyMessageResources(MessageResourcesFactory factory, String config, boolean

returnNull)
{
super(factory, config, returnNull);
log.info("Initializing, config='" + config + "', returnNull=" + returnNull);
}
protected void loadLocale(String localeKey)

{
label0:
{
if(log.isTraceEnabled())
log.trace("loadLocale(" + localeKey + ")");
synchronized(locales)
{
if(locales.get(localeKey) == null)
break label0;
}
return;
}
locales.put(localeKey, localeKey);
- 25 -
La FAQ Struts
String configFiles[] = config.split(",");

for(int i = 0; i < configFiles.length; i++)
{
String name = configFiles[i].trim().replace('.', '/');
if(localeKey.length() > 0)
name = name + "_" + localeKey;
name = name + ".properties";
InputStream is = null;
Properties props = new Properties();
try
{
log.trace(" Loading resource '" + name + "'");
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
if(classLoader == null)
classLoader = getClass().getClassLoader();
is = classLoader.getResourceAsStream(name);
if(is != null)
{
props.load(is);
is.close();
}
log.trace(" Loading resource completed");
}
catch(Throwable t)
{
log.error("loadLocale()", t);
if(is != null)
try
{
is.close();
}
catch(Throwable u) { }
}
if(props.size() < 1)
return;
synchronized(messages)
{
String key;
for(Enumeration names = props.keys(); names.hasMoreElements();
messages.put(messageKey(localeKey, key), props.getProperty(key)))
{
key = (String)names.nextElement();
log.trace(" Saving message key '" + messageKey(localeKey, key));
}
}
}
return;
}
static
{
log = LogFactory.getLog(MultiPropertyMessageResources.class);
}
}
Il faut ensuite écrire un Factory pour Struts :
package bla.bla.bla.struts;
import org.apache.struts.util.MessageResources;
- 26 -
La FAQ Struts
import org.apache.struts.util.PropertyMessageResourcesFactory;
public class MultiPropertyMessageResourcesFactory extends PropertyMessageResourcesFactory

{
public MultiPropertyMessageResourcesFactory()
{
}
public MessageResources createResources(String config)

{
return new MultiPropertyMessageResources(this, config, returnNull);
}
}
Puis il ne reste plus qu'à modifier le struts-config.xml :
<message-resources
parameter="fichier1,fichier2,fichier3"
factory="bla.bla.bla.struts.MultiPropertyMessageResourcesFactory"
/>
Cette solution règle bien évidemment le problème pour toutes les ressources utilisées par Struts, en particulier le plugin
Validator.
lien : Comment définir les fichiers de localisation en dehors du classpath ?

lien : Comment utiliser plusieurs ResourceBundle avec Struts ?
Comment définir les fichiers de localisation en dehors du classpath ?

Auteurs : Alwin ,
Pour pouvoir utiliser un ResourceBundle défini en dehors du classpath, il faut déclarer un module de chargement de
ressources comme suit :
Remarque : cette classe est une version améliorée de celle proposée pour la question sur le chargement de plusieurs
ResourceBundle (cf. lien).
Ses fonctionnalités sont les suivantes :

• Support de fichier de ressources multiples recours aux clés de bundle
• Accepte les ressources dans le classpath
• Accepte les ressources de type url
package com.vvic.struts.utils;
import java.io.InputStream;
import java.net.URL;
import java.util.Enumeration;
import java.util.Properties;
import org.apache.struts.util.MessageResourcesFactory;
import org.apache.struts.util.PropertyMessageResources;
public class MultiPropertyMessageResources extends PropertyMessageResources {
- 27 -
La FAQ Struts
protected static final Log log;
public MultiPropertyMessageResources(MessageResourcesFactory factory,

String config) {
super(factory, config);
log.info("Initializing, config='" + config + "'");
}
public MultiPropertyMessageResources(MessageResourcesFactory factory,

String config, boolean returnNull) {
super(factory, config, returnNull);
log.info("Initializing, config='" + config + "', returnNull="
+ returnNull);
}
protected void loadLocale(String localeKey) {

label0: {
if (log.isTraceEnabled())
log.trace("loadLocale(" + localeKey + ")");
synchronized (locales) {
if (locales.get(localeKey) == null)
break label0;
}
return;
}
locales.put(localeKey, localeKey);
String configFiles[] = config.split(",");

for (int i = 0; i < configFiles.length; i++) {
String name = configFiles[i].trim().replace('.', '/');
if (localeKey.length() > 0)
name = name + "_" + localeKey;
name = name + ".properties";
InputStream is = null;
Properties props = new Properties();
try {
log.trace(" Loading resource '" + name + "'");
ClassLoader classLoader = Thread.currentThread()
.getContextClassLoader();
if (classLoader == null)
classLoader = getClass().getClassLoader();
is = classLoader.getResourceAsStream(name);
if (is != null) {
props.load(is);
is.close();
}
log.trace(" Loading resource completed");
} catch (Throwable t) {
if (is != null)
try {
is.close();
} catch (Throwable u) {
}
}
if (props.size() < 1) {
try {
is = new URL(name).openStream();
props.load(is);
is.close();
} catch (Throwable t) {
}
}
if (props.size() < 1) {
- 28 -
La FAQ Struts
log.warn("Unable to load resource " + name);

return;
}
synchronized (messages) {
String key;
for (Enumeration names = props.keys(); names.hasMoreElements(); messages
.put(messageKey(localeKey, key), props.getProperty(key))) {
key = (String) names.nextElement();
log.trace(" Saving message key '"
+ messageKey(localeKey, key));
}
}
}
return;
}
static {
log = LogFactory.getLog(MultiPropertyMessageResources.class);
}
}
Exemple de configuration dans le fichier struts-config.xml :
<message-resources
parameter="resources.application,file:///workspace/globalResources/erreurs"
factory="com.vvic.struts.utils.MultiPropertyMessageResourcesFactory"
/>
lien : Comment charger plusieurs fichiers de ressources (bundles) sans avoir à utiliser les clés des bundles ?
- 29 -
La FAQ Struts
Sommaire > Formulaires

Comment factoriser plusieurs actions réalisables sur un seul ActionForm ? : Le DispatchAction
Auteurs : Lionel Roux (aka RanDomX) , Ricky81 , c_nvy ,
Il est souvent pratique de pouvoir réaliser plusieurs actions sur un même formulaire.
Par exemple, pour la gestion d'un panier virtuel, il est possible d'ajouter, de modifier ou de supprimer un élément.
Pour réaliser simplement ce genre de tâche, on peut utiliser le DispatchAction qui concentre en une seule action,
l'ensemble des opérations réalisables sur une seule JSP.
On utilise un simple JavaScript qui modifie la valeur d'un champ caché lors de la soumission.
<SCRIPT>
function setHidden(value){document.formulaire.hidden.value=value;}
</SCRIPT>
Dans le formulaire:
<html:form action="/cartManagement">
...
<html:hidden property="hidden" value="default"/>
...
<html:submit onclick="setHidden('add');">ADD ELEMENT</html:submit>
</html:form>
Ensuite dans l'Action concernée, il suffit de créer les méthodes portant les mêmes noms que les valeurs possibles du
champs hidden à la place de la méthode execute(...).
public class CartAction extends DispatchAction

{
public ActionForward add(ActionMapping mapping, ActionForm form,
throws IOException, ServletException { ... }
public ActionForward remove(ActionMapping mapping, ActionForm form,

public ActionForward modify(ActionMapping mapping, ActionForm form,

Dans le fichier de configuration struts-config.xml, il faut ajouter à la déclaration de l'action l'attribut "parameter" et
lui indiquer le nom du champ concerné.
<action
path="/cartManagement"
type="app.management.CartAction"
name="cartForm"
scope="request"
validate="true"
input="/page.jsp"
parameter="hidden"/>
- 30 -
La FAQ Struts
Il est aussi possible de créer des boutons dont les noms sont les noms des méthodes, car le nom d'un bouton est aussi
la valeur renvoyée par celui-ci.
Comment factoriser plusieurs actions réalisables sans JavaScript ? : Le LookupDispatchAction

Auteurs : Lionel Roux (aka RanDomX) , c_nvy , Alwin ,
Si le JavaScript n'est pas actif ou pas souhaité, le DispatchAction ne peut fonctionner. Heureusement, Struts offre le
LookupDispatchAction [org.apache.struts.actions.LookupDispatchAction] qui permet d'outrepasser cette limitation.
Le LookupDispatchAction reprend le mécanisme du Comment factoriser plusieurs actions réalisables sur un seul
ActionForm ? : Le DispatchAction. Les seules différences résident dans la déclaration du nom du (ou des) bouton(s)
de soumission qui doit être identique (attribut property de la balise submit) à la valeur (arbitraire) donnée à l'attribut
parameter dans la définition de l'action.
<action
path="/cartManagement"
type="app.management.CartAction"
name="cartForm"
scope="request"
validate="true"
input="/page.jsp"
parameter="monAction"/>
Dans la JSP, les boutons sont nommés grâce à une clé du Comment gérer l'internationalisation (I18N) et/ou la
localisation avec Struts ? : Le ResourceBundle.
<html:form action="/cartManagement">
<html:submit property="monAction">
<bean:message key="button.add"/>
</html:submit>
<html:submit property="monAction">
<bean:message key="button.delete"/>
</html:submit>
</html:form>
Les valeurs passées sont ainsi localisées et changent donc en fonction de la locale. Pour mapper ces valeurs à une méthode
particulière, on ajoute à l'Action une méthode qui est appelée lors de la soumission :
protected Map getKeyMethodMap() {

Map map = new HashMap();
map.put("button.add", "add");
map.put("button.delete", "delete");
return map;
}
- 31 -
La FAQ Struts
Le reste est identique au Comment factoriser plusieurs actions réalisables sur un seul ActionForm ? : Le DispatchAction.
lien : Comment utiliser le LookupDispatchAction avec un lien dans la jsp ?
Comment utiliser l'annulation d'un formulaire lorsque on utilise une LookupDispatchAction ?

Auteurs : dje_dje ,
Depuis la version de struts 1.2.0, le LookupDispatchAction propose une action "cancelled" à surcharger par les classes
filles.
Donc dans un formulaire si vous avez plusieurs html:submit et un html:cancel vous n'avez plus à vous soucier la manière
de récupérer l'appel dans l'action.
Il suffit juste d'implémenter la méthode "cancelled" et de rajouter la propriété cancellable pour l'action dans le fichier
struts-config.xml (une sécurité pour explicitement déclarer que cette action est annulable) :
<action ...>
<set-property property="cancellable" value="true"/>
</action>
De plus le fait d'utiliser html:cancel évite la validation du formulaire.
Attention : il ne faut pas mettre d'attribut "property" dans le tag html:cancel car sinon plus rien ne marchera. En
effet, la validation sera de nouveau effective et l'action voudra appeler la valeur de l'attribut property (identique au
tag html:submit).
lien : Comment factoriser plusieurs actions réalisables sans JavaScript ? : Le LookupDispatchAction
D'où provient l'erreur Javascript 'document.forms[0].submit is not a function' ?

Auteurs : c_nvy ,
Quand on utilise du Javascript dans une page jsp, il faut éviter de donner aux propriétés du formulaire des noms qui
correspondent à des attributs des tags comme par exemple submit et action.
Exemple :
Une propriété appelée submit

<html:submit property="submit" value="Valider">
Une tentative de soumission

<html:select property="itemSelected" onchange="document.forms[0].submit();">
On obtient le message d'erreur suivant induit par l'élément de formulaire identifié par "submit" :
document.forms[0].submit is not a function
- 32 -
La FAQ Struts
Sommaire > Formulaires > Validation

Comment valider les données d'un formulaire avec Struts ?
Struts offre deux principaux mécanismes de validations des données saisies dans les formulaires:
• Comment valider ses données avec le plug-in Validator de Struts ?
• Comment valider ses données avec la méthode validate() de l'ActionForm ?
Par validation, on entend deux choses :

• une validation dite de contrôle de surface ou qualitative : il s'agit de vérifier que les données saisies sont bien dans
la forme attendue (ex : une donnée numérique ne contient que des chiffres).
• une validation sémantique : il s'agit de vérifier que la valeur saisie est bien celle qui est attendue par le système
(ex : un numéro de carte bleue valide).
Bien que les deux systèmes sont à même de faire les deux, on utilise usuellement le plug-in Validator pour les contrôles
de surface, puisqu'il ne nécessite pas d'aller-retour entre le client et le serveur, et la méthode validate() des ActionForms
pour la validation sémantique.
lien : Comment valider ses données avec la méthode validate() de l'ActionForm ?

lien : Comment valider ses données avec le plug-in Validator de Struts ?
Comment valider ses données avec la méthode validate() de l'ActionForm ?

Il faut redéfinir la méthode validate(ActionMapping mapping,HttpServletRequest request) de l'ActionForm et y
implémenter les validations.
Cette méthode est appellée systématiquement après le remplissage de l'ActionForm.
Si aucune erreur n'est constatée, la méthode retourne null ou une instance de ActionErrors de taille 0.
Si une erreur est constatée, une instance de ActionErrors contenant une ou plusieurs instances de ActionMessage
(ActionError pour d'anciennes versions de Struts) est retournée. Les messages d'erreurs sont alors affichés grâce à la
balise <html:errors/>
Comment valider ses données avec le plug-in Validator de Struts ?

Auteurs : Lionel Roux (aka RanDomX) , c_nvy ,
Pour utiliser le validator, il faut :
• que le plug-in validator soit installé et configuré.

• que l'ActionForm hérite de ValidatorForm. Cette classe ne nécessite pas d'implémentation des méthodes reset( )
et validate( ).
• qu'une règle de validation soit définie dans le fichier xml de validation pour l'ActionForm.
• que l'attribut validate soit positionné à la valeur true dans le mapping de l'action correspondante.
Exemple de règle de validation:
<form-validation>
<formset>
<form name="logonForm">
- 33 -
La FAQ Struts
<field property="username" depends="required">

<msg name="required" key="error.username"/>
</field>
</form>
</formset>
</form-validation>
Pour que la validation se fasse également côté client, il convient de suivre les points suivants :
• que la page JSP intègre le tag <html:javascript formName="logonForm"> dans le header.

• que le formulaire intègre l'appel à la fonction JS générée (par défaut validateNomDuFormulaire)
<html:form .... onsubmit="return validateLogonForm(this)">
Il existe un ensemble de clés prédéfinies pour les messages d'erreurs les plus communs. Pensez à les ajouter dans votre
fichier de messages.
Ci-dessous la liste des messages les plus courants :
errors.required={0} est obligatoire.

errors.invalid={0} est invalide.
errors.maxlength={0} ne peut pas avoir plus de 8 caractère(s).
errors.minlength={0} ne peut pas avoir moins de {1} caractère(s).
errors.range={0} n'est pas dans l'intervalle de {1} à {2}.
errors.byte={0} doit être un nombre du type byte.
errors.date={0} incorrecte.
errors.double={0} doit être un nombre du type double.
errors.float={0} doit être un nombre du type float.
errors.integer={0} doit être un nombre du type Integer.
errors.long={0} doit être un nombre du type long.
errors.short={0} doit être un nombre du type short.
errors.creditcard={0} n'est pas un numéro de carte de crédit valide.
errors.email={0} n'est pas une adresse e-mail valide.
lien : Comment valider ses données avec la méthode validate() de l'ActionForm ?
Comment combiner la validation du Validator et la méthode validate() d'un formulaire ?

Auteurs : c_nvy ,
Si on souhaite fournir une validation complémentaire dans un ValidatorForm qui exploite le plugin Validator, il suffit
de redéfinir la méthode validate comme suit :
public ActionErrors validate(ActionMapping mapping, HttpServletRequest request)

{
// ici on récupère tous les messages d'erreurs gérés par le Validator
ActionErrors errors = super.validate(mapping, request);
if ( ... )
{
errors.add("idErreur",new ActionMessage ("cle.erreur"));
}
return errors;
}
lien : Comment valider les données d'un formulaire avec Struts ?
- 34 -
La FAQ Struts
Comment définir moi même le nom de la fonction de validation javascript ?

Auteurs : Ricky81 ,
Par défaut, l'utilisation de la balise <html:javascript > de génération de la fonction javascript de validation d'un
formulaire génère une fonction dont le nom est lié au nom du formulaire.
Par exemple, <html:javascript name="monForm" /> donnera une fonction validateMonForm.
Il peut être souhaité, pour une raison ou une autre (flexibilité en cas de changement de nom du formulaire,
normalisation, ...) de pouvoir définir soi même le nom de la fonction générée.
L'attribut method permet cela.
<html:javascript formName="monForm" method="strutsValidation" />

...
<html:form action="/monAction" onsubmit="return strutsValidation(this);">
...
</html:form>
Ainsi, si vous avez besoin d'écrire du code Javascript complémentaire pour la validation de certains éléments du
formulaire, vous n'aurez plus à vous soucier du nom de ce dernier :
function maValidation(form) {
if (...) {
return strutsValidation(form);
}
<html:javascript name="monForm" method="strutsValidation" />

...
<html:form action="/monAction" onsubmit="return maValidation(this);">
...
</html:form>
Comment gérer la validation d'un formulaire dans l'Action ?

Auteurs : c_nvy ,
Il arrive que dans certains cas il soit plus approprié de procéder à la validation d'un formulaire au niveau d'une classe
de type Action.
En effet, dans le cas de classes comme DispatchAction, LookupDispatchAction ou MappingDispatchAction, la
déclaration de validation (struts-config) va s'appliquer à toutes les méthodes, ce qui ne sera pas toujours satisfaisant.
L'appel de la validation (pouvant inclure l'utilisation du plugin validator) dans une Action nécessite de travailler avec
la classe ActionMessages.
Il est également possible de construire soit-même ses messages (notamment dans le cas d'une vérification nécessitant
un appel métier) et de l'ajouter à l'ensemble des messages.
- 35 -
La FAQ Struts
L'exemple ci-dessous montre l'appel de la validation classique par l'intermédiaire de la méthode validate, l'ajout d'un
message particulier, l'enregistrement des messages d'erreur, puis la gestion de la navigation.
Ce code a pour prérequis, dans le mapping de l'action, d'avoir positionné l'attribut validate à "false" et d'avoir renseigné
l'attribut input.
// Validation du formulaire
ActionMessages errors = form.validate(mapping, request);
// Appel backoffice
boolean existeDoublon = monService.rechercherDoublon(form.getNom());
if (existeDoublon) {
ActionError error = new ActionError("nom.existant");
errors.add("nom", error);
}
if ( !errors.isEmpty() )
{
this.saveErrors(request, errors);
return mapping.getInputForward() ;
}
- 36 -
La FAQ Struts
Sommaire > Formulaires > Checkbox et Radiobutton

Comment fonctionnent les checkboxes dans Struts ?
Auteurs : Lionel Roux (aka RanDomX) , OButterlin ,
Les checkboxes ont un fonctionnement particulier. En effet, une checkbox ne renvoie la valeur spécifiée dans l'attribut
value que si elle est cochée.
<html:checkbox property="someprop" value="true">Yes</html:checkbox>
Dans l'action, on récupère la valeur en faisant :
String somepropValue = null;

if((somepropValue = request.getParameter("someprop"))!=null)
{
// ckecked
System.out.println("The box is checked and its value is " + somepropValue);
}
else
{
// not ckecked
System.out.println("The box is not checked");
// set the value
someprop = "false";
}
Si la checkbox n'est pas cochée, alors vous devez explicitement donner une valeur (si vous en avez besoin). Dans le cas
contraire, vous ne serez pas capable de détecter qu'une checkbox initialement cochée a été décochée.
Une pratique courante pour contourner ce problème consiste à associer dans l'ActionForm un membre booléen à l'état
de la checkbox, et d'implémenter la méthode reset de l'ActionForm et d'y réinitialiser la valeur à false.
Ainsi, entre la soumission du formulaire et la magie du remplissage automatique des membres de l'ActionForm, la
méthode reset sera appelée et assurera la prise en compte d'un décochage.
public class MonForm extends ActionForm {
boolean alerterParMail = false;
public void reset(ActionMapping mapping, HttpServletRequest request) {

super.reset(mapping,request);
alerterParMail = false;
}
}
Comment configurer un ensemble de boutons radio à partir d'une collection d'objets ?

Auteurs : c_nvy ,
Tout d'abord, il s'agit d'itérer sur la collection d'objets en déclarant la variable de boucle identifiant l'élément courant
(cf. id).
Pour chaque élément, le composant radio créé doit référencer (cf. idName) l'élément à exploiter par l'intermédiaire du
nom de la variable définie précédemment.
Il s'agit également de définir la propriété de l'élément à utiliser pour définir la valeur associée au bouton radio (cf. value).
- 37 -
La FAQ Struts
<logic:iterate name="uneCollection" id="element">

<html:radio property="nomRadio" idName="element" value="id">
<bean:write name="element" value="nom"/>
</html:radio>
</logic:iterate>
Ainsi, les valeurs possibles au niveau du formulaire pour l'élément identifié "nomRadio" seront celles de la propriété
id de chaque objet de la collection.
- 38 -
La FAQ Struts
Sommaire > Formulaires > Listes

Comment utiliser les listes déroulantes avec Struts
Auteurs : c_nvy ,
Un tag html:select doit être dans un tag html:form afin de pouvoir récupérer le (ou les) éléments sélectionnés dans la
liste déroulante.
Struts utilisant par défaut le form-bean référencé dans le mapping de l'Action via l'attribut name, il n'est pas utile de
coder l'attribut name="nomDuFormBean" dans le tag html:select.
Dans l'attribut property du tag html:select, il faut spécifier le nom de la propriété qui contiendra la (ou les) valeur(s)
sélectionnée(s).
Sélection simple
<html:select property="selectedItem">
La propriété selectedItem doit être définie dans l'ActionForm avec getter et setter et doit être de type String.
Sélection multiple
<html:select property="selectedItems" multiple="true">
La propriété selectedItems doit être définie dans l'ActionForm avec getter et setter et doit être de type String[].
Pour afficher les options de la liste déroulante, il y a plusieurs possibilités :
1) Dans le cas où la collection a été mise dans le scope via un setAttribute, elle doit être référencée dans le tag html:options
ou html:optionsCollection via l'attribut name.
S'il s'agit d'un tableau de String ou d'Integer, d'une collection de String ou d'Integer, il suffit de coder ceci :
<html:options name="uneCollection"/>
</html:select>
S'il s'agit d'une collection d'objets ayant pour propriétés id et libelle :
<html:options collection="uneCollection" property="id" labelProperty="libelle"/>
</html:select>
ou
<html:optionsCollection name="uneCollection" value="id" label="libelle"/>
</html:select>
La propriété id spécifiée dans l'attribut property correspond à la valeur renvoyée si celle-ci est sélectionnée et la
propriété libelle spécifiée dans l'attribut labelProperty est le label qui s'affiche dans la liste déroulante.
- 39 -
La FAQ Struts
2) Dans le cas où la collection est une propriété de l'ActionForm et que celle-ci est initialisée via le setter de l'ActionForm
dans une Action qui s'exécute avant l'affichage du formulaire, elle doit être référencée dans le tag html:options ou
html:optionsCollection via l'attribut property.
S'il s'agit d'un tableau de String ou d'Integer, d'une collection de String ou d'Integer, il suffit de coder ceci :
<html:options property="uneCollection"/>
</html:select>
S'il s'agit d'une collection d'objets ayant pour propriétés id et libelle :
<html:optionsCollection property="uneCollection" value="id" label="libelle"/>
</html:select>
S'il s'agit d'une collection de LabelValueBean, celui-ci ayant pour propriété value et label, il n'est pas utile de coder les
attributs value et label dans le tag html:optionsCollection :
<html:optionsCollection property="uneCollection"/>
</html:select>
Si on veut sélectionner par défaut un élément de la liste déroulante, il suffit d'initialiser la propriété correspondante de
l'ActionForm dans l'Action qui s'exécute avant l'affichage du formulaire via le code suivant :
UneActionForm uneActionForm = (UneActionForm) form;

uneActionForm.setSelectedItem(variableContenantLaValeurParDefaut);
Ceci implique que le form-bean soit référencé via l'attribut name dans le mapping de cette Action dans le struts-
config.xml.
Dans le cas où la valeur par défaut est fixe, il est possible d'initialiser la propriété selectedItem dans la méthode reset()
dans le cas d'une ActionForm, ou dans l'attribut initial de la balise form-property dans le cas d'une DynaActionForm.
Comment construire des listes de choix dynamiques et dépendantes avec Struts ?: Les DropDownBox.
Les DropDownBox sont utilisées par exemple quand on choisit une valeur dans une première liste, on souhaite
restreindre les valeurs possibles dans une seconde liste.
<html:form name= "myform">

<html:select property="list1" onchange="document.myform.submit()">
...
</html:select>
<html:select property="list2">
...
</html:select>
</html:form>
- 40 -
La FAQ Struts
Lors d'un changement, un premier submit est déclenché par l'événement "onchange" de la liste list1.
Lors de cette soumission, il faut dans l'Action ou dans l'ActionForm définir les valeurs possibles retournées pour la
liste list2.
Ainsi, celles-ci seront affichées lors du réaffichage du formulaire.
Comment sélectionner par défaut un élément particulier

d'une liste dans un formulaire ? : L'attribut "value"
Auteurs : Lionel Roux (aka RanDomX) , mezoo ,
Il suffit de positionner l'attribut value du tag select à la valeur souhaitée.
Ex :
<html:select name="myForm" property="sex" value="M"/>

<html:option value="M">M</html:option>
<html:option value="F">F</html:option>
</html:select>
Une variante avec association directement de la valeur au formulaire (cas d'un scénario d'édition) consiste à définir la
valeur de la sélection dans l'action préparant l'affichage de la page :

HttpServletRequest request, HttpServletResponse response) throws Exception {
MonForm monForm = (MonForm) form;

...
String valeurSelectionnee = ...
form.setValeurSelection(valeurSelectionnee);
...
}
Le code de la vue suivant affichera ainsi la sélection correspondante :
<html:select property="valeurSelectionnee">
<html:optionsCollection property="listeValeur" label="label" value="value" />
</html:select>
- 41 -
La FAQ Struts
Sommaire > Formulaires > Fichiers

Comment uploader un fichier vers un serveur avec Struts ?
Il faut déclarer un formulaire d'envoi du fichier dans la JSP:
<html:form action="/upload.do?from=sender" method="post" enctype="multipart/form-data">

<html:file property="fichier"/>
...
</html:form>
Ensuite, il faut créer un bean que l'on nommera pour l'exemple "UploadForm" :
public class UploadActionForm extends ActionForm

{
protected FormFile fichier;
public FormFile getFichier()

{
return fichier;
}
public void setFile(FormFile fichier)

{
this.fichier = fichier;
}
...
}
Il faut créer aussi dans l'Action idoine "UploadAction" contenant :
{
...
UploadActionForm theForm = (UploadActionForm) actionForm;
FormFile file = theForm.getFichier();
...
}
Voila, vous avez votre objet implémentant FormFile [org.apache.struts.upload] , que vous pouvez manipuler sur le
serveur.
Comment envoyer au client un fichier avec Struts ?

Dans l'action il faut récupérer le nom du fichier à envoyer (filename).
Ensuite il faut ouvrir le stream de l'objet response et y envoyer le flux de données correspondant au fichier comme ceci:
File f = ...;
String filename = f.getName();
response.setContentType("multipart/zip");
response.setHeader("Content-Disposition",
"attachment; filename=\"" +
filename + "\";");
- 42 -
La FAQ Struts
response.setContentLength((int)f.length());
try
{
OutputStream os = response.getOutputStream();
FileInputStream stream = new FileInputStream(f);
BufferedInputStream bis = new BufferedInputStream(stream);
InputStream is = new BufferedInputStream(bis);
int count;
byte buf[] = new byte[4096];
while ((count = is.read(buf)) > -1)
{
os.write(buf, 0, count);
}
is.close();
os.close();
}
catch (Exception ex)
{
ex.printStackTrace();
}
..
return mapping.findforward("fichieenvoye");
Ceci provoque l'ouverture d'une boîte de dialogue vous invitant à enregistrer localement le fichier, et vous redirige vers
la ressource correpondant au mapping "fichieenvoye".
Comment ouvrir un fichier dans le navigateur avec Struts?

Prenons l'exemple d'un fichier PDF.
Dans la page (par exemple) on a :
<html:link page="/openpdf.do"
name="pdfForm"
property="pdfName"
target="_blank">
<html:img src="./images/PDF.gif" border="0" alt="View PDF"/>
</html:link>
Dans la méthode execute de l'Action :
ByteArrayOutputStream bos = new ByteArrayOutputStream(5000);

// Remplir ici votre bos avec le flux du PDF
httpServletResponse.setContentType("application/pdf");
httpServletResponse.setContentLength(bos.size());
OutputStream os = httpServletResponse.getOutputStream();
os.write(bos.toByteArray(), 0, bos.size());
os.flush();
os.close();
return null;
- 43 -
La FAQ Struts
Le fichier PDF s'ouvre alors dans le navigateur.
- 44 -
La FAQ Struts
Sommaire > Liens

Comment enrichir une URL avec la valeur d'une propriété d'un bean local?
Si la valeur à passer se trouve dans un bean, il faut récupérer celle-ci dans un bean local avec le tag <bean:define>
<bean:define id="myBeanValue" name="myBean" property="myProperty" />

<html:link href="action.do?prop='${myBeanValue}'" />
Comment enrichir une URL avec la propriété d'un ActionForm Struts ?

Si la (ou les valeurs) à passer se trouve dans un bean connu, on peut utiliser les attributs paramId et paramName. paramId
correspond au nom du paramètre à passer, et paramName au nom du bean qui contient la valeur.
<html:link href=action.do paramId="prop" paramName="myBean"/>
Si ce bean ne contient pas que la dite propriété, on utilise l'attribut paramProperty :
<html:link href="action.do" paramId="myProperty" paramName="myBean" paramProperty="myProperty"/>
Comment enrichir une URL avec une valeur connue ?

Si la valeur est statique ou connue, il suffit d'enrichir l'url à la main :
<html:link href="action.do?prop=thepropvalue" />
Comment enrichir une URL avec les propriétés d'un ActionForm ?

Dans certains cas, il peut être intéressant de soumettre des valeurs par le biais d'un lien.
Si l'on souhaite passer plusieurs paramètres, on peut utiliser l'attribut paramName seul dans le tag <html:link>.
Le bean référencé doit contenir une Map contenant les couples cles/valeurs pour chaque paramètre.
Une limitation existe cependant, les noms des clés sont les noms des paramètres qui seront transmis.
lien : Comment enrichir une URL avec la valeur d'une propriété d'un bean local?
lien : Comment enrichir une URL avec la propriété d'un ActionForm Struts ?
- 45 -
La FAQ Struts
lien : Comment enrichir une URL avec une valeur connue ?
Comment utiliser le LookupDispatchAction avec un lien dans la jsp ?

Auteurs : c_nvy , Ricky81 ,
Prenons l'exemple suivant :
Dans les struts-config :

<action path="/tonAction" parameter="action"...>
Dans l'action :
public ActionForward ajouter(...)
{...}
public ActionForward modifier(...)

{...}
protected Map getKeyMethodMap()

{
Map map = new HashMap() ;
map.put("bouton.ajouter", "ajouter");
map.put("bouton.modifier", "modifier");
return map ;
}
Dans le ResourceBundle :
bouton.ajouter=Ajouter
bouton.modifier=Modifier
Une première solution serait d'écrire le code suivant dans la JSP :
<html:link action="tonAction?action=Ajouter">
<bean:message key="bouton.ajouter"/>
</html:link>
Cependant, on n'exploite pas complètement les possibilités du LookupDispatchAction car on passe "en dur" le libellé
de la clé correspondant à la méthode contrairement au cas d'un bouton de type submit où la clé du libellé est suffisante
pour retrouver la méthode à exécuter.
Une solution consiste à utiliser les possibilités du tag <html:link> conjuguées à l'utilisation du tag <bean:define> :
<bean:define id="actionAjouter">
</bean:define>
<html:link action="tonAction" paramId="action" paramName="actionAjouter">

</html:link>
lien : Comment factoriser plusieurs actions réalisables sans JavaScript ? : Le LookupDispatchAction

lien : Comment enrichir une URL avec la valeur d'une propriété d'un bean local?
- 46 -
La FAQ Struts
Sommaire > Erreurs

Comment afficher un message d'erreur avec Struts ?
Pour insérer un message d'erreur sur vos pages, il suffit de positionner le tag <html:errors/>.
Ensuite pour alimenter ce tag, vous devez créer un ActionMessage en lui passant en paramètre soit la clé du message
d'erreur contenu dans un bundle, soit le message directement.
ActionMessage am = new ActionMessage("foo.bar.myKey");
Une fois que vous avez construit tous vos ActionMessage, vous devez les ajouter à un ActionErrors. C'est cet objet qui
sera retourné.
ActionErrors errors = new ActionErrors();

errors.add(ActionMessages.GLOBAL_MESSAGE, am);
..
return errors;
Il est à noter que pour d'anciennes versions de Struts, il sera fait usage de la classe ActionError en lieu et place de
ActionMessage.
Egalement le paramètre ActionMessages.GLOBAL_MESSAGE peut être remplacé par
ActionErrors.GLOBAL_ERROR dans les premières versions.
Comment afficher un message d'erreur simple et totalement dynamique ?

Pour un message simple et dynamique, on crée l'ActionMessage de la manière suivante :
Dans le ResourceBundle on a une clé comme ceci:
error.dynamic={0}
Dans l'ActionForm, on remplit l'ActionMessage:
..
..new ActionMessage("error.dynamic", "This_is_my_message");
..
Le résultat sera le suivant:
This_is_my_message.
- 47 -
La FAQ Struts
ActionMessage.
Comment afficher un message d'erreur simple référencé dans le ResourceBundle ?

Pour un message simple dont le texte est contenu dans le ResourceBundle, on crée l'ActionMessage de la manière
suivante :
Dans le resource bundle, on a une clé comme ceci:
error.myerror.foo.bar=This is my message from bundle
..
new ActionMessage("error.myerror.foo.bar");
..
This is my message from bundle.
ActionMessage.
lien : Comment afficher un message en retour d'une action ?
Comment afficher un message d'erreur personnalisé référencé dans le ResourceBundle ?

Pour un message personnalisable dont le texte est contenu dans le ResourceBundle, on crée l'ActionMessage de la
manière suivante :
Dans le ResourceBundle, on a une clé comme ceci:
error.myerror.foo.bar.custom=This is my {0} message from bundle
..
.. am1 = new ActionMessage("error.myerror.foo.bar.custom", "custom");
.. am2 = new ActionMessage("error.myerror.foo.bar.custom", "own");
..
This is my custom message from bundle.

This is my own message from bundle.
- 48 -
La FAQ Struts
De la mème manière, on peut imaginer toutes sortes de compositions :
error.myerror.foo.bar.custom.comp=This is my {0} message from bundle: {1}
avec la construction suivante :
..
new ActionMessage("error.myerror.foo.bar.custom.comp", "custom", "hello you");
..
pour l'affichage suivant :
This is my custom message from bundle: hello you
Ceci peut être fait dans la limite de 3 éléments configurables.
ActionMessage.
Comment savoir dans la JSP s'il y a des messages d'erreurs ?

Auteurs : mattheox ,
Il existe au moins 3 solutions pour savoir si la balise <html:errors/> est susceptible d'afficher des messages d'erreur.
1) Utilisation de taglib logic:present et de la constante Globals.ERROR_KEY
<logic:present name="<%=org.apache.struts.Globals.ERROR_KEY%>">
faire quelque chose de spécifique en cas d erreur
</logic:present>
Attention : ce code semble ne pas fonctionner sous Websphere à cause de l'utilisation de constantes dans la JSP. Il
fonctionne très bien sous Tomcat.
2) Utilisation de taglib logic:present et de l'objet ERROR
<logic:present name="org.apache.struts.action.ERROR">
</logic:present>
Remarque : Si Struts modifie la définition de la constante, ce code ne fonctionnera plus !
3) Implémenter un TagLib :
La TLD
<tag>
<name>isErrors</name>
<tag-class>package.tags.ErrorsTag</tag-class>
<description>Indique s'il y a des messages d'erreur</description>
- 49 -
La FAQ Struts
La TLD
<attribute>
<name>name</name>
<required>false</required>
<type>java.lang.String</type>
<description>
Nom du bean(dans n'importe quel scope) sous lequel les messages d'erreur ont été stockés.
S'il n'est pas défini, c'est le nom spécifié par la constante <code>Globals.ERROR_KEY</code>
qui est utilisé.
</description>
</attribute>
</tag>
Implémentation
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.Tag;
import org.apache.struts.Globals;
public class ErrorsTag implements Tag {
private String name = Globals.ERROR_KEY;
private Tag parent;
private PageContext pageContext;
public int doEndTag() throws JspException {

return EVAL_PAGE;
}
protected boolean test() {

return pageContext.getRequest().getAttribute(name) == null;
}
public int doStartTag() throws JspException {

int eval;
// On teste ici l'existence du bean dans la request
if (test()) {
eval = SKIP_BODY;
} else {
eval = EVAL_BODY_INCLUDE;
}
return eval;
}
public Tag getParent() {

return parent;
}
public void release() {

}
public void setPageContext(PageContext arg0) {

pageContext = arg0;
}
public void setParent(Tag arg0) {

parent = arg0;
}
public String getName() {

return name;
}
- 50 -
La FAQ Struts
Implémentation
public void setName(String name) {
this.name = name;
}
}
Utilisation
<X:isErrors>
</X:isErrors>
Pour définir l'opération inverse, à savoir détecter lorsqu'il n'y a pas d'erreur, il suffit par exemple de définir une nouvelle
TagLib qui hérite de la précédente et redéfinit la méthode test.
- 51 -
La FAQ Struts
Sommaire > Messages

Comment afficher un message en retour d'une action ?
Auteurs : c_nvy ,
En cas d'erreur technique ou métier, ou même pour signifier le bon déroulement d'un traitement, il est possible de
déclarer un message dans l'Action et de l'enregistrer dans le scope request ou session pour pouvoir l'afficher dans une
jsp.
Pour ce faire, il suffit d'utiliser les classes ActionMessage et ActionMessages :
Déclaration de l'ActionMessage dans l'Action

ActionMessages messages = new ActionMessages();
messages.add("message1", new ActionMessage("error.message"));
this.saveMessages(request, messages);
Le libellé du message (correspondant à la clé error.message dans l'exemple) doit être déclaré dans le fichier properties
d'internationalisation.
Ce message est paramétrable, comme indiqué dans la question sur l'affichage d'un message d'erreur (cf. lien).
La récupération du message dans la page jsp s'effectue via le tag <html:messages> :
<html:messages id="idMessage" message="true">

<bean:write name="idMessage"/>
</html:messages>
idMessage étant le nom de la variable permettant de boucler sur la liste des messages.
message="true" indiquant que ce sont les messages (ActionMessages) et non les erreurs (ActionErrors) que l'on souhaite
afficher.
Pour afficher un message en particulier, et non la liste des messages comme indiqué précédemment, il suffit de préciser
le nom de la variable contenant le message dans l'attribut property du tag <html:messages> comme ceci :
<html:messages id="idMessage" property="message1" message="true">

<bean:write name="idMessage" />
</html:messages>
lien : Comment afficher un message d'erreur simple référencé dans le ResourceBundle ?
- 52 -
La FAQ Struts
Sommaire > DataSource

Comment utiliser un DataSource directement avec Struts ?
Pour utiliser un datasource déclaré dans le fichier struts-config.xml, par exemple dans une Action, vous devez faire
comme ceci:
public ActionForward execute(ActionMapping mapping,

ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception
{
javax.sql.DataSource dataSource;
java.sql.Connection myConnection;
try
{
dataSource = getDataSource(request);
myConnection = dataSource.getConnection();
// faire ici le traitmement à partir de la connexion.
}
catch (SQLException sqle)
{
...
}
finally
{
try {
myConnection.close();
} catch (SQLException e) {
getServlet().log("Connection.close", e);
}
}
}
lien : Comment configurer un datasource utilisable directement par Struts ?
Comment utiliser plusieurs DataSources avec Struts?

Vous pouvez accéder à vos DataSources de la manière suivante, en les référencant :
...
try
{
dataSourceA = getDataSource(request, "FirstDataSource");
...
dataSourceB = getDataSource(request, "SecondDataSource");
...
}
...
lien : Comment configurer plusieurs datasources utilisables par Struts ?
- 53 -
La FAQ Struts
Sommaire > Sécurité

Comment appliquer la gestion de la sécurité par le conteneur avec Struts ?
Les invocations d'actions Struts peuvent être protégées au même titre que n'importe quelle url d'une application Web.
Pour ce faire on utilise le mécanisme de sécurité du conteneur.
En configurant le fichier web.xml, vous pouvez restreindre certains patterns d'url à un certain type d'utilisateurs.
Par exemple, vous pouvez choisir de restreindre "/restricted/*" au rôle "admin".
<security-constraint>
<web-resource-collection>
<web-resource-name>
restricted
</web-resource-name>
<url-pattern>/restricted/*</url-pattern>
</web-resource-collection>
<auth-constraint>
<role-name>admin</role-name>
</auth-constraint>
</security-constraint>
Dans le fichier struts-config.xml :
<action path="/myAction" type="...">

...
</action>
<action path="/restricted/myProtectedAction" type="...">

...
</action>
Ainsi, l'Action "/myAction" est accessible par tous les utilisateurs. En revanche, l'Action "/restricted/myProtectedAction"
n'est accessible que par le groupe "admin". Pour plus d'information, lisez la documentation de votre conteneur de
servlet concernant la sécurité.
Comment afficher certains éléments en fonction du rôle de l'utilisateur ?

Il faut utiliser la taglib logic et mettre le bloc à cacher entre <logic:present> en spécifiant le rôle autorisé dans l'attribut
role :
<logic:present role="admin">
This is hide to non admin user
</logic:present>
- 54 -
La FAQ Struts
Sommaire > Plug-ins

Qu'est ce qu'un plug-in dans Struts ?
Les plug-ins permettent globalement à Struts de découvrir dynamiquement des ressources et/ou des services au
démarrage de l'application.
Ils permettent surtout de ne pas avoir à redéfinir la servlet ActionServlet pour simplement initialiser un service au
démarrage de l'application.
Les plug-ins les plus connus sont Tiles, un framework de composition de page très puissant, et le Comment valider ses
données avec le plug-in Validator de Struts ? qui permet de valider déclarativement ses données coté client et serveur.
Vous pouvez aussi Comment créer son propre plug-in pour Struts ? pour adresser toutes vos problématiques qui ne
seraient pas prise en compte par Struts.
Techniquement, un plug-in reçoit une notification du démarrage et de l'extinction de l'application.
Au démarrage, le framework crée une instance de chaque classe de plug-in déclaré. La méthode init() est alors appelée.
A l'extinction, la méthode destroy() est appelée.
Comment installer un plug-in pour Struts ?

Pour installer un plug-in dans Struts, il suffit de le déclarer dans l'élément <plug-in> du fichier de configuration struts-
config.xml.
L'élément <plug-in> spécifie un nom complètement qualifié de la classe d'implémentation du plug-in.
Comme le spécifie la DTD du fichier struts-config.xml, l'élément <plug-in> peut contenir 0 ou plus éléments <set-
property>.
<!ELEMENT plug-in (set-property*)>
Ces éléments permettent de passer des valeurs d'attributs au plug-in.

Exemple de déclarations de plug-ins :
<plug-in className="foo.bar.MyPlugIn">
<set-property property="path" value="/WEB-INF/my.xml"/>
</plug-in>
<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
<set-property property="pathnames" value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/>
</plug-in>
Comment créer son propre plug-in pour Struts ?

Pour définir votre propre plug-in, vous devez fournir une classe d'implémentation non abstraite qui implémente
l'interface PlugIn [org.apache. struts.action.PlugIn] et la Comment installer un plug-in pour Struts ? dans le fichier de
configuration struts-config.xml.
Vous devez redéfinir les méthodes init() et destroy() et y insérer le code d'initialisation et de destruction de votre service.
- 55 -
La FAQ Struts
Sommaire > Trucs et Astuces

Comment définir une Action comme une page d'accueil d'une application ?
Le conteneur de Servlet attend d'un fichier de bienvenue référencé dans un noeud <welcome-file> qu'il soit un fichier
physique (une page JSP, un fichier plat...).
Ainsi vous ne pouvez pas mapper directement une Action comme fichier de bienvenue.
Toutefois, il est possible de définir dans une page JSP très simple, un forward automatique grâce à la balise
<logic:forward>.
Ce forward se chargera alors de retourner l'action demandée.
Dans le fichier struts-config.xml :
<action
path="/monaction" ...
type="foo.bar.MonType" />
Dans la JSP majsp.jsp :
...
<logic:forward name="monaction"/>
...
Dans le fichier web.xml :
<welcome-files>
<welcome-file>majsp.jsp</welcome-file>
<welcome-file>...</welcome-file>
</welcome-files>
L'ouverture de l'application web monapplication retourne le résultat de l'Action mappée par monaction.
Comment faire un "redirect" vers une ressource avec Struts ?

En général, après avoir invoqué une Action, vous souhaitez êtres redirigé vers l'un des mappings défini dans votre fichier
de configuration struts-config.xml.
<action path="/monAction"
type="struts.action.MonAction"
name="monActionForm"
scope="session"
input="/ma.jsp"
validate="true">
<forward name="jsp" path="/jsp.jsp"/>
<forward name="..." .../>
</action>
Si à la fin de votre Action vous choisissez le <forward> de nom "jsp", Struts va vous renvoyer la page jsp.jsp, mais sans
changer l'url http://monserveur/monapplication/monAction.do dans votre navigateur.
- 56 -
La FAQ Struts
Or il peut être intéressant ou souhaité parfois de changer l'url affichée dans le navigateur pour laisser apparaître la
véritable url de la ressource affichée.
Struts fournit pour cela un attribut qu'il suffit d'ajouter dans l'élément <forward>: l'attribut redirect="true".
Ainsi dans l'exemple précédent, cela donnerait :
<action path="/monAction"
type="struts.action.MonAction"
name="monActionForm"
scope="session"
input="/ma.jsp"
validate="true">
<forward name="jsp" path="/jsp.jsp" redirect="true"/>
<forward name="..." .../>
</action>
Comment automatiser la population des chaînes contenant des dates ?

Auteurs : Alwin ,
Les Commons BeanUtils ne prennent pas en charge de base la population d'un élément de type java.util.Date à partir
d'une chaîne de caractères.
Ainsi, si vous utilisez tel quel un attribut de type Date dans votre formulaire, vous rencontrerez l'erreur suivante :
javax.servlet.ServletException: BeanUtils.populate
Pour résoudre une fois pour toute ce satané problème, voici ce que j'utilise pour ma part :
Dans un premier temps, je crée un Converter :
package bla.bla.bla.utils;
import java.text.ParseException;
import java.util.Date;
import org.apache.commons.beanutils.Converter;
public class DateConverter implements Converter {
private static final Log logger = LogFactory.getLog(DateConverter.class);
private Object defaultValue = null;
public DateConverter() {
this.defaultValue = null;
}
public DateConverter(Object defaultValue) {

this.defaultValue = defaultValue;
}
public Object convert(Class type, Object value) {

if (value == null) {
return (defaultValue);
}
- 57 -
La FAQ Struts
if (value instanceof Date) {

return (value);
}
try {
return WrapperUtil.toDate(value.toString());
} catch (ParseException e) {
logger.debug("Unable to convert " + value + " into Date format.");
return defaultValue;
}
}
}
La classe WrapperUtil doit contenir une méthode statique assurant le formatage et le parsing selon un pattern
configurable, j'utilise spring pour injecter le pattern en général... A vous d'implémenter cette classe en fonction de votre
application...
Une fois ce Converter écrit et testé, il faut l'ajouter à la table des converters utilisés par les BeanUtils.
Pour cela on déclare un plug-in Struts :
package bla.bla.bla.struts.plugin;
import javax.servlet.ServletException;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.struts.action.ActionServlet;
import org.apache.struts.action.PlugIn;
import org.apache.struts.config.ModuleConfig;
import bla.bla.bla.DateConverter;
public class StrutsBootstrapPlugin implements PlugIn{
public void destroy() {

}
public void init(ActionServlet actionServlet, ModuleConfig moduleConfig) throws

ServletException {
ConvertUtils.register(new DateConverter(), java.util.Date.class);
}
Il ne reste plus qu'à ajouter ce plug-in au struts-config.xml avec la ligne suivante :
<plug-in className="bla.bla.bla.struts.plugin.StrutsBootstrapPlugin" />
Il n'en faut pas plus pour que Struts sache convertir définitivement de lui-même les String en Date lors de la population
d'un formBean.
Pourquoi ma page HTML est-elle tronquée à l'affichage suite à l'exécution d'une action Struts ?
Auteurs : jak0 ,
L'action Struts couplée à la page JSP utilise un buffer pour générer le code HTML à envoyer sur le navigateur client.
- 58 -
La FAQ Struts
Au fur et à mesure de son remplissage par la Servlet, le buffer est vidé et envoyé au client. Si une erreur se produit
pendant l'exécution de la Servlet, l'exécution se termine, le buffer en cours est détruit et n'est pas envoyé. Toutefois
comme les buffers précédents ont bien été envoyés (flush), le code HTML affiché par le navigateur se retrouve tronqué.
La troncature du code HTML ne se trouve pas forcément à l'endroit de la dernière écriture précédant l'erreur, car le
buffer qui était en cours a été détruit. Il faut donc chercher un peu plus loin.
Comment écrire soi-même le flux de réponse ?

Auteurs : mattheox ,
Il arrive de devoir écrire un flux de réponse directement sans renvoyer vers une vue de type JSP (XML, fichier Word,
Excel, XML, etc.).
Voici comment réaliser ceci.
Dans le struts-config.xml, créer une action sans forward :
<action name="DocumentForm" path="/documentAction" scope="request"

type="actions.DocumentAction" validate="false"/>
S'il n'y a pas de formulaire associé à l'action, omettre l'attribut "name".
Créer une action adaptée de la suivante :
public class DocumentAction extends Action {

throws Exception {
// Typer la réponse
//response.setContentType("");
// response.setContentLength(1000);
//response.setCharacterEncoding("");
// Calculer le flux à renvoyer au client

byte[] bytes = null;
// Envoyer le flux dans la réponse

os.write(bytes);
os.close();
// Retourne null pour dire à Struts de ne rien faire

return null;
}
}
Voici une implémentation possible pour envoyer un flux XML (pour Ajax) :

throws Exception {
response.setContentType("text/xml");
response.setCharacterEncoding("iso-8859-1");
- 59 -
La FAQ Struts

byte[] bytes = null;
StringBuffer xml = new StringBuffer();
xml.append("<?xml version='1.0' encoding='ISO-8859-1' ?>");
xml.append("<reponse>");
xml.append("</reponse>");
bytes = xml.toString().getBytes();

os.write(bytes);
os.close();

return null;
}
Voici une implémentation possible pour envoyer un flux/fichier Excel :

throws Exception {
response.setContentType("application/octet-stream");
response.setHeader("Content-Disposition",
"attachment; filename=\"fichier.xls\"");

FileInputStream is = new FileInputStream("fichier.xls");
byte buffer[] = new byte[1024];
int nbLecture;

while ((nbLecture = is.read(buffer)) != -1) {
os.write(buffer, 0, nbLecture);
}
os.close();

return null;
}
- 60 -

FaqStruts 2

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

FaqStruts 2

Загружено:

Авторское право:

Доступные форматы

La FAQ Struts

Date de publication : 17/05/2003

Dernière mise à jour : 22/12/2009

OButterlin - dje_dje - mattheox - mezoo - blbird - L'équipe

1. Informations (5) ......................................................................................................................................................................... 4

Sommaire > Informations

lien : Comment participer à cette FAQ ?

Comment participer à cette FAQ ?

Rédacteur : Bien évidemment, toute nouvelle question/réponse est la bienvenue.

lien : Quels sont les droits de reproduction de cette FAQ ?

Quels sont les droits de reproduction de cette FAQ ?

lien : Licence en anglais

Où trouver d'autres sources d'information ?

Sommaire > Généralités

Struts est-il le meilleur choix pour construire mes applications Web?

Qui a écrit Struts ?

Struts peut-il être utilisé dans une application commerciale ?

Sommaire > Configuration de l'application web

Comment changer le nom ou l'emplacement du fichier struts-config.xml ?

Comment déclarer le fichier de configuration d'un module Struts ?

Vous pouvez répéter le paramètre pour chaque module de votre application.

lien : Comment changer le nom ou l'emplacement du fichier struts-config.xml ?

Comment utiliser plusieurs fichiers de configuration pour un module Struts ?

lien : Comment déclarer le fichier de configuration d'un module Struts ?

Comment configurer les fichiers de bienvenue ?

Vous pouvez spécifier plusieurs éléments <welcome-file>

Comment configurer les taglibs de Struts pour l'application web ?

Quelle que soit la taglib, sa déclaration prends la forme suivante:

Par exemple pour la taglib html de Struts:

Dans la JSP, il faut ensuite faire référence à la taglib:

<%@ taglib uri="StrutsHtml" prefix="html" %>

On notera qu'il est d'usage de déclarer le chemin relatif comme alias.

lien : Pour plus de détails, consultez la FAQ Java EE.

Sommaire > Bibliothèques de tags

lien : Que sont les JSP Taglibs ?

Comment permettre/empêcher l'encodage en HTML dans un bean:write ?

Sommaire > Configuration de l'application Struts

Comment vérifier si l'utilisateur est identifié et si sa session n'a pas expiré?

Pour que Struts prenne en compte la nouvelle classe, modifier le struts-config.xml :

Dans notre nouvelle classe, il nous faudra écrire le code suivant :

// On verifie si l'utilsateur est bien connecté

return user != null;

protected boolean processRoles(HttpServletRequest request, HttpServletResponse response,

ActionMessages messages = new ActionMessages();

Comment rajouter des éléments de configuration aux actions ?

public class MonActionMapping extends ActionMapping {

public String getLevel() {

public void setLevel(String level) {

<action path="/titresecondaireinit" name="titreSecondaireBean" scope="session"

public class TitreSecondaireInit extends Action {

public ActionForward execute(ActionMapping mapping, ActionForm form,

Sommaire > Configuration de l'application Struts > Les ActionForms

L'attribut type désigne le nom qualifié de la classe d'implémentation de votre ActionForm.

Comment configurer un DynaActionForm (ActionForm dynamique) ?

Chaque élément <form-property> possède un certain nombre d'attributs parmi lesquels:

Sommaire > Configuration de l'application Struts > Les Exceptions

Conmment configurer la gestion d'une exception globale ?

lien : Comment configurer la gestion des exceptions dans Struts ?

Comment configurer une exception spécifique à une Action ?

lien : Comment configurer la gestion des exceptions dans Struts ?

Sommaire > Configuration de l'application Struts > Les Datasources

Note: la requête de la propriété validationQuery doit retourner au moins une ligne.

lien : Comment utiliser un DataSource directement avec Struts ?