2. L'applicazione Struts "persona"
Abbiamo trattato, con il metodo classico (servlet e pagine JSP), un'applicazione relativa alle persone. Ci proponiamo di introdurre Struts proprio con questa stessa applicazione.
2.1. Il funzionamento dell’applicazione
Ricordiamo qui il funzionamento dell’applicazione «persona» che abbiamo sviluppato. È composta da:
- da un servlet principale. È questo che gestisce tutta la logica dell’applicazione.
- tre pagine JSP: formulaire.personne.jsp, reponse.personne.jsp, erreurs.personne.jsp
Il funzionamento dell’applicazione è il seguente. È accessibile tramite l’URL http://localhost:8080/personne/main. A questo URL si ottiene un modulo fornito dalla pagina formulaire.personne.jsp:
L'utente compila il modulo e preme il pulsante [Envoyer] di tipo "submit". Il pulsante [Rétablir] è di tipo "reset", c.a.d, che riporta il documento allo stato in cui è stato ricevuto. Il pulsante [Effacer] è di tipo «button». L'utente deve inserire 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 si segue il link [Retour au formulaire], lo si ritrova nello stato in cui è stato lasciato:
Scambio n. 2
 |  |
Se l'utente invia dati corretti, l'applicazione gli invia una risposta tramite la pagina JSP reponse.personne.jsp.
Scambio n. 1
 |  |
Se si segue il link [Retour au formulaire], lo si ritrova nello stato in cui è stato 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
- FormulaireBean è la classe incaricata di memorizzare i valori del modulo presentato dalla vista formulaire.personne.jsp
- FormulaireAction è la classe incaricata di elaborare i valori di FormulaireBean e di indicare la pagina di risposta da inviare:
- la vista erreurs.personne.jsp se i dati del modulo sono errati
- la vista reponse.personne.jsp in caso contrario
Per lo sviluppatore, il lavoro consiste nello scrivere il codice:
- delle tre viste
- del bean FormulaireBean associato al modulo
- della classe FormulaireAction incaricata di elaborare il modulo
2.3. Compilare le classi necessarie per l'applicazione Struts
Per compilare le classi necessarie alla nostra applicazione, utilizzeremo JBuilder. Questo strumento opera con un JDK in cui non sono presenti le classi necessarie alle applicazioni Struts. È possibile configurare JBuilder nel modo seguente:
- opzione Tools (Strumenti) / Configure JDKs (Configura JDK)
- utilizzare il pulsante [Add/Ajouter] per aggiungere agli archivi di classi di JBuilder i file .jar forniti da Struts. Se l’archivio Struts è stato decompresso sul disco, è possibile aggiungere a JBuilder tutti i file .jar presenti nella cartella <struts>/lib:
È possibile aggiungere a JBuilder tutti i file .jar sopra indicati. Abbiamo già visto che anche Tomcat deve poter accedere agli archivi di Struts. Per Tomcat 4.x, è possibile collocare i file .jar di Struts in <tomcat4>\common\lib. Per Tomcat 5.x, è possibile collocarli in <tomcat5>\shared\lib. Si può quindi decidere che JBuilder trovi i file .jar di Struts nella stessa posizione di Tomcat. È quanto è stato fatto nella schermata che mostra, poco più sopra, i file .jar di JBuilder. Sono stati prelevati da <tomcat5>\shared\lib.
Se quindi, durante la compilazione di una classe, JBuilder segnala di non trovare una classe Struts, verificate due cose:
- l’ortografia del nome della classe
- i file .jar utilizzati da JBuilder. Tutti i file .jar di Struts devono essere presenti.
2.4. Le viste dell’applicazione strutspersonne
Le tre viste dell’applicazione sono le seguenti:
- formulaire.personne.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
- erreurs.personne.jsp: visualizza gli errori, se presenti
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 novità:
- la presenza di tag <html:XX/> che non sono tag HTML. È infatti possibile creare librerie di tag JSP che, durante la trasformazione della pagina JSP in servlet, vengono convertite in codice Java.
- 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 definisce le regole di utilizzo della libreria. Il file struts-html.tld è fornito nella distribuzione di Struts. Nell’esempio sopra riportato, lo si collocherà nella cartella WEB-INF.
- prefix: l'identificatore utilizzato nel codice per anteporre un prefisso ai tag della libreria. Ciò consente di evitare conflitti di nomi che potrebbero verificarsi durante l'utilizzo simultaneo di più librerie di tag. Potrebbe infatti capitare di trovare due tag con lo stesso nome in due librerie diverse. Assegnando un prefisso diverso a ciascuna libreria, si elimina ogni ambiguità.
- Il tag <html:errors> visualizza l'elenco degli errori che il controller Struts gli trasmette.
- Il tag <html:link> genera un link che punta a /C/page dove
- C è il contesto dell’applicazione
- page è il URL specificato nell’attributo page del tag
Il tag
genererà il seguente codice HTML:
dove C è il contesto dell'applicazione
2.4.2. Test della vista erreurs.personne.jsp
- il file erreurs.personne.jsp viene inserito nella cartella «vues» 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 nel file di configurazione una nuova URL /errori destinata ad essere gestita dal controller Struts. URL /erreurs.do verrà reindirizzato alla vista /vues/erreurs.personne.jsp. Il file struts-config.xml viene inserito nella cartella WEB-INF.
- Riavviamo Tomcat affinché il nuovo file struts-config.xml venga riconosciuto, quindi richiediamo l'URL http://localhost:8080/strutspersonne/erreurs.do:
Il tag <html:errors/> non ha prodotto alcun risultato. È normale, poiché l’azione ForwardAction non ha generato l’elenco di errori previsto dal tag. Tuttavia, la risposta sopra riportata dimostra che la nostra vista JSP è almeno sintatticamente corretta; in caso contrario, avremmo ottenuto una pagina di errori. Verifichiamo 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, in caso di cambio di macchina) senza dover modificare i link generati da <html:link>.
2.4.3. La vista reponse.personne.jsp
La vista che conferma i valori inseriti nel modulo è la seguente:
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%
// si recuperano i dati nome, età
//String nome = (String)request.getAttribute("nome");
String nom="jean";
//String età = (String)request.getAttribute("età");
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 informazioni, [nom] e [age], che le verranno passate dal controller nell'oggetto predefinito request. In questo caso, stiamo effettuando un test in cui il controller non avrà modo di impostare i valori di [nom] 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 è inserito nella cartella «vues» 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>
Nel file di configurazione creiamo una nuova risposta URL destinata ad essere elaborata dal controller Struts. La /URL /reponse.do verrà reindirizzata 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 riconosciuto, quindi richiediamo l'URL http://localhost:8080/strutspersonne/erreurs.do:
Otteniamo esattamente il risultato previsto.
2.4.5. La vista formulaire.personne.jsp
Questa vista presenta 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>
Ritroviamo la libreria di tag struts-html.tld utilizzata nella vista degli errori. Compaiono nuovi tag:
serve sia a generare il tag HTML <form> sia a fornire informazioni al controller che dovrà elaborare questo modulo:
Si noti che il metodo di invio dei parametri del modulo (GET/POST) al controller non è specificato. Si potrebbe specificarlo con l'attributo method. In assenza di quest'ultimo, viene utilizzato per impostazione predefinita il metodo POST. | |||||||
serve a generare il tag <input type="text" value="...">:
| |||||||
serve a generare il tag HTML <input type="submit"...> | |||||||
serve a generare il tag HTML <input type="reset"...> | |||||||
serve a 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 incaricato di memorizzare i valori del modulo e di conservarli nella sessione corrente. Un bean è una classe Java che deve rispettare una sintassi specifica. Il bean associato a un modulo deve derivare dalla classe ActionForm definita nelle librerie di Struts:
- i nomi degli attributi del bean devono corrispondere ai campi del modulo (attributi property dei tag html:text del modulo). In base al codice del modulo precedente, il bean deve quindi avere due campi denominati nome ed età.
- Per ogni campo XX del modulo, il bean deve definire due metodi:
- public void setXX(Type valore): per assegnare un valore all’attributo XX
- Type getXX(): per ottenere 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 {
// nome
private String nom = null;
public String getNom() {
return nom;
}
public void setNom(String nom) {
this.nom = nom;
}
// età
private String age = null;
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
}
Compileremo questa classe con JBuilder.
2.4.7. Test della vista formulaire.personne.jsp
Il file formulaire.personne.jsp è inserito nella cartella «vues» 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 modulo URL destinato ad essere elaborato dal controller Struts. Il modulo URL /formulaire.do verrà reindirizzato alla vista /vues/formulaire.personne.jsp. Il file struts-config.xml viene inserito nella cartella WEB-INF.
- Inseriamo la classe FormulaireBean nella cartella WEB-INF/classes:
- Riavviamo Tomcat affinché il nuovo file struts-config.xml venga riconosciuto, quindi accediamo all'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> che costellavano il 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 ottenuto, i pulsanti [Ripristina] e [Effacer] funzionano. Il pulsante [Envoyer] di tipo submit rimanda a URL /strutspersonne/main.do. In base al file web.xml dell’applicazione, il controller Struts se ne occuperà. In base al file struts-config.html, il controller deve reindirizzare la richiesta alla vista /vues/main.html. Proviamo:
Tutto funziona come previsto. Ora non resta che elaborare effettivamente i valori del modulo, c.a.d. Scriviamo la classe di tipo Action che riceverà i dati del modulo in un oggetto FormulaireBean.