Struts 2 - Guide rapide

Model View Controller ou MVCcomme on l'appelle couramment, est un modèle de conception de logiciel pour le développement d'applications Web. Un modèle Model View Controller est composé des trois parties suivantes:

Model - Le niveau le plus bas du modèle qui est responsable de la conservation des données.
View - Il est responsable de l'affichage de tout ou partie des données à l'utilisateur.
Controller - Code logiciel qui contrôle les interactions entre le modèle et la vue.

MVC est populaire car il isole la logique d'application de la couche d'interface utilisateur et prend en charge la séparation des préoccupations. Ici, le contrôleur reçoit toutes les demandes de l'application, puis travaille avec le modèle pour préparer toutes les données nécessaires à la vue. La vue utilise ensuite les données préparées par le contrôleur pour générer une réponse présentable finale. L'abstraction MVC peut être représentée graphiquement comme suit.

Le modèle

Le modèle est responsable de la gestion des données de l'application. Il répond à la demande de la vue et il répond également aux instructions du contrôleur de se mettre à jour.

La vue

Cela signifie la présentation des données dans un format particulier, déclenchée par la décision d'un responsable du traitement de présenter les données. Ce sont des systèmes de modèles basés sur des scripts comme JSP, ASP, PHP et très faciles à intégrer avec la technologie AJAX.

Le controlle

Le contrôleur est responsable de répondre à l'entrée de l'utilisateur et d'effectuer des interactions sur les objets du modèle de données. Le contrôleur reçoit l'entrée, il valide l'entrée, puis exécute l'opération commerciale qui modifie l'état du modèle de données.

Struts2est un framework basé sur MVC. Dans les chapitres suivants, voyons comment nous pouvons utiliser la méthodologie MVC dans Struts2.

Struts2est un framework d'application Web populaire et mature basé sur le modèle de conception MVC. Struts2 n'est pas seulement une nouvelle version de Struts 1, mais c'est une réécriture complète de l'architecture Struts.

Le framework Webwork a initialement commencé avec le framework Struts comme base et son objectif était d'offrir un framework amélioré et amélioré basé sur Struts pour faciliter le développement Web pour les développeurs.

Après un certain temps, le framework Webwork et la communauté Struts se sont associés pour créer le célèbre framework Struts2.

Fonctionnalités du framework Struts 2

Voici quelques-unes des fonctionnalités intéressantes qui peuvent vous obliger à envisager Struts2 -

POJO Forms and POJO Actions- Struts2 a supprimé les formulaires d'action qui faisaient partie intégrante du framework Struts. Avec Struts2, vous pouvez utiliser n'importe quel POJO pour recevoir l'entrée du formulaire. De même, vous pouvez désormais voir n'importe quel POJO en tant que classe Action.
Tag Support - Struts2 a amélioré les balises de formulaire et les nouvelles balises qui permettent aux développeurs d'écrire moins de code.
AJAX Support - Struts2 a reconnu la reprise des technologies Web2.0, et a intégré le support AJAX dans le produit en créant des balises AJAX, cette fonction est très similaire aux balises Struts2 standard.
Easy Integration - L'intégration avec d'autres frameworks comme Spring, Tiles et SiteMesh est maintenant plus facile avec une variété d'intégration disponible avec Struts2.
Template Support - Prise en charge de la génération de vues à l'aide de modèles.
Plugin Support- Le comportement principal de Struts2 peut être amélioré et augmenté par l'utilisation de plugins. Un certain nombre de plugins sont disponibles pour Struts2.
Profiling- Struts2 offre un profilage intégré pour déboguer et profiler l'application. En plus de cela, Struts propose également un débogage intégré à l'aide d'outils de débogage intégrés.
Easy to Modify Tags- Les marquages de balises dans Struts2 peuvent être modifiés à l'aide des modèles Freemarker. Cela ne nécessite pas de connaissances JSP ou Java. Des connaissances de base en HTML, XML et CSS sont suffisantes pour modifier les balises.
Promote Less configuration- Struts2 favorise moins de configuration à l'aide de l'utilisation des valeurs par défaut pour divers paramètres. Vous n'avez pas à configurer quelque chose à moins qu'il ne s'écarte des paramètres par défaut définis par Struts2.
View Technologies - Struts2 prend en charge plusieurs options d'affichage (JSP, Freemarker, Velocity et XSLT)

Voici les 10 principales fonctionnalités de Struts 2 ce qui en fait un cadre prêt pour l'entreprise.

Inconvénients de Struts 2

Bien que Struts 2 soit livré avec une liste de fonctionnalités intéressantes, il existe certaines limitations de la version actuelle - Struts 2 qui nécessite une amélioration supplémentaire. Voici quelques-uns des principaux points -

Bigger Learning Curve - Pour utiliser MVC avec Struts, vous devez être à l'aise avec le JSP standard, les API Servlet et un framework large et élaboré.
Poor Documentation - Par rapport au servlet standard et aux API JSP, Struts a moins de ressources en ligne, et de nombreux utilisateurs novices trouvent la documentation Apache en ligne confuse et mal organisée.
Less Transparent - Avec les applications Struts, il se passe beaucoup plus dans les coulisses qu'avec les applications Web Java normales, ce qui rend difficile la compréhension du cadre.

Remarque finale, un bon cadre devrait fournir un comportement générique que de nombreux types d'applications différents peuvent utiliser.

Struts 2 est l'un des meilleurs frameworks Web et est très utilisé pour le développement d'applications Internet riches (RIA).

Notre première tâche est de faire fonctionner une application Struts 2 minimale. Ce chapitre vous explique comment préparer un environnement de développement pour commencer votre travail avec Struts 2.

Je suppose que vous avez déjà JDK (5+), Tomcat et Eclipse installés sur votre machine. Si vous n'avez pas installé ces composants, suivez les étapes indiquées en accéléré -

Étape 1 - Configuration du kit de développement Java (JDK)

Vous pouvez télécharger la dernière version du SDK à partir du site Java d'Oracle - Téléchargements Java SE . Vous trouverez des instructions pour installer JDK dans les fichiers téléchargés, suivez les instructions données pour installer et configurer la configuration. Enfin, définissez les variables d'environnement PATH et JAVA_HOME pour faire référence au répertoire qui contient java et javac, généralement rép_install_java / bin et rép_install_java respectivement.

Si vous exécutez Windows et avez installé le SDK dans C: \ jdk1.5.0_20, vous devez entrer la ligne suivante dans votre fichier C: \ autoexec.bat.

set PATH = C:\jdk1.5.0_20\bin;%PATH%
set JAVA_HOME = C:\jdk1.5.0_20

Alternativement, sous Windows NT / 2000 / XP -

Vous pouvez cliquer avec le bouton droit sur Poste de travail, sélectionner Propriétés, puis Avancé, puis Variables d'environnement. Ensuite, vous mettriez à jour la valeur PATH et appuyez sur le bouton OK.
Sous Unix (Solaris, Linux, etc.), si le SDK est installé dans /usr/local/jdk1.5.0_20 et que vous utilisez le shell C, vous mettriez ce qui suit dans votre fichier .cshrc.

Sous Unix (Solaris, Linux, etc.), si le SDK est installé dans /usr/local/jdk1.5.0_20 et que vous utilisez le shell C, vous mettriez ce qui suit dans votre fichier .cshrc.

setenv PATH /usr/local/jdk1.5.0_20/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.5.0_20

Alternativement, si vous utilisez un environnement de développement intégré (IDE) tel que Borland JBuilder, Eclipse, IntelliJ IDEA ou Sun ONE Studio, compilez et exécutez un programme simple pour confirmer que l'EDI sait où vous avez installé Java, sinon effectuez la configuration appropriée selon le document donné de l'IDE.

Étape 2 - Configurer Apache Tomcat

Vous pouvez télécharger la dernière version de Tomcat sur https://tomcat.apache.org/. Une fois que vous avez téléchargé l'installation, décompressez la distribution binaire dans un emplacement pratique.

Par exemple dans C: \ apache-tomcat-6.0.33 sous Windows, ou /usr/local/apachetomcat-6.0.33 sous Linux / Unix et créez la variable d'environnement CATALINA_HOME pointant vers ces emplacements.

Vous pouvez démarrer Tomcat en exécutant les commandes suivantes sur la machine Windows, ou vous pouvez simplement double-cliquer sur startup.bat

%CATALINA_HOME%\bin\startup.bat
 
or
 
C:\apache-tomcat-6.0.33\bin\startup.bat

Tomcat peut être démarré en exécutant les commandes suivantes sur une machine Unix (Solaris, Linux, etc.) -

$CATALINA_HOME/bin/startup.sh
 
or
 
/usr/local/apache-tomcat-6.0.33/bin/startup.sh

Après un démarrage réussi, les applications Web par défaut incluses avec Tomcat seront disponibles en visitant http://localhost:8080/. Si tout va bien, il devrait afficher le résultat suivant -

Vous trouverez de plus amples informations sur la configuration et l'exécution de Tomcat dans la documentation incluse ici, ainsi que sur le site Web de Tomcat: https://tomcat.apache.org/

Tomcat peut être arrêté en exécutant les commandes suivantes sur la machine Windows -

%CATALINA_HOME%\bin\shutdown

or

C:\apache-tomcat-5.5.29\bin\shutdown

Tomcat peut être arrêté en exécutant les commandes suivantes sur une machine Unix (Solaris, Linux, etc.) -

$CATALINA_HOME/bin/shutdown.sh

or

/usr/local/apache-tomcat-5.5.29/bin/shutdown.sh

Étape 3 - Configurer Eclipse (IDE)

Tous les exemples de ce didacticiel sont écrits à l'aide de l'IDE Eclipse. Je suggère que vous ayez la dernière version d'Eclipse installée sur votre machine.

Pour installer Eclipse Téléchargez les derniers binaires Eclipse depuis https://www.eclipse.org/downloads/. Une fois l'installation téléchargée, décompressez la distribution binaire dans un emplacement pratique.

Par exemple dans C: \ eclipse sous Windows, ou / usr / local / eclipse sous Linux / Unix et définissez enfin la variable PATH de manière appropriée. Eclipse peut être démarré en exécutant les commandes suivantes sur la machine Windows, ou vous pouvez simplement double-cliquer sur eclipse.exe

%C:\eclipse\eclipse.exe

Eclipse peut être démarré en exécutant les commandes suivantes sur une machine Unix (Solaris, Linux, etc.) -

$/usr/local/eclipse/eclipse

Après un démarrage réussi, si tout va bien, il devrait afficher le résultat suivant -

Étape 4 - Configuration des bibliothèques Struts2

Maintenant, si tout va bien, vous pouvez procéder à la configuration de votre cadre Struts2. Voici les étapes simples pour télécharger et installer Struts2 sur votre machine.

Choisissez si vous souhaitez installer Struts2 sous Windows ou Unix, puis passez à l'étape suivante pour télécharger le fichier .zip pour Windows et le fichier .tz pour Unix.
Téléchargez la dernière version des binaires Struts2 sur https://struts.apache.org/download.cgi.
Au moment de la rédaction de ce tutoriel, j'ai téléchargé struts-2.0.14-all.zip et lorsque vous décompressez le fichier téléchargé, il vous donnera la structure de répertoires dans C: \ struts-2.2.3 comme suit.

La deuxième étape consiste à extraire le fichier zip dans n'importe quel endroit, j'ai téléchargé et extrait struts-2.2.3-all.zip dans c:\ dossier sur ma machine Windows 7 afin d'avoir tous les fichiers jar dans C:\struts-2.2.3\lib. Assurez-vous de définir correctement votre variable CLASSPATH, sinon vous rencontrerez un problème lors de l'exécution de votre application.

De haut niveau, Struts2 est un framework pull-MVC (ou MVC2). Le modèle Model-ViewController dans Struts2 est implémenté avec les cinq composants principaux suivants:

Actions
Interceptors
Value Stack / OGNL
Résultats / types de résultats
Voir les technologies

Struts 2 est légèrement différent d'un framework MVC traditionnel, où l'action prend le rôle de modèle plutôt que de contrôleur, bien qu'il y ait un certain chevauchement.

Le diagramme ci-dessus illustre le Model, View et Controller à l'architecture de haut niveau Struts2. Le contrôleur est implémenté avec unStruts2répartir le filtre de servlet ainsi que les intercepteurs, ce modèle est implémenté avec des actions, et la vue est une combinaison de types de résultats et de résultats. La pile de valeurs et OGNL fournissent un fil conducteur, reliant et permettant l'intégration entre les autres composants.

Outre les composants ci-dessus, il y aura de nombreuses informations relatives à la configuration. Configuration de l'application Web, ainsi que configuration des actions, intercepteurs, résultats, etc.

Voici la présentation architecturale du modèle Struts 2 MVC. Nous passerons en revue chaque composant plus en détail dans les chapitres suivants.

Demander le cycle de vie

Sur la base du diagramme ci-dessus, vous pouvez comprendre le flux de travail tout au long du cycle de vie de la demande de l'utilisateur dans Struts 2 comme suit -

L'utilisateur envoie une demande au serveur pour demander une ressource (c'est-à-dire des pages).
Le répartiteur de filtres examine la demande, puis détermine l'action appropriée.
Les fonctionnalités d'intercepteur configurées s'appliquent telles que la validation, le téléchargement de fichiers, etc.
L'action sélectionnée est exécutée en fonction de l'opération demandée.
Là encore, des intercepteurs configurés sont appliqués pour effectuer tout post-traitement si nécessaire.
Enfin, le résultat est préparé par la vue et renvoie le résultat à l'utilisateur.

Comme vous l'avez déjà appris de l'architecture Struts 2, lorsque vous cliquez sur un lien hypertexte ou que vous soumettez un formulaire HTML dans une application Web Struts 2, l'entrée est collectée par le contrôleur qui est envoyée à une classe Java appelée Actions. Une fois l'action exécutée, un résultat sélectionne une ressource pour rendre la réponse. La ressource est généralement un JSP, mais il peut également s'agir d'un fichier PDF, d'une feuille de calcul Excel ou d'une fenêtre d'applet Java.

En supposant que vous ayez déjà construit votre environnement de développement. Maintenant, procédons à la construction de notre premierHello World Struts2projet. Le but de ce projet est de créer une application Web qui collecte le nom de l'utilisateur et affiche «Hello World» suivi du nom d'utilisateur.

Nous devrons créer les quatre composants suivants pour tout projet Struts 2 -

Sr.Non	Composants et description
1	Action Créez une classe d'action qui contiendra une logique métier complète et contrôlera l'interaction entre l'utilisateur, le modèle et la vue.
2	Interceptors Créez des intercepteurs si nécessaire ou utilisez des intercepteurs existants. Cela fait partie de Controller.
3	View Créez des JSP pour interagir avec l'utilisateur pour prendre des entrées et présenter les messages finaux.
4	Configuration Files Créez des fichiers de configuration pour coupler l'action, la vue et les contrôleurs. Ces fichiers sont struts.xml, web.xml, struts.properties.

Je vais utiliser Eclipse IDE, de sorte que tous les composants requis soient créés sous un projet Web dynamique. Commençons maintenant par créer un projet Web dynamique.

Créer un projet Web dynamique

Démarrez votre Eclipse puis continuez avec File > New > Dynamic Web Project et entrez le nom du projet comme HelloWorldStruts2 et définissez le reste des options comme indiqué dans l'écran suivant -

Sélectionnez toutes les options par défaut dans les écrans suivants et vérifiez enfin Generate Web.xml deployment descriptoroption. Cela créera pour vous un projet Web dynamique dans Eclipse. Maintenant allez avecWindows > Show View > Project Explorer, et vous verrez la fenêtre de votre projet quelque chose comme ci-dessous -

Maintenant, copiez les fichiers suivants à partir du dossier lib struts 2 C:\struts-2.2.3\lib à notre projet WEB-INF\libdossier. Pour ce faire, vous pouvez simplement faire glisser et déposer tous les fichiers suivants dans le dossier WEB-INF \ lib.

commons-fileupload-x.y.z.jar
commons-io-x.y.z.jar
commons-lang-x.y.jar
commons-logging-x.y.z.jar
commons-logging-api-x.y.jar
freemarker-x.y.z.jar
javassist-.xy.z.GA
ognl-x.y.z.jar
struts2-core-x.y.z.jar
xwork-core.x.y.z.jar

Créer une classe d'action

La classe d'action est la clé de l'application Struts 2 et nous implémentons la plupart de la logique métier dans la classe d'action. Alors créons un fichier java HelloWorldAction.java sousJava Resources > src avec un nom de package com.tutorialspoint.struts2 avec le contenu donné ci-dessous.

La classe Action répond à une action de l'utilisateur lorsque l'utilisateur clique sur une URL. Une ou plusieurs méthodes de la classe Action sont exécutées et un résultat String est renvoyé. En fonction de la valeur du résultat, une page JSP spécifique est rendue.

package com.tutorialspoint.struts2;

public class HelloWorldAction {
   private String name;

   public String execute() throws Exception {
      return "success";
   }
   
   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }
}

C'est une classe très simple avec une propriété appelée "nom". Nous avons des getters et des méthodes de définition standard pour la propriété "name" et une méthode d'exécution qui renvoie la chaîne "success".

Le framework Struts 2 créera un objet du HelloWorldActionclass et appelez la méthode exécutée en réponse à l'action d'un utilisateur. Vous placez votre logique métier dans cette méthode qui renvoie finalement la constante String. En d'autres termes, pour chaque URL, vous devrez implémenter une classe d'action et soit vous pouvez utiliser ce nom de classe directement comme nom d'action, soit vous pouvez mapper vers un autre nom en utilisant le fichier struts.xml comme indiqué ci-dessous.

Créer une vue

Nous avons besoin d'un JSP pour présenter le message final, cette page sera appelée par le framework Struts 2 lorsqu'une action prédéfinie se produira et ce mappage sera défini dans le fichier struts.xml. Alors créons le fichier jsp ci-dessousHelloWorld.jspdans le dossier WebContent de votre projet eclipse. Pour ce faire, faites un clic droit sur le dossier WebContent dans l'explorateur de projet et sélectionnezNew >JSP File.

<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>

<html>
   <head>
      <title>Hello World</title>
   </head>
   
   <body>
      Hello World, <s:property value = "name"/>
   </body>
</html>

La directive taglib indique au conteneur Servlet que cette page utilisera le Struts 2 balises et que ces balises seront précédées de s.

La balise s: property affiche la valeur de la propriété de classe d'action "nom> qui est renvoyée par la méthode getName() de la classe HelloWorldAction.

Créer une page principale

Nous devons également créer index.jspdans le dossier WebContent. Ce fichier servira d'URL d'action initiale où un utilisateur peut cliquer pour indiquer au framework Struts 2 d'appeler une méthode définie de la classe HelloWorldAction et de restituer la vue HelloWorld.jsp.

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
   <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
"http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>Hello World</title>
   </head>
   
   <body>
      <h1>Hello World From Struts2</h1>
      <form action = "hello">
         <label for = "name">Please enter your name</label><br/>
         <input type = "text" name = "name"/>
         <input type = "submit" value = "Say Hello"/>
      </form>
   </body>
</html>

le hellol'action définie dans le fichier de vue ci-dessus sera mappée à la classe HelloWorldAction et à sa méthode d'exécution à l'aide du fichier struts.xml. Lorsqu'un utilisateur clique sur le bouton Soumettre, le framework Struts 2 exécute la méthode d'exécution définie dans la classe HelloWorldAction et en fonction de la valeur renvoyée de la méthode, une vue appropriée est sélectionnée et rendue en tant que réponse.

Fichiers de configuration

Nous avons besoin d'un mappage pour lier l'URL, la classe HelloWorldAction (Model) et HelloWorld.jsp (la vue) ensemble. Le mappage indique au framework Struts 2 quelle classe répondra à l'action de l'utilisateur (l'URL), quelle méthode de cette classe sera exécutée et quelle vue afficher en fonction du résultat String retourné par cette méthode.

Alors créons un fichier appelé struts.xml. Puisque Struts 2 nécessite que struts.xml soit présent dans le dossier classes. Par conséquent, créez le fichier struts.xml dans le dossier WebContent / WEB-INF / classes. Eclipse ne crée pas le dossier «classes» par défaut, vous devez donc le faire vous-même. Pour ce faire, faites un clic droit sur le dossier WEB-INF dans l'explorateur de projet et sélectionnezNew > Folder. Votre struts.xml devrait ressembler à -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <constant name = "struts.devMode" value = "true" />
   
   <package name = "helloworld" extends = "struts-default">
     <action name = "hello" 
         class = "com.tutorialspoint.struts2.HelloWorldAction" 
         method = "execute">
         <result name = "success">/HelloWorld.jsp</result>
      </action>
   </package>
</struts>

Quelques mots à comprendre concernant le fichier de configuration ci-dessus. Ici, nous définissons la constantestruts.devMode à true, car nous travaillons dans un environnement de développement et nous avons besoin de voir quelques messages de journal utiles. Ensuite, nous définissons un package appeléhelloworld.

La création d'un package est utile lorsque vous souhaitez regrouper vos actions. Dans notre exemple, nous avons nommé notre action "bonjour", ce qui correspond à l'URL/hello.action et est soutenu par leHelloWorldAction.class. leexecute méthode de HelloWorldAction.class est la méthode qui est exécutée lorsque l'URL /hello.actionest invoquée. Si le résultat de la méthode d'exécution renvoie "succès", alors nous amenons l'utilisateur àHelloWorld.jsp.

La prochaine étape consiste à créer un web.xmlfichier qui est un point d'entrée pour toute demande à Struts 2. Le point d'entrée de l'application Struts2 sera un filtre défini dans le descripteur de déploiement (web.xml). Par conséquent, nous définirons une entrée de la classe org.apache.struts2.dispatcher.FilterDispatcher dans web.xml. Le fichier web.xml doit être créé dans le dossier WEB-INF sous WebContent. Eclipse avait déjà créé un fichier squelette web.xml pour vous lorsque vous avez créé le projet. Alors, modifions-le comme suit -

<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns = "http://java.sun.com/xml/ns/javaee" 
   xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee 
   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   id = "WebApp_ID" version = "3.0">
   
   <display-name>Struts 2</display-name>
   
   <welcome-file-list>
      <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>
   
   <filter>
      <filter-name>struts2</filter-name>
      <filter-class>
         org.apache.struts2.dispatcher.FilterDispatcher
      </filter-class>
   </filter>

   <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
   </filter-mapping>
</web-app>

Nous avons spécifié index.jsp comme fichier de bienvenue. Ensuite, nous avons configuré le filtre Struts2 pour qu'il s'exécute sur toutes les URL (c'est-à-dire, toute URL qui correspond au modèle / *)

Pour activer le journal détaillé

Vous pouvez activer la fonctionnalité de journalisation complète tout en travaillant avec Struts 2 en créant logging.properties fichier sous WEB-INF/classesdossier. Conservez les deux lignes suivantes dans votre dossier de propriété -

org.apache.catalina.core.ContainerBase.[Catalina].level = INFO
org.apache.catalina.core.ContainerBase.[Catalina].handlers = \
   java.util.logging.ConsoleHandler

Le logging.properties par défaut spécifie un ConsoleHandler pour le routage de la journalisation vers stdout et également un FileHandler. Le seuil de niveau de journal d'un gestionnaire peut être défini à l'aide de SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST ou ALL.

C'est ça. Nous sommes prêts à exécuter notre application Hello World en utilisant le framework Struts 2.

Procédure d'exécution de l'application

Faites un clic droit sur le nom du projet et cliquez sur Export > WAR File pour créer un fichier War.

Déployez ensuite ce WAR dans le répertoire webapps de Tomcat.

Enfin, démarrez le serveur Tomcat et essayez d'accéder à l'URL http://localhost:8080/HelloWorldStruts2/index.jsp. Cela vous donnera l'écran suivant -

Entrez une valeur "Struts2" et soumettez la page. Vous devriez voir la page suivante

Notez que vous pouvez définir index comme une action dans le fichier struts.xml et dans ce cas, vous pouvez appeler la page d'index comme http://localhost:8080/HelloWorldStruts2/index.action. Vérifiez ci-dessous comment vous pouvez définir l'index comme une action -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "helloworld" extends = "struts-default">

      <action name = "index">
         <result >/index.jsp</result>
      </action>

      <action name = "hello" 
         class = "com.tutorialspoint.struts2.HelloWorldAction" 
         method = "execute">
         <result name = "success">/HelloWorld.jsp</result>
      </action>

   </package>
</struts>

Ce chapitre vous présente la configuration de base requise pour un Struts 2application. Ici, nous verrons ce qui peut être configuré à l'aide de quelques fichiers de configuration importants commeweb.xml, struts.xml, strutsconfig.xml et struts.properties

Honnêtement, vous pouvez commencer à travailler en utilisant simplement web.xml et struts.xmlfichiers de configuration (comme vous l'avez déjà vu dans notre chapitre précédent où notre exemple fonctionnait en utilisant ces deux fichiers). Cependant, pour votre connaissance, nous vous expliquerons également concernant d'autres fichiers.

Le fichier web.xml

Le fichier de configuration web.xml est un fichier de configuration J2EE qui détermine comment les éléments de la requête HTTP sont traités par le conteneur de servlet. Ce n'est pas strictement un fichier de configuration Struts2, mais c'est un fichier qui doit être configuré pour que Struts2 fonctionne.

Comme indiqué précédemment, ce fichier fournit un point d'entrée pour toute application Web. Le point d'entrée de l'application Struts2 sera un filtre défini dans le descripteur de déploiement (web.xml). Nous allons donc définir une entrée de la classe FilterDispatcher dans web.xml. Le fichier web.xml doit être créé sous le dossierWebContent/WEB-INF.

C'est le premier fichier de configuration que vous devrez configurer si vous démarrez sans l'aide d'un modèle ou d'un outil qui le génère (comme Eclipse ou Maven2).

Voici le contenu du fichier web.xml que nous avons utilisé dans notre dernier exemple.

<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns = "http://java.sun.com/xml/ns/javaee" 
   xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee 
   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   id = "WebApp_ID" version = "3.0">
   
   <display-name>Struts 2</display-name>
   <welcome-file-list>
      <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>
   
   <filter>
      <filter-name>struts2</filter-name>
      <filter-class>
         org.apache.struts2.dispatcher.FilterDispatcher
      </filter-class>
   </filter>

   <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
   </filter-mapping>

</web-app>

Notez que nous mappons le filtre Struts 2 à /*, et ne pas /*.actionce qui signifie que toutes les URL seront analysées par le filtre Struts. Nous en parlerons lorsque nous passerons en revue le chapitre Annotations.

Le fichier Struts.xml

le struts.xmlLe fichier contient les informations de configuration que vous modifierez au fur et à mesure du développement des actions. Ce fichier peut être utilisé pour remplacer les paramètres par défaut d'une application, par exemple struts.devMode = false et d'autres paramètres définis dans le fichier de propriétés. Ce fichier peut être créé sous le dossierWEB-INF/classes.

Jetons un coup d'œil au fichier struts.xml que nous avons créé dans l'exemple Hello World expliqué dans le chapitre précédent.

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "helloworld" extends = "struts-default">
     
      <action name = "hello" 
         class = "com.tutorialspoint.struts2.HelloWorldAction" 
         method = "execute">
         <result name = "success">/HelloWorld.jsp</result>
      </action>
      
      <-- more actions can be listed here -->

   </package>
   <-- more packages can be listed here -->

</struts>

La première chose à noter est le DOCTYPE. Tous les fichiers de configuration Struts doivent avoir le bon doctype comme indiqué dans notre petit exemple. <struts> est l'élément de balise racine, sous lequel nous déclarons différents packages en utilisant les balises <package>. Ici <package> permet la séparation et la modularisation de la configuration. Ceci est très utile lorsque vous avez un grand projet et que le projet est divisé en différents modules.

Par exemple, si votre projet comporte trois domaines: application_entreprise, application_client et application_employé, vous pouvez créer trois packages et stocker les actions associées dans le package approprié.

La balise package a les attributs suivants -

Sr.Non	Attribut et description
1	name (required) L'identifiant unique du package
2	extends De quel package s'étend ce package? Par défaut, nous utilisons struts-default comme package de base.
3	abstract S'il est marqué true, le package n'est pas disponible pour la consommation de l'utilisateur final.
4	namespace Espace de noms unique pour les actions

le constant La balise ainsi que les attributs de nom et de valeur doivent être utilisés pour remplacer l'une des propriétés suivantes définies dans default.properties, comme nous venons de définir struts.devModepropriété. Réglagestruts.devMode La propriété nous permet de voir plus de messages de débogage dans le fichier journal.

Nous définissons action Les balises correspondent à chaque URL à laquelle nous voulons accéder et nous définissons une classe avec la méthode execute () qui sera accessible chaque fois que nous accéderons à l'URL correspondante.

Les résultats déterminent ce qui est renvoyé au navigateur après l'exécution d'une action. La chaîne renvoyée par l'action doit être le nom d'un résultat. Les résultats sont configurés par action comme ci-dessus, ou en tant que résultat «global», disponible pour chaque action d'un package. Les résultats sont facultatifsname et typeles attributs. La valeur par défaut du nom est "succès".

Le fichier Struts.xml peut grossir avec le temps et le casser par paquets est donc un moyen de le modulariser, mais Strutsoffre un autre moyen de modulariser le fichier struts.xml. Vous pouvez diviser le fichier en plusieurs fichiers xml et les importer de la manière suivante.

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <include file="my-struts1.xml"/>
   <include file="my-struts2.xml"/>
</struts>

L'autre fichier de configuration que nous n'avons pas couvert est le struts-default.xml. Ce fichier contient les paramètres de configuration standard pour Struts et vous n'auriez pas à toucher ces paramètres pour 99,99% de vos projets. Pour cette raison, nous n'entrerons pas trop dans les détails sur ce dossier. Si vous êtes intéressé, jetez un œil à ladefault.properties fichier disponible dans le fichier struts2-core-2.2.3.jar.

Le fichier Struts-config.xml

Le fichier de configuration struts-config.xml est un lien entre les composants Vue et Modèle dans le client Web, mais vous n'auriez pas à toucher ces paramètres pour 99,99% de vos projets.

Le fichier de configuration contient essentiellement les éléments principaux suivants -

Sr.Non	Intercepteur et description
1	struts-config Il s'agit du nœud racine du fichier de configuration.
2	form-beans C'est là que vous mappez votre sous-classe ActionForm à un nom. Vous utilisez ce nom comme alias pour votre ActionForm dans le reste du fichier strutsconfig.xml, et même sur vos pages JSP.
3	global forwards Cette section associe une page de votre application Web à un nom. Vous pouvez utiliser ce nom pour faire référence à la page réelle. Cela évite le codage en dur des URL sur vos pages Web.
4	action-mappings C'est là que vous déclarez les gestionnaires de formulaires et ils sont également appelés mappages d'actions.
5	controller Cette section configure les composants internes de Struts et est rarement utilisée dans des situations pratiques.
6	plug-in Cette section indique à Struts où trouver vos fichiers de propriétés, qui contiennent des invites et des messages d'erreur

Voici l'exemple de fichier struts-config.xml -

<?xml version = "1.0" Encoding = "ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 1.0//EN"
   "http://jakarta.apache.org/struts/dtds/struts-config_1_0.dtd">

<struts-config>

   <!-- ========== Form Bean Definitions ============ -->
   <form-beans>
      <form-bean name = "login" type = "test.struts.LoginForm" />
   </form-beans>

   <!-- ========== Global Forward Definitions ========= -->
   <global-forwards>
   </global-forwards>

   <!-- ========== Action Mapping Definitions ======== -->
   <action-mappings>
      <action
         path = "/login"
         type = "test.struts.LoginAction" >

         <forward name = "valid" path = "/jsp/MainMenu.jsp" />
         <forward name = "invalid" path = "/jsp/LoginView.jsp" />
      </action>
   </action-mappings>

   <!-- ========== Controller Definitions ======== -->
   <controller contentType = "text/html;charset = UTF-8"
      debug = "3" maxFileSize = "1.618M" locale = "true" nocache = "true"/>

</struts-config>

Pour plus de détails sur le fichier struts-config.xml, veuillez consulter votre documentation struts.

Le fichier Struts.properties

Ce fichier de configuration fournit un mécanisme pour modifier le comportement par défaut du framework. En fait, toutes les propriétés contenues dans lestruts.properties le fichier de configuration peut également être configuré dans web.xml en utilisant le init-param, ainsi qu'en utilisant la balise constante dans le struts.xmlfichier de configuration. Mais, si vous souhaitez garder les choses séparées et plus spécifiques, vous pouvez créer ce fichier sous le dossierWEB-INF/classes.

Les valeurs configurées dans ce fichier remplaceront les valeurs par défaut configurées dans default.propertiesqui est contenu dans la distribution struts2-core-xyzjar. Vous pouvez envisager de modifier quelques propriétés à l’aide destruts.properties fichier -

### When set to true, Struts will act much more friendly for developers
struts.devMode = true

### Enables reloading of internationalization files
struts.i18n.reload = true

### Enables reloading of XML configuration files
struts.configuration.xml.reload = true

### Sets the port that the server is run on
struts.url.http.port = 8080

Ici toute ligne commençant par hash (#) sera considéré comme un commentaire et ignoré par Struts 2.

Actionssont au cœur du framework Struts2, comme ils le sont pour tout framework MVC (Model View Controller). Chaque URL est mappée à une action spécifique, qui fournit la logique de traitement nécessaire pour traiter la demande de l'utilisateur.

Mais l'action sert également dans deux autres capacités importantes. Premièrement, l'action joue un rôle important dans le transfert des données de la requête à la vue, qu'il s'agisse d'une JSP ou d'un autre type de résultat. Deuxièmement, l'action doit aider le cadre à déterminer quel résultat doit rendre la vue qui sera renvoyée dans la réponse à la demande.

Créer une action

La seule exigence pour les actions dans Struts2est qu'il doit y avoir une méthode noargument qui renvoie un objet String ou Result et doit être un POJO. Si la méthode sans argument n'est pas spécifiée, le comportement par défaut est d'utiliser la méthode execute ().

En option, vous pouvez étendre le ActionSupport classe qui implémente six interfaces dont Actioninterface. L'interface Action est la suivante -

public interface Action {
   public static final String SUCCESS = "success";
   public static final String NONE = "none";
   public static final String ERROR = "error";
   public static final String INPUT = "input";
   public static final String LOGIN = "login";
   public String execute() throws Exception;
}

Jetons un coup d'œil à la méthode d'action dans l'exemple Hello World -

package com.tutorialspoint.struts2;

public class HelloWorldAction {
   private String name;

   public String execute() throws Exception {
      return "success";
   }
   
   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }
}

Pour illustrer le fait que la méthode d'action contrôle la vue, apportons la modification suivante à la execute et étendez la classe ActionSupport comme suit -

package com.tutorialspoint.struts2;

import com.opensymphony.xwork2.ActionSupport;

public class HelloWorldAction extends ActionSupport {
   private String name;

   public String execute() throws Exception {
      if ("SECRET".equals(name)) {
         return SUCCESS;
      } else {
         return ERROR;  
      }
   }
   
   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }
}

Dans cet exemple, nous avons une certaine logique dans la méthode d'exécution pour examiner l'attribut name. Si l'attribut est égal à la chaîne"SECRET", nous retournons SUCCESS comme résultat sinon nous retournons ERRORcomme résultat. Parce que nous avons étendu ActionSupport, nous pouvons donc utiliser des constantes StringSUCCESSet ERREUR. Maintenant, modifions notre fichier struts.xml comme suit -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "helloworld" extends = "struts-default">
      <action name = "hello" 
         class = "com.tutorialspoint.struts2.HelloWorldAction"
         method = "execute">
         <result name = "success">/HelloWorld.jsp</result>
         <result name = "error">/AccessDenied.jsp</result>
      </action>
   </package>
</struts>

Créer une vue

Créons le fichier jsp ci-dessous HelloWorld.jspdans le dossier WebContent de votre projet eclipse. Pour ce faire, faites un clic droit sur le dossier WebContent dans l'explorateur de projet et sélectionnezNew >JSP File. Ce fichier sera appelé dans le cas où le résultat du retour est SUCCESS qui est une constante String "success" telle que définie dans l'interface Action -

<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>

<html>
   <head>
      <title>Hello World</title>
   </head>
   
   <body>
      Hello World, <s:property value = "name"/>
   </body>
</html>

Voici le fichier qui sera appelé par le framework dans le cas où le résultat de l'action est ERROR qui est égal à la constante String "error". Voici le contenu deAccessDenied.jsp

<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>

<html>  
   <head>
      <title>Access Denied</title>
   </head>
   
   <body>
      You are not authorized to view this page.
   </body>
</html>

Nous devons également créer index.jspdans le dossier WebContent. Ce fichier servira d'URL d'action initiale sur laquelle l'utilisateur peut cliquer pour indiquer au framework Struts 2 d'appeler leexecuteméthode de la classe HelloWorldAction et restituer la vue HelloWorld.jsp.

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
   <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>  
   <head>
      <title>Hello World</title>
   </head>
   
   <body>
      <h1>Hello World From Struts2</h1>
      <form action = "hello">
         <label for = "name">Please enter your name</label><br/>
         <input type = "text" name = "name"/>
         <input type = "submit" value = "Say Hello"/>
      </form>
   </body>
</html>

Voilà, il n'y a pas de changement requis pour le fichier web.xml, alors utilisons le même web.xml que nous avons créé dans Exampleschapitre. Maintenant, nous sommes prêts à exécuter notreHello World application utilisant le framework Struts 2.

Exécutez l'application

Faites un clic droit sur le nom du projet et cliquez sur Export > WARFichier pour créer un fichier War. Déployez ensuite ce WAR dans le répertoire webapps de Tomcat. Enfin, démarrez le serveur Tomcat et essayez d'accéder à l'URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Cela vous donnera l'écran suivant -

Laissez-nous entrer un mot comme "SECRET" et vous devriez voir la page suivante -

Entrez maintenant un mot autre que "SECRET" et vous devriez voir la page suivante -

Créer plusieurs actions

Vous définirez fréquemment plus d'une action pour gérer différentes demandes et pour fournir différentes URL aux utilisateurs, en conséquence vous définirez différentes classes comme défini ci-dessous -

package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;

class MyAction extends ActionSupport {
   public static String GOOD = SUCCESS;
   public static String BAD = ERROR;
}

public class HelloWorld extends ActionSupport {
   ...
   public String execute() {
      if ("SECRET".equals(name)) return MyAction.GOOD;
      return MyAction.BAD;
   }
   ...
}

public class SomeOtherClass extends ActionSupport {
   ...
   public String execute() {
      return MyAction.GOOD;
   }
   ...
}

Vous allez configurer ces actions dans le fichier struts.xml comme suit -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <constant name = "struts.devMode" value = "true" />
   
   <package name = "helloworld" extends = "struts-default">
      <action name = "hello" 
         class = "com.tutorialspoint.struts2.HelloWorld" 
         method = "execute">
         <result name = "success">/HelloWorld.jsp</result>
         <result name = "error">/AccessDenied.jsp</result>
      </action>
      
      <action name = "something" 
         class = "com.tutorialspoint.struts2.SomeOtherClass" 
         method = "execute">
         <result name = "success">/Something.jsp</result>
         <result name = "error">/AccessDenied.jsp</result>
      </action>
   </package>
</struts>

Comme vous pouvez le voir dans l'exemple hypothétique ci-dessus, l'action résulte SUCCESS et ERROR’s sont dupliqués.

Pour contourner ce problème, il est suggéré de créer une classe contenant les résultats des résultats.

Les intercepteurs sont conceptuellement identiques aux filtres de servlet ou à la classe JDK Proxy. Les intercepteurs permettent de mettre en œuvre des fonctionnalités transversales séparément de l'action ainsi que du cadre. Vous pouvez réaliser ce qui suit en utilisant des intercepteurs -

Fournir une logique de prétraitement avant que l'action ne soit appelée.
Fournir une logique de post-traitement après l'appel de l'action.
Attraper des exceptions pour qu'un autre traitement puisse être effectué.

De nombreuses fonctionnalités fournies dans le Struts2 le cadre est implémenté à l'aide d'intercepteurs;

Examples incluent la gestion des exceptions, le téléchargement de fichiers, les rappels de cycle de vie, etc. En fait, comme Struts2 met l'accent sur une grande partie de ses fonctionnalités sur les intercepteurs, il est peu probable que 7 ou 8 intercepteurs soient affectés par action.

Intercepteurs de structure Struts2

Le framework Struts 2 fournit une bonne liste d'intercepteurs prêts à l'emploi qui sont préconfigurés et prêts à l'emploi. Peu des intercepteurs importants sont répertoriés ci-dessous -

Sr.Non	Intercepteur et description
1	alias Permet aux paramètres d'avoir des alias de nom différents selon les demandes.
2	checkbox Aide à gérer les cases à cocher en ajoutant une valeur de paramètre false pour les cases à cocher qui ne sont pas cochées.
3	conversionError Place les informations d'erreur de la conversion des chaînes en types de paramètres dans les erreurs de champ de l'action.
4	createSession Crée automatiquement une session HTTP s'il n'en existe pas déjà une.
5	debugging Fournit plusieurs écrans de débogage différents au développeur.
6	execAndWait Envoie l'utilisateur vers une page d'attente intermédiaire pendant que l'action s'exécute en arrière-plan.
sept	exception Mappe les exceptions qui sont levées d'une action à un résultat, permettant la gestion automatique des exceptions via la redirection.
8	fileUpload Facilite le téléchargement facile des fichiers.
9	i18n Garde une trace des paramètres régionaux sélectionnés pendant la session d'un utilisateur.
dix	logger Fournit une journalisation simple en affichant le nom de l'action en cours d'exécution.
11	params Définit les paramètres de demande sur l'action.
12	prepare Ceci est généralement utilisé pour effectuer des travaux de prétraitement, comme la configuration des connexions à la base de données.
13	profile Permet de consigner des informations de profilage simples pour les actions.
14	scope Stocke et récupère l'état de l'action dans la session ou l'étendue de l'application.
15	ServletConfig Fournit à l'action un accès à diverses informations basées sur les servlets.
16	timer Fournit des informations de profilage simples sous la forme de la durée d'exécution de l'action.
17	token Vérifie l'action pour un jeton valide pour éviter la soumission de formulaires en double.
18	validation Fournit un support de validation pour les actions

Veuillez consulter la documentation de Struts 2 pour plus de détails sur les intercepteurs mentionnés ci-dessus. Mais je vais vous montrer comment utiliser un intercepteur en général dans votre application Struts.

Comment utiliser les intercepteurs?

Voyons comment utiliser un intercepteur déjà existant dans notre programme "Hello World". Nous utiliserons letimerintercepteur dont le but est de mesurer combien de temps il a fallu pour exécuter une méthode d'action. En même temps, j'utiliseparamsintercepteur dont le but est d'envoyer les paramètres de requête à l'action. Vous pouvez essayer votre exemple sans utiliser cet intercepteur et vous constaterez quename La propriété n'est pas définie car le paramètre ne peut pas accéder à l'action.

Nous conserverons les fichiers HelloWorldAction.java, web.xml, HelloWorld.jsp et index.jsp tels qu'ils ont été créés dans Examples chapitre mais modifions le struts.xml fichier pour ajouter un intercepteur comme suit -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
   <constant name = "struts.devMode" value = "true" />
   
   <package name = "helloworld" extends = "struts-default">
      <action name = "hello" 
         class = "com.tutorialspoint.struts2.HelloWorldAction"
         method = "execute">
         <interceptor-ref name = "params"/>
         <interceptor-ref name = "timer" />
         <result name = "success">/HelloWorld.jsp</result>
      </action>
   </package>
</struts>

Faites un clic droit sur le nom du projet et cliquez sur Export > WAR Filepour créer un fichier War. Déployez ensuite ce WAR dans le répertoire webapps de Tomcat. Enfin, démarrez le serveur Tomcat et essayez d'accéder à l'URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Cela produira l'écran suivant -

Maintenant, entrez n'importe quel mot dans la zone de texte donnée et cliquez sur le bouton Say Hello pour exécuter l'action définie. Maintenant, si vous vérifiez le journal généré, vous trouverez le texte suivant -

INFO: Server startup in 3539 ms
27/08/2011 8:40:53 PM 
com.opensymphony.xwork2.util.logging.commons.CommonsLogger info
INFO: Executed action [//hello!execute] took 109 ms.

Ici, la ligne du bas est générée en raison de timer l'intercepteur qui dit que l'action a pris au total 109 ms pour être exécutée.

Créer des intercepteurs personnalisés

L'utilisation d'intercepteurs personnalisés dans votre application est un moyen élégant de fournir des fonctionnalités d'application transversales. La création d'un intercepteur personnalisé est facile; l'interface qui doit être étendue est la suivanteInterceptor interface -

public interface Interceptor extends Serializable {
   void destroy();
   void init();
   String intercept(ActionInvocation invocation)
   throws Exception;
}

Comme son nom l'indique, la méthode init () fournit un moyen d'initialiser l'intercepteur, et la méthode destroy () fournit une fonction de nettoyage de l'intercepteur. Contrairement aux actions, les intercepteurs sont réutilisés à travers les requêtes et doivent être threadsafe, en particulier la méthode intercept ().

le ActionInvocationobjet donne accès à l'environnement d'exécution. Il permet d'accéder à l'action elle-même et aux méthodes d'appeler l'action et de déterminer si l'action a déjà été appelée.

Si vous n'avez pas besoin de code d'initialisation ou de nettoyage, le AbstractInterceptorla classe peut être étendue. Ceci fournit une implémentation par défaut nooperation des méthodes init () et destroy ().

Créer une classe d'intercepteur

Créons le MyInterceptor.java suivant dans Java Resources > src dossier -

package com.tutorialspoint.struts2;

import java.util.*;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;

public class MyInterceptor extends AbstractInterceptor {

   public String intercept(ActionInvocation invocation)throws Exception {

      /* let us do some pre-processing */
      String output = "Pre-Processing"; 
      System.out.println(output);

      /* let us call action or next interceptor */
      String result = invocation.invoke();

      /* let us do some post-processing */
      output = "Post-Processing"; 
      System.out.println(output);

      return result;
   }
}

Comme vous le remarquez, l'action réelle sera exécutée à l'aide de l'intercepteur par invocation.invoke()appel. Ainsi, vous pouvez effectuer un pré-traitement et un post-traitement en fonction de vos besoins.

Le framework lui-même démarre le processus en effectuant le premier appel à invoke () de l'objet ActionInvocation. Chaque foisinvoke()est appelée, ActionInvocation consulte son état et exécute l'intercepteur suivant. Lorsque tous les intercepteurs configurés ont été invoqués, la méthode invoke () provoquera l'exécution de l'action elle-même.

Le diagramme suivant montre le même concept via un flux de demande -

Créer une classe d'action

Créons un fichier java HelloWorldAction.java sous Java Resources > src avec un nom de package com.tutorialspoint.struts2 avec le contenu donné ci-dessous.

package com.tutorialspoint.struts2;

import com.opensymphony.xwork2.ActionSupport;

public class HelloWorldAction extends ActionSupport {
   private String name;

   public String execute() throws Exception {
      System.out.println("Inside action....");
      return "success";
   }  

   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }
}

C'est une même classe que nous avons vue dans les exemples précédents. Nous avons des getters et des méthodes de définition standard pour la propriété "name" et une méthode d'exécution qui renvoie la chaîne "success".

Créer une vue

Créons le fichier jsp ci-dessous HelloWorld.jsp dans le dossier WebContent de votre projet eclipse.

<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>

<html>
   <head>
      <title>Hello World</title>
   </head>
   
   <body>
      Hello World, <s:property value = "name"/>
   </body>
</html>

Créer une page principale

Nous devons également créer index.jspdans le dossier WebContent. Ce fichier servira d'URL d'action initiale où un utilisateur peut cliquer pour indiquer au framework Struts 2 d'appeler la méthode définie de la classe HelloWorldAction et de restituer la vue HelloWorld.jsp.

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
   <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>Hello World</title>
   </head>
   
   <body>
      <h1>Hello World From Struts2</h1>
      <form action = "hello">
         <label for = "name">Please enter your name</label><br/>
         <input type = "text" name = "name"/>
         <input type = "submit" value = "Say Hello"/>
      </form>
   </body>
</html>

le hello l'action définie dans le fichier de vue ci-dessus sera mappée à la classe HelloWorldAction et à sa méthode d'exécution à l'aide du fichier struts.xml.

Fichiers de configuration

Maintenant, nous devons enregistrer notre intercepteur, puis l'appeler comme nous l'avions appelé l'intercepteur par défaut dans l'exemple précédent. Pour enregistrer un intercepteur nouvellement défini, les balises <interceptors> ... </interceptors> sont placées directement sous la balise <package> insstruts.xmlfichier. Vous pouvez ignorer cette étape pour les intercepteurs par défaut comme nous l'avons fait dans notre exemple précédent. Mais ici, enregistrons-le et utilisons-le comme suit -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "helloworld" extends = "struts-default">

      <interceptors>
         <interceptor name = "myinterceptor"
            class = "com.tutorialspoint.struts2.MyInterceptor" />
      </interceptors>

      <action name = "hello" 
         class = "com.tutorialspoint.struts2.HelloWorldAction" 
         method = "execute">
         <interceptor-ref name = "params"/>
         <interceptor-ref name = "myinterceptor" />
         <result name = "success">/HelloWorld.jsp</result>
      </action>

   </package>
</struts>

Il est à noter que vous pouvez enregistrer plus d'un intercepteur à l'intérieur <package> et en même temps, vous pouvez appeler plus d'un intercepteur à l'intérieur du <action>marque. Vous pouvez appeler le même intercepteur avec les différentes actions.

Le fichier web.xml doit être créé dans le dossier WEB-INF sous WebContent comme suit -

<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns = "http://java.sun.com/xml/ns/javaee" 
   xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee 
   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   id = "WebApp_ID" version = "3.0">
   
   <display-name>Struts 2</display-name>
   
   <welcome-file-list>
      <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>
   
   <filter>
      <filter-name>struts2</filter-name>
      <filter-class>
         org.apache.struts2.dispatcher.FilterDispatcher
      </filter-class>
   </filter>

   <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
   </filter-mapping>
</web-app>

Maintenant, entrez n'importe quel mot dans la zone de texte donnée et cliquez sur le bouton Say Hello pour exécuter l'action définie. Maintenant si vous allez vérifier le journal généré, vous trouverez le texte suivant en bas -

Pre-Processing
Inside action....
Post-Processing

Empiler plusieurs intercepteurs

Comme vous pouvez l'imaginer, devoir configurer plusieurs intercepteurs pour chaque action deviendrait rapidement extrêmement ingérable. Pour cette raison, les intercepteurs sont gérés avec des piles d'intercepteurs. Voici un exemple, directement à partir du fichier strutsdefault.xml -

<interceptor-stack name = "basicStack">
   <interceptor-ref name = "exception"/>
   <interceptor-ref name = "servlet-config"/>
   <interceptor-ref name = "prepare"/>
   <interceptor-ref name = "checkbox"/>
   <interceptor-ref name = "params"/>
   <interceptor-ref name = "conversionError"/>
</interceptor-stack>

L'enjeu ci-dessus est appelé basicStacket peut être utilisé dans votre configuration comme indiqué ci-dessous. Ce nœud de configuration est placé sous le nœud <package ... />. Chaque balise <interceptor-ref ... /> fait référence à un intercepteur ou à une pile d'intercepteurs qui a été configurée avant la pile d'intercepteurs actuelle. Il est donc très important de s'assurer que le nom est unique dans toutes les configurations d'intercepteurs et de piles d'intercepteurs lors de la configuration des intercepteurs initiaux et des piles d'intercepteurs.

Nous avons déjà vu comment appliquer l'intercepteur à l'action, appliquer des piles d'intercepteurs n'est pas différent. En fait, nous utilisons exactement la même balise -

<action name = "hello" class = "com.tutorialspoint.struts2.MyAction">
   <interceptor-ref name = "basicStack"/>
   <result>view.jsp</result>
</action

L'enregistrement ci-dessus de "basicStack" enregistrera la mise complète des six intercepteurs avec l'action bonjour. Il convient de noter que les intercepteurs sont exécutés dans l'ordre dans lequel ils ont été configurés. Par exemple, dans le cas ci-dessus, l'exception sera exécutée en premier, la seconde sera servlet-config et ainsi de suite.

Comme mentionné précédemment, le <results> tag joue le rôle d'un viewdans le framework Struts2 MVC. L'action est responsable de l'exécution de la logique métier. L'étape suivante après l'exécution de la logique métier consiste à afficher la vue à l'aide du<results> marque.

Souvent, certaines règles de navigation sont jointes aux résultats. Par exemple, si la méthode d'action consiste à authentifier un utilisateur, trois résultats sont possibles.

Connexion réussie
Connexion infructueuse - Nom d'utilisateur ou mot de passe incorrect
Compte bloqué

Dans ce scénario, la méthode d'action sera configurée avec trois chaînes de résultat possibles et trois vues différentes pour rendre le résultat. Nous l'avons déjà vu dans les exemples précédents.

Mais Struts2 ne vous oblige pas à utiliser JSP comme technologie d'affichage. Après tout, le but du paradigme MVC est de garder les couches séparées et hautement configurables. Par exemple, pour un client Web2.0, vous souhaiterez peut-être renvoyer XML ou JSON comme sortie. Dans ce cas, vous pouvez créer un nouveau type de résultat pour XML ou JSON et y parvenir.

Struts est livré avec un certain nombre de result types et tout ce que nous avons déjà vu était le type de résultat par défaut dispatcher, qui est utilisé pour envoyer aux pages JSP. Les Struts vous permettent d'utiliser d'autres langages de balisage pour la technologie d'affichage afin de présenter les résultats et les choix populaires incluentVelocity, Freemaker, XSLT et Tiles.

Le type de résultat Dispatcher

le dispatchertype de résultat est le type par défaut et est utilisé si aucun autre type de résultat n'est spécifié. Il est utilisé pour transférer vers un servlet, une JSP, une page HTML, etc. sur le serveur. Il utilise la méthode RequestDispatcher.forward () .

Nous avons vu la version "abrégée" dans nos exemples précédents, où nous avons fourni un chemin JSP comme corps de la balise de résultat.

<result name = "success">
   /HelloWorld.jsp
</result>

Nous pouvons également spécifier le fichier JSP en utilisant une balise <param name = "location"> dans l'élément <result ...> comme suit -

<result name = "success" type = "dispatcher">
   <param name = "location">
      /HelloWorld.jsp
   </param >
</result>

Nous pouvons également fournir un parseparamètre, qui est vrai par défaut. Le paramètre parse détermine si le paramètre d'emplacement sera analysé pour les expressions OGNL.

Le type de résultat FreeMaker

Dans cet exemple, nous allons voir comment nous pouvons utiliser FreeMakercomme la technologie de vue. Freemaker est un moteur de création de modèles populaire utilisé pour générer une sortie à l'aide de modèles prédéfinis. Créons maintenant un fichier de modèle Freemaker appeléhello.fm avec le contenu suivant -

Hello World ${name}

Le fichier ci-dessus est un modèle où nameest un paramètre qui sera passé de l'extérieur en utilisant l'action définie. Vous conserverez ce fichier dans votre CLASSPATH.

Ensuite, modifions le struts.xml pour spécifier le résultat comme suit -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "helloworld" extends = "struts-default">

      <action name = "hello" 
         class = "com.tutorialspoint.struts2.HelloWorldAction"
         method = "execute">
         <result name = "success" type = "freemarker">
            <param name = "location">/hello.fm</param>
         </result>
      </action>
      
   </package>

</struts>

Gardons nos fichiers HelloWorldAction.java, HelloWorldAction.jsp et index.jsp tels que nous les avons créés dans le chapitre des exemples.

Maintenant, faites un clic droit sur le nom du projet et cliquez sur Export > WAR File pour créer un fichier War.

Déployez ensuite ce WAR dans le répertoire webapps de Tomcat. Enfin, démarrez le serveur Tomcat et essayez d'accéder à l'URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Cela produira l'écran suivant.

Entrez une valeur "Struts2" et soumettez la page. Vous devriez voir la page suivante.

Comme vous pouvez le voir, c'est exactement la même chose que la vue JSP, sauf que nous ne sommes pas liés à l'utilisation de JSP comme technologie de vue. Nous avons utilisé Freemaker dans cet exemple.

Le type de résultat de la redirection

le redirectresult type appelle la méthode standard response.sendRedirect () , ce qui oblige le navigateur à créer une nouvelle requête à l'emplacement donné.

Nous pouvons fournir l'emplacement soit dans le corps de l'élément <result ...>, soit en tant qu'élément <param name = "location">. Redirect prend également en charge leparseparamètre. Voici un exemple configuré à l'aide de XML -

<action name = "hello" 
   class = "com.tutorialspoint.struts2.HelloWorldAction"
   method = "execute">
   <result name = "success" type = "redirect">
      <param name = "location">
         /NewWorld.jsp
      </param >
   </result>
</action>

Il suffit donc de modifier votre fichier struts.xml pour définir le type de redirection comme mentionné ci-dessus et de créer un nouveau fichier NewWorld.jpg où vous serez redirigé chaque fois que l'action hello retournera avec succès. Vous pouvez consulter l' exemple d' action de redirection Struts 2 pour une meilleure compréhension.

La pile de valeur

La pile de valeurs est un ensemble de plusieurs objets qui conserve les objets suivants dans l'ordre fourni -

Sr.Non	Objets et description
1	Temporary Objects Il existe différents objets temporaires qui sont créés lors de l'exécution d'une page. Par exemple, la valeur d'itération actuelle pour une collection bouclée dans une balise JSP.
2	The Model Object Si vous utilisez des objets de modèle dans votre application Struts, l'objet de modèle actuel est placé avant l'action sur la pile de valeurs.
3	The Action Object Ce sera l'objet d'action en cours d'exécution.
4	Named Objects Ces objets incluent #application, #session, #request, #attr et #parameters et font référence aux portées de servlet correspondantes.

La pile de valeurs est accessible via les balises fournies pour JSP, Velocity ou Freemarker. Il existe différentes balises que nous étudierons dans des chapitres séparés, utilisées pour obtenir et définir la pile de valeurs struts 2.0. Vous pouvez obtenir l'objet valueStack dans votre action comme suit -

ActionContext.getContext().getValueStack()

Une fois que vous avez un objet ValueStack, vous pouvez utiliser les méthodes suivantes pour manipuler cet objet -

Sr.Non	Méthodes ValueStack et description
1	Object findValue(String expr) Trouvez une valeur en évaluant l'expression donnée par rapport à la pile dans l'ordre de recherche par défaut.
2	CompoundRoot getRoot() Obtenez le CompoundRoot qui contient les objets poussés sur la pile.
3	Object peek() Obtenez l'objet sur le dessus de la pile sans changer la pile.
4	Object pop() Récupérez l'objet sur le dessus de la pile et retirez-le de la pile.
5	void push(Object o) Mettez cet objet sur le dessus de la pile.
6	void set(String key, Object o) Définit un objet sur la pile avec la clé donnée afin qu'il soit récupérable par findValue (key, ...)
sept	void setDefaultType(Class defaultType) Définit le type par défaut vers lequel convertir si aucun type n'est fourni lors de l'obtention d'une valeur.
8	void setValue(String expr, Object value) Tente de définir une propriété sur un bean dans la pile avec l'expression donnée en utilisant l'ordre de recherche par défaut.
9	int size() Obtenez le nombre d'objets dans la pile.

L'OGNL

le Object-Graph Navigation Language(OGNL) est un langage d'expression puissant utilisé pour référencer et manipuler des données sur ValueStack. OGNL aide également au transfert de données et à la conversion de type.

L'OGNL est très similaire au langage d'expression JSP. OGNL est basé sur l'idée d'avoir un objet racine ou par défaut dans le contexte. Les propriétés de l'objet par défaut ou racine peuvent être référencées à l'aide de la notation de balisage, qui est le symbole dièse.

Comme mentionné précédemment, OGNL est basé sur un contexte et Struts crée une carte ActionContext à utiliser avec OGNL. La carte ActionContext comprend les éléments suivants:

Application - Variables de portée de l'application
Session - Variables de portée de session
Root / value stack - Toutes vos variables d'action sont stockées ici
Request - Demander des variables de portée
Parameters - Paramètres de demande
Atributes - Les attributs stockés dans la portée de la page, de la requête, de la session et de l'application

Il est important de comprendre que l'objet Action est toujours disponible dans la pile de valeurs. Donc, donc si votre objet Action a des propriétés“x” et “y” ils sont facilement disponibles pour vous.

Les objets de l'ActionContext sont référencés à l'aide du symbole dièse, cependant, les objets de la pile de valeurs peuvent être directement référencés.

Par exemple, si employee est une propriété d'une classe d'action, alors elle peut être référencée comme suit -

<s:property value = "name"/>

au lieu de

<s:property value = "#name"/>

Si vous avez un attribut dans la session appelé "login", vous pouvez le récupérer comme suit -

<s:property value = "#session.login"/>

OGNL prend également en charge le traitement des collections - à savoir Map, List et Set. Par exemple, pour afficher une liste déroulante de couleurs, vous pouvez faire -

<s:select name = "color" list = "{'red','yellow','green'}" />

L'expression OGNL est intelligente pour interpréter le "rouge", "jaune", "vert" comme des couleurs et construire une liste basée sur cela.

Les expressions OGNL seront largement utilisées dans les prochains chapitres lorsque nous étudierons différentes balises. Donc, plutôt que de les examiner isolément, examinons-les en utilisant quelques exemples dans la section Balises de formulaire / Balises de contrôle / Balises de données et Balises Ajax.

Exemple ValueStack / OGNL

Créer une action

Considérons la classe d'action suivante où nous accédons à valueStack et définissons ensuite quelques clés auxquelles nous accèderons en utilisant OGNL dans notre vue, c'est-à-dire la page JSP.

package com.tutorialspoint.struts2;

import java.util.*; 

import com.opensymphony.xwork2.util.ValueStack;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;

public class HelloWorldAction extends ActionSupport {
   private String name;

   public String execute() throws Exception {
      ValueStack stack = ActionContext.getContext().getValueStack();
      Map<String, Object> context = new HashMap<String, Object>();

      context.put("key1", new String("This is key1")); 
      context.put("key2", new String("This is key2"));
      stack.push(context);

      System.out.println("Size of the valueStack: " + stack.size());
      return "success";
   }  

   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }
}

En fait, Struts 2 ajoute votre action en haut de valueStack lors de son exécution. Ainsi, la manière habituelle de placer des éléments sur la pile de valeurs est d'ajouter des getters / setters pour les valeurs à votre classe Action, puis d'utiliser la balise <s: property> pour accéder aux valeurs. Mais je vous montre comment exactement ActionContext et ValueStack fonctionnent dans des entretoises.

Créer des vues

Créons le fichier jsp ci-dessous HelloWorld.jspdans le dossier WebContent de votre projet eclipse. Cette vue sera affichée au cas où l'action retourne un succès -

<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>

<html>
   <head>
      <title>Hello World</title>
   </head>
   
   <body>
      Entered value : <s:property value = "name"/><br/>
      Value of key 1 : <s:property value = "key1" /><br/>
      Value of key 2 : <s:property value = "key2" /> <br/>
   </body>
</html>

Nous devons également créer index.jsp dans le dossier WebContent dont le contenu est le suivant -

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
   <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>Hello World</title>
   </head>
   
   <body>
      <h1>Hello World From Struts2</h1>
      <form action = "hello">
         <label for = "name">Please enter your name</label><br/>
         <input type = "text" name = "name"/>
         <input type = "submit" value = "Say Hello"/>
      </form>
   </body>
</html>

Fichiers de configuration

Voici le contenu de struts.xml fichier -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "helloworld" extends = "struts-default">

      <action name = "hello" 
         class = "com.tutorialspoint.struts2.HelloWorldAction" 
         method = "execute">
         <result name = "success">/HelloWorld.jsp</result>
      </action>

   </package>
</struts>

Voici le contenu de web.xml fichier -

<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns = "http://java.sun.com/xml/ns/javaee" 
   xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee 
   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   id = "WebApp_ID" version = "3.0">
   
   <display-name>Struts 2</display-name>
   
   <welcome-file-list>
      <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>
   
   <filter>
      <filter-name>struts2</filter-name>
      <filter-class>
         org.apache.struts2.dispatcher.FilterDispatcher
      </filter-class>
   </filter>

   <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
   </filter-mapping>
</web-app>

Faites un clic droit sur le nom du projet et cliquez sur Export > WAR Filepour créer un fichier War. Déployez ensuite ce WAR dans le répertoire webapps de Tomcat.

Enfin, démarrez le serveur Tomcat et essayez d'accéder à l'URL http://localhost:8080/HelloWorldStruts2/index.jsp. Cela produira l'écran suivant

Maintenant, entrez n'importe quel mot dans la zone de texte donnée et cliquez sur le bouton "Dire bonjour" pour exécuter l'action définie. Maintenant, si vous vérifiez le journal généré, vous trouverez le texte suivant en bas -

Size of the valueStack: 3

Cela affichera l'écran suivant, qui affichera la valeur que vous entrerez et la valeur de key1 et key2 que nous avions mis sur ValueStack.

Le framework Struts 2 fournit un support intégré pour le traitement du téléchargement de fichiers à l'aide de «Téléchargement de fichiers basé sur des formulaires en HTML». Lorsqu'un fichier est téléchargé, il est généralement stocké dans un répertoire temporaire et doit être traité ou déplacé par votre classe Action vers un répertoire permanent pour garantir que les données ne sont pas perdues.

Note - Les serveurs peuvent avoir une politique de sécurité en place qui vous interdit d'écrire dans des répertoires autres que le répertoire temporaire et les répertoires appartenant à votre application Web.

Le téléchargement de fichiers dans Struts est possible via un intercepteur prédéfini appelé FileUpload intercepteur, disponible via la classe org.apache.struts2.interceptor.FileUploadInterceptor et inclus dans le cadre dedefaultStack. Vous pouvez toujours l'utiliser dans votre struts.xml pour définir divers paramètres comme nous le verrons ci-dessous.

Créer des fichiers de vue

Commençons par créer notre vue qui sera nécessaire pour parcourir et télécharger un fichier sélectionné. Alors créons unindex.jsp avec un formulaire de téléchargement HTML simple qui permet à l'utilisateur de télécharger un fichier -

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>File Upload</title>
   </head>
   
   <body>
      <form action = "upload" method = "post" enctype = "multipart/form-data">
         <label for = "myFile">Upload your file</label>
         <input type = "file" name = "myFile" />
         <input type = "submit" value = "Upload"/>
      </form>
   </body>
</html>

Il y a quelques points à noter dans l'exemple ci-dessus. Tout d'abord, le enctype du formulaire est défini surmultipart/form-data. Ceci doit être défini pour que les téléchargements de fichiers soient gérés avec succès par l'intercepteur de téléchargement de fichiers. Le point suivant est la méthode d'action du formulaireupload et le nom du champ de téléchargement de fichier - qui est myFile. Nous avons besoin de ces informations pour créer la méthode d'action et la configuration des struts.

Ensuite, créons un simple fichier jsp success.jsp pour afficher le résultat de notre téléchargement de fichier au cas où il réussirait.

<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>

<html>
   <head>
      <title>File Upload Success</title>
   </head>
   
   <body>
      You have successfully uploaded <s:property value = "myFileFileName"/>
   </body>
</html>

Voici le fichier de résultats error.jsp au cas où il y aurait une erreur lors du téléchargement du fichier -

<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>

<html>
   <head>
      <title>File Upload Error</title>
   </head>
   
   <body>
      There has been an error in uploading the file.
   </body>
</html>

Créer une classe d'action

Ensuite, créons une classe Java appelée uploadFile.java qui se chargera de télécharger le fichier et de stocker ce fichier dans un emplacement sécurisé -

package com.tutorialspoint.struts2;

import java.io.File;
import org.apache.commons.io.FileUtils;
import java.io.IOException; 

import com.opensymphony.xwork2.ActionSupport;

public class uploadFile extends ActionSupport {
   private File myFile;
   private String myFileContentType;
   private String myFileFileName;
   private String destPath;

   public String execute() {
      /* Copy file to a safe location */
      destPath = "C:/apache-tomcat-6.0.33/work/";

      try {
         System.out.println("Src File name: " + myFile);
         System.out.println("Dst File name: " + myFileFileName);
     	    	 
         File destFile  = new File(destPath, myFileFileName);
         FileUtils.copyFile(myFile, destFile);
  
      } catch(IOException e) {
         e.printStackTrace();
         return ERROR;
      }

      return SUCCESS;
   }
   
   public File getMyFile() {
      return myFile;
   }
   
   public void setMyFile(File myFile) {
      this.myFile = myFile;
   }
   
   public String getMyFileContentType() {
      return myFileContentType;
   }
   
   public void setMyFileContentType(String myFileContentType) {
      this.myFileContentType = myFileContentType;
   }
   
   public String getMyFileFileName() {
      return myFileFileName;
   }
   
   public void setMyFileFileName(String myFileFileName) {
      this.myFileFileName = myFileFileName;
   }
}

le uploadFile.javaest une classe très simple. La chose importante à noter est que l'intercepteur FileUpload avec l'intercepteur de paramètres fait tout le gros du travail pour nous.

L'intercepteur FileUpload met à votre disposition trois paramètres par défaut. Ils sont nommés dans le modèle suivant -

[your file name parameter] - Il s'agit du fichier réel que l'utilisateur a téléchargé. Dans cet exemple, ce sera "myFile"
[your file name parameter]ContentType- Il s'agit du type de contenu du fichier qui a été téléchargé. Dans cet exemple, ce sera "myFileContentType"
[your file name parameter]FileName- C'est le nom du fichier qui a été téléchargé. Dans cet exemple, ce sera "myFileFileName"

Les trois paramètres sont disponibles pour nous, grâce aux intercepteurs Struts. Tout ce que nous avons à faire est de créer trois paramètres avec les noms corrects dans notre classe Action et automatiquement ces variables sont automatiquement câblées pour nous. Ainsi, dans l'exemple ci-dessus, nous avons trois paramètres et une méthode d'action qui renvoie simplement «succès» si tout se passe bien, sinon elle renvoie «erreur».

Fichiers de configuration

Voici les propriétés de configuration Struts2 qui contrôlent le processus de téléchargement des fichiers -

Sr.Non	Propriétés et description
1	struts.multipart.maxSize La taille maximale (en octets) d'un fichier à accepter comme téléchargement de fichier. La valeur par défaut est 250M.
2	struts.multipart.parser La bibliothèque utilisée pour télécharger le formulaire en plusieurs parties. Par défaut estjakarta
3	struts.multipart.saveDir L'emplacement de stockage du fichier temporaire. Par défaut, javax.servlet.context.tempdir.

Pour modifier l'un de ces paramètres, vous pouvez utiliser constant tag dans le fichier struts.xml de votre application, comme je l'ai fait pour modifier la taille maximale d'un fichier à télécharger.

Laissez-nous notre struts.xml comme suit -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <constant name = "struts.devMode" value = "true" />
   <constant name = "struts.multipart.maxSize" value = "1000000" />
   <package name = "helloworld" extends = "struts-default">
      <action name = "upload" class = "com.tutorialspoint.struts2.uploadFile">
         <result name = "success">/success.jsp</result>
         <result name = "error">/error.jsp</result>
      </action>
   </package>
</struts>

Depuis, FileUploadl'intercepteur fait partie de la pile d'intercepteurs par défaut, nous n'avons pas besoin de le configurer explicitement. Mais, vous pouvez ajouter la balise <interceptor-ref> dans <action>. L'intercepteur fileUpload prend deux paramètres(a) maximumSize et (b) allowedTypes.

Le paramètre maximumSize définit la taille de fichier maximale autorisée (la valeur par défaut est d'environ 2 Mo). Le paramètre allowedTypes est une liste séparée par des virgules des types de contenu accepté (MIME) comme indiqué ci-dessous -

<action name = "upload" class = "com.tutorialspoint.struts2.uploadFile">
   <interceptor-ref name = "basicStack">
   <interceptor-ref name = "fileUpload">
      <param name = "allowedTypes">image/jpeg,image/gif</param>
   </interceptor-ref>
   <result name = "success">/success.jsp</result>
   <result name = "error">/error.jsp</result>
</action>

Voici le contenu de web.xml fichier -

<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns = "http://java.sun.com/xml/ns/javaee" 
   xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee 
   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   id = "WebApp_ID" version = "3.0">
   
   <display-name>Struts 2</display-name>
   
   <welcome-file-list>
      <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>
   
   <filter>
      <filter-name>struts2</filter-name>
      <filter-class>
         org.apache.struts2.dispatcher.FilterDispatcher
      </filter-class>
   </filter>

   <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
   </filter-mapping>
</web-app>

Maintenant, faites un clic droit sur le nom du projet et cliquez sur Export > WAR Filepour créer un fichier War. Déployez ensuite ce WAR dans le répertoire webapps de Tomcat. Enfin, démarrez le serveur Tomcat et essayez d'accéder à l'URLhttp://localhost:8080/HelloWorldStruts2/upload.jsp. Cela produira l'écran suivant -

Sélectionnez maintenant un fichier "Contacts.txt" en utilisant le bouton Parcourir et cliquez sur le bouton de téléchargement qui téléchargera le fichier sur votre service et vous devriez voir la page suivante. Vous pouvez vérifier que le fichier téléchargé doit être enregistré dans C: \ apache-tomcat-6.0.33 \ work.

Notez que le FileUpload Interceptor supprime automatiquement le fichier téléchargé, vous devrez donc enregistrer le fichier téléchargé par programme à un endroit avant qu'il ne soit supprimé.

Messages d'erreur

L'intercepteur fileUplaod utilise plusieurs touches de message d'erreur par défaut -

Sr.Non	Clé et description du message d'erreur
1	struts.messages.error.uploading Erreur générale qui se produit lorsque le fichier n'a pas pu être téléchargé.
2	struts.messages.error.file.too.large Se produit lorsque le fichier téléchargé est trop volumineux comme spécifié par maximumSize.
3	struts.messages.error.content.type.not.allowed Se produit lorsque le fichier téléchargé ne correspond pas aux types de contenu attendus spécifiés.

Vous pouvez remplacer le texte de ces messages dans WebContent/WEB-INF/classes/messages.properties fichiers de ressources.

Ce chapitre vous apprendra comment accéder à une base de données à l'aide de Struts 2 en quelques étapes simples. Struts est un framework MVC et non un framework de base de données, mais il fournit un excellent support pour l'intégration JPA / Hibernate. Nous examinerons l'intégration de la mise en veille prolongée dans un chapitre ultérieur, mais dans ce chapitre, nous utiliserons l'ancien JDBC pour accéder à la base de données.

La première étape de ce chapitre consiste à configurer et à amorcer notre base de données. J'utilise MySQL comme base de données pour cet exemple. J'ai MySQL installé sur ma machine et j'ai créé une nouvelle base de données appelée "struts_tutorial". J'ai créé une table appeléeloginet l'a rempli avec quelques valeurs. Vous trouverez ci-dessous le script que j'ai utilisé pour créer et remplir la table.

Ma base de données MYSQL a le nom d'utilisateur par défaut "root" et le mot de passe "root123"

CREATE TABLE `struts_tutorial`.`login` (
   `user` VARCHAR( 10 ) NOT NULL ,
   `password` VARCHAR( 10 ) NOT NULL ,
   `name` VARCHAR( 20 ) NOT NULL ,
   PRIMARY KEY ( `user` )
) ENGINE = InnoDB;

INSERT INTO `struts_tutorial`.`login` (`user`, `password`, `name`)
VALUES ('scott', 'navy', 'Scott Burgemott');

L'étape suivante consiste à télécharger le fichier jar MySQL Connector et à placer ce fichier dans le dossier WEB-INF \ lib de votre projet. Après avoir fait cela, nous sommes maintenant prêts à créer la classe d'action.

Créer une action

La classe d'action a les propriétés correspondant aux colonnes de la table de base de données. Nous avonsuser, password et namecomme attributs String. Dans la méthode d'action, nous utilisons les paramètres utilisateur et mot de passe pour vérifier si l'utilisateur existe, si c'est le cas, nous affichons le nom d'utilisateur dans l'écran suivant.

Si l'utilisateur a entré des informations erronées, nous les renvoyons à l'écran de connexion.

Voici le contenu de LoginAction.java fichier -

package com.tutorialspoint.struts2;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import com.opensymphony.xwork2.ActionSupport;

public class LoginAction extends ActionSupport {

   private String user;
   private String password;
   private String name;

   public String execute() {
      String ret = ERROR;
      Connection conn = null;

      try {
         String URL = "jdbc:mysql://localhost/struts_tutorial";
         Class.forName("com.mysql.jdbc.Driver");
         conn = DriverManager.getConnection(URL, "root", "root123");
         String sql = "SELECT name FROM login WHERE";
         sql+=" user = ? AND password = ?";
         PreparedStatement ps = conn.prepareStatement(sql);
         ps.setString(1, user);
         ps.setString(2, password);
         ResultSet rs = ps.executeQuery();

         while (rs.next()) {
            name = rs.getString(1);
            ret = SUCCESS;
         }
      } catch (Exception e) {
         ret = ERROR;
      } finally {
         if (conn != null) {
            try {
               conn.close();
            } catch (Exception e) {
            }
         }
      }
      return ret;
   }

   public String getUser() {
      return user;
   }

   public void setUser(String user) {
      this.user = user;
   }

   public String getPassword() {
      return password;
   }

   public void setPassword(String password) {
      this.password = password;
   }

   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }
}

Créer une page principale

Maintenant, créons un fichier JSP index.jsppour collecter le nom d'utilisateur et le mot de passe. Ce nom d'utilisateur et ce mot de passe seront vérifiés par rapport à la base de données.

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>Login</title>
   </head>
   
   <body>
      <form action = "loginaction" method = "post">
         User:<br/><input type = "text" name = "user"/><br/>
         Password:<br/><input type = "password" name = "password"/><br/>
         <input type = "submit" value = "Login"/>		
      </form>
   </body>
</html>

Créer des vues

Maintenant, créons success.jsp fichier qui sera invoqué au cas où l'action retourne SUCCESS, mais nous aurons un autre fichier de vue au cas où une ERREUR serait renvoyée par l'action.

<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>

<html>
   <head>
      <title>Successful Login</title>
   </head>
   
   <body>
      Hello World, <s:property value = "name"/>
   </body>
</html>

Voici le fichier de vue error.jsp en cas d'ERREUR est renvoyé de l'action.

<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>

<html>
   <head>
      <title>Invalid User Name or Password</title>
   </head>
   
   <body>
      Wrong user name or password provided.
   </body>
</html>

Fichiers de configuration

Enfin, mettons tout ensemble en utilisant le fichier de configuration struts.xml comme suit -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "helloworld" extends = "struts-default">
   
      <action name = "loginaction" 
         class = "com.tutorialspoint.struts2.LoginAction"
         method = "execute">
         <result name = "success">/success.jsp</result>
         <result name = "error">/error.jsp</result>
      </action>
   
   </package>
</struts>

Voici le contenu de web.xml fichier -

<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns = "http://java.sun.com/xml/ns/javaee" 
   xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee 
   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   id = "WebApp_ID" version = "3.0">
   
   <display-name>Struts 2</display-name>
   
   <welcome-file-list>
      <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>
   
   <filter>
      <filter-name>struts2</filter-name>
      <filter-class>
         org.apache.struts2.dispatcher.FilterDispatcher
      </filter-class>
   </filter>

   <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
   </filter-mapping>
</web-app>

Entrez un nom d'utilisateur et un mot de passe erronés. Vous devriez voir la page suivante.

Entrez maintenant scott comme nom d'utilisateur et navycomme mot de passe. Vous devriez voir la page suivante.

Ce chapitre explique comment envoyer un e-mail à l'aide de votre application Struts 2.

Pour cet exercice, vous devez télécharger et installer le fichier mail.jar à partir de l' API JavaMail 1.4.4 et placer lemail.jar dans votre dossier WEB-INF \ lib, puis suivez les étapes standard de création de fichiers d'action, de vue et de configuration.

Créer une action

L'étape suivante consiste à créer une méthode Action qui s'occupe de l'envoi de l'e-mail. Créons une nouvelle classe appeléeEmailer.java avec le contenu suivant.

package com.tutorialspoint.struts2;

import java.util.Properties;
import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

import com.opensymphony.xwork2.ActionSupport;

public class Emailer extends ActionSupport {

   private String from;
   private String password;
   private String to;
   private String subject;
   private String body;

   static Properties properties = new Properties();
   static {
      properties.put("mail.smtp.host", "smtp.gmail.com");
      properties.put("mail.smtp.socketFactory.port", "465");
      properties.put("mail.smtp.socketFactory.class",
         "javax.net.ssl.SSLSocketFactory");
      properties.put("mail.smtp.auth", "true");
      properties.put("mail.smtp.port", "465");
   }

   public String execute() {
      String ret = SUCCESS;
      try {
         Session session = Session.getDefaultInstance(properties,  
            new javax.mail.Authenticator() {
               protected PasswordAuthentication 
               getPasswordAuthentication() {
                  return new 
                  PasswordAuthentication(from, password);
               }
            }
         );

         Message message = new MimeMessage(session);
         message.setFrom(new InternetAddress(from));
         message.setRecipients(Message.RecipientType.TO, 
            InternetAddress.parse(to));
         message.setSubject(subject);
         message.setText(body);
         Transport.send(message);
      } catch(Exception e) {
         ret = ERROR;
         e.printStackTrace();
      }
      return ret;
   }

   public String getFrom() {
      return from;
   }

   public void setFrom(String from) {
      this.from = from;
   }

   public String getPassword() {
      return password;
   }

   public void setPassword(String password) {
      this.password = password;
   }

   public String getTo() {
      return to;
   }

   public void setTo(String to) {
      this.to = to;
   }

   public String getSubject() {
      return subject;
   }

   public void setSubject(String subject) {
      this.subject = subject;
   }

   public String getBody() {
      return body;
   }

   public void setBody(String body) {
      this.body = body;
   }

   public static Properties getProperties() {
      return properties;
   }

   public static void setProperties(Properties properties) {
      Emailer.properties = properties;
   }
}

Comme on le voit dans le code source ci-dessus, le Emailer.javaa des propriétés qui correspondent aux attributs de formulaire dans la page email.jsp ci-dessous. Ces attributs sont -

From- L'adresse e-mail de l'expéditeur. Comme nous utilisons le SMTP de Google, nous avons besoin d'un identifiant gtalk valide
Password - Le mot de passe du compte ci-dessus
To - À qui envoyer l'e-mail?
Subject - objet de l'e-mail
Body - Le message électronique réel

Nous n'avons envisagé aucune validation sur les champs ci-dessus, des validations seront ajoutées dans le chapitre suivant. Regardons maintenant la méthode execute (). La méthode execute () utilise la bibliothèque javax Mail pour envoyer un e-mail en utilisant les paramètres fournis. Si le courrier est envoyé avec succès, l'action renvoie SUCCESS, sinon elle renvoie ERROR.

Créer une page principale

Écrivons le fichier JSP de la page principale index.jsp, qui seront utilisées pour collecter les informations relatives aux e-mails mentionnées ci-dessus -

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
   <title>Email Form</title>
   </head>
   
   <body>
      <em>The form below uses Google's SMTP server. 
         So you need to enter a gmail username and password
      </em>
      
      <form action = "emailer" method = "post">
         <label for = "from">From</label><br/>
         <input type = "text" name = "from"/><br/>
         <label for = "password">Password</label><br/>
         <input type = "password" name = "password"/><br/>
         <label for = "to">To</label><br/>
         <input type = "text" name = "to"/><br/>
         <label for = "subject">Subject</label><br/>
         <input type = "text" name = "subject"/><br/>
         <label for = "body">Body</label><br/>
         <input type = "text" name = "body"/><br/>
         <input type = "submit" value = "Send Email"/>
      </form>
   </body>
</html>

Créer des vues

Nous utiliserons le fichier JSP success.jsp qui sera invoqué au cas où l'action retourne SUCCESS, mais nous aurons un autre fichier de vue au cas où une ERREUR serait renvoyée par l'action.

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>Email Success</title>
   </head>
   
   <body>
      Your email to <s:property value = "to"/> was sent successfully.
   </body>
</html>

Voici le fichier de vue error.jsp en cas d'ERREUR est renvoyé de l'action.

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>Email Error</title>
   </head>
   
   <body>
      There is a problem sending your email to <s:property value = "to"/>.
   </body>
</html>

Fichiers de configuration

Maintenant, mettons tout ensemble en utilisant le fichier de configuration struts.xml comme suit -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "helloworld" extends = "struts-default">

      <action name = "emailer" 
         class = "com.tutorialspoint.struts2.Emailer"
         method = "execute">
         <result name = "success">/success.jsp</result>
         <result name = "error">/error.jsp</result>
      </action>

   </package>
</struts>

Voici le contenu de web.xml fichier -

<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns = "http://java.sun.com/xml/ns/javaee" 
   xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee 
   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   id = "WebApp_ID" version = "3.0">
   
   <display-name>Struts 2</display-name>
   
   <welcome-file-list>
      <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>

   <filter>
      <filter-name>struts2</filter-name>
      <filter-class>
         org.apache.struts2.dispatcher.FilterDispatcher
      </filter-class>
   </filter>

   <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
   </filter-mapping>
</web-app>

Entrez les informations requises et cliquez sur Send Emailbouton. Si tout se passe bien, vous devriez voir la page suivante.

Dans ce chapitre, nous examinerons plus en détail le cadre de validation Struts. Au cœur de Struts, nous avons le cadre de validation qui aide l'application à exécuter les règles pour effectuer la validation avant que la méthode d'action ne soit exécutée.

La validation côté client est généralement réalisée à l'aide de Javascript. Cependant, il ne faut pas se fier uniquement à la validation côté client. Les meilleures pratiques suggèrent que la validation doit être introduite à tous les niveaux de votre infrastructure d'application. Voyons maintenant deux façons d'ajouter une validation à notre projet Struts.

Ici, nous prendrons un exemple de Employee dont le nom et l'âge doivent être saisis à l'aide d'une simple page, et nous mettrons ces deux validations pour nous assurer que l'utilisateur entre toujours un nom et un âge qui doivent être compris entre 28 et 65 ans.

Commençons par la page JSP principale de l'exemple.

Créer une page principale

Écrivons le fichier JSP de la page principale index.jsp, qui seront utilisées pour collecter les informations relatives aux employés mentionnées ci-dessus.

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>Employee Form</title>
   </head>

   <body>
      <s:form action = "empinfo" method = "post">
         <s:textfield name = "name" label = "Name" size = "20" />
         <s:textfield name = "age" label = "Age" size = "20" />
         <s:submit name = "submit" label = "Submit" align="center" />
      </s:form>
   </body>
</html>

L'index.jsp utilise la balise Struts, que nous n'avons pas encore abordée, mais nous les étudierons dans les chapitres relatifs aux balises. Mais pour l'instant, supposons simplement que la balise s: textfield imprime un champ d'entrée et que s: submit imprime un bouton d'envoi. Nous avons utilisé la propriété label pour chaque balise qui crée une étiquette pour chaque balise.

Créer des vues

Nous utiliserons le fichier JSP success.jsp qui sera appelé au cas où l'action définie renvoie SUCCESS.

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>Success</title>
   </head>
   
   <body>
      Employee Information is captured successfully.
   </body>
</html>

Créer une action

Alors définissons une petite classe d'action Employee, puis ajoutez une méthode appelée validate() comme indiqué ci-dessous dans Employee.javafichier. Assurez-vous que votre classe d'action étend laActionSupport class, sinon votre méthode validate ne sera pas exécutée.

package com.tutorialspoint.struts2;

import com.opensymphony.xwork2.ActionSupport;

public class Employee extends ActionSupport {
   private String name;
   private int age;
   
   public String execute() {
       return SUCCESS;
   }
   
   public String getName() {
       return name;
   }
   
   public void setName(String name) {
       this.name = name;
   }
   
   public int getAge() {
       return age;
   }
   
   public void setAge(int age) {
       this.age = age;
   }

   public void validate() {
      if (name == null || name.trim().equals("")) {
         addFieldError("name","The name is required");
      }
      
      if (age < 28 || age > 65) {
         addFieldError("age","Age must be in between 28 and 65");
      }
   }
}

Comme indiqué dans l'exemple ci-dessus, la méthode de validation vérifie si le champ «Nom» a une valeur ou non. Si aucune valeur n'a été fournie, nous ajoutons une erreur de champ pour le champ «Nom» avec un message d'erreur personnalisé. Deuxièmement, nous vérifions si la valeur saisie pour le champ «Âge» est comprise entre 28 et 65 ans ou non, si cette condition ne répond pas, nous ajoutons une erreur au-dessus du champ validé.

Fichiers de configuration

Enfin, mettons tout ensemble en utilisant le struts.xml fichier de configuration comme suit -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "helloworld" extends = "struts-default">

      <action name = "empinfo" 
         class = "com.tutorialspoint.struts2.Employee"
         method = "execute">
         <result name = "input">/index.jsp</result>
         <result name = "success">/success.jsp</result>
      </action>

   </package>
</struts>

Voici le contenu de web.xml fichier -

<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns = "http://java.sun.com/xml/ns/javaee"
   xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   id = "WebApp_ID" version = "3.0">

   <display-name>Struts 2</display-name>
   
   <welcome-file-list>
      <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>

   <filter>
      <filter-name>struts2</filter-name>
      <filter-class>
         org.apache.struts2.dispatcher.FilterDispatcher
      </filter-class>
   </filter>

   <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
   </filter-mapping>
</web-app>

Maintenant, ne saisissez aucune information requise, cliquez simplement sur Submitbouton. Vous verrez le résultat suivant -

Entrez les informations requises mais entrez un mauvais champ De, disons le nom comme "test" et l'âge de 30 ans, et enfin cliquez sur Submitbouton. Vous verrez le résultat suivant -

Comment fonctionne cette validation?

Lorsque l'utilisateur appuie sur le bouton d'envoi, Struts 2 exécute automatiquement la méthode de validation et si l'un des “if”les instructions répertoriées dans la méthode sont vraies, Struts 2 appellera sa méthode addFieldError. Si des erreurs ont été ajoutées, Struts 2 ne procèdera pas à l'appel de la méthode d'exécution. Plutôt le framework Struts 2 reviendrainput à la suite de l'appel de l'action.

Par conséquent, lorsque la validation échoue et que Struts 2 revient input, le framework Struts 2 réaffichera le fichier index.jsp. Depuis, nous avons utilisé les balises de formulaire Struts 2, Struts 2 ajoutera automatiquement les messages d'erreur juste au-dessus du formulaire déposé.

Ces messages d'erreur sont ceux que nous avons spécifiés dans l'appel de la méthode addFieldError. La méthode addFieldError prend deux arguments. Le premier est leform nom du champ auquel l'erreur s'applique et le second, est le message d'erreur à afficher au-dessus de ce champ de formulaire.

addFieldError("name","The name is required");

Pour gérer la valeur de retour de input nous devons ajouter le résultat suivant à notre nœud d'action dans struts.xml.

<result name = "input">/index.jsp</result>

Validation basée sur XML

La deuxième méthode de validation consiste à placer un fichier xml à côté de la classe d'action. La validation basée sur XML Struts2 fournit plus d'options de validation comme la validation par e-mail, la validation de plage d'entiers, le champ de validation de formulaire, la validation d'expression, la validation regex, la validation requise, la validation de chaîne requise, la validation de longueur de chaîne, etc.

Le fichier xml doit être nommé '[action-class]'-validation.xml. Donc, dans notre cas, nous créons un fichier appeléEmployee-validation.xml avec le contenu suivant -

<!DOCTYPE validators PUBLIC 
   "-//OpenSymphony Group//XWork Validator 1.0.2//EN"
   "http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">

<validators>
   <field name = "name">
      <field-validator type = "required">
         <message>
            The name is required.
         </message>
      </field-validator>
   </field>

   <field name = "age">
     <field-validator type = "int">
         <param name = "min">29</param>
         <param name = "max">64</param>
         <message>
            Age must be in between 28 and 65
         </message>
      </field-validator>
   </field>
</validators>

Le fichier XML ci-dessus serait idéalement conservé dans votre CLASSPATH avec le fichier de classe. Laissez-nous avoir notre classe d'action des employés comme suit sans avoirvalidate() méthode -

package com.tutorialspoint.struts2;

import com.opensymphony.xwork2.ActionSupport;

public class Employee extends ActionSupport{
   private String name;
   private int age;
   
   public String execute() {
       return SUCCESS;
   }
   
   public String getName() {
       return name;
   }
   
   public void setName(String name) {
       this.name = name;
   }
   
   public int getAge() {
       return age;
   }
   
   public void setAge(int age) {
       this.age = age;
   }
}

Le reste de la configuration restera tel quel dans l'exemple précédent, maintenant si vous exécutez l'application, elle produira le même résultat que celui que nous avons reçu dans l'exemple précédent.

L'avantage d'avoir un fichier xml pour stocker la configuration permet de séparer la validation du code de l'application. Vous pouvez demander à un développeur d'écrire le code et à un analyste commercial de créer les fichiers xml de validation. Une autre chose à noter est les types de validateurs qui sont disponibles par défaut.

De nombreux autres validateurs sont fournis par défaut avec Struts. Les validateurs courants incluent le validateur de date, le validateur Regex et le validateur de longueur de chaîne. Consultez le lien suivant pour plus de détails Struts - Validateurs basés sur XML .

L'internationalisation (i18n) est le processus de planification et de mise en œuvre de produits et de services afin qu'ils puissent être facilement adaptés à des langues et cultures locales spécifiques, un processus appelé localisation. Le processus d'internationalisation est appelé traduction ou activation de la localisation.

L'internationalisation est abrégée i18n parce que le mot commence par la lettre “i” et se termine par “n”, et il y a 18 caractères entre le premier i et le dernier n.

Struts2 fournit la localisation, c'est-à-dire la prise en charge de l'internationalisation (i18n) via des ensembles de ressources, des intercepteurs et des bibliothèques de balises aux endroits suivants -

Les balises de l'interface utilisateur
Messages et erreurs.
Au sein des classes d'action.

Bundles de ressources

Struts2 utilise des ensembles de ressources pour fournir plusieurs options de langue et de paramètres régionaux aux utilisateurs de l'application Web. Vous n'avez pas à vous soucier d'écrire des pages dans différentes langues. Tout ce que vous avez à faire est de créer un ensemble de ressources pour chaque langue souhaitée. Les ensembles de ressources contiendront des titres, des messages et d'autres textes dans la langue de votre utilisateur. Les ensembles de ressources sont le fichier qui contient les paires clé / valeur pour la langue par défaut de votre application.

Le format de dénomination le plus simple pour un fichier de ressources est -

bundlename_language_country.properties

Ici, bundlenamepeut être ActionClass, Interface, SuperClass, Model, Package, Global resource properties. Partie suivantelanguage_country représente les paramètres régionaux du pays par exemple, les paramètres régionaux espagnols (Espagne) sont représentés par es_ES et les paramètres régionaux anglais (États-Unis) sont représentés par en_US etc.

Lorsque vous référencez un élément de message par sa clé, le framework Struts recherche un groupe de messages correspondant dans l'ordre suivant -

ActionClass.properties
Interface.properties
SuperClass.properties
model.properties
package.properties
struts.properties
global.properties

Pour développer votre application dans plusieurs langues, vous devez gérer plusieurs fichiers de propriétés correspondant à ces langues / paramètres régionaux et définir tout le contenu en termes de paires clé / valeur.

Par exemple, si vous envisagez de développer votre application pour l'anglais américain (par défaut), l'espagnol et le français, vous devrez créer trois fichiers de propriétés. Ici, je vais utiliserglobal.properties uniquement, vous pouvez également utiliser différents fichiers de propriétés pour séparer différents types de messages.

global.properties - Par défaut, l'anglais (États-Unis) sera appliqué
global_fr.properties - Cela sera utilisé pour les paramètres régionaux de Franch.
global_es.properties - Cela sera utilisé pour les paramètres régionaux espagnols.

Accéder aux messages

Il existe plusieurs façons d'accéder aux ressources du message, notamment getText, la balise de texte, l'attribut clé des balises d'interface utilisateur et la balise i18n. Voyons-les en bref -

Afficher i18n texte, utilisez un appel pour getText dans la balise de propriété, ou toute autre balise, comme les balises d'interface utilisateur comme suit -

<s:property value = "getText('some.key')" />

le text tag récupère un message du groupe de ressources par défaut, c'est-à-dire struts.properties

<s:text name = "some.key" />

le i18n tagpousse un ensemble de ressources arbitraires sur la pile de valeurs. D'autres balises dans le cadre de la balise i18n peuvent afficher les messages de ce groupe de ressources.

<s:i18n name = "some.package.bundle">
   <s:text name = "some.key" />
</s:i18n>

le key l'attribut de la plupart des balises d'interface utilisateur peut être utilisé pour générer un message à partir d'un ensemble de ressources -

<s:textfield key = "some.key" name = "textfieldName"/>

Exemple de localisation

Laissez-nous cibler pour créer index.jspdu chapitre précédent en plusieurs langues. Le même fichier serait écrit comme suit -

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
"http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>Employee Form with Multilingual Support</title>
   </head>

   <body>
      <h1><s:text name = "global.heading"/></h1>

      <s:url id = "indexEN" namespace="/" action = "locale" >
         <s:param name = "request_locale" >en</s:param>
      </s:url>
      
      <s:url id = "indexES" namespace="/" action = "locale" >
         <s:param name = "request_locale" >es</s:param>
      </s:url>
      
      <s:url id = "indexFR" namespace="/" action = "locale" >
         <s:param name = "request_locale" >fr</s:param>
      </s:url>

      <s:a href="%{indexEN}" >English</s:a>
      <s:a href="%{indexES}" >Spanish</s:a>
      <s:a href="%{indexFR}" >France</s:a>

      <s:form action = "empinfo" method = "post" namespace = "/">
         <s:textfield name = "name" key = "global.name" size = "20" />
         <s:textfield name = "age" key = "global.age" size = "20" />
         <s:submit name = "submit" key = "global.submit" />
      </s:form>

   </body>
</html>

Nous allons créer success.jsp fichier qui sera appelé en cas de retour de l'action définie SUCCESS.

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
	pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>Success</title>
   </head>
   
   <body>
      <s:property value = "getText('global.success')" />
   </body>
</html>

Ici, nous aurions besoin de créer les deux actions suivantes. (a) Première action a pour prendre soin des paramètres régionaux et afficher le même fichier index.jsp avec une langue différente (b) Une autre action consiste à prendre soin de soumettre le formulaire lui-même. Les deux actions renverront SUCCESS, mais nous prendrons des actions différentes en fonction des valeurs de retour car notre objectif est différent pour les deux actions

Action pour prendre soin des paramètres régionaux

package com.tutorialspoint.struts2;

import com.opensymphony.xwork2.ActionSupport;

public class Locale extends ActionSupport {
   public String execute() {
       return SUCCESS;
   }
}

Action pour soumettre le formulaire

package com.tutorialspoint.struts2;

import com.opensymphony.xwork2.ActionSupport;

public class Employee extends ActionSupport{
   private String name;
   private int age;
   
   public String execute() {
      return SUCCESS;
   }
   
   public String getName() {
      return name;
   }
   
   public void setName(String name) {
      this.name = name;
   }
   
   public int getAge() {
      return age;
   }
   
   public void setAge(int age) {
      this.age = age;
   }
}

Maintenant, créons les trois suivants global.properties fichiers et insérez les CLASSPATH -

global.properties

global.name = Name
global.age = Age
global.submit = Submit
global.heading = Select Locale
global.success = Successfully authenticated

global_fr.properties

global.name = Nom d'utilisateur 
global.age = l'âge
global.submit = Soumettre des
global.heading = Sé lectionnez Local
global.success = Authentifi	é  avec succès

global_es.properties

global.name = Nombre de usuario
global.age = Edad
global.submit = Presentar
global.heading = seleccionar la configuracion regional
global.success = Autenticado correctamente

Nous allons créer notre struts.xml avec deux actions comme suit -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <constant name = "struts.devMode" value = "true" />
   <constant name = "struts.custom.i18n.resources" value = "global" />
   <package name = "helloworld" extends = "struts-default" namespace="/">
      <action name = "empinfo" 
         class = "com.tutorialspoint.struts2.Employee"
         method = "execute">
         <result name = "input">/index.jsp</result>
         <result name = "success">/success.jsp</result>
      </action>
      
      <action name = "locale" 
         class = "com.tutorialspoint.struts2.Locale"
         method = "execute">
         <result name = "success">/index.jsp</result>
      </action>
   </package>

</struts>

Voici le contenu de web.xml fichier -

<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns = "http://java.sun.com/xml/ns/javaee"
   xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   id = "WebApp_ID" version = "3.0">

   <display-name>Struts 2</display-name>
   <welcome-file-list>
      <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>

   <filter>
      <filter-name>struts2</filter-name>
      <filter-class>
         org.apache.struts2.dispatcher.FilterDispatcher
      </filter-class>
   </filter>

   <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
   </filter-mapping>
</web-app>

Maintenant, sélectionnez l'une des langues, disons que nous sélectionnons Spanish, il afficherait le résultat suivant -

Vous pouvez également essayer avec la langue française. Enfin, essayons de cliquerSubmit lorsque nous sommes dans les paramètres régionaux espagnols, il affichera l'écran suivant -

Félicitations, maintenant que vous avez une page Web multilingue, vous pouvez lancer votre site Web dans le monde entier.

Tout sur une requête HTTP est traité comme un Stringpar le protocole. Cela inclut les nombres, les booléens, les entiers, les dates, les décimales et tout le reste. Cependant, dans la classe Struts, vous pouvez avoir des propriétés de n'importe quel type de données.

Comment Struts gère-t-il automatiquement les propriétés pour vous?

Struts utilise une variété de convertisseurs de type sous les couvercles pour faire le gros du travail.

Par exemple, si vous avez un attribut entier dans votre classe Action, Struts convertit automatiquement le paramètre de demande en attribut entier sans que vous ne fassiez quoi que ce soit. Par défaut, Struts est livré avec un certain nombre de convertisseurs de type

Si vous utilisez l'un des convertisseurs répertoriés ci-dessous, vous n'avez rien à craindre -

Entier, flottant, double, décimal
Date et Datetime
Tableaux et collections
Enumerations
Boolean
BigDecimal

Parfois, lorsque vous utilisez votre propre type de données, il est nécessaire d'ajouter vos propres convertisseurs pour que Struts sache comment convertir ces valeurs avant de les afficher. Considérez la classe POJO suivanteEnvironment.java.

package com.tutorialspoint.struts2;

public class Environment {
   private String name;
   
   public  Environment(String name) {
      this.name = name;
   }
   
   public String getName() {
      return name;
   }
   
   public void setName(String name) {
      this.name = name;
   }
}

Il s'agit d'une classe très simple qui a un attribut appelé name, donc rien de spécial à propos de cette classe. Créons une autre classe qui contient des informations sur le système -SystemDetails.java.

Pour les besoins de cet exercice, j'ai codé en dur l'environnement sur «Développement» et le système d'exploitation sur «Windows XP SP3».

Dans un projet en temps réel, vous obtiendrez ces informations à partir de la configuration du système.

Laissez-nous avoir la classe d'action suivante -

package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;

public class SystemDetails extends ActionSupport {
   private Environment environment = new Environment("Development");
   private String operatingSystem = "Windows XP SP3";

   public String execute() {
      return SUCCESS;
   }
   
   public Environment getEnvironment() {
      return environment;
   }
   
   public void setEnvironment(Environment environment) {
      this.environment = environment;
   }
   
   public String getOperatingSystem() {
      return operatingSystem;
   }
   
   public void setOperatingSystem(String operatingSystem) {
      this.operatingSystem = operatingSystem;
   }
}

Ensuite, créons un simple fichier JSP System.jsp pour afficher les informations sur l'environnement et le système d'exploitation.

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>System Details</title>
   </head>
   
   <body>
      Environment: <s:property value = "environment"/><br/>
      Operating System:<s:property value = "operatingSystem"/>
   </body>
</html>

Laissez-nous câbler le system.jsp et le SystemDetails.java classe ensemble en utilisant struts.xml.

La classe SystemDetails a une méthode execute () simple qui renvoie la chaîne "SUCCESS".

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "helloworld" extends = "struts-default">
      
      <action name = "system" 
            class = "com.tutorialspoint.struts2.SystemDetails" 
            method = "execute">
         <result name = "success">/System.jsp</result>
      </action>
   </package>
</struts>

Faites un clic droit sur le nom du projet et cliquez sur Export > WAR File pour créer un fichier War.
Déployez ensuite ce WAR dans le répertoire webapps de Tomcat.
Enfin, démarrez le serveur Tomcat et essayez d'accéder à l'URL http://localhost:8080/HelloWorldStruts2/system.action. Cela produira l'écran suivant -

Quel est le problème avec la sortie ci-dessus? Struts sait comment afficher et convertir la chaîne "Windows XP SP3" et d'autres types de données intégrés, mais il ne sait pas quoi faire avec la propriété deEnvironmenttype. Il est simplement appelétoString() méthode sur la classe

Pour résoudre ce problème, créons et enregistrons maintenant un simple TypeConverter pour la classe Environnement.

Créez une classe appelée EnvironmentConverter.java avec ce qui suit.

package com.tutorialspoint.struts2;

import java.util.Map;
import org.apache.struts2.util.StrutsTypeConverter;

public class EnvironmentConverter extends StrutsTypeConverter {
   @Override
   public Object convertFromString(Map context, String[] values, Class clazz) {
      Environment env = new Environment(values[0]);
      return env;
   }

   @Override
   public String convertToString(Map context, Object value) {
      Environment env  = (Environment) value;
      return env == null ? null : env.getName();
   }	
}

le EnvironmentConverter étend le StrutsTypeConverter classe et indique à Struts comment convertir l'environnement en chaîne et vice versa en remplaçant deux méthodes qui sont convertFromString() et convertToString().

Enregistrons maintenant ce convertisseur avant de l'utiliser dans notre application. Il existe deux façons d'enregistrer un convertisseur.

Si le convertisseur n'est utilisé que dans une action particulière, vous devrez créer un fichier de propriétés qui doit être nommé comme '[action-class]'converstion.properties.

Dans notre cas, nous créons un fichier appelé SystemDetails-converstion.properties avec l'inscription d'inscription suivante -

environment = com.tutorialspoint.struts2.EnvironmentConverter

Dans l'exemple ci-dessus, "environnement" est le nom de la propriété dans le SystemDetails.java classe et nous disons à Struts d'utiliser le EnvironmentConverter pour la conversion vers et depuis cette propriété.

Cependant, nous n'allons pas faire cela, nous allons plutôt enregistrer ce convertisseur globalement, afin qu'il puisse être utilisé dans toute l'application. Pour ce faire, créez un fichier de propriétés appeléxwork-conversion.properties dans le WEBINF/classes dossier avec la ligne suivante

com.tutorialspoint.struts2.Environment = \
   com.tutorialspoint.struts2.EnvironmentConverter

Cela enregistre simplement le convertisseur globalement, de sorte que Strutspeut effectuer automatiquement la conversion à chaque fois qu'il rencontre un objet de type Environnement. Maintenant, si vous recompilez et relancez le programme, vous obtiendrez une meilleure sortie comme suit -

De toute évidence, le résultat sera maintenant meilleur, ce qui signifie que notre convertisseur Struts fonctionne correctement.

C'est ainsi que vous pouvez créer plusieurs convertisseurs et les enregistrer pour les utiliser selon vos besoins.

Avant de commencer le didacticiel pour ce chapitre, examinons quelques définitions données par https://struts.apache.org-

Sr.Non	Terme et description
1	TAG Un petit morceau de code exécuté à partir de JSP, FreeMarker ou Velocity.
2	TEMPLATE Un peu de code, généralement écrit en FreeMarker, qui peut être rendu par certaines balises (balises HTML).
3	THEME Une collection de modèles regroupés pour fournir des fonctionnalités communes.

Je suggérerais également de parcourir le chapitre sur la localisation de Struts2 car nous reprendrons le même exemple une fois de plus pour effectuer notre exercice.

Lorsque vous utilisez un Struts 2comme <s: submit ...>, <s: textfield ...> etc dans votre page Web, le framework Struts 2 génère du code HTML avec un style et une mise en page préconfigurés. Struts 2 est livré avec trois thèmes intégrés -

Sr.Non	Thème et description
1	SIMPLE theme Un thème minimal sans "cloches et sifflets". Par exemple, la balise textfield rend la balise HTML <input /> sans étiquette, validation, rapport d'erreurs ou toute autre mise en forme ou fonctionnalité.
2	XHTML theme C'est le thème par défaut utilisé par Struts 2 et fournit toutes les bases que le thème simple fournit et ajoute plusieurs fonctionnalités telles que la disposition de table standard à deux colonnes pour le HTML, les étiquettes pour chacun des HTML, la validation et les rapports d'erreurs, etc.
3	CSS_XHTML theme Ce thème fournit toutes les bases que le thème simple fournit et ajoute plusieurs fonctionnalités telles que la mise en page standard basée sur CSS à deux colonnes, en utilisant <div> pour les balises HTML Struts, des étiquettes pour chacune des balises HTML Struts, placées selon la feuille de style CSS .

Comme mentionné ci-dessus, si vous ne spécifiez pas de thème, Struts 2 utilisera le thème xhtml par défaut. Par exemple, cette balise de sélection Struts 2 -

<s:textfield name = "name" label = "Name" />

génère le balisage HTML suivant -

<tr>

   <td class="tdLabel">
      <label for = "empinfo_name" class="label">Name:</label>
   </td>
   <td>
      <input type = "text" name = "name" value = "" id = "empinfo_name"/>
   </td>

</tr>

Ici empinfo est le nom de l'action défini dans le fichier struts.xml.

Sélection de thèmes

Vous pouvez spécifier le thème selon Struts 2, sur la base des balises ou vous pouvez utiliser l'une des méthodes suivantes pour spécifier le thème que Struts 2 doit utiliser -

L'attribut de thème sur la balise spécifique
L'attribut de thème sur la balise de formulaire entourant une balise
L'attribut de portée de page nommé "thème"
L'attribut de portée de la demande nommé "thème"
L'attribut de portée session nommé "thème"
L'attribut à l'échelle de l'application nommé "thème"
La propriété struts.ui.theme dans struts.properties (par défaut, xhtml)

Voici la syntaxe pour les spécifier au niveau des balises si vous souhaitez utiliser différents thèmes pour différentes balises -

<s:textfield name = "name" label = "Name" theme="xhtml"/>

Parce qu'il n'est pas très pratique d'utiliser des thèmes par tag, nous pouvons donc simplement spécifier la règle dans struts.properties fichier en utilisant les balises suivantes -

# Standard UI theme
struts.ui.theme = xhtml
# Directory where theme template resides
struts.ui.templateDir = template
# Sets the default template type. Either ftl, vm, or jsp
struts.ui.templateSuffix = ftl

Voici le résultat que nous avons tiré du chapitre sur la localisation où nous avons utilisé le thème par défaut avec un paramètre struts.ui.theme = xhtml dans struts-default.properties fichier qui vient par défaut dans le fichier struts2-core.xy.z.jar.

Comment fonctionne un thème?

Pour un thème donné, chaque balise struts a un modèle associé comme s:textfield → text.ftl et s:password → password.ftl etc.

Ces fichiers de modèle sont compressés dans le fichier struts2-core.xy.z.jar. Ces fichiers modèles conservent une mise en page HTML prédéfinie pour chaque balise.

De cette façon, Struts 2 framework génère le code de balisage HTML final à l'aide des balises Sturts et des modèles associés.

Struts 2 tags + Associated template file = Final HTML markup code.

Les modèles par défaut sont écrits en FreeMarker et ils ont une extension .ftl.

Vous pouvez également concevoir vos modèles à l'aide de la vitesse ou de JSP et définir en conséquence la configuration dans struts.properties à l'aide de struts.ui.templateSuffix et struts.ui.templateDir.

Créer de nouveaux thèmes

Le moyen le plus simple de créer un nouveau thème est de copier l'un des fichiers de thème / modèle existants et d'effectuer les modifications requises.

Commençons par créer un dossier appelé templatedans WebContent / WEBINF / classes et un sous-dossier avec le nom de notre nouveau thème. Par exemple, WebContent / WEB-INF / classes / template / mytheme .

À partir de là, vous pouvez commencer à créer des modèles à partir de zéro, ou vous pouvez également copier les modèles à partir du Struts2 distribution où vous pouvez les modifier si nécessaire à l'avenir.

Nous allons modifier le modèle par défaut existant xhtmlà des fins d'apprentissage. Maintenant, copions le contenu de struts2-core-xyzjar / template / xhtml dans notre répertoire de thèmes et modifions uniquement le fichier WebContent / WEBINF / classes / template / mytheme / control .ftl. Lorsque nous ouvrirons control.ftl qui aura les lignes suivantes -

<table class="${parameters.cssClass?default('wwFormTable')?html}"<#rt/>
<#if parameters.cssStyle??> style="${parameters.cssStyle?html}"<#rt/>
</#if>
>

Changeons le fichier ci-dessus control.ftl avoir le contenu suivant -

<table style = "border:1px solid black;">

Si vous allez vérifier form.ftl alors tu trouveras que control.ftlest utilisé dans ce fichier, mais form.ftl fait référence à ce fichier à partir du thème xhtml. Alors changeons-le comme suit -

<#include "/${parameters.templateDir}/xhtml/form-validate.ftl" />
<#include "/${parameters.templateDir}/simple/form-common.ftl" /> <#if (parameters.validate?default(false))> onreset = "${parameters.onreset?default('clearErrorMessages(this);\
   clearErrorLabels(this);')}"
   
<#else>
   <#if parameters.onreset??>
      onreset="${parameters.onreset?html}" </#if> </#if> #include "/${parameters.templateDir}/mytheme/control.ftl" />

Je suppose que vous n'auriez pas beaucoup de compréhension de la FreeMarker langage de modèle, vous pouvez toujours avoir une bonne idée de ce qui doit être fait en regardant les fichiers .ftl.

Cependant, sauvegardons les modifications ci-dessus, revenons à notre exemple de localisation et créons le WebContent/WEB-INF/classes/struts.properties fichier avec le contenu suivant

# Customized them
struts.ui.theme = mytheme
# Directory where theme template resides
struts.ui.templateDir = template
# Sets the template type to ftl.
struts.ui.templateSuffix = ftl

Maintenant, après ce changement, faites un clic droit sur le nom du projet et cliquez sur Export > WAR Filepour créer un fichier War. Déployez ensuite ce WAR dans le répertoire webapps de Tomcat. Enfin, démarrez le serveur Tomcat et essayez d'accéder à l'URLhttp://localhost:8080/HelloWorldStruts2. Cela produira l'écran suivant -

Vous pouvez voir une bordure autour du composant de formulaire qui est le résultat du changement que nous avons effectué dans le thème après l'avoir copié à partir du thème xhtml. Si vous faites peu d'efforts pour apprendre FreeMarker, vous pourrez créer ou modifier vos thèmes très facilement.

J'espère que maintenant vous avez une compréhension de base sur Sturts 2 thèmes et modèles, n'est-ce pas?

Strutsfournit un moyen plus simple de gérer les exceptions non interceptées et de rediriger les utilisateurs vers une page d'erreur dédiée. Vous pouvez facilement configurer Struts pour avoir différentes pages d'erreur pour différentes exceptions.

Struts facilite la gestion des exceptions grâce à l'utilisation de l'intercepteur "exception". L'intercepteur "d'exception" fait partie de la pile par défaut, vous n'avez donc rien à faire de plus pour le configurer. Il est prêt à l'emploi et prêt à être utilisé.

Voyons un exemple simple de Hello World avec quelques modifications dans le fichier HelloWorldAction.java. Ici, nous avons délibérément introduit une exception NullPointer dans notreHelloWorldAction code d'action.

package com.tutorialspoint.struts2;

import com.opensymphony.xwork2.ActionSupport;

public class HelloWorldAction extends ActionSupport{
   private String name;

   public String execute(){
      String x = null;
      x = x.substring(0);
      return SUCCESS;
   }
   
   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }
}

Gardons le contenu de HelloWorld.jsp comme suit -

<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>

<html>
   <head>
      <title>Hello World</title>
   </head>
   
   <body>
      Hello World, <s:property value = "name"/>
   </body>
</html>

Voici le contenu de index.jsp -

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>Hello World</title>
   </head>
   
   <body>
      <h1>Hello World From Struts2</h1>
      <form action = "hello">
         <label for = "name">Please enter your name</label><br/>
         <input type = "text" name = "name"/>
         <input type = "submit" value = "Say Hello"/>
      </form>
   </body>
</html>

Votre struts.xml devrait ressembler à -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "helloworld" extends = "struts-default">
     
      <action name = "hello" 
         class = "com.tutorialspoint.struts2.HelloWorldAction" 
         method = "execute">
         <result name = "success">/HelloWorld.jsp</result>
      </action>

   </package>
</struts>

Entrez une valeur "Struts2" et soumettez la page. Vous devriez voir la page suivante -

Comme indiqué dans l'exemple ci-dessus, l'intercepteur d'exceptions par défaut fait un excellent travail de gestion de l'exception.

Créons maintenant une page d'erreur dédiée pour notre exception. Créez un fichier appeléError.jsp avec le contenu suivant -

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
	pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title></title>
   </head>
   
   <body>
      This is my custom error page
   </body>
</html>

Configurons maintenant Struts pour utiliser cette page d'erreur en cas d'exception. Modifions lestruts.xml comme suit -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "helloworld" extends = "struts-default">
   
      <action name = "hello" 
         class = "com.tutorialspoint.struts2.HelloWorldAction" 
         method = "execute">
         <exception-mapping exception = "java.lang.NullPointerException"
         result = "error" />
         <result name = "success">/HelloWorld.jsp</result>
         <result name = "error">/Error.jsp</result>
      </action>

   </package>
</struts>

Comme le montre l'exemple ci-dessus, nous avons maintenant configuré Struts pour utiliser le Error.jsp dédié pour NullPointerException. Si vous réexécutez le programme maintenant, vous verrez maintenant la sortie suivante -

En plus de cela, le framework Struts2 est livré avec un intercepteur de «journalisation» pour enregistrer les exceptions. En permettant à l'enregistreur de consigner les exceptions non interceptées, nous pouvons facilement consulter la trace de la pile et déterminer ce qui n'a pas fonctionné

Mappages d'exceptions globales

Nous avons vu comment nous pouvons gérer une exception spécifique à une action. Nous pouvons définir une exception globalement qui s'appliquera à toutes les actions. Par exemple, pour attraper les mêmes exceptions NullPointerException, nous pourrions ajouter<global-exception-mappings...> La balise à l'intérieur de la balise <package ...> et sa balise <result ...> doivent être ajoutées à l'intérieur de la balise <action ...> dans le fichier struts.xml comme suit -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "helloworld" extends = "struts-default">
      <global-exception-mappings>
         <exception-mapping exception = "java.lang.NullPointerException"
         result = "error" />
      </global-exception-mappings>

      <action name = "hello" 
         class = "com.tutorialspoint.struts2.HelloWorldAction" 
         method = "execute">
         <result name = "success">/HelloWorld.jsp</result>
         <result name = "error">/Error.jsp</result>
      </action>

   </package>
</struts>

Comme mentionné précédemment, Struts propose deux formes de configuration. La manière traditionnelle est d'utiliser lestruts.xmlfichier pour toutes les configurations. Nous en avons vu tant d'exemples dans le didacticiel jusqu'à présent. L'autre façon de configurer Struts consiste à utiliser la fonction d'annotations Java 5. En utilisant les annotations Struts, nous pouvons réaliserZero Configuration.

Pour commencer à utiliser des annotations dans votre projet, assurez-vous d'avoir inclus les fichiers jar suivants dans votre WebContent/WEB-INF/lib dossier -

struts2-convention-plugin-x.y.z.jar
asm-x.y.jar
antlr-x.y.z.jar
commons-fileupload-x.y.z.jar
commons-io-x.y.z.jar
commons-lang-x.y.jar
commons-logging-x.y.z.jar
commons-logging-api-x.y.jar
freemarker-x.y.z.jar
javassist-.xy.z.GA
ognl-x.y.z.jar
struts2-core-x.y.z.jar
xwork-core.x.y.z.jar

Voyons maintenant comment vous pouvez supprimer la configuration disponible dans le struts.xml fichier et remplacez-le par des annotations.

Pour expliquer le concept d'annotation dans Struts2, il faudrait reconsidérer notre exemple de validation expliqué dans le chapitre Validations de Struts2 .

Ici, nous prendrons un exemple d'employé dont le nom, l'âge seraient capturés à l'aide d'une simple page, et nous mettrons deux validations pour nous assurer que ÜSER entre toujours un nom et que l'âge doit être compris entre 28 et 65 ans.

Commençons par la page JSP principale de l'exemple.

Créer une page principale

Écrivons le fichier JSP de la page principale index.jsp, qui est utilisé pour collecter les informations relatives aux employés mentionnées ci-dessus.

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>Employee Form</title>
   </head>

   <body>
      
      <s:form action = "empinfo" method = "post">
         <s:textfield name = "name" label = "Name" size = "20" />
         <s:textfield name = "age" label = "Age" size = "20" />
         <s:submit name = "submit" label = "Submit" align="center" />
      </s:form>

   </body>
</html>

L'index.jsp utilise la balise Struts, que nous n'avons pas encore abordée mais nous les étudierons dans les chapitres relatifs aux balises. Mais pour l'instant, supposons simplement que la balise s: textfield imprime un champ d'entrée et que s: submit imprime un bouton d'envoi. Nous avons utilisé la propriété label pour chaque balise qui crée une étiquette pour chaque balise.

Créer des vues

Nous utiliserons le fichier JSP success.jsp qui sera invoquée au cas où l'action définie retourne SUCCESS.

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
	pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>Success</title>
   </head>
   
   <body>
      Employee Information is captured successfully.
   </body>
</html>

Créer une action

C'est l'endroit où l'annotation est utilisée. Laissez-nous redéfinir la classe d'actionEmployee avec annotation, puis ajoutez une méthode appelée validate () comme indiqué ci-dessous dans Employee.javafichier. Assurez-vous que votre classe d'action étend laActionSupport class, sinon votre méthode validate ne sera pas exécutée.

package com.tutorialspoint.struts2;

import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import com.opensymphony.xwork2.validator.annotations.*;

@Results({
   @Result(name = "success", Location = "/success.jsp"),
   @Result(name = "input", Location = "/index.jsp")
})
public class Employee extends ActionSupport {
   private String name;
   private int age;

   @Action(value = "/empinfo")
   
   public String execute() {
      return SUCCESS;
   }

   @RequiredFieldValidator( message = "The name is required" )
   
   public String getName() {
      return name;
   }
   
   public void setName(String name) {
      this.name = name;
   }

   @IntRangeFieldValidator(message = "Age must be in between 28 and 65", min = "29", max = "65")
   
   public int getAge() {
      return age;
   }
   
   public void setAge(int age) {
      this.age = age;
   }
}

Nous avons utilisé quelques annotations dans cet exemple. Laissez-moi les parcourir un par un -

Premièrement, nous avons inclus le Resultsannotation. Une annotation Résultats est une collection de résultats.
Sous l'annotation des résultats, nous avons deux annotations de résultats. Les annotations de résultat ont lenamequi correspondent au résultat de la méthode d'exécution. Ils contiennent également un emplacement indiquant quelle vue doit être servie correspondant à la valeur de retour de execute ()
La prochaine annotation est le Actionannotation. Ceci est utilisé pour décorer la méthode execute (). La méthode Action prend également une valeur qui est l'URL sur laquelle l'action est appelée.
Enfin, j'en ai utilisé deux validationannotations. J'ai configuré le validateur de champ requis surname champ et le validateur de plage d'entiers sur le agechamp. J'ai également spécifié un message personnalisé pour les validations.

Fichiers de configuration

Nous n'avons vraiment pas besoin struts.xml fichier de configuration, supprimons ce fichier et vérifions le contenu de web.xml fichier -

<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns = "http://java.sun.com/xml/ns/javaee"
   xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   id = "WebApp_ID" version = "3.0">

   <display-name>Struts 2</display-name>
   
   <welcome-file-list>
      <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>

   <filter>
      <filter-name>struts2</filter-name>
      
      <filter-class>
         org.apache.struts2.dispatcher.FilterDispatcher
      </filter-class>
      
      <init-param>
         <param-name>struts.devMode</param-name>
         <param-value>true</param-value>
      </init-param>
   </filter>

   <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
   </filter-mapping>
</web-app>

Maintenant, ne saisissez aucune information requise, cliquez simplement sur Submitbouton. Vous verrez le résultat suivant -

Entrez les informations requises mais entrez un mauvais champ De, disons le nom comme "test" et l'âge de 30 ans, et enfin cliquez sur Submitbouton. Vous verrez le résultat suivant -

Types d'annotations Struts 2

Les applications Struts 2 peuvent utiliser les annotations Java 5 comme alternative à la configuration des propriétés XML et Java. Vous pouvez consulter la liste des annotations les plus importantes liées aux différentes catégories -

Types d'annotations Struts 2 .

Les balises Struts 2 ont un ensemble de balises qui facilite le contrôle du flux d'exécution de la page.

Voici la liste des balises de contrôle Struts 2 importantes -

Les balises If et Else

Ces balises exécutent le flux de conditions de base trouvé dans chaque langue.

'If' la balise est utilisée seule ou avec 'Else If' Tag et / ou simple / multiple 'Else' Tag comme indiqué ci-dessous -

<s:if test = "%{false}">
   <div>Will Not Be Executed</div>
</s:if>

<s:elseif test = "%{true}">
   <div>Will Be Executed</div>
</s:elseif>

<s:else>
   <div>Will Not Be Executed</div>
</s:else>

Vérifier l'exemple détaillé

Les balises Iterator

Ce iteratoritérera sur une valeur. Une valeur itérative peut être un fichier itherjava.util.Collection ou java.util.Iterator. Lors de l'itération sur un itérateur, vous pouvez utiliserSort tag pour trier le résultat ou SubSet tag pour obtenir un sous-ensemble de la liste ou du tableau.

L'exemple suivant récupère la valeur de la méthode getDays () de l'objet actuel sur la pile de valeurs et l'utilise pour effectuer une itération.

La balise <s: property /> imprime la valeur actuelle de l'itérateur.

<s:iterator value = "days">
   <p>day is: <s:property/></p>
</s:iterator>

Vérifier l'exemple détaillé

La balise de fusion

Celles-ci merge La balise prend deux listes ou plus comme paramètres et les fusionne toutes ensemble comme indiqué ci-dessous -

<s:merge var = "myMergedIterator">
   <s:param value = "%{myList1}" />
   <s:param value = "%{myList2}" />
   <s:param value = "%{myList3}" />
</s:merge>

<s:iterator value = "%{#myMergedIterator}">
   <s:property />
</s:iterator>

Vérifier l'exemple détaillé

La balise Ajouter

Celles-ci append tag prend deux listes ou plus comme paramètres et les ajoute toutes ensemble comme indiqué ci-dessous -

<s:append var = "myAppendIterator">
   <s:param value = "%{myList1}" />
   <s:param value = "%{myList2}" />
   <s:param value = "%{myList3}" />
</s:append>

<s:iterator value = "%{#myAppendIterator}">
   <s:property />
</s:iterator>

Vérifier l'exemple détaillé

L'étiquette du générateur

Celles-ci generatortag génère un itérateur basé sur l'attribut val fourni. La balise de générateur suivante génère un itérateur et l'imprime à l'aide de la balise iterator.

<s:generator val = "%{'aaa,bbb,ccc,ddd,eee'}">
   <s:iterator>
      <s:property /><br/>
   </s:iterator>
</s:generator>

Vérifier l'exemple détaillé

Les Struts 2 data tagssont principalement utilisés pour manipuler les données affichées sur une page. Vous trouverez ci-dessous les balises de données importantes: <Commencez ici>

La balise d'action

Cette balise permet aux développeurs d'appeler des actions directement à partir d'une page JSP en spécifiant le nom de l'action et un espace de noms facultatif. Le contenu du corps de la balise est utilisé pour rendre les résultats de l'action. Tout processeur de résultats défini pour cette action dans struts.xml sera ignoré, sauf si le paramètre executeResult est spécifié.

<div>Tag to execute the action</div>
<br />
<s:action name = "actionTagAction" executeresult = "true" />
<br />
<div>To invokes special method  in action class</div>
<br />
<s:action name = "actionTagAction!specialMethod" executeresult = "true" />

Vérifier l'exemple détaillé

La balise Inclure

Celles-ci include sera utilisé pour inclure un fichier JSP dans une autre page JSP.

<-- First Syntax -->
<s:include value = "myJsp.jsp" />

<-- Second Syntax -->
<s:include value = "myJsp.jsp">
   <s:param name = "param1" value = "value2" />
   <s:param name = "param2" value = "value2" />
</s:include>

<-- Third Syntax -->
<s:include value = "myJsp.jsp">
   <s:param name = "param1">value1</s:param>
   <s:param name = "param2">value2</s:param>
</s:include>

Vérifier l'exemple détaillé

Le Bean Tag

Celles-ci beantag instancie une classe conforme à la spécification JavaBeans. Cette balise a un corps qui peut contenir un certain nombre d'éléments Param pour définir toutes les méthodes de mutation sur cette classe. Si l'attribut var est défini sur le BeanTag, il placera le bean instancié dans le contexte de la pile.

<s:bean name = "org.apache.struts2.util.Counter" var = "counter">
   <s:param name = "first" value = "20"/>
   <s:param name = "last" value = "25" />
</s:bean>

Vérifier l'exemple détaillé

L'étiquette de date

Celles-ci dateLa balise vous permettra de formater une date de manière simple et rapide. Vous pouvez spécifier un format personnalisé (par exemple "jj / MM / aaaa hh: mm"), vous pouvez générer des notations faciles à lire (comme "dans 2 heures, 14 minutes"), ou vous pouvez simplement vous rabattre sur un format prédéfini avec clé 'struts.date.format' dans votre fichier de propriétés.

<s:date name = "person.birthday" format = "dd/MM/yyyy" />
<s:date name = "person.birthday" format = "%{getText('some.i18n.key')}" />
<s:date name = "person.birthday" nice="true" />
<s:date name = "person.birthday" />

Vérifier l'exemple détaillé

La balise Param

Celles-ci paramtag peut être utilisé pour paramétrer d'autres tags. Cette balise a les deux paramètres suivants.

name (String) - le nom du paramètre
value (Object) - la valeur du paramètre

<pre>
   <ui:component>
      <ui:param name = "key"     value = "[0]"/>
      <ui:param name = "value"   value = "[1]"/>
      <ui:param name = "context" value = "[2]"/>
   </ui:component>
</pre>

Vérifier l'exemple détaillé

L'étiquette de propriété

Celles-ci property tag est utilisé pour obtenir la propriété d'une valeur, qui se placera par défaut en haut de la pile si aucune n'est spécifiée.

<s:push value = "myBean">
   <!-- Example 1: -->
   <s:property value = "myBeanProperty" />

   <!-- Example 2: -->TextUtils
   <s:property value = "myBeanProperty" default = "a default value" />
</s:push>

Vérifier l'exemple détaillé

Le Push Tag

Celles-ci push La balise est utilisée pour pousser la valeur sur la pile pour une utilisation simplifiée.

<s:push value = "user">
   <s:propery value = "firstName" />
   <s:propery value = "lastName" />
</s:push>

Vérifier l'exemple détaillé

La balise Set

Celles-ci settag assigne une valeur à une variable dans une portée spécifiée. Il est utile lorsque vous souhaitez affecter une variable à une expression complexe, puis référencer simplement cette variable à chaque fois plutôt que l'expression complexe. Les portées disponibles sontapplication, session, request, page et action.

<s:set name = "myenv" value = "environment.name"/>
<s:property value = "myenv"/>

Vérifier l'exemple détaillé

La balise de texte

Celles-ci text La balise est utilisée pour rendre un message texte I18n.

<!-- First Example -->
<s:i18n name = "struts.action.test.i18n.Shop">
   <s:text name = "main.title"/>
</s:i18n>

<!-- Second Example -->
<s:text name = "main.title" />

<!-- Third Examlpe -->
<s:text name = "i18n.label.greetings">
   <s:param >Mr Smith</s:param>
</s:text>

Vérifier l'exemple détaillé

La balise URL

Celles-ci url La balise est utilisée pour créer une URL.

<-- Example 1 -->
<s:url value = "editGadget.action">
   <s:param name = "id" value = "%{selected}" />
</s:url>

<-- Example 2 -->
<s:url action = "editGadget">
   <s:param name = "id" value = "%{selected}" />
</s:url>

<-- Example 3-->
<s:url includeParams="get">
   <s:param name = "id" value = "%{'22'}" />
</s:url>

Vérifier l'exemple détaillé

La liste de formbalises est un sous-ensemble de balises d'interface utilisateur Struts. Ces balises aident au rendu de l'interface utilisateur requise pour les applications Web Struts et peuvent être classées en trois catégories. Ce chapitre vous présentera les trois types de balises d'interface utilisateur -

Balises d'interface utilisateur simples

Nous avons déjà utilisé ces balises dans nos exemples, nous les brosserons dans ce chapitre. Regardons une page de vue simpleemail.jsp avec plusieurs balises d'interface utilisateur simples -

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <s:head/>
      <title>Hello World</title>
   </head>
   
   <body>
      <s:div>Email Form</s:div>
      <s:text name = "Please fill in the form below:" />
      
      <s:form action = "hello" method = "post" enctype = "multipart/form-data">
         <s:hidden name = "secret" value = "abracadabra"/>
         <s:textfield key = "email.from" name = "from" />
         <s:password key = "email.password" name = "password" />
         <s:textfield key = "email.to" name = "to" />
         <s:textfield key = "email.subject" name = "subject" />
         <s:textarea key = "email.body" name = "email.body" />
         <s:label for = "attachment" value = "Attachment"/>
         <s:file name = "attachment" accept = "text/html,text/plain" />
         <s:token />
         <s:submit key = "submit" />
      </s:form>
      
   </body>
</html>

Si vous connaissez HTML, toutes les balises utilisées sont des balises HTML très courantes avec un préfixe supplémentaire s:avec chaque balise et différents attributs. Lorsque nous exécutons le programme ci-dessus, nous obtenons l'interface utilisateur suivante à condition que vous ayez configuré le mappage approprié pour toutes les clés utilisées.

Comme indiqué, le s: head génère les éléments javascript et la feuille de style requis pour l'application Struts2.

Ensuite, nous avons les éléments s: div et s: text. Le s: div est utilisé pour rendre un élément HTML Div. Ceci est utile pour les personnes qui n'aiment pas mélanger les balises HTML et Struts. Pour ces personnes, ils ont le choix d'utiliser s: div pour rendre un div.

Le s: texte comme indiqué est utilisé pour rendre un texte à l'écran.

Ensuite, nous avons la balise famiilar s: form. La balise s: form a un attribut d'action qui détermine où envoyer le formulaire. Étant donné que nous avons un élément de téléchargement de fichier dans le formulaire, nous devons définir l'enctype sur multipart. Sinon, nous pouvons laisser ce champ vide.

À la fin de la balise form, nous avons la balise s: submit. Ceci est utilisé pour soumettre le formulaire. Lorsque le formulaire est soumis, toutes les valeurs du formulaire sont soumises à l'action spécifiée dans la balise s: form.

À l'intérieur du formulaire s:, nous avons un attribut caché appelé secret. Cela rend un élément caché dans le HTML. Dans notre cas, l'élément "secret" a la valeur "abracadabra". Cet élément n'est pas visible par l'utilisateur final et est utilisé pour transporter l'état d'une vue à une autre.

Ensuite, nous avons les balises s: label, s: textfield, s: password et s: textarea. Ceux-ci sont utilisés pour rendre respectivement l'étiquette, le champ de saisie, le mot de passe et la zone de texte. Nous les avons vus en action dans l'exemple "Struts - Envoi d'e-mails".

La chose importante à noter ici est l'utilisation de l'attribut "clé". L'attribut "key" est utilisé pour récupérer le libellé de ces contrôles à partir du fichier de propriétés. Nous avons déjà couvert cette fonctionnalité dans le chapitre sur la localisation de Struts2, l'internationalisation.

Ensuite, nous avons la balise s: file qui rend un composant de téléchargement de fichier d'entrée. Ce composant permet à l'utilisateur de télécharger des fichiers. Dans cet exemple, nous avons utilisé le paramètre "accept" de la balise s: file pour spécifier les types de fichiers autorisés à être téléchargés.

Enfin, nous avons la balise s: token. La balise de jeton génère un jeton unique qui est utilisé pour savoir si un formulaire a été soumis deux fois

Lorsque le formulaire est rendu, une variable masquée est placée comme valeur de jeton. Disons, par exemple, que le jeton est "ABC". Lorsque ce formulaire est soumis, Struts Fitler vérifie le jeton par rapport au jeton stocké dans la session. S'il correspond, il supprime le jeton de la session. Maintenant, si le formulaire est renvoyé accidentellement (soit en actualisant, soit en appuyant sur le bouton Précédent du navigateur), le formulaire sera de nouveau soumis avec "ABC" comme jeton. Dans ce cas, le filtre vérifie à nouveau le jeton par rapport au jeton stocké dans la session. Mais comme le jeton "ABC" a été supprimé de la session, il ne correspondra pas et le filtre Struts rejettera la demande.

Balises de l'interface utilisateur de groupe

Les balises d'interface utilisateur de groupe sont utilisées pour créer le bouton radio et la case à cocher. Regardons une page de vue simpleHelloWorld.jsp avec des étiquettes de case à cocher et de bouton radio -

<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>

<html>
   <head>
      <title>Hello World</title>
      <s:head />
   </head>
   
   <body>
      <s:form action = "hello.action">
         <s:radio label = "Gender" name = "gender" list="{'male','female'}" />
         <s:checkboxlist label = "Hobbies" name = "hobbies"
         list = "{'sports','tv','shopping'}" />
      </s:form>
      
   </body>
</html>

Lorsque nous exécutons le programme ci-dessus, notre sortie ressemblera à ce qui suit -

Regardons maintenant l'exemple. Dans le premier exemple, nous créons un simple bouton radio avec le libellé "Genre". L'attribut name est obligatoire pour la balise de bouton radio, nous spécifions donc un nom qui est "gender". Nous fournissons ensuite une liste au genre. La liste contient les valeurs «homme» et «femme». Par conséquent, dans la sortie, nous obtenons un bouton radio avec deux valeurs.

Dans le deuxième exemple, nous créons une liste de cases à cocher. Il s'agit de rassembler les passe-temps de l'utilisateur. L'utilisateur peut avoir plus d'un passe-temps et c'est pourquoi nous utilisons la case à cocher au lieu du bouton radio. La case à cocher contient la liste "sports", "TV" et "Shopping". Cela présente les loisirs sous forme de liste de cases à cocher.

Sélectionnez les balises d'interface utilisateur

Explorons les différentes variantes du Select Tag proposées par Struts. Regardons une page de vue simpleHelloWorld.jsp avec des balises sélectionnées -

<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>

<html>
   <head>
      <title>Hello World</title>
      <s:head />
   </head>
   
   <body>
      <s:form action = "login.action">
         <s:select name = "username" label = "Username"
            list = "{'Mike','John','Smith'}" />

         <s:select label = "Company Office" name = "mySelection"
            value = "%{'America'}" list="%{#{'America':'America'}}">
            <s:optgroup label = "Asia" 
               list = "%{#{'India':'India','China':'China'}}" />
            <s:optgroup label = "Europe"
               list="%{#{'UK':'UK','Sweden':'Sweden','Italy':'Italy'}}" />
         </s:select>

         <s:combobox label = "My Sign" name = "mySign"
            list = "#{'aries':'aries','capricorn':'capricorn'}" headerkey = "-1" 
            headervalue = "--- Please Select ---" emptyOption = "true" value = "capricorn" />
         <s:doubleselect label = "Occupation" name = "occupation"
            list = "{'Technical','Other'}" doublename = "occupations2"
            doubleList="top == 'Technical' ? 
            {'I.T', 'Hardware'} : {'Accounting', 'H.R'}" />
      </s:form>
   </body>
</html>

Lorsque nous exécutons le programme ci-dessus, notre sortie ressemblera à ce qui suit -

Passons maintenant en revue les cas individuels, un par un.

Tout d'abord, la balise de sélection rend la zone de sélection HTML. Dans le premier exemple, nous créons une simple boîte de sélection avec le nom "username" et le libellé "username". La boîte de sélection sera remplie avec une liste qui contient les noms Mike, John et Smith.
Dans le deuxième exemple, notre société a des sièges sociaux en Amérique. Elle possède également des bureaux mondiaux en Asie et en Europe. Nous voulons afficher les bureaux dans une boîte de sélection mais nous voulons regrouper les bureaux mondiaux par le nom du continent. C'est là que l'optgroup est utile. Nous utilisons la balise s: optgroup pour créer un nouveau groupe. Nous donnons au groupe une étiquette et une liste séparée.
Dans le troisième exemple, la zone de liste déroulante est utilisée. Une zone de liste déroulante est une combinaison d'un champ de saisie et d'une zone de sélection. L'utilisateur peut soit sélectionner une valeur dans la zone de sélection, auquel cas le champ de saisie est automatiquement rempli avec la valeur sélectionnée par l'utilisateur. Si l'utilisateur saisit directement une valeur, aucune valeur de la zone de sélection ne sera sélectionnée.
Dans notre exemple, nous avons la liste déroulante listant les signes solaires. La boîte de sélection ne répertorie que quatre entrées permettant à l'utilisateur de saisir son signe solaire s'il ne figure pas dans la liste. Nous ajoutons également une entrée d'en-tête à la boîte de sélection. L'entrée d'en-tête est celle qui s'affiche en haut de la zone de sélection. Dans notre cas, nous voulons afficher "Veuillez sélectionner". Si l'utilisateur ne sélectionne rien, alors nous supposons -1 comme valeur. Dans certains cas, nous ne voulons pas que l'utilisateur sélectionne une valeur vide. Dans ces conditions, on définirait la propriété "emptyOption" sur false. Enfin, dans notre exemple, nous fournissons "capricorn" comme valeur par défaut pour la liste déroulante.
Dans le quatrième exemple, nous avons une double sélection. Une double sélection est utilisée lorsque vous souhaitez afficher deux boîtes de sélection. La valeur sélectionnée dans la première zone de sélection détermine ce qui apparaît dans la seconde zone de sélection. Dans notre exemple, la première boîte de sélection affiche «Technique» et «Autre». Si l'utilisateur sélectionne Technique, nous afficherons IT et matériel dans la deuxième case de sélection. Sinon, nous afficherons Comptabilité et RH. Ceci est possible en utilisant les attributs "list" et "doubleList" comme indiqué dans l'exemple.

Dans l'exemple ci-dessus, nous avons effectué une comparaison pour voir si la zone de sélection supérieure correspond à Technique. Si c'est le cas, nous affichons l'informatique et le matériel.

Nous devons également donner un nom à la case du haut ("name = 'Occupations') et à la case du bas (doubleName = 'occupations2')

Struts utilise le framework DOJO pour l'implémentation des balises AJAX. Tout d'abord, pour continuer avec cet exemple, vous devez ajouter struts2-dojo-plugin-2.2.3.jar à votre chemin de classe.

Vous pouvez obtenir ce fichier dans le dossier lib de votre téléchargement struts2 (C: \ struts-2.2.3all \ struts-2.2.3 \ lib \ struts2-dojo-plugin-2.2.3.jar)

Pour ces exercices, modifions HelloWorld.jsp comme suit -

<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<%@ taglib prefix = "sx" uri = "/struts-dojo-tags"%>

<html>
   <head>
      <title>Hello World</title>
      <s:head />
      <sx:head />
   </head>
   
   <body>
      <s:form>
         <sx:autocompleter label = "Favourite Colour"
            list = "{'red','green','blue'}" />
         <br />
         <sx:datetimepicker name = "deliverydate" label = "Delivery Date"
            displayformat = "dd/MM/yyyy" />
         <br />
         <s:url id = "url" value = "/hello.action" />
         <sx:div href="%{#url}" delay="2000">
            Initial Content
         </sx:div>
         <br/>
         <sx:tabbedpanel id = "tabContainer">
            <sx:div label = "Tab 1">Tab 1</sx:div>
            <sx:div label = "Tab 2">Tab 2</sx:div>
         </sx:tabbedpanel>
      </s:form>
   </body>
</html>

Lorsque nous exécutons l'exemple ci-dessus, nous obtenons la sortie suivante -

Passons maintenant en revue cet exemple étape par étape.

La première chose à noter est l'ajout d'une nouvelle bibliothèque de balises avec le préfixe sx. Ceci (struts-dojo-tags) est la bibliothèque de balises spécialement créée pour l'intégration ajax.

Ensuite, à l'intérieur de la tête HTML, nous appelons le sx: head. Cela initialise le framework dojo et le rend prêt pour toutes les invocations AJAX dans la page. Cette étape est importante - vos appels ajax ne fonctionneront pas sans l'initialisation du sx: head.

Nous avons d'abord la balise de saisie semi-automatique. La balise de saisie semi-automatique ressemble à peu près à une zone de sélection. Il est renseigné avec les valeurs rouge, vert et bleu. Mais la différence entre une boîte de sélection et celle-ci est qu'elle se complète automatiquement. Autrement dit, si vous commencez à taper gr, il le remplira de "vert". À part cela, cette balise est très similaire à la balise s: select que nous avons abordée précédemment.

Ensuite, nous avons un sélecteur de date et d'heure. Cette balise crée un champ de saisie avec un bouton à côté. Lorsque vous appuyez sur le bouton, un sélecteur de date et d'heure s'affiche. Lorsque l'utilisateur sélectionne une date, la date est renseignée dans le texte d'entrée dans le format spécifié dans l'attribut de balise. Dans notre exemple, nous avons spécifié jj / MM / aaaa comme format de la date.

Ensuite, nous créons une balise url dans le fichier system.action que nous avons créé dans les exercices précédents. Il n'est pas nécessaire que ce soit le system.action - il peut s'agir de n'importe quel fichier d'action que vous avez créé précédemment. Ensuite, nous avons un div avec le lien hypertexte défini sur l'url et le délai défini sur 2 secondes. Ce qui se passe lorsque vous exécutez ceci, c'est que le "Contenu initial" sera affiché pendant 2 secondes, puis le contenu de la div sera remplacé par le contenu duhello.action exécution.

Enfin, nous avons un panneau d'onglets simple avec deux onglets. Les onglets sont divs eux-mêmes avec les étiquettes Tab 1 et Tab2.

Il convient de noter que l'intégration des balises AJAX dans Struts est toujours un travail en cours et que la maturité de cette intégration augmente lentement à chaque version.

Spring est un framework Web populaire qui permet une intégration facile avec de nombreuses tâches Web courantes. La question est donc: pourquoi avons-nous besoin de Spring lorsque nous avons Struts2? Eh bien, Spring est plus qu'un framework MVC - il offre de nombreux autres goodies qui ne sont pas disponibles dans Struts.

Par exemple: injection de dépendances qui peut être utile à n'importe quel framework. Dans ce chapitre, nous allons passer par un exemple simple pour voir comment intégrer Spring et Struts2 ensemble.

Tout d'abord, vous devez ajouter les fichiers suivants au chemin de construction du projet à partir de l'installation de Spring. Vous pouvez télécharger et installer la dernière version de Spring Framework à partir dehttps://www.springsource.org/download

org.springframework.asm-x.y.z.M(a).jar
org.springframework.beans-x.y.z.M(a).jar
org.springframework.context-x.y.z.M(a).jar
org.springframework.core-x.y.z.M(a).jar
org.springframework.expression-x.y.z.M(a).jar
org.springframework.web-x.y.z.M(a).jar
org.springframework.web.servlet-x.y.z.M(a).jar

Enfin ajouter struts2-spring-plugin-x.y.z.jar dans ton WEB-INF/libà partir de votre répertoire struts lib. Si vous utilisez Eclipse, vous pouvez être confronté à une exception java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderListener .

Pour résoudre ce problème, vous devriez avoir à entrer Markeronglet et cliquez avec le bouton droit sur les dépendances de classe une par une et effectuez une correction rapide pour publier / exporter toutes les dépendances. Enfin, assurez-vous qu'il n'y a pas de conflit de dépendance disponible sous l'onglet marqueur.

Maintenant, laissez-nous configurer le web.xml pour l'intégration Struts-Spring comme suit -

<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns = "http://java.sun.com/xml/ns/javaee" 
   xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee 
   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   id = "WebApp_ID" version = "3.0">
	
   <display-name>Struts 2</display-name>
   
   <welcome-file-list>
      <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>

   <listener>
      <listener-class>
         org.springframework.web.context.ContextLoaderListener
      </listener-class>
   </listener>

   <filter>
      <filter-name>struts2</filter-name>
      <filter-class>
         org.apache.struts2.dispatcher.FilterDispatcher
      </filter-class>
   </filter>

   <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
   </filter-mapping>
</web-app>

La chose importante à noter ici est l'auditeur que nous avons configuré. leContextLoaderListenerest nécessaire pour charger le fichier de contexte Spring. Le fichier de configuration de Spring est appeléapplicationContext.xml fichier et il doit être placé au même niveau que le web.xml fichier

Créons une classe d'action simple appelée User.java avec deux propriétés - firstName et lastName.

package com.tutorialspoint.struts2;

public class User {
   private String firstName;
   private String lastName;

   public String execute() {
      return "success";
   }

   public String getFirstName() {
      return firstName;
   }

   public void setFirstName(String firstName) {
      this.firstName = firstName;
   }

   public String getLastName() {
      return lastName;
   }

   public void setLastName(String lastName) {
      this.lastName = lastName;
   }
}

Maintenant, créons le applicationContext.xml spring et instanciez le User.javaclasse. Comme mentionné précédemment, ce fichier doit se trouver dans le dossier WEB-INF -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" 
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
   <bean id = "userClass" class = "com.tutorialspoint.struts2.User">
      <property name = "firstName" value = "Michael" />
      <property name = "lastName" value = "Jackson" />
   </bean>
</beans>

Comme vu ci-dessus, nous avons configuré le bean utilisateur et nous avons injecté les valeurs Michael et Jacksondans le haricot. Nous avons également donné à ce bean un nom "userClass", afin de pouvoir le réutiliser ailleurs. Ensuite, créons leUser.jsp dans le dossier WebContent -

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>Hello World</title>
   </head>
   
   <body>
      <h1>Hello World From Struts2 - Spring integration</h1>

      <s:form>
         <s:textfield name = "firstName" label = "First Name"/><br/>
         <s:textfield name = "lastName" label = "Last Name"/><br/>
      </s:form>
      
   </body>
</html>

le User.jsple fichier est assez simple. Il n'a qu'un seul objectif: afficher les valeurs du prénom et du nom de l'objet utilisateur. Enfin, rassemblons toutes les entités en utilisant lestruts.xml fichier.

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "helloworld" extends = "struts-default">
      <action name = "user" class="userClass" 
         method = "execute">
         <result name = "success">/User.jsp</result>
      </action>
   </package>
</struts>

La chose importante à noter est que nous utilisons l'identifiant userClasspour faire référence à la classe. Cela signifie que nous utilisons spring pour effectuer l'injection de dépendances pour la classe User.

Nous avons maintenant vu comment réunir deux grands cadres. Ceci conclut le chapitre sur l'intégration de Struts - Spring.

Dans ce chapitre, passons en revue les étapes de l'intégration du framework Tiles avec Struts2. Apache Tiles est un framework de modèles conçu pour simplifier le développement d'interfaces utilisateur d'applications Web.

Tout d'abord, nous devons télécharger les fichiers jar tiles depuis le site Web Apache Tiles . Vous devez ajouter les fichiers jar suivants au chemin de classe du projet.

tiles-api-x.y.z.jar
tiles-compat-x.y.z.jar
tiles-core-x.y.z.jar
tiles-jsp-x.y.z.jar
tiles-servlet-x.y.z.jar

En plus de ce qui précède, nous devons copier les fichiers jar suivants du téléchargement struts2 dans votre WEB-INF/lib.

commons-beanutils-x.y.zjar
commons-digester-x.y.jar
struts2-tiles-plugin-x.y.z.jar

Maintenant, laissez-nous configurer le web.xmlpour l'intégration Struts-Tiles comme indiqué ci-dessous. Il y a deux points importants à noter ici. Tout d'abord, nous devons indiquer aux tuiles, où trouver le fichier de configuration des tuilestiles.xml. Dans notre cas, ce sera sous/WEB-INFdossier. Ensuite, nous devons lancer l'écouteur Tiles fourni avec le téléchargement de Struts2.

<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns = "http://java.sun.com/xml/ns/javaee" 
   xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee 
   http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   id = "WebApp_ID" version = "2.5">
   <display-name>Struts2Example15</display-name>
	
   <context-param>
      <param-name>
         org.apache.tiles.impl.BasicTilesContainer.DEFINITIONS_CONFIG
      </param-name>
      
      <param-value>
         /WEB-INF/tiles.xml
      </param-value>
   </context-param>

   <listener>
      <listener-class>
         org.apache.struts2.tiles.StrutsTilesListener
      </listener-class>
   </listener>

   <filter>
      <filter-name>struts2</filter-name>
      <filter-class>
         org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
      </filter-class>
   </filter>

   <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
   </filter-mapping>

   <welcome-file-list>
      <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>
</web-app>

Ensuite, créons tiles.xml sous le dossier / WEB-INF avec le contenu suivant -

<?xml version = "1.0" Encoding = "UTF-8" ?>

<!DOCTYPE tiles-definitions PUBLIC
   "-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN"
   "http://tiles.apache.org/dtds/tiles-config_2_0.dtd">

<tiles-definitions>

   <definition name = "baseLayout" template="/baseLayout.jsp">
      <put-attribute name = "title"  value = "Template"/>
      <put-attribute name = "banner" value = "/banner.jsp"/>
      <put-attribute name = "menu"   value = "/menu.jsp"/>
      <put-attribute name = "body"   value = "/body.jsp"/>
      <put-attribute name = "footer"   value = "/footer.jsp"/>
   </definition>

   <definition name = "tiger" extends = "baseLayout">
      <put-attribute name = "title"  value = "Tiger"/>
      <put-attribute name = "body"   value = "/tiger.jsp"/>      
   </definition>

   <definition name = "lion" extends = "baseLayout">
      <put-attribute name = "title"  value = "Lion"/>
      <put-attribute name = "body"   value = "/lion.jsp"/>      
   </definition>
  
</tiles-definitions>

Ensuite, nous définissons une disposition de squelette de base dans le baseLayout.jsp. Il a cinq zones réutilisables / remplaçables. À savoirtitle, banner, menu, body et footer. Nous fournissons les valeurs par défaut pour baseLayout, puis nous créons deux personnalisations qui s'étendent à partir de la disposition par défaut. La disposition du tigre est similaire à la disposition de base, sauf qu'elle utilisetiger.jspcomme son corps et le texte "Tiger" comme titre. De même, la disposition du lion est similaire à la disposition de base, sauf qu'elle utilise lelion.jsp comme son corps et le texte "Lion" comme titre.

Jetons un coup d'œil aux fichiers jsp individuels. Voici le contenu debaseLayout.jsp fichier -

<%@ taglib uri = "http://tiles.apache.org/tags-tiles" prefix = "tiles"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <meta http-equiv="Content-Type" content="text/html; charset = UTF-8">
      <title>
         <tiles:insertAttribute name = "title" ignore="true" />
      </title>
   </head>

   <body>
      <tiles:insertAttribute name = "banner" /><br/>
      <hr/>
      <tiles:insertAttribute name = "menu" /><br/>
      <hr/>
      <tiles:insertAttribute name = "body" /><br/>
      <hr/>
      <tiles:insertAttribute name = "footer" /><br/>
   </body>
</html>

Ici, nous venons de créer une page HTML de base qui a les attributs de tuiles. Nous insérons les attributs de tuiles aux endroits où nous en avons besoin. Ensuite, créons unbanner.jsp fichier avec le contenu suivant -

<img src="http://www.tutorialspoint.com/images/tp-logo.gif"/>

le menu.jsp Le fichier aura les lignes suivantes qui sont les liens - vers les actions TigerMenu.action et LionMenu.action struts.

<%@taglib uri = "/struts-tags" prefix = "s"%>

<a href = "<s:url action = "tigerMenu"/>" Tiger</a><br>
<a href = "<s:url action = "lionMenu"/>" Lion</a><br>

le lion.jsp le fichier aura le contenu suivant -

<img src="http://upload.wikimedia.org/wikipedia/commons/d/d2/Lion.jpg"/>
The lion

le tiger.jsp le fichier aura le contenu suivant -

<img src="http://www.freewebs.com/tigerofdarts/tiger.jpg"/>
The tiger

Ensuite, créons le fichier de classe d'action MenuAction.java qui contient ce qui suit -

package com.tutorialspoint.struts2;

import com.opensymphony.xwork2.ActionSupport;

public class MenuAction extends ActionSupport {
   public String tiger() { return "tiger"; }
   public String lion() { return "lion"; }
}

C'est une classe assez simple. Nous avons déclaré deux méthodes tiger () et lion () qui renvoient respectivement le tigre et le lion. Mettons tout cela ensemble dans lestruts.xml fichier -

<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <package name = "default" extends = "struts-default">
      <result-types>
         <result-type name = "tiles" 
         class="org.apache.struts2.views.tiles.TilesResult" />
      </result-types>

      <action name = "*Menu" method = "{1}" 
         class = "com.tutorialspoint.struts2.MenuAction">
         <result name = "tiger" type = "tiles">tiger</result>
         <result name = "lion" type = "tiles">lion</result>
      </action>

   </package>
</struts>

Laissez-nous vérifier ce que nous avons fait dans le fichier ci-dessus. Tout d'abord, nous avons déclaré un nouveau type de résultat appelé "tiles" car nous utilisons maintenant des tiles au lieu de plain jsp pour la technologie d'affichage. Struts2 prend en charge le type de résultat Tiles View, nous créons donc le type de résultat "tiles" pour qu'il appartienne à la classe "org.apache.struts2.view.tiles.TilesResult".

Ensuite, nous voulons dire si la demande est pour /tigerMenu.action amenez l'utilisateur à la page des tuiles de tigre et si la demande est pour /lionMenu.action amène l'utilisateur à la page des tuiles de lion.

Nous y parvenons en utilisant un peu d'expression régulière. Dans notre définition d'action, nous disons que tout ce qui correspond au modèle "* Menu" sera traité par cette action. La méthode correspondante sera appelée dans la classe MenuAction. Autrement dit, tigerMenu.action invoquera tiger () et lionMenu.action invoquera lion (). Nous devons ensuite mapper le résultat du résultat sur les pages de tuiles appropriées.

De même, si vous accédez à la page lionMenu.action, vous verrez la page lion qui utilise la même disposition de tuiles.

Hibernate est un service de persistance et de requête objet / relationnel haute performance qui est sous licence open source GNU Lesser General Public License (LGPL) et est téléchargeable gratuitement. Dans ce chapitre. nous allons apprendre comment réaliser l'intégration de Struts 2 avec Hibernate. Si vous n'êtes pas familier avec Hibernate, vous pouvez consulter notre didacticiel Hibernate .

Configuration de la base de données

Pour ce tutoriel, je vais utiliser la base de données MySQL "struts2_tutorial". Je me connecte à cette base de données sur ma machine en utilisant le nom d'utilisateur "root" et aucun mot de passe. Tout d'abord, vous devez exécuter le script suivant. Ce script crée une nouvelle table appeléestudent et crée quelques enregistrements dans ce tableau -

CREATE TABLE IF NOT EXISTS `student` (
   `id` int(11) NOT NULL AUTO_INCREMENT,
   `first_name` varchar(40) NOT NULL,
   `last_name` varchar(40) NOT NULL,
   `marks` int(11) NOT NULL,
   PRIMARY KEY (`id`)
);

--
-- Dumping data for table `student`
--

INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
   VALUES(1, 'George', 'Kane', 20);
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
   VALUES(2, 'Melissa', 'Michael', 91);
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
   VALUES(3, 'Jessica', 'Drake', 21);

Configuration de la mise en veille prolongée

Ensuite, créons le hibernate.cfg.xml qui est le fichier de configuration de l'hibernate.

<?xml version = '1.0' encoding = 'utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
   "-//Hibernate/Hibernate Configuration DTD//EN"
   "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
   <session-factory>
      <property name = "hibernate.connection.driver_class">c
         om.mysql.jdbc.Driver
      </property>
      
      <property name = "hibernate.connection.url">
         jdbc:mysql://www.tutorialspoint.com/struts_tutorial
      </property>
      
      <property name = "hibernate.connection.username">root</property>
      
      <property name = "hibernate.connection.password"></property>
      
      <property name = "hibernate.connection.pool_size">10</property>
      
      <property name = "show_sql">true</property>
      
      <property name = "dialect">
         org.hibernate.dialect.MySQLDialect
      </property>
      
      <property name = "hibernate.hbm2ddl.auto">update</property>
      
      <mapping class = "com.tutorialspoint.hibernate.Student" />
   </session-factory>
</hibernate-configuration>

Passons en revue le fichier de configuration d'hibernation. Tout d'abord, nous avons déclaré que nous utilisons le pilote MySQL. Ensuite, nous avons déclaré l'url jdbc pour la connexion à la base de données. Ensuite, nous avons déclaré le nom d'utilisateur, le mot de passe et la taille du pool de la connexion. Nous avons également indiqué que nous aimerions voir le SQL dans le fichier journal en activant "show_sql" sur true. Veuillez parcourir le didacticiel de mise en veille prolongée pour comprendre ce que signifient ces propriétés.

Enfin, nous définissons la classe de mappage sur com.tutorialspoint.hibernate.Student que nous créerons dans ce chapitre.

Configuration de l'environnement

Ensuite, vous avez besoin de beaucoup de pots pour ce projet. Vous trouverez ci-joint une capture d'écran de la liste complète des fichiers JAR requis -

La plupart des fichiers JAR peuvent être obtenus dans le cadre de votre distribution struts. Si vous avez un serveur d'applications tel que glassfish, websphere ou jboss installé, vous pouvez obtenir la majorité des fichiers jar restants à partir du dossier lib du serveur d'applications. Sinon, vous pouvez télécharger les fichiers individuellement -

Fichiers JAR Hibernate - Hibernate.org
Plugin Hibernate Struts - Plugin Hibernate Struts
Fichiers JTA - fichiers JTA
Fichiers Dom4j - Dom4j
fichiers log4j - log4j

Reste des fichiers, vous devriez pouvoir obtenir de votre distribution Struts2.

Classes Hibernate

Créons maintenant les classes Java requises pour l'intégration hibernate. Voici le contenu deStudent.java -

package com.tutorialspoint.hibernate;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "student")
public class Student {
	
   @Id
   @GeneratedValue
   private int id;
   @Column(name = "last_name")
   private String lastName;
   @Column(name = "first_name")
   private String firstName;
   private int marks;
   
   public int getId() {
    return id;
   }
   
   public void setId(int id) {
    this.id = id;
   }
   
   public String getLastName() {
      return lastName;
   }
   
   public void setLastName(String lastName) {
      this.lastName = lastName;
   }
   
   public String getFirstName() {
      return firstName;
   }
   
   public void setFirstName(String firstName) {
      this.firstName = firstName;
   }
   
   public int getMarks() {
      return marks;
   }
   
   public void setMarks(int marks) {
      this.marks = marks;
   }
}

Il s'agit d'une classe POJO qui représente le studenttable selon les spécifications Hibernate. Il a les propriétés id, firstName et lastName qui correspondent aux noms de colonne de la table Student. Ensuite, créonsStudentDAO.java fichier comme suit -

package com.tutorialspoint.hibernate;

import java.util.ArrayList;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.googlecode.s2hibernate.struts2.plugin.\
   annotations.SessionTarget;
import com.googlecode.s2hibernate.struts2.plugin.\
   annotations.TransactionTarget;

public class StudentDAO {
	
   @SessionTarget
   Session session;

   @TransactionTarget
   Transaction transaction;

   @SuppressWarnings("unchecked")
   public List<Student> getStudents() {
      List<Student> students = new ArrayList<Student>();
      
      try {
         students = session.createQuery("from Student").list();
      } catch(Exception e) {
         e.printStackTrace();
      }
      return students;
   }

   public void addStudent(Student student) {
      session.save(student);
   }
}

La classe StudentDAO est la couche d'accès aux données de la classe Student. Il a des méthodes pour lister tous les étudiants, puis pour sauvegarder un nouveau dossier étudiant.

Classe d'action

Fichier suivant AddStudentAction.javadéfinit notre classe d'action. Nous avons deux méthodes d'action ici - execute () et listStudents (). La méthode execute () est utilisée pour ajouter le nouvel enregistrement étudiant. Nous utilisons la méthode save () du dao pour y parvenir.

L'autre méthode, listStudents () est utilisée pour lister les étudiants. Nous utilisons la méthode de liste de dao pour obtenir la liste de tous les élèves.

package com.tutorialspoint.struts2;

import java.util.ArrayList;
import java.util.List;

import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.tutorialspoint.hibernate.Student;
import com.tutorialspoint.hibernate.StudentDAO;

public class AddStudentAction extends ActionSupport implements ModelDriven<Student> {

   Student student  = new Student();
   List<Student> students = new ArrayList<Student>();
   StudentDAO dao = new StudentDAO();
   @Override
  
  public Student getModel() {
      return student;
   }

   public String execute() {
      dao.addStudent(student);
      return "success";
   }

   public String listStudents() {
      students = dao.getStudents();
      return "success";
   }

   public Student getStudent() {
      return student;
   }

   public void setStudent(Student student) {
      this.student = student;
   }

   public List<Student> getStudents() {
      return students;
   }

   public void setStudents(List<Student> students) {
      this.students = students;
   }
	
}

Vous remarquerez que nous implémentons l'interface ModelDriven. Ceci est utilisé lorsque votre classe d'action traite une classe de modèle concrète (telle que Student) par opposition à des propriétés individuelles (telles que firstName, lastName). L'interface ModelAware nécessite que vous implémentiez une méthode pour renvoyer le modèle. Dans notre cas, nous retournons l'objet "étudiant".

Créer des fichiers de vue

Créons maintenant le student.jsp afficher le fichier avec le contenu suivant -

<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>

<html>
   <head>
      <title>Hello World</title>
      <s:head />
   </head>
   
   <body>
      <s:form action = "addStudent">
         <s:textfield name = "firstName" label = "First Name"/>
         <s:textfield name = "lastName" label = "Last Name"/>
         <s:textfield name = "marks" label = "Marks"/>
         <s:submit/>
         <hr/>
         
         <table>
            <tr>
               <td>First Name</td>
               <td>Last Name</td>
               <td>Marks</td>
            </tr>
            
            <s:iterator value = "students">	
               <tr>
                  <td><s:property value = "firstName"/></td>
                  <td><s:property value = "lastName"/></td>
                  <td><s:property value = "marks"/></td>
                 </tr>
            </s:iterator>	
         </table>
      </s:form>
   </body>
</html>

Le fichier student.jsp est assez simple. Dans la section supérieure, nous avons un formulaire qui se soumet à "addStudent.action". Il prend firstName, lastName et les marques. Comme l'action addStudent est liée à ModelAware "AddSudentAction", un bean étudiant sera automatiquement créé avec les valeurs de firstName, lastName et les marques remplies automatiquement.

Dans la partie inférieure, nous parcourons la liste des étudiants (voir AddStudentAction.java). Nous parcourons la liste et affichons les valeurs du prénom, du nom et des marques dans un tableau.

Configuration des jambes de force

Mettons tout cela ensemble en utilisant struts.xml -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "myhibernate" extends = "hibernate-default">

      <action name = "addStudent" method = "execute"
         class = "com.tutorialspoint.struts2.AddStudentAction">
         <result name = "success" type = "redirect">
            listStudents
         </result>
      </action>

      <action name = "listStudents" method = "listStudents"
         class = "com.tutorialspoint.struts2.AddStudentAction">
         <result name = "success">/students.jsp</result>
      </action>

   </package>
</struts>

La chose importante à noter ici est que notre paquet "myhibernate" étend le paquetage par défaut struts2 appelé "hibernate-default". Nous déclarons ensuite deux actions - addStudent et listStudents. addStudent appelle la méthode execute () sur la classe AddStudentAction, puis en cas de succès, il appelle la méthode d'action listStudents.

La méthode d'action listStudent appelle le listStudents () sur la classe AddStudentAction et utilise le student.jsp comme vue.

Dans la section supérieure, nous obtenons un formulaire pour saisir les valeurs d'un nouvel enregistrement d'étudiant et la section inférieure répertorie les étudiants dans la base de données. Allez-y, ajoutez un nouveau dossier d'étudiant et appuyez sur Soumettre. L'écran s'actualisera et vous montrera une liste mise à jour chaque fois que vous cliquez sur Soumettre.