2. L'applicazione strutspersonne
Abbiamo implementato un'applicazione "person" utilizzando il metodo tradizionale: servlet e pagine JSP. Proponiamo ora di introdurre Struts utilizzando questa stessa applicazione.
2.1. Come funziona l'applicazione
Rivediamo come funziona l'applicazione "person" che abbiamo sviluppato. Essa è composta da:
- un servlet principale. Questo gestisce tutta la logica dell'applicazione.
- tre pagine JSP: formulaire.personne.jsp, reponse.personne.jsp ed erreurs.personne.jsp
L'applicazione funziona come segue. È accessibile tramite l'URL http://localhost:8080/personne/main. A questo URL, viene visualizzato un modulo fornito dalla pagina formulaire.personne.jsp:
L'utente compila il modulo e fa clic sul pulsante [Invia]. Il pulsante [Reimposta] serve a ripristinare il documento allo stato in cui è stato ricevuto. Il pulsante [Elimina] è un pulsante standard. L'utente deve fornire un nome e un'età validi. In caso contrario, gli viene inviata una pagina di errore tramite la pagina JSP erreurs.personne.jsp. Ecco alcuni esempi:
Scambio n. 1
 |  |
Se clicchi sul link [Torna al modulo], troverai il modulo nello stato in cui l'hai lasciato:
Scambio n. 2
 |  |
Se l'utente invia dati validi, l'applicazione invia una risposta tramite la pagina JSP reponse.personne.jsp.
Scambio n. 1
 |  |
Se clicchi sul link [Torna al modulo], troverai il modulo nello stato in cui l'hai lasciato:
Scambio n. 2
 |  |
2.2. L'architettura Struts dell'applicazione
Adotteremo la seguente architettura Struts:
 |
- Ci saranno tre viste
- Il controller sarà quello fornito da Struts
- FormBean è la classe responsabile della memorizzazione dei valori provenienti dal modulo presentato dalla vista form.person.jsp
- FormAction è la classe responsabile dell'elaborazione dei valori di FormBean e della specificazione della pagina di risposta da inviare:
- la vista errors.person.jsp se i dati del modulo sono errati
- la vista reponse.personne.jsp in caso contrario
Per lo sviluppatore, il compito consiste nello scrivere il codice:
- le tre viste
- il FormBean associato al modulo
- la classe FormAction responsabile dell'elaborazione del modulo
2.3. Compilazione delle classi necessarie per l'applicazione Struts
Per compilare le classi necessarie per la nostra applicazione, useremo JBuilder. JBuilder funziona con un JDK che non contiene le classi necessarie per le applicazioni Struts. Possiamo configurare JBuilder come segue:
- Strumenti / Configura JDK
- Utilizzare il pulsante [Aggiungi] per aggiungere i file .jar forniti da Struts agli archivi di classi di JBuilder. Se avete estratto l'archivio Struts sul vostro disco, potete aggiungere tutti i file .jar dalla cartella <struts>/lib a JBuilder:
Puoi aggiungere tutti i file .jar sopra indicati agli archivi di JBuilder. Abbiamo già visto che anche Tomcat necessita di accedere agli archivi di Struts. Per Tomcat 4.x, puoi collocare i file .jar di Struts in <tomcat4>\common\lib. Per Tomcat 5.x, puoi collocarli in <tomcat5>\shared\lib. È quindi possibile configurare JBuilder in modo che individui i file .jar di Struts nella stessa posizione di Tomcat. Questo è ciò che è stato fatto nella schermata che mostra i file .jar di JBuilder menzionati in precedenza. Sono stati presi da <tomcat5>\shared\lib.
Quindi, se JBuilder segnala di non riuscire a trovare una classe Struts durante la compilazione di una classe, controllate due cose:
- l'ortografia del nome della classe
- i file .jar utilizzati da JBuilder. Tutti i file .jar di Struts devono essere inclusi.
2.4. Le viste dell'applicazione strutspersonne
Le tre viste dell'applicazione sono le seguenti:
- form.person.jsp: visualizza il modulo per l'inserimento del nome e dell'età di una persona
- reponse.personne.jsp: visualizza i valori inseriti se sono validi
- errors.person.jsp: visualizza eventuali errori
2.4.1. La vista erreurs.personne.jsp
Questa vista, che visualizza un elenco di errori, sarà definita come segue:
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<html>
<head>
<title>Personne</title>
</head>
<body>
<h2>Les erreurs suivantes se sont produites</h2>
<html:errors/>
<html:link page="/formulaire.do">
Retour au formulaire
</html:link>
</body>
</html>
In questo codice sono presenti due nuove funzionalità:
- la presenza dei tag <html:XX/>, che non sono tag HTML. È possibile creare librerie di tag JSP che vengono convertiti in codice Java quando la pagina JSP viene trasformata in un servlet.
- La pagina JSP deve dichiarare le librerie di tag che utilizza. Lo fa qui con la riga
Questa riga fornisce due informazioni:
- uri: il percorso del file che regola le regole di utilizzo della libreria. Il file struts-html.tld è incluso nella distribuzione di Struts. Nell'esempio sopra riportato, si trova nella cartella WEB-INF.
- prefix: l'identificatore utilizzato nel codice per anteporre ai tag della libreria. Ciò previene i conflitti di denominazione che potrebbero sorgere quando si utilizzano più librerie di tag contemporaneamente. È possibile trovare due tag con lo stesso nome in due librerie diverse. Assegnando a ciascuna libreria un prefisso diverso, si elimina qualsiasi ambiguità.
- Il tag <html:errors> visualizza l'elenco degli errori che il controller Struts gli invia.
- Il tag <html:link> genera un link che punta a /C/page dove
- C è il contesto dell'applicazione
- page è l'URL specificato nell'attributo page del tag
Il
genererà il seguente codice HTML:
dove C è il contesto dell'applicazione
2.4.2. Verifica della vista errors.person.jsp
- Il file errors.person.jsp si trova nella cartella views dell'applicazione strutspersonne:
- Il file struts-html.tld viene prelevato dalla distribuzione Struts (<struts>/lib) e inserito in WEB-INF:
- Il file struts-config.xml viene modificato come segue:
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"
"http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">
<struts-config>
<action-mappings>
<action
path="/main"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
<action
path="/erreurs"
parameter="/vues/erreurs.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
</action-mappings>
</struts-config>
Creiamo un nuovo URL /errors nel file di configurazione, che verrà gestito dal controller Struts. L'URL /errors.do verrà reindirizzato alla vista /views/errors.person.jsp. Il file struts-config.xml viene inserito nella cartella WEB-INF.
- Riavviamo Tomcat affinché il nuovo file struts-config.xml venga preso in considerazione, quindi richiediamo l'URL http://localhost:8080/strutspersonne/erreurs.do:
Il tag <html:errors/> non ha prodotto nulla. Questo è normale; ForwardAction non ha generato l'elenco di errori previsto dal tag. Tuttavia, la risposta sopra riportata mostra che la nostra vista JSP è almeno sintatticamente corretta; altrimenti, avremmo ricevuto una pagina di errore. Controlliamo il codice HTML ricevuto dal browser (Visualizza/Sorgente):
<html>
<head>
<title>Personne - erreurs</title>
</head>
<body>
<h2>Les erreurs suivantes se sont produites</h2>
<a href="/strutspersonne/formulaire.do">Retour au formulaire</a>
</body>
</html>
Si noti il link generato dal tag <html:link>. Il contesto /strutspersonne è stato automaticamente incluso nel link. Ciò consente di spostare l'applicazione da un contesto all'altro (ad esempio, cambiando macchina) senza dover modificare i link generati da <html:link>.
2.4.3. La vista reponse.personne.jsp
Questa vista, che conferma i valori inseriti nel modulo, è la seguente:
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%
// on récupère les données nom, age
//String nom=(String)request.getAttribute("nom");
String nom="jean";
//String age=(String)request.getAttribute("age");
String age="24";
%>
<html>
<head>
<title>Personne</title>
</head>
<body>
<h2>Personne - réponse</h2>
<hr>
<table>
<tr>
<td>Nom</td>
<td><%= nom %>
</tr>
<tr>
<td>Age</td>
<td><%= age %>
</tr>
</table>
<br>
<html:link page="/formulaire.do">
Retour au formulaire
</html:link>
</body>
</html>
La pagina visualizza due dati, [name] e [age], che le verranno passati dal controller nell'oggetto richiesta predefinito. In questo caso, stiamo effettuando un test in cui il controller non avrà la possibilità di impostare i valori di [name] e [age]. Pertanto, inizializziamo questi due dati con valori arbitrari. Inoltre, anche in questo caso il link di ritorno al modulo viene generato da un tag <html:link>.
2.4.4. Test della vista reponse.personne.jsp
- Il file reponse.personne.jsp si trova nella cartella views dell'applicazione strutspersonne:
- Il file struts-config.xml viene modificato come segue:
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"
"http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">
<struts-config>
<action-mappings>
<action
path="/main"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
<action
path="/erreurs"
parameter="/vues/erreurs.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
<action
path="/reponse"
parameter="/vues/reponse.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
</action-mappings>
</struts-config>
Creiamo un nuovo URL /reponse nel file di configurazione che sarà gestito dal controller Struts. L'URL /reponse.do verrà reindirizzato alla vista /vues/reponse.personne.jsp. Il file struts-config.xml viene inserito nella cartella WEB-INF.
- Riavviamo Tomcat affinché il nuovo file struts-config.xml venga preso in considerazione, quindi richiediamo l'URL http://localhost:8080/strutspersonne/erreurs.do:
Otteniamo esattamente ciò che ci aspettavamo.
2.4.5. La vista formulaire.personne.jsp
Questa vista mostra il modulo per l'inserimento del nome e dell'età dell'utente. Il suo codice JSP è il seguente:
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<html>
<meta http-equiv="pragma" content="no-cache">
<head>
<title>Personne - formulaire</title>
<script language="javascript">
function effacer(){
with(document.frmPersonne){
nom.value="";
age.value="";
}
}
</script>
</head>
<body>
<center>
<h2>Personne - formulaire</h2>
<hr>
<html:form action="/main" name="frmPersonne" type="istia.st.struts.personne.FormulaireBean">
<table>
<tr>
<td>Nom</td>
<td><html:text property="nom" size="20"/></td>
</tr>
<tr>
<td>Age</td>
<td><html:text property="age" size="3"/></td>
</tr>
<tr>
</table>
<table>
<tr>
<td><html:submit value="Envoyer"/></td>
<td><html:reset value="Rétablir"/></td>
<td><html:button property="btnEffacer" value="Effacer" onclick="effacer()"/></td>
</tr>
</table>
</html:form>
</center>
</body>
</html>
Vediamo la libreria di tag struts-html.tld utilizzata nella vista degli errori. Appaiono nuovi tag:
viene utilizzato sia per generare il tag HTML <form> sia per fornire informazioni al controller che elaborerà questo modulo:
Si noti che il metodo utilizzato per inviare i parametri del modulo (GET/POST) al controller non è specificato. Ciò potrebbe essere fatto utilizzando l'attributo method. Se questo attributo manca, viene utilizzato il metodo POST per impostazione predefinita. | |||||||
Utilizzato per generare il tag <input type="text" value="...">:
| |||||||
viene utilizzato per generare il tag HTML <input type="submit"...> | |||||||
viene utilizzato per generare il tag HTML <input type="reset"...> | |||||||
viene utilizzato per generare il tag HTML <input type="button"...> |
2.4.6. Il bean associato al modulo formulaire.personne.jsp
- Con Struts, ogni modulo deve essere associato a un bean responsabile della memorizzazione dei valori del modulo e del loro mantenimento nella sessione corrente. Un bean è una classe Java che deve rispettare una sintassi specifica. Il bean associato a un modulo deve estendere la classe ActionForm definita nella libreria Struts:
- I nomi degli attributi del bean devono corrispondere ai campi del modulo (attributi di proprietà dei tag <html:text> del modulo). Sulla base del codice del modulo precedente, il bean deve quindi avere due campi denominati name e age.
- Per ogni campo XX nel modulo, il bean deve definire due metodi:
- public void setXX(Type value): per assegnare un valore all'attributo XX
- public getXX(Value type): per recuperare il valore del campo XX
Il bean associato al modulo precedente potrebbe essere il seguente:
package istia.st.struts.personne;
import org.apache.struts.action.ActionForm;
public class FormulaireBean extends ActionForm {
// name
private String nom = null;
public String getNom() {
return nom;
}
public void setNom(String nom) {
this.nom = nom;
}
// age
private String age = null;
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
}
Compileremo questa classe utilizzando JBuilder.
2.4.7. Test della vista formulaire.personne.jsp
Il file formulaire.personne.jsp si trova nella cartella views dell'applicazione strutspersonne:
- Il file struts-config.xml viene modificato come segue:
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"
"http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">
<struts-config>
<action-mappings>
<action
path="/main"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
<action
path="/erreurs"
parameter="/vues/erreurs.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
<action
path="/reponse"
parameter="/vues/reponse.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
<action
path="/formulaire"
parameter="/vues/formulaire.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
</action-mappings>
</struts-config>
Nel file di configurazione, creiamo un nuovo URL /form che sarà gestito dal controller Struts. L'URL /form.do verrà reindirizzato alla vista /views/form.person.jsp. Il file struts-config.xml viene inserito nella cartella WEB-INF.
- Inseriamo la classe FormulaireBean in WEB-INF/classes:
- Riavviamo Tomcat affinché venga preso in considerazione il nuovo file struts-config.xml, quindi richiediamo l'URL http://localhost:8080/strutspersonne/formulaire.do:
Il modulo viene visualizzato correttamente. Potremmo essere curiosi di vedere come sono stati “tradotti” i tag <html:XX> sparsi nel codice JSP del modulo:
<html>
<meta http-equiv="pragma" content="no-cache">
<head>
<title>Personne - formulaire</title>
<script language="javascript">
function effacer(){
with(document.frmPersonne){
nom.value="";
age.value="";
}
}
</script>
</head>
<body>
<center>
<h2>Personne - formulaire</h2>
<hr>
<form name="frmPersonne" method="post" action="/strutspersonne/main.do">
<table>
<tr>
<td>Nom</td>
<td><input type="text" name="nom" size="20" value=""></td>
</tr>
<tr>
<td>Age</td>
<td><input type="text" name="age" size="3" value=""></td>
</tr>
<tr>
</table>
<table>
<tr>
<td><input type="submit" value="Envoyer"></td>
<td><input type="reset" value="Rétablir"></td>
<td><input type="button" name="btnEffacer" value="Effacer" onclick="effacer()"></td>
</tr>
</table>
</form>
</center>
</body>
</html>
Nel modulo risultante, i pulsanti [Reset] e [Clear] funzionano. Il pulsante [Submit] reindirizza all'URL /strutspersonne/main.do. Secondo il file web.xml dell'applicazione, sarà il controller Struts a gestire questa operazione. Secondo il file struts-config.html, il controller deve reindirizzare la richiesta alla vista /vues/main.html. Proviamo:
Tutto funziona come previsto. Dobbiamo ancora elaborare effettivamente i valori del modulo, ovvero scrivere la classe Action che riceverà i dati del modulo in un oggetto FormBean.