Struts 2 - Guida rapida

Model Visualizzare Controller o MVCcome viene comunemente chiamato, è un modello di progettazione di software per lo sviluppo di applicazioni web. Un pattern Model View Controller è composto dalle seguenti tre parti:

• Model - Il livello più basso del pattern che è responsabile del mantenimento dei dati.

• View - Questo è responsabile della visualizzazione di tutti o una parte dei dati all'utente.

• Controller - Codice software che controlla le interazioni tra il Modello e la Vista.

MVC è popolare in quanto isola la logica dell'applicazione dal livello dell'interfaccia utente e supporta la separazione dei problemi. Qui il Titolare riceve tutte le richieste dell'applicazione e poi lavora con il Modello per preparare i dati necessari alla View. The View utilizza quindi i dati preparati dal Titolare per generare una risposta presentabile finale. L'astrazione MVC può essere rappresentata graficamente come segue.

Il modello

Il modello è responsabile della gestione dei dati dell'applicazione. Risponde alla richiesta della vista e risponde anche alle istruzioni del controller per aggiornarsi.

La vista

Significa presentazione dei dati in un formato particolare, innescata dalla decisione di un responsabile del trattamento di presentare i dati. Sono sistemi di creazione di modelli basati su script come JSP, ASP, PHP e molto facili da integrare con la tecnologia AJAX.

Il controller

Il controller è responsabile della risposta all'input dell'utente ed esegue le interazioni sugli oggetti del modello di dati. Il controller riceve l'input, convalida l'input e quindi esegue l'operazione di business che modifica lo stato del modello dati.

Struts2è un framework basato su MVC. Nei prossimi capitoli, vediamo come possiamo utilizzare la metodologia MVC all'interno di Struts2.

Struts2è un framework per applicazioni web diffuso e maturo basato sul modello di progettazione MVC. Struts2 non è solo una nuova versione di Struts 1, ma è una riscrittura completa dell'architettura di Struts.

Il framework Webwork inizialmente è iniziato con il framework Struts come base e il suo obiettivo era offrire un framework potenziato e migliorato costruito su Struts per rendere più facile lo sviluppo web per gli sviluppatori.

Dopo un po ', il framework Webwork e la comunità Struts si sono uniti per creare il famoso framework Struts2.

Caratteristiche del framework Struts 2

Ecco alcune delle fantastiche funzionalità che potrebbero costringerti a considerare Struts2:

• POJO Forms and POJO Actions- Struts2 ha eliminato gli Action Forms che erano parte integrante del framework Struts. Con Struts2, puoi utilizzare qualsiasi POJO per ricevere l'input del modulo. Allo stesso modo, ora puoi vedere qualsiasi POJO come una classe Action.

• Tag Support - Struts2 ha migliorato i tag del form e i nuovi tag che consentono agli sviluppatori di scrivere meno codice.

• AJAX Support - Struts2 ha riconosciuto la presa in consegna delle tecnologie Web2.0 e ha integrato il supporto AJAX nel prodotto creando tag AJAX, questa funzione è molto simile ai tag Struts2 standard.

• Easy Integration - L'integrazione con altri framework come Spring, Tiles e SiteMesh è ora più semplice con una varietà di integrazione disponibile con Struts2.

• Template Support - Supporto per la generazione di visualizzazioni utilizzando modelli.

• Plugin Support- Il comportamento principale di Struts2 può essere migliorato e potenziato mediante l'uso di plugin. Sono disponibili numerosi plugin per Struts2.

• Profiling- Struts2 offre la creazione di profili integrata per eseguire il debug e il profilo dell'applicazione. Oltre a questo, Struts offre anche il debug integrato con l'aiuto di strumenti di debug incorporati.

• Easy to Modify Tags- I markup dei tag in Struts2 possono essere modificati utilizzando i modelli Freemarker. Ciò non richiede la conoscenza di JSP o Java. La conoscenza di base di HTML, XML e CSS è sufficiente per modificare i tag.

• Promote Less configuration- Struts2 promuove una minore configurazione con l'aiuto dell'utilizzo di valori predefiniti per varie impostazioni. Non è necessario configurare qualcosa a meno che non si discosti dalle impostazioni predefinite impostate da Struts2.

• View Technologies - Struts2 ha un ottimo supporto per più opzioni di visualizzazione (JSP, Freemarker, Velocity e XSLT)

Di seguito sono elencate le 10 principali funzionalità di Struts 2 che lo rende un framework pronto per le aziende.

Struts 2 Svantaggi

Sebbene Struts 2 venga fornito con un elenco di fantastiche funzionalità, ci sono alcune limitazioni della versione corrente: Struts 2 che necessita di ulteriori miglioramenti. Sono elencati alcuni dei punti principali:

• Bigger Learning Curve - Per utilizzare MVC con Struts, devi essere a tuo agio con il JSP standard, le API Servlet e un framework ampio ed elaborato.

• Poor Documentation - Rispetto al servlet standard e alle API JSP, Struts ha meno risorse online e molti utenti alle prime armi trovano la documentazione online di Apache confusa e mal organizzata.

• Less Transparent - Con le applicazioni Struts, c'è molto di più dietro le quinte rispetto alle normali applicazioni Web basate su Java, il che rende difficile la comprensione del framework.

Nota finale, un buon framework dovrebbe fornire un comportamento generico che molti diversi tipi di applicazioni possono utilizzare.

Struts 2 è uno dei migliori framework web ed è molto utilizzato per lo sviluppo di Rich Internet Applications (RIA).

Il nostro primo compito è far funzionare un'applicazione Struts 2 minima. Questo capitolo ti guiderà su come preparare un ambiente di sviluppo per iniziare a lavorare con Struts 2.

Presumo che tu abbia già JDK (5+), Tomcat ed Eclipse installati sulla tua macchina. Se non hai questi componenti installati, segui i passaggi indicati in modo rapido:

Passaggio 1: configurazione del Java Development Kit (JDK)

È possibile scaricare l'ultima versione di SDK dal sito Java di Oracle - Download di Java SE . Troverai le istruzioni per l'installazione di JDK nei file scaricati, segui le istruzioni fornite per installare e configurare il setup. Infine, impostare le variabili di ambiente PATH e JAVA_HOME in modo che facciano riferimento alla directory che contiene java e javac, tipicamente java_install_dir / bin e java_install_dir rispettivamente.

Se stai utilizzando Windows e hai installato l'SDK in C: \ jdk1.5.0_20, dovresti inserire la seguente riga nel tuo file C: \ autoexec.bat.

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

In alternativa, su Windows NT / 2000 / XP -

• È possibile fare clic con il pulsante destro del mouse su Risorse del computer, selezionare Proprietà, quindi Avanzate, quindi Variabili d'ambiente. Quindi, si aggiorna il valore PATH e si preme il pulsante OK.

• Su Unix (Solaris, Linux, ecc.), Se l'SDK è installato in /usr/local/jdk1.5.0_20 e si utilizza la shell C, inserire quanto segue nel file .cshrc.

Su Unix (Solaris, Linux, ecc.), Se l'SDK è installato in /usr/local/jdk1.5.0_20 e si utilizza la shell C, inserire quanto segue nel file .cshrc.

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

In alternativa, se utilizzi un IDE (Integrated Development Environment) come Borland JBuilder, Eclipse, IntelliJ IDEA o Sun ONE Studio, compila ed esegui un semplice programma per confermare che l'IDE sa dove hai installato Java, altrimenti esegui la configurazione corretta come da dato documento di IDE.

Passaggio 2: configurazione di Apache Tomcat

Puoi scaricare l'ultima versione di Tomcat da https://tomcat.apache.org/. Dopo aver scaricato l'installazione, decomprimere la distribuzione binaria in una posizione comoda.

Ad esempio in C: \ apache-tomcat-6.0.33 su Windows o /usr/local/apachetomcat-6.0.33 su Linux / Unix e creare la variabile di ambiente CATALINA_HOME che punta a queste posizioni.

Puoi avviare Tomcat eseguendo i seguenti comandi sulla macchina Windows, oppure puoi semplicemente fare doppio clic su startup.bat

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

Tomcat può essere avviato eseguendo i seguenti comandi su una macchina Unix (Solaris, Linux, ecc.) -

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

Dopo un avvio riuscito, le applicazioni Web predefinite incluse con Tomcat saranno disponibili visitando http://localhost:8080/. Se tutto va bene, dovrebbe visualizzare il seguente risultato:

Ulteriori informazioni sulla configurazione e l'esecuzione di Tomcat sono disponibili nella documentazione inclusa qui, nonché sul sito Web Tomcat: https://tomcat.apache.org/

Tomcat può essere arrestato eseguendo i seguenti comandi sulla macchina Windows:

%CATALINA_HOME%\bin\shutdown

or

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

Tomcat può essere arrestato eseguendo i seguenti comandi su una macchina Unix (Solaris, Linux, ecc.) -

$CATALINA_HOME/bin/shutdown.sh

or

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

Passaggio 3: configurazione di Eclipse (IDE)

Tutti gli esempi in questo tutorial sono scritti utilizzando Eclipse IDE. Ti suggerisco di avere l'ultima versione di Eclipse installata sulla tua macchina.

Per installare Eclipse Scaricare gli ultimi binari di Eclipse da https://www.eclipse.org/downloads/. Dopo aver scaricato l'installazione, decomprimere la distribuzione binaria in una posizione comoda.

Ad esempio in C: \ eclipse su Windows, o / usr / local / eclipse su Linux / Unix e infine imposta la variabile PATH in modo appropriato. Eclipse può essere avviato eseguendo i seguenti comandi sulla macchina Windows, oppure puoi semplicemente fare doppio clic su eclipse.exe

%C:\eclipse\eclipse.exe

Eclipse può essere avviato eseguendo i seguenti comandi su una macchina Unix (Solaris, Linux, ecc.) -

$/usr/local/eclipse/eclipse

Dopo un avvio riuscito, se tutto va bene, dovrebbe visualizzare il seguente risultato:

Passaggio 4: configurazione delle librerie Struts2

Ora, se tutto va bene, puoi procedere alla configurazione del tuo framemwork di Struts2. Di seguito sono riportati i semplici passaggi per scaricare e installare Struts2 sul tuo computer.

• Scegli se installare Struts2 su Windows o Unix, quindi procedi al passaggio successivo per scaricare il file .zip per Windows e il file .tz per Unix.

• Scarica l'ultima versione dei binari di Struts2 da https://struts.apache.org/download.cgi.

• Al momento della stesura di questo tutorial, ho scaricato struts-2.0.14-all.zip e quando si decomprime il file scaricato, verrà visualizzata la struttura della directory all'interno di C: \ struts-2.2.3 come segue.

Il secondo passo è estrarre il file zip in qualsiasi posizione, ho scaricato ed estratto struts-2.2.3-all.zip in c:\ cartella sulla mia macchina Windows 7 in modo da avere tutti i file jar in C:\struts-2.2.3\lib. Assicurati di impostare correttamente la tua variabile CLASSPATH altrimenti dovrai affrontare problemi durante l'esecuzione dell'applicazione.

Da un livello elevato, Struts2 è un framework pull-MVC (o MVC2). Il pattern Model-ViewController in Struts2 è implementato con i seguenti cinque componenti principali:

• Actions
• Interceptors
• Stack di valori / OGNL
• Risultati / Tipi di risultati
• Visualizza le tecnologie

Struts 2 è leggermente diverso da un framework MVC tradizionale, in cui l'azione assume il ruolo di modello piuttosto che di controller, sebbene vi siano alcune sovrapposizioni.

Il diagramma sopra mostra il file Model, Visualizzare e Controller all'architettura di alto livello di Struts2. Il controller è implementato con un fileStruts2Dispaccia il filtro servlet così come gli intercettori, questo modello è implementato con le azioni e la vista è una combinazione di tipi di risultati e risultati. Lo stack di valori e OGNL forniscono un filo conduttore, collegando e consentendo l'integrazione tra gli altri componenti.

Oltre ai componenti di cui sopra, ci saranno molte informazioni relative alla configurazione. Configurazione per l'applicazione Web, nonché configurazione per azioni, intercettori, risultati, ecc.

Questa è la panoramica dell'architettura del pattern MVC di Struts 2. Esamineremo ogni componente in modo più dettagliato nei capitoli successivi.

Richiedi ciclo di vita

Sulla base del diagramma sopra, è possibile comprendere il flusso di lavoro attraverso il ciclo di vita della richiesta dell'utente in formato Struts 2 come segue -

• L'utente invia una richiesta al server per richiedere alcune risorse (ad esempio pagine).

• Il Filter Dispatcher esamina la richiesta e quindi determina l'azione appropriata.

• Si applicano funzionalità di intercettazione configurate come convalida, caricamento di file ecc.

• L'azione selezionata viene eseguita in base all'operazione richiesta.

• Anche in questo caso, gli intercettori configurati vengono applicati per eseguire qualsiasi post-elaborazione, se necessario.

• Infine, il risultato viene preparato dalla visualizzazione e restituisce il risultato all'utente.

Come hai già appreso dall'architettura Struts 2, quando fai clic su un collegamento ipertestuale o invii un modulo HTML in un'applicazione web Struts 2, l'input viene raccolto dal controller che viene inviato a una classe Java chiamata Actions. Dopo che l'azione è stata eseguita, un risultato seleziona una risorsa per eseguire il rendering della risposta. La risorsa è generalmente un JSP, ma può anche essere un file PDF, un foglio di calcolo Excel o una finestra di applet Java.

Supponendo che tu abbia già creato il tuo ambiente di sviluppo. Ora, procediamo per costruire il nostro primoHello World Struts2progetto. Lo scopo di questo progetto è costruire un'applicazione web che raccolga il nome dell'utente e visualizzi "Hello World" seguito dal nome utente.

Dovremmo creare i seguenti quattro componenti per qualsiasi progetto Struts 2:

Suor n	Componenti e descrizione
1	Action Creare una classe di azioni che conterrà la logica aziendale completa e controllerà l'interazione tra l'utente, il modello e la vista.
2	Interceptors Se necessario, creare intercettori o utilizzare intercettori esistenti. Questo fa parte di Controller.
3	View Creare un JSP per interagire con l'utente per ricevere input e presentare i messaggi finali.
4	Configuration Files Crea file di configurazione per accoppiare Azione, Vista e Controller. Questi file sono struts.xml, web.xml, struts.properties.

Userò Eclipse IDE, in modo che tutti i componenti richiesti vengano creati in un progetto Web dinamico. Cominciamo ora con la creazione di Dynamic Web Project.

Crea un progetto Web dinamico

Avvia il tuo Eclipse e poi vai con File > New > Dynamic Web Project e inserisci il nome del progetto come HelloWorldStruts2 e impostare il resto delle opzioni come indicato nella schermata seguente:

Seleziona tutte le opzioni predefinite nelle schermate successive e infine controlla Generate Web.xml deployment descriptoropzione. Questo creerà un progetto web dinamico per te in Eclipse. Adesso vai conWindows > Show View > Project Explorere vedrai la finestra del tuo progetto come di seguito -

Ora copia i seguenti file dalla cartella lib di struts 2 C:\struts-2.2.3\lib al nostro progetto WEB-INF\libcartella. Per fare ciò, puoi semplicemente trascinare e rilasciare tutti i seguenti file nella cartella 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

Crea classe d'azione

La classe di azione è la chiave dell'applicazione Struts 2 e implementiamo la maggior parte della logica di business nella classe di azione. Quindi creiamo un file java HelloWorldAction.java sottoJava Resources > src con un nome di pacchetto com.tutorialspoint.struts2 con i contenuti riportati di seguito.

La classe Action risponde a un'azione dell'utente quando l'utente fa clic su un URL. Uno o più metodi della classe Action vengono eseguiti e viene restituito un risultato String. In base al valore del risultato, viene visualizzata una pagina JSP specifica.

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;
   }
}

Questa è una classe molto semplice con una proprietà chiamata "nome". Abbiamo standard getter e metodi setter per la proprietà "name" e un metodo di esecuzione che restituisce la stringa "success".

Il framework Struts 2 creerà un oggetto di HelloWorldActionclass e chiama il metodo eseguito in risposta all'azione di un utente. Metti la tua logica aziendale all'interno di questo metodo che alla fine restituisce la costante String. In altre parole, per ogni URL, dovresti implementare una classe di azione e puoi usare quel nome di classe direttamente come nome di azione oppure puoi mappare un altro nome usando il file struts.xml come mostrato di seguito.

Crea una vista

Abbiamo bisogno di un JSP per presentare il messaggio finale, questa pagina verrà richiamata dal framework Struts 2 quando si verificherà un'azione predefinita e questa mappatura sarà definita nel file struts.xml. Quindi creiamo il file jsp di seguitoHelloWorld.jspnella cartella WebContent nel tuo progetto eclipse. A tale scopo, fare clic con il pulsante destro del mouse sulla cartella WebContent in Esplora progetti e selezionareNew >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 direttiva taglib dice al contenitore Servlet che questa pagina utilizzerà il file Struts 2 tag e che questi tag saranno preceduti da s.

Il tag s: property mostra il valore della proprietà della classe di azioni "nome> restituito dal metodo getName() della classe HelloWorldAction.

Crea pagina principale

Dobbiamo anche creare index.jspnella cartella WebContent. Questo file servirà come URL dell'azione iniziale su cui un utente può fare clic per indicare al framework Struts 2 di chiamare un metodo definito della classe HelloWorldAction e di eseguire il rendering della vista 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>

Il hellol'azione definita nel file di visualizzazione sopra verrà mappata alla classe HelloWorldAction e al suo metodo di esecuzione utilizzando il file struts.xml. Quando un utente fa clic sul pulsante Invia, il framework Struts 2 esegue il metodo di esecuzione definito nella classe HelloWorldAction e, in base al valore restituito del metodo, verrà selezionata e renderizzata una vista appropriata come risposta.

File di configurazione

Abbiamo bisogno di una mappatura per legare insieme l'URL, la classe HelloWorldAction (Model) e HelloWorld.jsp (la vista). La mappatura indica al framework Struts 2 quale classe risponderà all'azione dell'utente (l'URL), quale metodo di quella classe verrà eseguito e quale vista rendere in base al risultato String restituito dal metodo.

Quindi creiamo un file chiamato struts.xml. Poiché Struts 2 richiede che struts.xml sia presente nella cartella delle classi. Quindi, crea il file struts.xml nella cartella WebContent / WEB-INF / classes. Eclipse non crea la cartella "classes" per impostazione predefinita, quindi è necessario farlo da soli. A tale scopo, fare clic con il pulsante destro del mouse sulla cartella WEB-INF nell'esploratore del progetto e selezionareNew > Folder. Il tuo struts.xml dovrebbe avere il seguente aspetto:

<?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>

Poche parole che devono essere comprese riguardo al file di configurazione di cui sopra. Qui impostiamo la costantestruts.devMode per true, perché stiamo lavorando in un ambiente di sviluppo e abbiamo bisogno di vedere alcuni messaggi di log utili. Quindi, definiamo un pacchetto chiamatohelloworld.

La creazione di un pacchetto è utile quando desideri raggruppare le tue azioni. Nel nostro esempio, abbiamo chiamato la nostra azione "ciao", che corrisponde all'URL/hello.action ed è supportato daHelloWorldAction.class. Ilexecute metodo di HelloWorldAction.class è il metodo che viene eseguito quando l'URL /hello.actionviene invocato. Se il risultato del metodo di esecuzione restituisce "successo", allora portiamo l'utente aHelloWorld.jsp.

Il prossimo passo è creare un file web.xmlfile che è un punto di ingresso per qualsiasi richiesta a Struts 2. Il punto di ingresso dell'applicazione Struts2 sarà un filtro definito nel descrittore di distribuzione (web.xml). Quindi, definiremo una voce della classe org.apache.struts2.dispatcher.FilterDispatcher in web.xml. Il file web.xml deve essere creato nella cartella WEB-INF in WebContent. Eclipse aveva già creato un file skeleton web.xml per te quando hai creato il progetto. Quindi, modifichiamolo come segue:

<?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>

Abbiamo specificato index.jsp come nostro file di benvenuto. Quindi abbiamo configurato il filtro Struts2 per essere eseguito su tutti gli URL (cioè, qualsiasi URL che corrisponde al pattern / *)

Per abilitare il registro dettagliato

È possibile abilitare la funzionalità di registrazione completa mentre si lavora con Struts 2 creando logging.properties file sotto WEB-INF/classescartella. Mantieni le seguenti due righe nel file delle proprietà:

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

Il logging.properties predefinito specifica un ConsoleHandler per l'instradamento della registrazione a stdout e anche un FileHandler. La soglia del livello di registro di un gestore può essere impostata utilizzando SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST o ALL.

Questo è tutto. Siamo pronti per eseguire la nostra applicazione Hello World utilizzando il framework Struts 2.

Procedura per l'esecuzione dell'applicazione

Fare clic con il tasto destro sul nome del progetto e fare clic Export > WAR File per creare un file War.

Quindi distribuire questo WAR nella directory webapps di Tomcat.

Infine, avvia il server Tomcat e prova ad accedere all'URL http://localhost:8080/HelloWorldStruts2/index.jsp. Questo ti darà la seguente schermata:

Immettere un valore "Struts2" e inviare la pagina. Dovresti vedere la pagina successiva

Nota che puoi definire index come azione nel file struts.xml e in tal caso puoi chiamare la pagina indice come http://localhost:8080/HelloWorldStruts2/index.action. Controlla di seguito come definire l'indice come azione:

<?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>

Questo capitolo ti guiderà attraverso la configurazione di base necessaria per un file Struts 2applicazione. Qui vedremo cosa può essere configurato con l'aiuto di pochi importanti file di configurazione comeweb.xml, struts.xml, strutsconfig.xml e struts.properties

Onestamente parlando, puoi iniziare a lavorare semplicemente usando web.xml e struts.xmlfile di configurazione (come hai già visto nel capitolo precedente in cui il nostro esempio ha funzionato utilizzando questi due file). Tuttavia, per tua conoscenza spiegheremo anche per quanto riguarda altri file.

Il file web.xml

Il file di configurazione web.xml è un file di configurazione J2EE che determina il modo in cui gli elementi della richiesta HTTP vengono elaborati dal contenitore servlet. Non è strettamente un file di configurazione di Struts2, ma è un file che deve essere configurato affinché Struts2 funzioni.

Come discusso in precedenza, questo file fornisce un punto di ingresso per qualsiasi applicazione web. Il punto di ingresso dell'applicazione Struts2 sarà un filtro definito nel descrittore di distribuzione (web.xml). Quindi definiremo una voce della classe FilterDispatcher in web.xml. Il file web.xml deve essere creato nella cartellaWebContent/WEB-INF.

Questo è il primo file di configurazione che dovrai configurare se stai avviando senza l'ausilio di un modello o di uno strumento che lo genera (come Eclipse o Maven2).

Di seguito è riportato il contenuto del file web.xml che abbiamo utilizzato nel nostro ultimo esempio.

<?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>

Nota che mappiamo il filtro Struts 2 a /*e non a /*.actionil che significa che tutti gli URL verranno analizzati dal filtro struts. Ne parleremo quando passeremo attraverso il capitolo Annotazioni.

Il file Struts.xml

Il struts.xmlfile contiene le informazioni di configurazione che verranno modificate durante lo sviluppo delle azioni. Questo file può essere utilizzato per sovrascrivere le impostazioni predefinite per un'applicazione, ad esempio struts.devMode = false e altre impostazioni definite nel file delle proprietà. Questo file può essere creato nella cartellaWEB-INF/classes.

Diamo un'occhiata al file struts.xml che abbiamo creato nell'esempio Hello World spiegato nel capitolo precedente.

<?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 prima cosa da notare è il file DOCTYPE. Tutti i file di configurazione di struts devono avere il doctype corretto come mostrato nel nostro piccolo esempio. <struts> è l'elemento tag radice, in base al quale dichiariamo pacchetti diversi utilizzando i tag <package>. Qui <package> consente la separazione e la modularizzazione della configurazione. Questo è molto utile quando hai un progetto di grandi dimensioni e il progetto è diviso in diversi moduli.

Ad esempio, se il progetto ha tre domini: business_application, customer_application e staff_application, è possibile creare tre pacchetti e memorizzare le azioni associate nel pacchetto appropriato.

Il tag del pacchetto ha i seguenti attributi:

Suor n	Attributo e descrizione
1	name (required) L'identificativo univoco per il pacchetto
2	extends Da quale pacchetto si estende questo pacchetto? Per impostazione predefinita, usiamo struts-default come pacchetto base.
3	abstract Se contrassegnato come true, il pacchetto non è disponibile per il consumo da parte dell'utente finale.
4	namespace Spazio dei nomi univoco per le azioni

Il constant tag insieme agli attributi name e value dovrebbero essere usati per sovrascrivere una qualsiasi delle seguenti proprietà definite in default.properties, come abbiamo appena impostato struts.devModeproprietà. Ambientazionestruts.devMode la proprietà ci consente di vedere più messaggi di debug nel file di registro.

Definiamo action tag corrisponde a ogni URL a cui vogliamo accedere e definiamo una classe con il metodo execute () a cui si accederà ogni volta che accediamo all'URL corrispondente.

I risultati determinano cosa viene restituito al browser dopo l'esecuzione di un'azione. La stringa restituita dall'azione dovrebbe essere il nome di un risultato. I risultati sono configurati per azione come sopra, o come risultato "globale", disponibile per ogni azione in un pacchetto. I risultati sono facoltativiname e typeattributi. Il valore del nome predefinito è "successo".

Il file Struts.xml può crescere nel tempo e quindi suddividerlo in pacchetti è un modo per modularizzarlo, ma Strutsoffre un altro modo per modularizzare il file struts.xml. È possibile dividere il file in più file xml e importarli nel modo seguente.

<?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'altro file di configurazione di cui non abbiamo parlato è struts-default.xml. Questo file contiene le impostazioni di configurazione standard per Struts e non dovresti toccare queste impostazioni per il 99,99% dei tuoi progetti. Per questo motivo, non entreremo troppo nei dettagli su questo file. Se sei interessato, dai un'occhiata aldefault.properties file disponibile nel file struts2-core-2.2.3.jar.

Il file Struts-config.xml

Il file di configurazione struts-config.xml è un collegamento tra i componenti Visualizza e Modello nel client Web, ma non dovresti toccare queste impostazioni per il 99,99% dei tuoi progetti.

Il file di configurazione contiene fondamentalmente i seguenti elementi principali:

Suor n	Interceptor e descrizione
1	struts-config Questo è il nodo radice del file di configurazione.
2	form-beans Qui è dove si associa la sottoclasse ActionForm a un nome. Questo nome viene utilizzato come alias per ActionForm in tutto il resto del file strutsconfig.xml e anche nelle pagine JSP.
3	global forwards Questa sezione mappa una pagina della tua webapp su un nome. È possibile utilizzare questo nome per fare riferimento alla pagina effettiva. Ciò evita di codificare gli URL nelle tue pagine web.
4	action-mappings Qui è dove si dichiarano i gestori di moduli, noti anche come mapping di azioni.
5	controller Questa sezione configura gli interni di Struts e viene usata raramente in situazioni pratiche.
6	plug-in Questa sezione indica a Struts dove trovare i file delle proprietà, che contengono richieste e messaggi di errore

Di seguito è riportato il file struts-config.xml di esempio:

<?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>

Per maggiori dettagli sul file struts-config.xml, controlla gentilmente la documentazione di struts.

Il file Struts.properties

Questo file di configurazione fornisce un meccanismo per modificare il comportamento predefinito del framework. In realtà, tutte le proprietà contenute all'interno delstruts.properties il file di configurazione può essere configurato anche nel file web.xml usando il init-param, nonché utilizzando il tag costante in struts.xmlfile di configurazione. Ma, se ti piace mantenere le cose separate e più specifiche, puoi creare questo file nella cartellaWEB-INF/classes.

I valori configurati in questo file sovrascriveranno i valori predefiniti configurati in default.propertiescontenuto nella distribuzione struts2-core-xyzjar. Ci sono un paio di proprietà che potresti prendere in considerazione di cambiare usando ilstruts.properties file -

### 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

Qui ogni riga che inizia con hash (#) verrà considerato come un commento e verrà ignorato da Struts 2.

Actionssono il cuore del framework Struts2, come lo sono per qualsiasi framework MVC (Model View Controller). Ogni URL è mappato a un'azione specifica, che fornisce la logica di elaborazione necessaria per soddisfare la richiesta dell'utente.

Ma l'azione serve anche per altre due importanti capacità. In primo luogo, l'azione gioca un ruolo importante nel trasferimento dei dati dalla richiesta alla visualizzazione, sia che si tratti di un JSP o di un altro tipo di risultato. In secondo luogo, l'azione deve aiutare il framework a determinare quale risultato dovrebbe fornire la vista che verrà restituita nella risposta alla richiesta.

Crea azione

L'unico requisito per azioni in Struts2è che deve esserci un metodo noargument che restituisce un oggetto String o Result e deve essere un POJO. Se il metodo senza argomenti non è specificato, il comportamento predefinito è usare il metodo execute ().

Facoltativamente puoi estendere il file ActionSupport class che implementa sei interfacce tra cui Actioninterfaccia. L'interfaccia di azione è la seguente:

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;
}

Diamo un'occhiata al metodo di azione nell'esempio 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;
   }
}

Per illustrare il punto in cui il metodo di azione controlla la visualizzazione, apportiamo la seguente modifica al file execute metodo ed estendere la classe ActionSupport come segue:

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;
   }
}

In questo esempio, abbiamo una logica nel metodo execute per esaminare l'attributo name. Se l'attributo è uguale alla stringa"SECRET", torniamo SUCCESS come risultato altrimenti torniamo ERRORcome risultato. Perché abbiamo esteso ActionSupport, quindi possiamo usare le costanti StringSUCCESSe ERRORE. Ora, modifichiamo il nostro file struts.xml come segue:

<?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>

Crea una vista

Creiamo il file jsp di seguito HelloWorld.jspnella cartella WebContent nel tuo progetto eclipse. A tale scopo, fare clic con il pulsante destro del mouse sulla cartella WebContent in Esplora progetti e selezionareNew >JSP File. Questo file verrà chiamato nel caso in cui il risultato restituito sia SUCCESS che è una costante di stringa "successo" come definito nell'interfaccia di azione -

<%@ 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>

Di seguito è riportato il file che verrà richiamato dal framework nel caso in cui il risultato dell'azione sia ERROR che è uguale a String costante "errore". Di seguito è riportato il contenuto diAccessDenied.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>

Dobbiamo anche creare index.jspnella cartella WebContent. Questo file servirà come URL dell'azione iniziale su cui l'utente può fare clic per indicare al framework Struts 2 di chiamare il fileexecutemetodo della classe HelloWorldAction ed eseguire il rendering della vista 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>

Ecco fatto, non è richiesta alcuna modifica per il file web.xml, quindi usiamo lo stesso web.xml che avevamo creato in Examplescapitolo. Ora siamo pronti per eseguire il nostroHello World applicazione utilizzando il framework Struts 2.

Esegui l'applicazione

Fare clic con il tasto destro sul nome del progetto e fare clic Export > WARFile per creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Questo ti darà la seguente schermata:

Inseriamo una parola come "SEGRETO" e dovresti vedere la pagina seguente:

Ora inserisci una parola diversa da "SEGRETO" e dovresti vedere la pagina seguente:

Crea più azioni

Definirai frequentemente più di un'azione per gestire richieste diverse e fornire URL diversi agli utenti, di conseguenza definirai classi diverse come definito di seguito:

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;
   }
   ...
}

Configurerai queste azioni nel file struts.xml come segue:

<?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>

Come puoi vedere nell'esempio ipotetico sopra, l'azione risulta SUCCESS e ERROR’s sono duplicati.

Per aggirare questo problema, si suggerisce di creare una classe che contenga i risultati.

Gli intercettatori sono concettualmente gli stessi dei filtri servlet o della classe proxy JDK. Gli intercettatori consentono di implementare funzionalità trasversali separatamente dall'azione e dal framework. È possibile ottenere quanto segue utilizzando gli intercettori:

• Fornire la logica di pre-elaborazione prima che l'azione venga chiamata.

• Fornire la logica di postelaborazione dopo che l'azione è stata chiamata.

• Cattura delle eccezioni in modo che sia possibile eseguire un'elaborazione alternativa.

Molte delle funzionalità fornite in Struts2 framework sono implementati utilizzando gli intercettori;

Examples includono la gestione delle eccezioni, il caricamento di file, i callback del ciclo di vita, ecc. Infatti, poiché Struts2 enfatizza gran parte delle sue funzionalità sugli intercettori, è improbabile che siano assegnati 7 o 8 intercettori per azione.

Struts2 Framework Interceptor

Il framework Struts 2 fornisce un buon elenco di intercettatori pronti all'uso preconfigurati e pronti per l'uso. Di seguito sono elencati alcuni degli intercettori importanti:

Suor n	Interceptor e descrizione
1	alias Consente ai parametri di avere alias di nome diversi tra le richieste.
2	checkbox Aiuta nella gestione delle caselle di controllo aggiungendo un valore di parametro false per le caselle di controllo che non sono selezionate.
3	conversionError Inserisce le informazioni sugli errori dalla conversione delle stringhe in tipi di parametri negli errori del campo dell'azione.
4	createSession Crea automaticamente una sessione HTTP se non ne esiste già una.
5	debugging Fornisce diverse schermate di debug allo sviluppatore.
6	execAndWait Invia l'utente a una pagina di attesa intermedia mentre l'azione viene eseguita in background.
7	exception Associa le eccezioni generate da un'azione a un risultato, consentendo la gestione automatica delle eccezioni tramite il reindirizzamento.
8	fileUpload Facilita il caricamento semplice dei file.
9	i18n Tiene traccia delle impostazioni internazionali selezionate durante la sessione di un utente.
10	logger Fornisce una registrazione semplice mediante l'output del nome dell'azione in esecuzione.
11	params Imposta i parametri di richiesta sull'azione.
12	prepare Questo è in genere utilizzato per eseguire il lavoro di pre-elaborazione, come l'impostazione delle connessioni al database.
13	profile Consente di registrare semplici informazioni di profilazione per le azioni.
14	scope Memorizza e recupera lo stato dell'azione nell'ambito della sessione o dell'applicazione.
15	ServletConfig Fornisce all'azione l'accesso a varie informazioni basate su servlet.
16	timer Fornisce semplici informazioni di profilazione sotto forma di quanto tempo richiede l'esecuzione dell'azione.
17	token Verifica l'azione per un token valido per impedire l'invio di moduli duplicati.
18	validation Fornisce supporto di convalida per le azioni

Si prega di esaminare la documentazione di Struts 2 per i dettagli completi sugli intercettatori di cui sopra. Ma ti mostrerò come utilizzare un intercettore in generale nella tua applicazione Struts.

Come utilizzare gli intercettatori?

Vediamo come utilizzare un intercettore già esistente per il nostro programma "Hello World". Useremo il filetimerinterceptor il cui scopo è misurare il tempo impiegato per eseguire un metodo di azione. Allo stesso tempo, sto usandoparamsinterceptor il cui scopo è inviare i parametri della richiesta all'azione. Puoi provare il tuo esempio senza usare questo intercettore e lo troverainame la proprietà non è stata impostata perché il parametro non è in grado di raggiungere l'azione.

Manterremo i file HelloWorldAction.java, web.xml, HelloWorld.jsp e index.jsp così come sono stati creati in Examples capitolo ma modifichiamo il struts.xml file per aggiungere un intercettore come segue:

<?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>

Fare clic con il tasto destro sul nome del progetto e fare clic Export > WAR Fileper creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Questo produrrà la seguente schermata:

Ora inserisci una parola nella casella di testo data e fai clic sul pulsante Say Hello per eseguire l'azione definita. Ora se controllerai il log generato, troverai il seguente testo:

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.

Qui la linea di fondo viene generata a causa di timer intercettore che sta dicendo che l'azione ha richiesto un totale di 109 ms per essere eseguita.

Crea intercettatori personalizzati

L'utilizzo di intercettori personalizzati nella propria applicazione è un modo elegante per fornire funzionalità trasversali dell'applicazione. Creare un intercettore personalizzato è facile; l'interfaccia che deve essere estesa è la seguenteInterceptor interfaccia -

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

Come suggeriscono i nomi, il metodo init () fornisce un modo per inizializzare l'interceptor e il metodo destroy () fornisce una struttura per la pulizia dell'interceptor. A differenza delle azioni, gli intercettori vengono riutilizzati tra le richieste e devono essere sicuri per i thread, in particolare il metodo intercept ().

Il ActionInvocationL'oggetto fornisce l'accesso all'ambiente di runtime. Consente l'accesso all'azione stessa e ai metodi per richiamare l'azione e determinare se l'azione è già stata invocata.

Se non è necessario eseguire l'inizializzazione o il codice di pulizia, il file AbstractInterceptorclasse può essere estesa. Questo fornisce un'implementazione predefinita senza operazioni dei metodi init () e destroy ().

Crea classe intercettore

Creiamo il seguente MyInterceptor.java in Java Resources > src cartella -

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;
   }
}

Come noti, l'azione effettiva verrà eseguita utilizzando l'interceptor di invocation.invoke()chiamata. Quindi puoi eseguire un po 'di pre-elaborazione e un po' di post-elaborazione in base alle tue esigenze.

Il framework stesso avvia il processo effettuando la prima chiamata a invoke () dell'oggetto ActionInvocation. Ogni voltainvoke()viene chiamato, ActionInvocation consulta il suo stato ed esegue qualunque intercettore venga dopo. Quando tutti gli intercettori configurati sono stati invocati, il metodo invoke () farà eseguire l'azione stessa.

Il diagramma seguente mostra lo stesso concetto attraverso un flusso di richieste:

Crea classe d'azione

Creiamo un file java HelloWorldAction.java sotto Java Resources > src con un nome di pacchetto com.tutorialspoint.struts2 con i contenuti riportati di seguito.

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;
   }
}

Questa è la stessa classe che abbiamo visto negli esempi precedenti. Abbiamo standard getter e metodi setter per la proprietà "name" e un metodo di esecuzione che restituisce la stringa "success".

Crea una vista

Creiamo il file jsp di seguito HelloWorld.jsp nella cartella WebContent nel tuo progetto 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>

Crea pagina principale

Dobbiamo anche creare index.jspnella cartella WebContent. Questo file servirà come URL dell'azione iniziale su cui un utente può fare clic per indicare al framework Struts 2 di chiamare il metodo definito della classe HelloWorldAction e di eseguire il rendering della vista 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>

Il hello l'azione definita nel file di visualizzazione sopra verrà mappata alla classe HelloWorldAction e al suo metodo di esecuzione utilizzando il file struts.xml.

File di configurazione

Ora, dobbiamo registrare il nostro intercettore e quindi chiamarlo come avevamo chiamato l'interceptor predefinito nell'esempio precedente. Per registrare un intercettore appena definito, i tag <interceptors> ... </interceptors> vengono posti direttamente sotto il tag <package> insstruts.xmlfile. Puoi saltare questo passaggio per un intercettore predefinito come abbiamo fatto nel nostro esempio precedente. Ma qui registriamoci e usiamolo come segue:

<?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>

Va notato che è possibile registrare più di un intercettore all'interno <package> e allo stesso tempo puoi chiamare più di un intercettore all'interno del <action>etichetta. Puoi chiamare lo stesso intercettore con le diverse azioni.

Il file web.xml deve essere creato nella cartella WEB-INF in WebContent come segue:

<?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>

Fare clic con il tasto destro sul nome del progetto e fare clic Export > WAR Fileper creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Questo produrrà la seguente schermata:

Ora inserisci una parola nella casella di testo data e fai clic sul pulsante Say Hello per eseguire l'azione definita. Ora se controllerai il log generato, troverai il seguente testo in fondo -

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

Impilamento di più intercettori

Come puoi immaginare, dover configurare più intercettori per ogni azione diventerebbe rapidamente estremamente ingestibile. Per questo motivo, gli intercettori vengono gestiti con stack di intercettori. Ecco un esempio, direttamente dal file 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>

Viene chiamata la puntata di cui sopra basicStacke può essere utilizzato nella configurazione come mostrato di seguito. Questo nodo di configurazione si trova sotto il nodo <pacchetto ... />. Ogni tag <interceptor-ref ... /> fa riferimento a un interceptor oa uno stack di intercettori che è stato configurato prima dello stack di intercettatori corrente. È quindi molto importante assicurarsi che il nome sia univoco in tutte le configurazioni dello stack di intercettatori e intercettori durante la configurazione degli intercettori iniziali e degli stack di intercettori.

Abbiamo già visto come applicare l'interceptor all'azione, l'applicazione di stack di intercettori non è diverso. In effetti, usiamo esattamente lo stesso tag:

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

La suddetta registrazione di "basicStack" registrerà lo stake completo di tutti e sei gli intercettori con azione hello. Si noti che gli intercettori vengono eseguiti nell'ordine in cui sono stati configurati. Ad esempio, nel caso precedente, l'eccezione verrà eseguita per prima, la seconda sarà servlet-config e così via.

Come accennato in precedenza, il <results> tag svolge il ruolo di un viewnel framework Struts2 MVC. L'azione è responsabile dell'esecuzione della logica di business. Il passaggio successivo dopo aver eseguito la logica aziendale consiste nel visualizzare la vista utilizzando il<results> etichetta.

Spesso sono presenti alcune regole di navigazione allegate ai risultati. Ad esempio, se il metodo di azione è autenticare un utente, ci sono tre possibili risultati.

• Login effettuato con successo
• Accesso non riuscito: nome utente o password errati
• Account bloccato

In questo scenario, il metodo di azione verrà configurato con tre possibili stringhe di risultati e tre diverse visualizzazioni per eseguire il rendering del risultato. Lo abbiamo già visto negli esempi precedenti.

Ma Struts2 non ti lega all'uso di JSP come tecnologia di visualizzazione. Dopotutto, l'intero scopo del paradigma MVC è mantenere i livelli separati e altamente configurabili. Ad esempio, per un client Web2.0, potresti voler restituire XML o JSON come output. In questo caso, potresti creare un nuovo tipo di risultato per XML o JSON e ottenere questo risultato.

Struts viene fornito con una serie di file predefiniti result types e tutto ciò che abbiamo già visto era il tipo di risultato predefinito dispatcher, utilizzato per l'invio alle pagine JSP. Struts ti consente di utilizzare altri linguaggi di markup per la tecnologia di visualizzazione per presentare i risultati e le scelte popolari includonoVelocity, Freemaker, XSLT e Tiles.

Il tipo di risultato del Dispatcher

Il dispatcheril tipo di risultato è il tipo predefinito e viene utilizzato se non viene specificato nessun altro tipo di risultato. Viene utilizzato per inoltrare a un servlet, JSP, pagina HTML e così via sul server. Utilizza il metodo RequestDispatcher.forward () .

Abbiamo visto la versione "abbreviata" nei nostri esempi precedenti, in cui abbiamo fornito un percorso JSP come corpo del tag risultato.

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

Possiamo anche specificare il file JSP utilizzando un tag <param name = "location"> all'interno dell'elemento <risultato ...> come segue:

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

Possiamo anche fornire un file parseparametro, che è vero per impostazione predefinita. Il parametro parse determina se il parametro location verrà analizzato o meno per le espressioni OGNL.

Il tipo di risultato di FreeMaker

In questo esempio, vedremo come possiamo usare FreeMakercome la tecnologia di visualizzazione. Freemaker è un popolare motore di creazione di modelli utilizzato per generare output utilizzando modelli predefiniti. Creiamo ora un file modello Freemaker chiamatohello.fm con i seguenti contenuti -

Hello World ${name}

Il file sopra è un modello in cui nameè un parametro che verrà passato dall'esterno utilizzando l'azione definita. Manterrai questo file nel tuo CLASSPATH.

Successivamente, modifichiamo il file struts.xml per specificare il risultato come segue -

<?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>

Conserviamo i nostri file HelloWorldAction.java, HelloWorldAction.jsp e index.jsp come li abbiamo creati nel capitolo degli esempi.

Ora fai clic con il pulsante destro del mouse sul nome del progetto e fai clic Export > WAR File per creare un file War.

Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Questo produrrà la seguente schermata.

Immettere un valore "Struts2" e inviare la pagina. Dovresti vedere la pagina successiva.

Come puoi vedere, questo è esattamente lo stesso della vista JSP tranne per il fatto che non siamo legati all'uso di JSP come tecnologia di visualizzazione. Abbiamo usato Freemaker in questo esempio.

Il tipo di risultato di reindirizzamento

Il redirectil tipo di risultato chiama il metodo response.sendRedirect () standard , facendo in modo che il browser crei una nuova richiesta nella posizione specificata.

Possiamo fornire la posizione sia nel corpo dell'elemento <risultato ...> che come elemento <param name = "location">. Redirect supporta anche ilparseparametro. Ecco un esempio configurato utilizzando XML:

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

Quindi modifica il tuo file struts.xml per definire il tipo di reindirizzamento come menzionato sopra e crea un nuovo file NewWorld.jpg dove sarai reindirizzato ogni volta che l'azione ciao avrà successo. Puoi controllare l' esempio di azione di reindirizzamento di Struts 2 per una migliore comprensione.

Il Value Stack

Lo stack di valori è un insieme di diversi oggetti che mantiene i seguenti oggetti nell'ordine fornito:

Suor n	Oggetti e descrizione
1	Temporary Objects Ci sono vari oggetti temporanei che vengono creati durante l'esecuzione di una pagina. Ad esempio, il valore di iterazione corrente per una raccolta di cui viene eseguito il loop in un tag JSP.
2	The Model Object Se si utilizzano oggetti del modello nella propria applicazione Struts, l'oggetto del modello corrente viene posizionato prima dell'azione nella pila dei valori.
3	The Action Object Questo sarà l'oggetto azione corrente che viene eseguito.
4	Named Objects Questi oggetti includono #application, #session, #request, #attr e #parameters e fanno riferimento agli ambiti servlet corrispondenti.

È possibile accedere allo stack di valori tramite i tag forniti per JSP, Velocity o Freemarker. Ci sono vari tag che studieremo in capitoli separati, sono usati per ottenere e impostare lo stack di valori di struts 2.0. Puoi ottenere un oggetto valueStack all'interno della tua azione come segue:

ActionContext.getContext().getValueStack()

Una volta che hai un oggetto ValueStack, puoi usare i seguenti metodi per manipolare quell'oggetto:

Suor n	Metodi e descrizione ValueStack
1	Object findValue(String expr) Trova un valore valutando l'espressione data rispetto allo stack nell'ordine di ricerca predefinito.
2	CompoundRoot getRoot() Ottieni CompoundRoot che tiene gli oggetti spinti nella pila.
3	Object peek() Porta l'oggetto in cima alla pila senza cambiare la pila.
4	Object pop() Prendi l'oggetto in cima alla pila e rimuovilo dalla pila.
5	void push(Object o) Metti questo oggetto in cima alla pila.
6	void set(String key, Object o) Imposta un oggetto sullo stack con la chiave data in modo che sia recuperabile da findValue (key, ...)
7	void setDefaultType(Class defaultType) Imposta il tipo predefinito da convertire se non viene fornito alcun tipo quando si ottiene un valore.
8	void setValue(String expr, Object value) Tenta di impostare una proprietà su un bean nello stack con l'espressione data utilizzando l'ordine di ricerca predefinito.
9	int size() Ottieni il numero di oggetti nella pila.

L'OGNL

Il Object-Graph Navigation Language(OGNL) è un potente linguaggio di espressione che viene utilizzato per fare riferimento e manipolare i dati su ValueStack. OGNL aiuta anche nel trasferimento dei dati e nella conversione del tipo.

L'OGNL è molto simile al linguaggio di espressione JSP. OGNL si basa sull'idea di avere un oggetto root o predefinito all'interno del contesto. È possibile fare riferimento alle proprietà dell'oggetto predefinito o radice utilizzando la notazione markup, che è il simbolo cancelletto.

Come accennato in precedenza, OGNL è basato su un contesto e Struts crea una mappa ActionContext da utilizzare con OGNL. La mappa ActionContext è composta da quanto segue:

• Application - Variabili nell'ambito dell'applicazione

• Session - Variabili con ambito di sessione

• Root / value stack - Tutte le tue variabili di azione sono memorizzate qui

• Request - Richiedi variabili con ambito

• Parameters - Richiedi parametri

• Atributes - Gli attributi memorizzati in pagina, richiesta, sessione e ambito dell'applicazione

È importante comprendere che l'oggetto Action è sempre disponibile nello stack di valori. Quindi, quindi, se il tuo oggetto Action ha proprietà“x” e “y” sono prontamente disponibili per l'uso.

Gli oggetti nell'ActionContext vengono indicati utilizzando il simbolo cancelletto, tuttavia è possibile fare riferimento direttamente agli oggetti nello stack di valori.

Ad esempio, se employee è una proprietà di una classe di azione, quindi è possibile fare riferimento come segue:

<s:property value = "name"/>

invece di

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

Se hai un attributo nella sessione chiamato "login" puoi recuperarlo come segue:

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

OGNL supporta anche la gestione delle raccolte, ovvero Map, List e Set. Ad esempio, per visualizzare un elenco a discesa di colori, potresti fare:

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

L'espressione OGNL è intelligente per interpretare il "rosso", "giallo", "verde" come colori e costruire un elenco basato su questo.

Le espressioni OGNL saranno ampiamente utilizzate nei prossimi capitoli quando studieremo diversi tag. Quindi, piuttosto che guardarli isolatamente, guardiamoli usando alcuni esempi nella sezione Tag modulo / Tag di controllo / Tag dati e Tag Ajax.

ValueStack / OGNL Esempio

Crea azione

Consideriamo la seguente classe di azione in cui accediamo a valueStack e quindi impostiamo alcune chiavi a cui accederemo utilizzando OGNL nella nostra vista, ovvero la pagina 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;
   }
}

In realtà, Struts 2 aggiunge la tua azione all'inizio del valueStack quando viene eseguita. Quindi, il modo usuale per inserire elementi nello Stack dei valori è aggiungere getter / setter per i valori alla classe Action e quindi utilizzare il tag <s: property> per accedere ai valori. Ma ti sto mostrando come funzionano esattamente ActionContext e ValueStack in struts.

Crea viste

Creiamo il file jsp di seguito HelloWorld.jspnella cartella WebContent nel tuo progetto eclipse. Questa visualizzazione verrà visualizzata nel caso in cui l'azione abbia esito positivo -

<%@ 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>

Dobbiamo anche creare index.jsp nella cartella WebContent il cui contenuto è il seguente:

<%@ 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>

File di configurazione

Di seguito è riportato il contenuto di struts.xml file -

<?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>

Di seguito è riportato il contenuto di web.xml file -

<?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>

Fare clic con il tasto destro sul nome del progetto e fare clic Export > WAR Fileper creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat.

Infine, avvia il server Tomcat e prova ad accedere all'URL http://localhost:8080/HelloWorldStruts2/index.jsp. Questo produrrà la seguente schermata

Ora inserisci una parola nella casella di testo data e fai clic sul pulsante "Say Hello" per eseguire l'azione definita. Ora, se controllerai il log generato, troverai il seguente testo in fondo -

Size of the valueStack: 3

Verrà visualizzata la schermata seguente, che visualizzerà il valore immesso e il valore di key1 e key2 che abbiamo inserito in ValueStack.

Il framework Struts 2 fornisce il supporto integrato per l'elaborazione del caricamento di file utilizzando "Caricamento di file basato su modulo in HTML". Quando un file viene caricato, in genere viene archiviato in una directory temporanea e devono essere elaborati o spostati dalla classe Action in una directory permanente per garantire che i dati non vadano persi.

Note - I server potrebbero disporre di una politica di sicurezza che vieta di scrivere in directory diverse dalla directory temporanea e dalle directory che appartengono alla vostra applicazione web.

Il caricamento dei file in Struts è possibile tramite un intercettore predefinito chiamato FileUpload interceptor disponibile tramite la classe org.apache.struts2.interceptor.FileUploadInterceptor e incluso come parte delladefaultStack. Puoi comunque usarlo nel tuo struts.xml per impostare vari parametri come vedremo di seguito.

Crea file di visualizzazione

Cominciamo con la creazione della nostra vista che sarà richiesta per sfogliare e caricare un file selezionato. Quindi creiamo un fileindex.jsp con semplice modulo di caricamento HTML che consente all'utente di caricare un file -

<%@ 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>

Ci sono un paio di punti che vale la pena notare nell'esempio sopra. Innanzitutto, l'enctype del modulo è impostato sumultipart/form-data. Questo dovrebbe essere impostato in modo che i caricamenti di file siano gestiti correttamente dall'intercettatore di caricamento file. Il punto successivo da notare è il metodo di azione del moduloupload e il nome del campo di caricamento del file, che è myFile. Abbiamo bisogno di queste informazioni per creare il metodo di azione e la configurazione dei montanti.

Successivamente, creiamo un semplice file jsp success.jsp per visualizzare il risultato del nostro caricamento di file nel caso in cui abbia successo.

<%@ 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>

Di seguito sarà il file dei risultati error.jsp in caso di errore nel caricamento del file -

<%@ 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>

Crea classe d'azione

Successivamente, creiamo una classe Java chiamata uploadFile.java che si occuperà del caricamento del file e dell'archiviazione del file in un luogo sicuro -

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;
   }
}

Il uploadFile.javaè una classe molto semplice. La cosa importante da notare è che l'interceptor FileUpload insieme a Parameters Interceptor fa tutto il lavoro pesante per noi.

L'intercettatore FileUpload rende disponibili tre parametri per impostazione predefinita. Sono denominati nel seguente schema:

• [your file name parameter] - Questo è il file effettivo che l'utente ha caricato. In questo esempio sarà "myFile"

• [your file name parameter]ContentType- Questo è il tipo di contenuto del file che è stato caricato. In questo esempio sarà "myFileContentType"

• [your file name parameter]FileName- Questo è il nome del file che è stato caricato. In questo esempio sarà "myFileFileName"

I tre parametri sono disponibili per noi, grazie agli Struts Interceptors. Tutto quello che dobbiamo fare è creare tre parametri con i nomi corretti nella nostra classe Action e automaticamente queste variabili vengono cablate automaticamente per noi. Quindi, nell'esempio sopra, abbiamo tre parametri e un metodo di azione che restituisce semplicemente "successo" se tutto va bene altrimenti restituisce "errore".

File di configurazione

Di seguito sono riportate le proprietà di configurazione di Struts2 che controllano il processo di caricamento dei file:

Suor n	Proprietà e descrizione
1	struts.multipart.maxSize La dimensione massima (in byte) di un file da accettare come caricamento di file. L'impostazione predefinita è 250M.
2	struts.multipart.parser La libreria utilizzata per caricare il modulo multiparte. Di default èjakarta
3	struts.multipart.saveDir La posizione in cui archiviare il file temporaneo. Di default è javax.servlet.context.tempdir.

Per modificare una qualsiasi di queste impostazioni, puoi utilizzare constant tag nel file struts.xml delle applicazioni, come ho fatto per modificare la dimensione massima di un file da caricare.

Facciamo il nostro struts.xml come segue -

<?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>

Da, FileUploadinterceptor fa parte dello Stack predefinito di interceptor, non è necessario configurarlo esplicitamente. Ma puoi aggiungere il tag <interceptor-ref> all'interno di <action>. L'interceptor fileUpload accetta due parametri(a) maximumSize e (b) allowedTypes.

Il parametro maximumSize imposta la dimensione massima del file consentita (il valore predefinito è circa 2 MB). Il parametro allowedTypes è un elenco separato da virgole di tipi di contenuto accettato (MIME) come mostrato di seguito:

<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>

Di seguito è riportato il contenuto di web.xml file -

<?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>

Ora fai clic con il pulsante destro del mouse sul nome del progetto e fai clic Export > WAR Fileper creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2/upload.jsp. Questo produrrà la seguente schermata:

Ora seleziona un file "Contacts.txt" utilizzando il pulsante Sfoglia e fai clic sul pulsante di caricamento che caricherà il file sul tuo servizio e dovresti vedere la pagina successiva. Puoi controllare che il file caricato sia stato salvato in C: \ apache-tomcat-6.0.33 \ work.

Si noti che FileUpload Interceptor elimina automaticamente il file caricato, quindi è necessario salvare il file caricato a livello di programmazione in una posizione prima che venga eliminato.

Messaggio di errore

L'intercettatore fileUplaod utilizza diversi tasti di messaggio di errore predefiniti:

Suor n	Chiave e descrizione del messaggio di errore
1	struts.messages.error.uploading Un errore generale che si verifica quando il file non può essere caricato.
2	struts.messages.error.file.too.large Si verifica quando il file caricato è troppo grande come specificato da maximumSize.
3	struts.messages.error.content.type.not.allowed Si verifica quando il file caricato non corrisponde ai tipi di contenuto previsti specificati.

Puoi sovrascrivere il testo di questi messaggi in WebContent/WEB-INF/classes/messages.properties file di risorse.

Questo capitolo ti insegnerà come accedere a un database utilizzando Struts 2 in semplici passaggi. Struts è un framework MVC e non un framework di database, ma fornisce un eccellente supporto per l'integrazione JPA / Hibernate. Esamineremo l'integrazione di ibernazione in un capitolo successivo, ma in questo capitolo useremo il semplice vecchio JDBC per accedere al database.

Il primo passo in questo capitolo è configurare e caricare il nostro database. Sto usando MySQL come database per questo esempio. Ho MySQL installato sulla mia macchina e ho creato un nuovo database chiamato "struts_tutorial". Ho creato una tabella chiamatalogine lo ha popolato con alcuni valori. Di seguito è riportato lo script che ho utilizzato per creare e popolare la tabella.

Il mio database MYSQL ha il nome utente predefinito "root" e la password "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');

Il prossimo passo è scaricare il file jar di MySQL Connector e posizionare questo file nella cartella WEB-INF \ lib del tuo progetto. Dopo aver eseguito questa operazione, siamo ora pronti per creare la classe di azioni.

Crea azione

La classe di azione ha le proprietà corrispondenti alle colonne nella tabella del database. abbiamouser, password e namecome attributi String. Nel metodo di azione, utilizziamo i parametri utente e password per verificare se l'utente esiste, in tal caso, visualizziamo il nome utente nella schermata successiva.

Se l'utente ha inserito informazioni errate, lo inviamo nuovamente alla schermata di accesso.

Di seguito è riportato il contenuto di LoginAction.java file -

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;
   }
}

Crea pagina principale

Ora creiamo un file JSP index.jspper raccogliere il nome utente e la password. Questo nome utente e password verranno verificati nel database.

<%@ 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>

Crea viste

Ora creiamo success.jsp file che verrà richiamato nel caso in cui l'azione restituisca SUCCESS, ma avremo un altro file di visualizzazione nel caso in cui venga restituito un ERRORE dall'azione.

<%@ 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>

Di seguito sarà il file di visualizzazione error.jsp in caso di ERRORE viene restituito dall'azione.

<%@ 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>

File di configurazione

Infine, mettiamo insieme tutto usando il file di configurazione struts.xml come segue:

<?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>

Di seguito è riportato il contenuto di web.xml file -

<?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>

Ora, fai clic con il pulsante destro del mouse sul nome del progetto e fai clic Export > WAR Fileper creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Questo produrrà la seguente schermata:

Immettere un nome utente e una password errati. Dovresti vedere la pagina successiva.

Adesso entra scott come nome utente e navycome password. Dovresti vedere la pagina successiva.

Questo capitolo spiega come inviare un'e-mail utilizzando l'applicazione Struts 2.

Per questo esercizio, è necessario scaricare e installare mail.jar da JavaMail API 1.4.4 e posizionare il filemail.jar file nella cartella WEB-INF \ lib e quindi procedere con i passaggi standard di creazione dei file di azione, visualizzazione e configurazione.

Crea azione

Il passaggio successivo consiste nel creare un metodo Action che si occupi dell'invio dell'email. Creiamo una nuova classe chiamataEmailer.java con i seguenti contenuti.

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;
   }
}

Come visto nel codice sorgente sopra, il Emailer.javaha proprietà che corrispondono agli attributi del modulo nella pagina email.jsp fornita di seguito. Questi attributi sono:

• From- L'indirizzo e-mail del mittente. Poiché utilizziamo l'SMTP di Google, abbiamo bisogno di un ID gtalk valido

• Password - La password dell'account di cui sopra

• To - A chi inviare l'email?

• Subject - oggetto dell'email

• Body - Il messaggio di posta elettronica effettivo

Non abbiamo considerato alcuna convalida sui campi sopra, le convalide verranno aggiunte nel prossimo capitolo. Vediamo ora il metodo execute (). Il metodo execute () utilizza la libreria javax Mail per inviare un'e-mail utilizzando i parametri forniti. Se la posta viene inviata correttamente, l'azione restituisce SUCCESS, altrimenti restituisce ERROR.

Crea pagina principale

Scriviamo il file JSP della pagina principale index.jsp, che verranno utilizzati per raccogliere le informazioni relative alla posta elettronica sopra menzionate -

<%@ 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>

Crea viste

Useremo il file JSP success.jsp che verrà richiamato nel caso in cui l'azione restituisca SUCCESS, ma avremo un altro file di visualizzazione nel caso in cui venga restituito un ERRORE dall'azione.

<%@ 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>

Di seguito sarà il file di visualizzazione error.jsp in caso di ERRORE viene restituito dall'azione.

<%@ 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>

File di configurazione

Ora mettiamo insieme tutto usando il file di configurazione struts.xml come segue:

<?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>

Di seguito è riportato il contenuto di web.xml file -

<?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>

Ora, fai clic con il pulsante destro del mouse sul nome del progetto e fai clic Export > WAR Fileper creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Questo produrrà la seguente schermata:

Immettere le informazioni richieste e fare clic Send Emailpulsante. Se tutto va bene, dovresti vedere la pagina seguente.

In questo capitolo, esamineremo più in profondità il framework di convalida di Struts. Al centro di Struts, abbiamo il framework di convalida che aiuta l'applicazione a eseguire le regole per eseguire la convalida prima che il metodo di azione venga eseguito.

La convalida lato client viene solitamente ottenuta utilizzando Javascript. Tuttavia, non si dovrebbe fare affidamento solo sulla convalida lato client. Le migliori pratiche suggeriscono che la convalida dovrebbe essere introdotta a tutti i livelli del framework dell'applicazione. Vediamo ora due modi per aggiungere la convalida al nostro progetto Struts.

Qui, prenderemo un esempio di un file Employee il cui nome ed età dovrebbero essere catturati usando una semplice pagina, e metteremo queste due convalide per assicurarci che l'utente inserisca sempre un nome e un'età che dovrebbero essere compresi tra 28 e 65.

Cominciamo con la pagina JSP principale dell'esempio.

Crea pagina principale

Scriviamo il file JSP della pagina principale index.jsp, che verrà utilizzato per raccogliere le informazioni relative ai dipendenti di cui sopra.

<%@ 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'indice index.jsp utilizza i tag Struts, che non abbiamo ancora trattato, ma li studieremo nei capitoli relativi ai tag. Ma per ora, supponi che il tag s: textfield stampi un campo di input e che s: submit stampi un pulsante di invio. Abbiamo utilizzato la proprietà label per ogni tag che crea l'etichetta per ogni tag.

Crea viste

Useremo il file JSP success.jsp che verrà richiamato nel caso in cui l'azione definita restituisca 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>

Crea azione

Quindi definiamo una piccola classe di azione Employeee quindi aggiungi un metodo chiamato validate() come mostrato di seguito in Employee.javafile. Assicurati che la tua classe di azione estenda l'estensioneActionSupport class, altrimenti il ​​tuo metodo di validazione non verrà eseguito.

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");
      }
   }
}

Come mostrato nell'esempio precedente, il metodo di convalida controlla se il campo "Nome" ha un valore o meno. Se non è stato fornito alcun valore, aggiungiamo un errore di campo per il campo "Nome" con un messaggio di errore personalizzato. In secondo luogo, controlliamo se il valore immesso per il campo "Età" è compreso tra 28 e 65 o meno, se questa condizione non soddisfa aggiungiamo un errore sopra il campo convalidato.

File di configurazione

Infine, mettiamo insieme tutto usando il struts.xml file di configurazione come segue -

<?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>

Di seguito è riportato il contenuto di web.xml file -

<?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>

Ora, fai clic con il pulsante destro del mouse sul nome del progetto e fai clic Export > WAR Fileper creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Questo produrrà la seguente schermata:

Ora non inserire le informazioni richieste, basta fare clic su Submitpulsante. Vedrai il seguente risultato:

Inserisci le informazioni richieste ma inserisci un campo Da sbagliato, diciamo il nome "test" e l'età di 30 anni, e infine fai clic su Submitpulsante. Vedrai il seguente risultato:

Come funziona questa convalida?

Quando l'utente preme il pulsante di invio, Struts 2 eseguirà automaticamente il metodo di convalida e se uno qualsiasi dei file “if”le istruzioni elencate all'interno del metodo sono vere, Struts 2 chiamerà il suo metodo addFieldError. Se sono stati aggiunti errori, Struts 2 non procederà a chiamare il metodo di esecuzione. Piuttosto il framework Struts 2 torneràinput come risultato della chiamata all'azione.

Quindi, quando la convalida fallisce e Struts 2 ritorna input, il framework Struts 2 visualizzerà nuovamente il file index.jsp. Poiché abbiamo utilizzato i tag del modulo di Struts 2, Struts 2 aggiungerà automaticamente i messaggi di errore appena sopra il modulo archiviato.

Questi messaggi di errore sono quelli che abbiamo specificato nella chiamata al metodo addFieldError. Il metodo addFieldError accetta due argomenti. Il primo è il fileform il nome del campo a cui si applica l'errore e il secondo, è il messaggio di errore da visualizzare sopra quel campo del modulo.

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

Per gestire il valore restituito di input dobbiamo aggiungere il seguente risultato al nostro nodo di azione in struts.xml.

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

Convalida basata su XML

Il secondo metodo per eseguire la convalida è posizionare un file xml accanto alla classe di azione. La convalida basata su XML di Struts2 fornisce più opzioni di convalida come la convalida della posta elettronica, la convalida dell'intervallo intero, il campo di convalida del modulo, la convalida dell'espressione, la convalida dell'espressione regolare, la convalida obbligatoria, la convalida della stringa obbligatoria, la convalida della lunghezza della stringa e così via.

Il file xml deve essere denominato '[action-class]'-validation.xml. Quindi, nel nostro caso creiamo un file chiamatoEmployee-validation.xml con i seguenti contenuti -

<!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>

Il file XML sopra sarebbe conservato nel tuo CLASSPATH idealmente insieme al file di classe. Facciamo la nostra classe di azione Employee come segue senza averlavalidate() metodo -

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;
   }
}

Il resto del setup rimarrà come nell'esempio precedente, ora se eseguirai l'applicazione, produrrà lo stesso risultato che abbiamo ricevuto nell'esempio precedente.

Il vantaggio di avere un file xml per memorizzare la configurazione consente la separazione della validazione dal codice dell'applicazione. Potresti chiedere a uno sviluppatore di scrivere il codice e un analista aziendale per creare i file xml di convalida. Un'altra cosa da notare sono i tipi di validatore che sono disponibili per impostazione predefinita.

Ci sono molti altri validatori forniti di default con Struts. I validatori comuni includono Date Validator, Regex validator e String Length validator. Controllare il seguente collegamento per maggiori dettagli Struts - Validatori basati su XML .

L'internazionalizzazione (i18n) è il processo di pianificazione e implementazione di prodotti e servizi in modo che possano essere facilmente adattati a specifiche lingue e culture locali, un processo chiamato localizzazione. Il processo di internazionalizzazione è chiamato abilitazione alla traduzione o alla localizzazione.

L'internazionalizzazione è abbreviata i18n perché la parola inizia con la lettera “i” e termina con “n”e ci sono 18 caratteri tra il primo i e l'ultimo n.

Struts2 fornisce supporto per la localizzazione, ovvero l'internazionalizzazione (i18n) tramite bundle di risorse, intercettatori e librerie di tag nei seguenti luoghi:

• I tag dell'interfaccia utente

• Messaggi ed errori.

• All'interno delle classi di azione.

Pacchetti di risorse

Struts2 utilizza bundle di risorse per fornire più lingue e opzioni locali agli utenti dell'applicazione web. Non devi preoccuparti di scrivere pagine in lingue diverse. Tutto quello che devi fare è creare un pacchetto di risorse per ogni lingua che desideri. I bundle di risorse conterranno titoli, messaggi e altro testo nella lingua dell'utente. I pacchetti di risorse sono il file che contiene le coppie chiave / valore per la lingua predefinita dell'applicazione.

Il formato di denominazione più semplice per un file di risorse è:

bundlename_language_country.properties

Qui, bundlenamepotrebbe essere ActionClass, Interface, SuperClass, Model, Package, Global resource properties. Parte successivalanguage_country rappresenta la locale locale, ad esempio, la lingua spagnola (Spagna) è rappresentata da es_ES e la locale inglese (Stati Uniti) è rappresentata da en_US ecc. dove è possibile saltare la parte del paese che è facoltativa.

Quando si fa riferimento a un elemento del messaggio tramite la sua chiave, il framework Struts cerca un pacchetto di messaggi corrispondente nel seguente ordine:

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

Per sviluppare l'applicazione in più lingue, è necessario mantenere più file di proprietà corrispondenti a tali lingue / impostazioni locali e definire tutto il contenuto in termini di coppie chiave / valore.

Ad esempio, se si intende sviluppare la propria applicazione per l'inglese americano (predefinito), lo spagnolo e il francese, sarà necessario creare tre file delle proprietà. Qui useròglobal.properties solo file, puoi anche utilizzare diversi file di proprietà per separare diversi tipi di messaggi.

• global.properties - Per impostazione predefinita, verrà applicato l'inglese (Stati Uniti)

• global_fr.properties - Questo verrà utilizzato per la lingua francese.

• global_es.properties - Questo verrà utilizzato per la lingua spagnola.

Accedi ai messaggi

Esistono diversi modi per accedere alle risorse del messaggio, inclusi getText, il tag di testo, l'attributo chiave dei tag dell'interfaccia utente e il tag i18n. Vediamoli in breve:

Per visualizzare i18n testo, usa una chiamata a getText nel tag della proprietà o in qualsiasi altro tag, come i tag dell'interfaccia utente come segue:

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

Il text tag recupera un messaggio dal bundle di risorse predefinito, ovvero struts.properties

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

Il i18n taginserisce un bundle di risorse arbitrario nello stack di valori. Altri tag nell'ambito del tag i18n possono visualizzare i messaggi da quel resource bundle

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

Il key l'attributo della maggior parte dei tag dell'interfaccia utente può essere utilizzato per generare un messaggio da un pacchetto di risorse -

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

Esempio di localizzazione

Miriamo a creare index.jspdal capitolo precedente in più lingue. Lo stesso file verrebbe scritto come segue:

<%@ 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>

Creeremo success.jsp file che verrà richiamato nel caso in cui l'azione definita ritorni 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>

Qui avremmo bisogno di creare le seguenti due azioni. (a) Prima azione a per occuparsi delle impostazioni internazionali e visualizzare lo stesso file index.jsp con una lingua diversa (b) Un'altra azione è occuparsi dell'invio del modulo stesso. Entrambe le azioni restituiranno SUCCESSO, ma intraprenderemo azioni diverse in base ai valori di ritorno perché il nostro scopo è diverso per entrambe le azioni

Azione per prendersi cura delle impostazioni locali

package com.tutorialspoint.struts2;

import com.opensymphony.xwork2.ActionSupport;

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

Azione per inviare il modulo

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;
   }
}

Ora creiamo i seguenti tre global.properties file e inserire il file in 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

Creeremo il nostro struts.xml con due azioni come segue:

<?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>

Di seguito è riportato il contenuto di web.xml file -

<?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>

Ora, fai clic con il pulsante destro del mouse sul nome del progetto e fai clic Export > WAR Fileper creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Questo produrrà la seguente schermata:

Ora seleziona una delle lingue, diciamo che selezioniamo Spanish, visualizzerebbe il seguente risultato:

Puoi provare anche con la lingua francese. Infine, proviamo a fare clicSubmit quando siamo in lingua spagnola, verrà visualizzata la seguente schermata:

Congratulazioni, ora che hai una pagina web multilingue, puoi lanciare il tuo sito web a livello globale.

Tutto su una richiesta HTTP viene trattato come un file Stringdal protocollo. Ciò include numeri, valori booleani, numeri interi, date, decimali e tutto il resto. Tuttavia, nella classe Struts, potresti avere proprietà di qualsiasi tipo di dati.

In che modo Struts autowire le proprietà per te?

Struts utilizza una varietà di convertitori di tipo sotto le coperte per fare il sollevamento pesante.

Ad esempio, se hai un attributo intero nella tua classe Action, Struts converte automaticamente il parametro della richiesta nell'attributo intero senza che tu debba fare nulla. Per impostazione predefinita, Struts viene fornito con una serie di convertitori di tipi

Se stai utilizzando uno dei convertitori elencati di seguito, non devi preoccuparti di nulla:

• Intero, Float, Double, Decimal
• Data e data e ora
• Array e collezioni
• Enumerations
• Boolean
• BigDecimal

A volte, quando si utilizza il proprio tipo di dati, è necessario aggiungere i propri convertitori per rendere Struts consapevole di come convertire quei valori prima della visualizzazione. Considera la seguente classe POJOEnvironment.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;
   }
}

Questa è una classe molto semplice che ha un attributo chiamato name, quindi niente di speciale in questa classe. Creiamo un'altra classe che contenga informazioni sul sistema -SystemDetails.java.

Ai fini di questo esercizio, ho codificato l'ambiente in "Sviluppo" e il sistema operativo in "Windows XP SP3".

In un progetto in tempo reale, otterresti queste informazioni dalla configurazione del sistema.

Facciamo la seguente classe d'azione:

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;
   }
}

Successivamente, creiamo un semplice file JSP System.jsp per visualizzare le informazioni sull'ambiente e sul sistema operativo.

<%@ 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>

Cerchiamo di collegare il system.jsp e il SystemDetails.java classe insieme usando struts.xml.

La classe SystemDetails ha un semplice metodo execute () che restituisce la stringa "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>

• Fare clic con il tasto destro sul nome del progetto e fare clic Export > WAR File per creare un file War.

• Quindi distribuire questo WAR nella directory webapps di Tomcat.

• Infine, avvia il server Tomcat e prova ad accedere all'URL http://localhost:8080/HelloWorldStruts2/system.action. Questo produrrà la seguente schermata:

Cosa c'è di sbagliato nell'output di cui sopra? Struts sa come visualizzare e convertire la stringa "Windows XP SP3" e altri tipi di dati incorporati, ma non sa cosa fare con la proprietà diEnvironmentgenere. Si chiama semplicementetoString() metodo sulla classe

Per risolvere questo problema, ora creiamo e registriamo un semplice file TypeConverter per la classe Ambiente.

Crea una classe chiamata EnvironmentConverter.java con quanto segue.

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();
   }	
}

Il EnvironmentConverter estende il StrutsTypeConverter class e dice a Struts come convertire l'ambiente in una stringa e viceversa sovrascrivendo due metodi che sono convertFromString() e convertToString().

Registriamo ora questo convertitore prima di usarlo nella nostra applicazione. Esistono due modi per registrare un convertitore.

Se il convertitore verrà utilizzato solo in una determinata azione, sarà necessario creare un file di proprietà che deve essere denominato come '[action-class]'converstion.properties.

Nel nostro caso creiamo un file chiamato SystemDetails-converstion.properties con la seguente voce di registrazione -

environment = com.tutorialspoint.struts2.EnvironmentConverter

Nell'esempio precedente, "ambiente" è il nome della proprietà nel file SystemDetails.java class e stiamo dicendo a Struts di usare il EnvironmentConverter per la conversione da e verso questa proprietà.

Tuttavia, non lo faremo, ma registreremo questo convertitore a livello globale, in modo che possa essere utilizzato in tutta l'applicazione. A tale scopo, creare un file delle proprietà denominatoxwork-conversion.properties nel WEBINF/classes cartella con la riga seguente

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

Questo registra semplicemente il convertitore a livello globale, quindi Strutspuò eseguire automaticamente la conversione ogni volta che incontra un oggetto del tipo Environment. Ora, se ricompili e riesegui il programma, otterrai un output migliore come segue:

Ovviamente, ora il risultato sarà migliore, il che significa che il nostro convertitore Struts funziona bene.

In questo modo puoi creare più convertitori e registrarli per utilizzarli secondo le tue esigenze.

Prima di iniziare il tutorial vero e proprio per questo capitolo, esaminiamo alcune definizioni fornite da https://struts.apache.org-

Suor n	Termine e descrizione
1	TAG Un piccolo pezzo di codice eseguito da JSP, FreeMarker o Velocity.
2	TEMPLATE Un po 'di codice, solitamente scritto in FreeMarker, che può essere reso da determinati tag (tag HTML).
3	THEME Una raccolta di modelli confezionati insieme per fornire funzionalità comuni.

Suggerirei anche di esaminare il capitolo sulla localizzazione di Struts2 perché prenderemo di nuovo lo stesso esempio per eseguire il nostro esercizio.

Quando usi un file Struts 2tag come <s: submit ...>, <s: textfield ...> ecc nella tua pagina web, il framework Struts 2 genera codice HTML con uno stile e layout preconfigurati. Struts 2 viene fornito con tre temi integrati:

Suor n	Tema e descrizione
1	SIMPLE theme Un tema minimale senza "campane e fischietti". Ad esempio, il tag textfield esegue il rendering del tag HTML <input /> senza etichetta, convalida, segnalazione di errori o qualsiasi altra formattazione o funzionalità.
2	XHTML theme Questo è il tema predefinito utilizzato da Struts 2 e fornisce tutte le nozioni di base fornite dal tema semplice e aggiunge diverse funzionalità come il layout della tabella standard a due colonne per l'HTML, le etichette per ciascuno degli HTML, la convalida e la segnalazione degli errori ecc.
3	CSS_XHTML theme Questo tema fornisce tutte le nozioni di base fornite dal tema semplice e aggiunge diverse funzionalità come il layout standard basato su CSS a due colonne, utilizzando <div> per i tag HTML Struts, etichette per ciascuno dei tag HTML Struts, posizionati secondo il foglio di stile CSS .

Come accennato in precedenza, se non specifichi un tema, Struts 2 utilizzerà il tema xhtml per impostazione predefinita. Ad esempio, questo tag di selezione di Struts 2:

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

genera il seguente markup HTML -

<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>

Qui empinfo è il nome dell'azione definito nel file struts.xml.

Selezione di temi

Puoi specificare il tema secondo Struts 2, in base ai tag oppure puoi usare uno dei seguenti metodi per specificare quale tema Struts 2 dovrebbe usare:

• L'attributo del tema sul tag specifico

• L'attributo del tema sul tag del modulo circostante a un tag

• L'attributo con ambito di pagina denominato "tema"

• L'attributo con ambito di richiesta denominato "tema"

• L'attributo con ambito di sessione denominato "tema"

• L'attributo con ambito applicazione denominato "tema"

• La proprietà struts.ui.theme in struts.properties (il valore predefinito è xhtml)

Di seguito è riportata la sintassi per specificarli a livello di tag se si desidera utilizzare temi diversi per tag diversi:

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

Poiché non è molto pratico utilizzare i temi in base ai tag, quindi semplicemente possiamo specificare la regola in struts.properties file utilizzando i seguenti tag:

# 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

Di seguito è riportato il risultato che abbiamo raccolto dal capitolo sulla localizzazione in cui abbiamo utilizzato il tema predefinito con un'impostazione struts.ui.theme = xhtml in struts-default.properties file che viene fornito per impostazione predefinita nel file struts2-core.xy.z.jar.

Come funziona un tema?

Per un dato tema, ogni tag struts ha un modello associato come s:textfield → text.ftl e s:password → password.ftl eccetera.

Questi file modello vengono compressi nel file struts2-core.xy.z.jar. Questi file modello mantengono un layout HTML predefinito per ogni tag.

In questo modo, Struts 2 framework genera il codice di markup HTML finale utilizzando i tag Sturts e i modelli associati.

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

I modelli predefiniti sono scritti in FreeMarker e hanno un'estensione .ftl.

Puoi anche progettare i tuoi modelli usando velocity o JSP e di conseguenza impostare la configurazione in struts.properties usando struts.ui.templateSuffix e struts.ui.templateDir.

Creazione di nuovi temi

Il modo più semplice per creare un nuovo tema è copiare uno qualsiasi dei file tema / modello esistenti e apportare le modifiche necessarie.

Cominciamo con la creazione di una cartella chiamata templatein WebContent / WEBINF / classes e una sottocartella con il nome del nostro nuovo tema. Ad esempio, WebContent / WEB-INF / classes / template / mytheme .

Da qui, puoi iniziare a creare modelli da zero oppure puoi anche copiare i modelli dal file Struts2 distribution dove è possibile modificarli come richiesto in futuro.

Stiamo per modificare il modello predefinito esistente xhtmlper scopi di apprendimento. Ora, copiamo il contenuto da struts2-core-xyzjar / template / xhtml alla nostra directory del tema e modifichiamo solo il file WebContent / WEBINF / classes / template / mytheme / control .ftl. Quando apriamo control.ftl che avrà le seguenti righe:

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

Cambiamo il file sopra control.ftl per avere il seguente contenuto:

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

Se controlli form.ftl allora lo troverai control.ftlè utilizzato in questo file, ma form.ftl fa riferimento a questo file dal tema xhtml. Quindi cambiamolo come segue:

<#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" />

Presumo che non avresti molta comprensione del file FreeMarker linguaggio template, puoi comunque avere una buona idea di cosa fare guardando i file .ftl.

Tuttavia, salviamo le modifiche precedenti, torniamo al nostro esempio di localizzazione e creiamo il file WebContent/WEB-INF/classes/struts.properties file con il seguente contenuto

# 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

Ora dopo questa modifica, fai clic con il pulsante destro del mouse sul nome del progetto e fai clic Export > WAR Fileper creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2. Questo produrrà la seguente schermata:

Puoi vedere un bordo attorno al componente del modulo che è il risultato della modifica che abbiamo apportato al tema dopo averlo copiato dal tema xhtml. Se fai poco sforzo nell'apprendimento di FreeMarker, sarai in grado di creare o modificare i tuoi temi molto facilmente.

Spero che ora tu abbia una conoscenza di base su Sturts 2 temi e modelli, non è vero?

Strutsfornisce un modo più semplice per gestire le eccezioni non rilevate e reindirizzare gli utenti a una pagina di errore dedicata. Puoi facilmente configurare Struts in modo che abbia pagine di errore diverse per eccezioni diverse.

Struts semplifica la gestione delle eccezioni mediante l'uso dell'intercettore "eccezioni". L'intercettore "eccezioni" è incluso come parte dello stack predefinito, quindi non devi fare nulla in più per configurarlo. È disponibile out-of-the-box pronto per l'uso.

Vediamo un semplice esempio di Hello World con alcune modifiche nel file HelloWorldAction.java. Qui, abbiamo deliberatamente introdotto un'eccezione NullPointer nel nostroHelloWorldAction codice azione.

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;
   }
}

Manteniamo il contenuto di HelloWorld.jsp come segue -

<%@ 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>

Di seguito è riportato il contenuto di 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>

Il tuo struts.xml dovrebbe apparire come -

<?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>

Ora fai clic con il pulsante destro del mouse sul nome del progetto e fai clic Export > WAR Fileper creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Questo produrrà la seguente schermata:

Immettere un valore "Struts2" e inviare la pagina. Dovresti vedere la pagina seguente:

Come mostrato nell'esempio precedente, l'intercettore di eccezioni predefinito fa un ottimo lavoro nel gestire l'eccezione.

Creiamo ora una pagina di errore dedicata per la nostra eccezione. Crea un file chiamatoError.jsp con i seguenti contenuti -

<%@ 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>

Configuriamo ora Struts per utilizzare questa pagina di errore in caso di eccezione. Modifichiamo il filestruts.xml come segue -

<?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>

Come mostrato nell'esempio sopra, ora abbiamo configurato Struts per utilizzare Error.jsp dedicato per NullPointerException. Se riesegui il programma ora, ora vedrai il seguente output:

Oltre a questo, il framework Struts2 viene fornito con un intercettore di "registrazione" per registrare le eccezioni. Abilitando il logger a registrare le eccezioni non rilevate, possiamo facilmente guardare la traccia dello stack e capire cosa è andato storto

Mapping delle eccezioni globali

Abbiamo visto come possiamo gestire l'eccezione specifica dell'azione. Possiamo impostare un'eccezione a livello globale che verrà applicata a tutte le azioni. Ad esempio, per catturare le stesse eccezioni NullPointerException, potremmo aggiungere<global-exception-mappings...> tag all'interno del tag <pacchetto ...> e il suo tag <risultato ...> dovrebbero essere aggiunti all'interno del tag <azione ...> nel file struts.xml come segue:

<?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>

Come accennato in precedenza, Struts fornisce due forme di configurazione. Il modo tradizionale è usare ilstruts.xmlfile per tutte le configurazioni. Finora ne abbiamo visti tanti esempi nel tutorial. L'altro modo per configurare Struts è utilizzare la funzione Annotazioni di Java 5. Usando le annotazioni sui montanti, possiamo ottenereZero Configuration.

Per iniziare a utilizzare le annotazioni nel tuo progetto, assicurati di aver incluso i seguenti file jar nel tuo file WebContent/WEB-INF/lib cartella -

• 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

Vediamo ora come eliminare la configurazione disponibile in struts.xml file e sostituirlo con annotaions.

Per spiegare il concetto di annotazione in Struts2, dovremmo riconsiderare il nostro esempio di convalida spiegato nel capitolo Validazioni di Struts2 .

Qui, prenderemo un esempio di un Dipendente il cui nome, età sarebbe catturato utilizzando una semplice pagina, e metteremo due convalide per assicurarci che ÜSER inserisca sempre un nome e l'età dovrebbe essere compresa tra 28 e 65 anni.

Cominciamo con la pagina JSP principale dell'esempio.

Crea pagina principale

Scriviamo il file JSP della pagina principale index.jsp, che viene utilizzato per raccogliere le informazioni relative ai dipendenti di cui sopra.

<%@ 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'indice index.jsp utilizza i tag Struts, che non abbiamo ancora trattato ma li studieremo nei capitoli relativi ai tag. Ma per ora, supponi che il tag s: textfield stampi un campo di input e che s: submit stampi un pulsante di invio. Abbiamo utilizzato la proprietà label per ogni tag che crea l'etichetta per ogni tag.

Crea viste

Useremo il file JSP success.jsp che verrà richiamato nel caso in cui l'azione definita ritorni 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>

Crea azione

Questo è il luogo in cui viene utilizzata l'annotazione. Ridefiniamo la classe di azioneEmployee con annotazione, quindi aggiungi un metodo chiamato validate () come mostrato di seguito in Employee.javafile. Assicurati che la tua classe di azione estenda l'estensioneActionSupport class, altrimenti il ​​tuo metodo di validazione non verrà eseguito.

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;
   }
}

Abbiamo usato poche annotazioni in questo esempio. Fammi esaminare uno per uno -

• Innanzitutto, abbiamo incluso il file Resultsannotazione. Un'annotazione dei risultati è una raccolta di risultati.

• Sotto l'annotazione dei risultati, abbiamo due annotazioni dei risultati. Le annotazioni dei risultati hanno l'estensionenameche corrispondono al risultato del metodo di esecuzione. Contengono anche una posizione su quale vista dovrebbe essere servita corrispondente al valore restituito da execute ()

• La prossima annotazione è il file Actionannotazione. Viene utilizzato per decorare il metodo execute (). Il metodo Action accetta anche un valore che è l'URL su cui viene richiamata l'azione.

• Infine, ne ho usati due validationannotazioni. Ho configurato il validatore di campo richiesto suname campo e il validatore dell'intervallo intero sul agecampo. Ho anche specificato un messaggio personalizzato per le convalide.

File di configurazione

Non ne abbiamo davvero bisogno struts.xml file di configurazione, quindi rimuoviamolo e controlliamo il contenuto di web.xml file -

<?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>

Ora, fai clic con il pulsante destro del mouse sul nome del progetto e fai clic Export > WAR Fileper creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Questo produrrà la seguente schermata:

Ora non inserire le informazioni richieste, basta fare clic su Submitpulsante. Vedrai il seguente risultato:

Inserisci le informazioni richieste ma inserisci un campo Da sbagliato, diciamo il nome "test" e l'età di 30 anni, e infine fai clic su Submitpulsante. Vedrai il seguente risultato:

Tipi di annotazioni di Struts 2

Le applicazioni Struts 2 possono utilizzare le annotazioni Java 5 come alternativa alla configurazione delle proprietà XML e Java. Puoi controllare l'elenco delle annotazioni più importanti relative a diverse categorie -

Tipi di annotazioni di Struts 2 .

I tag Struts 2 hanno una serie di tag che facilitano il controllo del flusso di esecuzione della pagina.

Di seguito è riportato l'elenco dei tag di controllo importanti di Struts 2:

I tag If e Else

Questi tag eseguono il flusso delle condizioni di base che si trovano in ogni lingua.

'If' tag viene utilizzato da solo o con 'Else If' Tag e / o singolo / multiplo 'Else' Etichetta come mostrato di seguito -

<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>

Controllare l'esempio dettagliato

I tag Iterator

Questo iteratoritererà su un valore. Un valore iterabile può essere un file itherjava.util.Collection o java.util.Iterator. Durante l'iterazione su un iteratore, puoi usareSort tag per ordinare il risultato o SubSet tag per ottenere un sottoinsieme dell'elenco o dell'array.

L'esempio seguente recupera il valore del metodo getDays () dell'oggetto corrente nello stack di valori e lo utilizza per eseguire l'iterazione.

Il tag <s: property /> stampa il valore corrente dell'iteratore.

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

Controllare l'esempio dettagliato

Il tag di unione

Queste merge tag accetta due o più elenchi come parametri e li unisce tutti insieme come mostrato di seguito -

<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>

Controllare l'esempio dettagliato

Il tag di aggiunta

Queste append il tag accetta due o più elenchi come parametri e li aggiunge tutti insieme come mostrato di seguito -

<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>

Controllare l'esempio dettagliato

Il tag generatore

Queste generatortag genera un iteratore basato sull'attributo val fornito. Il seguente tag generatore genera un iteratore e lo stampa usando il tag iteratore.

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

Controllare l'esempio dettagliato

The Struts 2 data tagsvengono utilizzati principalmente per manipolare i dati visualizzati su una pagina. Di seguito sono elencati i tag di dati importanti: <Inizia qui>

Il tag di azione

Questo tag consente agli sviluppatori di chiamare le azioni direttamente da una pagina JSP specificando il nome dell'azione e uno spazio dei nomi facoltativo. Il contenuto del corpo del tag viene utilizzato per visualizzare i risultati dell'azione. Qualsiasi processore dei risultati definito per questa azione in struts.xml verrà ignorato, a meno che non venga specificato il parametro executeResult.

<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" />

Controllare l'esempio dettagliato

Il tag di inclusione

Queste include verrà utilizzato per includere un file JSP in un'altra pagina 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>

Controllare l'esempio dettagliato

The Bean Tag

Queste beantag crea un'istanza di una classe conforme alla specifica JavaBeans. Questo tag ha un corpo che può contenere un numero di elementi Param per impostare qualsiasi metodo mutatore su quella classe. Se l'attributo var è impostato sul BeanTag, posizionerà il bean istanziato nel contesto dello stack.

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

Controllare l'esempio dettagliato

Il tag della data

Queste datetag ti permetterà di formattare una data in modo semplice e veloce. Puoi specificare un formato personalizzato (ad es. "Gg / MM / aaaa hh: mm"), puoi generare notazioni facilmente leggibili (come "in 2 ore, 14 minuti") o puoi semplicemente ripiegare su un formato predefinito con chiave "struts.date.format" nel file delle proprietà.

<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" />

Controllare l'esempio dettagliato

Il tag Param

Queste paramtag può essere utilizzato per parametrizzare altri tag. Questo tag ha i seguenti due parametri.

• name (String) - il nome del parametro

• value (Object) - il valore del parametro

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

Controllare l'esempio dettagliato

Il tag di proprietà

Queste property tag viene utilizzato per ottenere la proprietà di un valore, che verrà impostato automaticamente in cima allo stack se non ne viene specificato nessuno.

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

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

Controllare l'esempio dettagliato

Il Push Tag

Queste push tag viene utilizzato per spingere il valore sullo stack per un utilizzo semplificato.

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

Controllare l'esempio dettagliato

Il Set Tag

Queste settag assegna un valore a una variabile in un ambito specificato. È utile quando si desidera assegnare una variabile a un'espressione complessa e quindi fare semplicemente riferimento a quella variabile ogni volta anziché all'espressione complessa. Gli ambiti disponibili sonoapplication, session, request, page e action.

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

Controllare l'esempio dettagliato

Il tag di testo

Queste text tag viene utilizzato per visualizzare un messaggio di testo 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>

Controllare l'esempio dettagliato

Il tag URL

Queste url tag viene utilizzato per creare un 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>

Controllare l'esempio dettagliato

L'elenco di formtag è un sottoinsieme dei tag dell'interfaccia utente di Struts. Questi tag aiutano nel rendering dell'interfaccia utente richiesta per le applicazioni web Struts e possono essere classificati in tre categorie. Questo capitolo ti mostrerà tutti e tre i tipi di tag dell'interfaccia utente:

Tag dell'interfaccia utente semplici

Abbiamo già usato questi tag nei nostri esempi, li tratteremo in questo capitolo. Guardiamo una semplice pagina di visualizzazioneemail.jsp con diversi tag dell'interfaccia utente semplici -

<%@ 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>

Se sei a conoscenza dell'HTML, tutti i tag utilizzati sono tag HTML molto comuni con un prefisso aggiuntivo s:insieme a ogni tag e attributi diversi. Quando eseguiamo il programma di cui sopra, otteniamo la seguente interfaccia utente a condizione che tu abbia impostato la mappatura corretta per tutti i tasti utilizzati.

Come mostrato, s: head genera gli elementi javascript e del foglio di stile richiesti per l'applicazione Struts2.

Successivamente, abbiamo gli elementi s: div e s: text. Il s: div viene utilizzato per eseguire il rendering di un elemento Div HTML. Questo è utile per le persone che non amano mischiare insieme tag HTML e Struts. Per quelle persone, hanno la possibilità di usare s: div per rendere un div.

Il testo s: come mostrato viene utilizzato per visualizzare un testo sullo schermo.

Poi abbiamo il famiilar s: form tag. Il tag s: form ha un attributo di azione che determina dove inviare il modulo. Poiché abbiamo un elemento di caricamento del file nel modulo, dobbiamo impostare l'enctype su multipart. Altrimenti, possiamo lasciare questo campo vuoto.

Alla fine del tag del form, abbiamo il tag s: submit. Viene utilizzato per inviare il modulo. Quando il modulo viene inviato, tutti i valori del modulo vengono inviati all'azione specificata nel tag s: form.

All'interno del s: form, abbiamo un attributo nascosto chiamato secret. Questo rende un elemento nascosto nell'HTML. Nel nostro caso, l'elemento "segreto" ha il valore "abracadabra". Questo elemento non è visibile all'utente finale e viene utilizzato per trasferire lo stato da una vista all'altra.

Successivamente abbiamo i tag s: label, s: textfield, s: password e s: textarea. Questi sono usati per rendere rispettivamente l'etichetta, il campo di input, la password e l'area di testo. Li abbiamo visti in azione nell'esempio "Struts - Invio di e-mail".

La cosa importante da notare qui è l'uso dell'attributo "chiave". L'attributo "chiave" viene utilizzato per recuperare l'etichetta per questi controlli dal file delle proprietà. Abbiamo già trattato questa funzione nel capitolo Localizzazione di Struts2, internazionalizzazione.

Quindi, abbiamo il tag s: file che rende un componente di caricamento del file di input. Questo componente consente all'utente di caricare file. In questo esempio, abbiamo utilizzato il parametro "accept" del tag s: file per specificare quali tipi di file possono essere caricati.

Infine abbiamo il tag s: token. Il tag token genera un token univoco che viene utilizzato per scoprire se un modulo è stato inviato due volte

Quando viene eseguito il rendering del modulo, una variabile nascosta viene inserita come valore del token. Diciamo, ad esempio, che il token è "ABC". Quando questo modulo viene inviato, Struts Fitler confronta il token con il token memorizzato nella sessione. Se corrisponde, rimuove il token dalla sessione. Ora, se il modulo viene reinviato accidentalmente (sia aggiornando o premendo il pulsante Indietro del browser), il modulo verrà nuovamente inviato con "ABC" come token. In questo caso, il filtro controlla nuovamente il token rispetto al token memorizzato nella sessione. Ma poiché il token "ABC" è stato rimosso dalla sessione, non corrisponderà e il filtro Struts rifiuterà la richiesta.

Tag dell'interfaccia utente di gruppo

I tag dell'interfaccia utente di gruppo vengono utilizzati per creare il pulsante di opzione e la casella di controllo. Guardiamo una semplice pagina di visualizzazioneHelloWorld.jsp con casella di controllo e tag del pulsante di opzione -

<%@ 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>

Quando eseguiamo il programma sopra, il nostro output sarà simile al seguente:

Vediamo ora l'esempio. Nel primo esempio, stiamo creando un semplice pulsante di opzione con l'etichetta "Gender". L'attributo name è obbligatorio per il tag del pulsante di opzione, quindi specifichiamo un nome che è "sesso". Forniamo quindi un elenco al sesso. L'elenco è popolato con i valori "maschio" e "femmina". Pertanto, nell'output otteniamo un pulsante di opzione con due valori al suo interno.

Nel secondo esempio, stiamo creando un elenco di caselle di controllo. Questo per raccogliere gli hobby dell'utente. L'utente può avere più di un hobby e quindi stiamo utilizzando la casella di controllo invece del pulsante di opzione. La casella di controllo è popolata con l'elenco "sport", "TV" e "Shopping". Questo presenta gli hobby come un elenco di caselle di controllo.

Seleziona Tag dell'interfaccia utente

Esploriamo le diverse varianti del Select Tag offerto da Struts. Guardiamo una semplice pagina di visualizzazioneHelloWorld.jsp con tag selezionati -

<%@ 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>

Quando eseguiamo il programma sopra, il nostro output sarà simile al seguente:

Esaminiamo ora i singoli casi, uno per uno.

• Innanzitutto, il tag di selezione esegue il rendering della casella di selezione HTML. Nel primo esempio, stiamo creando una semplice casella di selezione con il nome "nome utente" e l'etichetta "nome utente". La casella di selezione verrà popolata con un elenco che contiene i nomi Mike, John e Smith.

• Nel secondo esempio, la nostra azienda ha sede in America. Ha anche uffici globali in Asia ed Europa. Vogliamo visualizzare gli uffici in una casella di selezione ma vogliamo raggruppare gli uffici globali in base al nome del continente. È qui che l'optgroup torna utile. Usiamo il tag s: optgroup per creare un nuovo gruppo. Diamo al gruppo un'etichetta e un elenco separato.

• Nel terzo esempio, viene utilizzata la casella combinata. Una casella combinata è una combinazione di un campo di input e una casella di selezione. L'utente può selezionare un valore dalla casella di selezione, nel qual caso il campo di input viene automaticamente riempito con il valore selezionato dall'utente. Se l'utente inserisce un valore direttamente, non verrà selezionato alcun valore dalla casella di selezione.

• Nel nostro esempio abbiamo la casella combinata che elenca i segni del sole. La casella di selezione elenca solo quattro voci che consentono all'utente di digitare il proprio segno solare se non è nell'elenco. Aggiungiamo anche una voce di intestazione alla casella di selezione. La voce di intestazione è quella visualizzata nella parte superiore della casella di selezione. Nel nostro caso vogliamo visualizzare "Please Select". Se l'utente non seleziona nulla, assumiamo -1 come valore. In alcuni casi, non vogliamo che l'utente selezioni un valore vuoto. In queste condizioni, si imposta la proprietà "emptyOption" su false. Infine, nel nostro esempio forniamo "capricorno" come valore predefinito per la casella combinata.

• Nel quarto esempio, abbiamo una doppia selezione. Una doppia selezione viene utilizzata quando si desidera visualizzare due caselle di selezione. Il valore selezionato nella prima casella di selezione determina ciò che appare nella seconda casella di selezione. Nel nostro esempio, la prima casella di selezione mostra "Tecnico" e "Altro". Se l'utente seleziona Tecnico, visualizzeremo IT e Hardware nella seconda casella di selezione. Altrimenti visualizzeremo Contabilità e Risorse umane. Ciò è possibile utilizzando gli attributi "list" e "doubleList" come mostrato nell'esempio.

Nell'esempio sopra, abbiamo fatto un confronto per vedere se la casella di selezione in alto è uguale a Tecnico. In caso affermativo, visualizziamo IT e hardware.

Dobbiamo anche dare un nome alla casella superiore ("name = 'Occupations') e alla casella inferiore (doubleName = 'occupations2')

Struts utilizza il framework DOJO per l'implementazione del tag AJAX. Prima di tutto, per procedere con questo esempio, devi aggiungere struts2-dojo-plugin-2.2.3.jar al tuo classpath.

È possibile ottenere questo file dalla cartella lib del download di struts2 (C: \ struts-2.2.3all \ struts-2.2.3 \ lib \ struts2-dojo-plugin-2.2.3.jar)

Per questi esercizi, modifichiamo HelloWorld.jsp come segue -

<%@ 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>

Quando eseguiamo l'esempio precedente, otteniamo il seguente output:

Esaminiamo ora questo esempio un passo alla volta.

La prima cosa da notare è l'aggiunta di una nuova libreria di tag con il prefisso sx. Questa (struts-dojo-tags) è la libreria di tag creata appositamente per l'integrazione con ajax.

Quindi all'interno della testata HTML chiamiamo sx: head. Questo inizializza il framework dojo e lo rende pronto per tutte le chiamate AJAX all'interno della pagina. Questo passaggio è importante: le tue chiamate ajax non funzioneranno senza l'inizializzazione di sx: head.

Per prima cosa abbiamo il tag autocompleter. Il tag di completamento automatico assomiglia più o meno a una casella di selezione. È popolato con i valori rosso, verde e blu. Ma la differenza tra una casella di selezione e questa è che si completa automaticamente. Cioè, se inizi a digitare gr, lo riempirà di "verde". Oltre a questo, questo tag è molto simile al tag s: select di cui abbiamo parlato in precedenza.

Successivamente, abbiamo un selettore di data e ora. Questo tag crea un campo di input con un pulsante accanto ad esso. Quando si preme il pulsante, viene visualizzato un popup di selezione della data e dell'ora. Quando l'utente seleziona una data, la data viene inserita nel testo di input nel formato specificato nell'attributo tag. Nel nostro esempio, abbiamo specificato gg / MM / aaaa come formato per la data.

Successivamente creiamo un tag URL nel file system.action che abbiamo creato negli esercizi precedenti. Non deve essere necessariamente system.action: potrebbe essere qualsiasi file di azione creato in precedenza. Quindi abbiamo un div con il collegamento ipertestuale impostato sull'URL e il ritardo impostato su 2 secondi. Quello che succede quando lo esegui è che il "Contenuto iniziale" verrà visualizzato per 2 secondi, quindi il contenuto del div verrà sostituito con il contenuto delhello.action esecuzione.

Infine abbiamo un semplice pannello a schede con due schede. Le schede sono divs themseleves con le etichette Tab 1 e Tab2.

Vale la pena notare che l'integrazione del tag AJAX in Struts è ancora un work in progress e la maturità di questa integrazione sta lentamente aumentando ad ogni release.

Spring è un popolare framework web che fornisce una facile integrazione con molte attività web comuni. Quindi la domanda è: perché abbiamo bisogno della primavera quando abbiamo Struts2? Bene, Spring è più di un framework MVC: offre molte altre chicche che non sono disponibili in Struts.

Ad esempio: inserimento delle dipendenze che può essere utile a qualsiasi framework. In questo capitolo, esamineremo un semplice esempio per vedere come integrare Spring e Struts2 insieme.

Prima di tutto, devi aggiungere i seguenti file al percorso di compilazione del progetto dall'installazione di Spring. Puoi scaricare e installare l'ultima versione di Spring Framework dahttps://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

Infine aggiungi struts2-spring-plugin-x.y.z.jar nel tuo WEB-INF/libdalla directory lib di struts. Se stai usando Eclipse, potresti incontrare un'eccezione java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderListener .

Per risolvere questo problema, dovresti entrare MarkerFare clic con il tasto Tab e destro sulle dipendenze delle classi una per una ed eseguire la correzione rapida per pubblicare / esportare tutte le dipendenze. Infine assicurati che non ci siano conflitti di dipendenza disponibili nella scheda marker.

Ora impostiamo il file web.xml per l'integrazione Struts-Spring come segue:

<?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 cosa importante da notare qui è l'ascoltatore che abbiamo configurato. IlContextLoaderListenerè necessario per caricare il file di contesto della molla. Viene chiamato il file di configurazione di SpringapplicationContext.xml file e deve essere posizionato allo stesso livello del file web.xml file

Creiamo una semplice classe di azioni chiamata User.java con due proprietà: firstName e 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;
   }
}

Ora creiamo il file applicationContext.xml file di configurazione spring e istanziare il file User.javaclasse. Come accennato in precedenza, questo file dovrebbe trovarsi nella cartella 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>

Come visto sopra, abbiamo configurato lo user bean e abbiamo inserito i valori Michael e Jacksonnel fagiolo. Abbiamo anche dato a questo bean un nome "userClass", in modo da poterlo riutilizzare altrove. Quindi creiamo il fileUser.jsp nella cartella 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>

Il User.jspil file è piuttosto semplice. Ha un solo scopo: visualizzare i valori del nome e del cognome dell'oggetto utente. Infine, mettiamo insieme tutte le entità usando ilstruts.xml file.

<?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 cosa importante da notare è che stiamo usando l'id userClassper fare riferimento alla classe. Ciò significa che stiamo usando la molla per eseguire l'inserimento delle dipendenze per la classe User.

Ora fai clic con il pulsante destro del mouse sul nome del progetto e fai clic Export > WAR Fileper creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2/User.jsp. Questo produrrà la seguente schermata:

Abbiamo ora visto come mettere insieme due grandi strutture. Questo conclude il capitolo sull'integrazione di Struts - Spring.

In questo capitolo, esaminiamo i passaggi coinvolti nell'integrazione del framework Tiles con Struts2. Apache Tiles è un framework di modelli creato per semplificare lo sviluppo delle interfacce utente delle applicazioni web.

Prima di tutto dobbiamo scaricare i file jar delle piastrelle dal sito Web di Apache Tiles . È necessario aggiungere i seguenti file jar al percorso di classe del progetto.

• 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

Oltre a quanto sopra, dobbiamo copiare i seguenti file jar dal download di struts2 nel tuo file WEB-INF/lib.

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

Ora impostiamo il file web.xmlper l'integrazione Struts-Tiles come indicato di seguito. Ci sono due punti importanti da notare qui. Per prima cosa, dobbiamo dire alle piastrelle, dove trovare il file di configurazione delle piastrelletiles.xml. Nel nostro caso, sarà sotto/WEB-INFcartella. Quindi dobbiamo inizializzare il listener Tiles fornito con il download di 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>

Quindi creiamo tiles.xml nella cartella / WEB-INF con i seguenti contenuti -

<?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>

Successivamente, definiamo un layout scheletro di base nel file baseLayout.jsp. Ha cinque aree riutilizzabili / sovrascrivibili. Vale a diretitle, banner, menu, body e footer. Forniamo i valori predefiniti per baseLayout e quindi creiamo due personalizzazioni che si estendono dal layout predefinito. Il layout della tigre è simile al layout di base, tranne per il fatto che utilizza l'estensionetiger.jspcome corpo e il testo "Tiger" come titolo. Allo stesso modo, il layout del leone è simile al layout di base, tranne che utilizza l'estensionelion.jsp come corpo e il testo "Leone" come titolo.

Diamo uno sguardo ai singoli file jsp. Di seguito è riportato il contenuto dibaseLayout.jsp file -

<%@ 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>

Qui, abbiamo appena messo insieme una pagina HTML di base che ha gli attributi delle tessere. Inseriamo gli attributi delle tessere nei punti in cui ne abbiamo bisogno. Successivamente, creiamo un filebanner.jsp file con il seguente contenuto -

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

Il menu.jsp file avrà le seguenti righe che sono i collegamenti - alle azioni TigerMenu.action e LionMenu.action.

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

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

Il lion.jsp il file avrà il seguente contenuto:

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

Il tiger.jsp il file avrà il seguente contenuto:

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

Successivamente, creiamo il file della classe di azioni MenuAction.java che contiene quanto segue -

package com.tutorialspoint.struts2;

import com.opensymphony.xwork2.ActionSupport;

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

Questa è una lezione piuttosto semplice. Abbiamo dichiarato due metodi tiger () e lion () che restituiscono rispettivamente tiger e lion come risultati. Mettiamo tutto insieme nel filestruts.xml file -

<!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>

Controlliamo cosa abbiamo fatto nel file sopra. Prima di tutto, abbiamo dichiarato un nuovo tipo di risultato chiamato "tile" poiché ora stiamo usando tile invece di semplice jsp per la tecnologia di visualizzazione. Struts2 ha il suo supporto per il tipo di risultato Tiles View, quindi creiamo il tipo di risultato "tiles" in modo che sia della classe "org.apache.struts2.view.tiles.TilesResult".

Successivamente, vogliamo dire se la richiesta è per /tigerMenu.action porta l'utente alla pagina delle tessere della tigre e se la richiesta è per /lionMenu.action porta l'utente alla pagina delle tessere del leone.

Otteniamo questo utilizzando un po 'di espressione regolare. Nella nostra definizione di azione, diciamo che tutto ciò che corrisponde al pattern "* Menu" sarà gestito da questa azione. Il metodo di corrispondenza verrà richiamato nella classe MenuAction. Cioè, tigerMenu.action richiamerà tiger () e lionMenu.action richiamerà lion (). Dobbiamo quindi mappare il risultato del risultato alle pagine delle tessere appropriate.

Ora fai clic con il pulsante destro del mouse sul nome del progetto e fai clic Export > WAR Fileper creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2/tigerMenu.jsp. Questo produrrà la seguente schermata:

Allo stesso modo, se vai alla pagina lionMenu.action, vedrai la pagina del leone che utilizza lo stesso layout delle tessere.

Hibernate è un servizio di query e persistenza di oggetti / relazionali ad alte prestazioni concesso in licenza con GNU Lesser General Public License (LGPL) open source ed è scaricabile gratuitamente. In questo capitolo. impareremo come ottenere l'integrazione di Struts 2 con Hibernate. Se non hai familiarità con Hibernate, puoi controllare il nostro tutorial Hibernate .

Configurazione del database

Per questo tutorial, userò il database MySQL "struts2_tutorial". Mi collego a questo database sulla mia macchina utilizzando il nome utente "root" e nessuna password. Prima di tutto, devi eseguire il seguente script. Questo script crea una nuova tabella chiamatastudent e crea pochi record in questa tabella -

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);

Configurazione di ibernazione

Quindi creiamo hibernate.cfg.xml che è il file di configurazione di 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>

Esaminiamo il file di configurazione di ibernazione. Innanzitutto, abbiamo dichiarato che stiamo utilizzando il driver MySQL. Quindi abbiamo dichiarato l'URL jdbc per la connessione al database. Quindi abbiamo dichiarato il nome utente, la password e la dimensione del pool della connessione. Abbiamo anche indicato che vorremmo vedere l'SQL nel file di registro attivando "show_sql" su true. Segui il tutorial di ibernazione per capire cosa significano queste proprietà.

Infine, impostiamo la classe di mappatura com.tutorialspoint.hibernate.Student che creeremo in questo capitolo.

Configurazione dell'ambiente

Successivamente hai bisogno di un sacco di barattoli per questo progetto. In allegato è uno screenshot dell'elenco completo dei file JAR richiesti -

La maggior parte dei file JAR può essere ottenuta come parte della distribuzione di struts. Se è installato un server delle applicazioni come glassfish, websphere o jboss, è possibile ottenere la maggior parte dei file jar rimanenti dalla cartella lib del server delle applicazioni. In caso contrario, puoi scaricare i file individualmente -

• File jar di ibernazione - Hibernate.org

• Plugin di ibernazione di Struts - Plugin di ibernazione di Struts

• File JTA: file JTA

• File dom4j - Dom4j

• file log4j - log4j

Il resto dei file, dovresti essere in grado di ottenerlo dalla tua distribuzione Struts2.

Classi di ibernazione

Creiamo ora le classi java richieste per l'integrazione di ibernazione. Di seguito è riportato il contenuto diStudent.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;
   }
}

Questa è una classe POJO che rappresenta il file studenttabella secondo le specifiche di Hibernate. Ha proprietà id, firstName e lastName che corrispondono ai nomi delle colonne della tabella degli studenti. Quindi creiamoStudentDAO.java file come segue -

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 è il livello di accesso ai dati per la classe Student. Ha metodi per elencare tutti gli studenti e quindi per salvare un nuovo record studente.

Classe di azione

File seguente AddStudentAction.javadefinisce la nostra classe di azione. Abbiamo due metodi di azione qui: execute () e listStudents (). Il metodo execute () viene utilizzato per aggiungere il nuovo record dello studente. Usiamo il metodo save () di dao per ottenere questo risultato.

L'altro metodo, listStudents () viene utilizzato per elencare gli studenti. Usiamo il metodo list di dao per ottenere l'elenco di tutti gli studenti.

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;
   }
	
}

Noterai che stiamo implementando l'interfaccia ModelDriven. Viene utilizzato quando la classe di azione ha a che fare con una classe modello concreta (come Student) anziché con proprietà individuali (come firstName, lastName). L'interfaccia ModelAware richiede di implementare un metodo per restituire il modello. Nel nostro caso restituiamo l'oggetto "studente".

Crea file di visualizzazione

Creiamo ora il file student.jsp visualizza file con il seguente contenuto -

<%@ 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>

Student.jsp è piuttosto semplice. Nella sezione superiore, abbiamo un modulo che invia a "addStudent.action". Accetta firstName, lastName e mark. Poiché l'azione addStudent è legata all'azione ModelAware "AddSudentAction", verrà creato automaticamente un bean studente con i valori per firstName, lastName e contrassegni popolati automaticamente.

Nella sezione inferiore, esaminiamo l'elenco degli studenti (vedi AddStudentAction.java). Scorriamo l'elenco e visualizziamo i valori per nome, cognome e contrassegni in una tabella.

Configurazione Struts

Mettiamo tutto insieme usando 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 cosa importante da notare qui è che il nostro pacchetto "myhibernate" estende il pacchetto predefinito di struts2 chiamato "hibernate-default". Dichiariamo quindi due azioni: addStudent e listStudents. addStudent chiama execute () sulla classe AddStudentAction e quindi, in caso di esito positivo, chiama il metodo di azione listStudents.

Il metodo di azione listStudent chiama listStudents () sulla classe AddStudentAction e utilizza student.jsp come vista.

Ora, fai clic con il pulsante destro del mouse sul nome del progetto e fai clic Export > WAR Fileper creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2/student.jsp. Questo produrrà la seguente schermata:

Nella sezione superiore, otteniamo un modulo per inserire i valori per un nuovo record studente e la sezione inferiore elenca gli studenti nel database. Vai avanti e aggiungi un nuovo record studente e premi Invia. La schermata si aggiornerà e ti mostrerà un elenco aggiornato ogni volta che fai clic su Invia.