3. Formularverarbeitung durch den Controller
Wir konzentrieren uns nun darauf, wie der Controller die Formularwerte verarbeitet, wenn der Benutzer auf die Schaltfläche [Submit] im Formular klickt.
3.1. Die Datei struts-config.xml
Die neue Konfigurationsdatei struts-config.xml für den Struts-Controller sieht wie folgt aus:
<?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>
<form-beans>
<form-bean
name="frmPersonne"
type="istia.st.struts.personne.FormulaireBean"
/>
</form-beans>
<action-mappings>
<action
path="/main"
name="frmPersonne"
scope="session"
validate="true"
input="/erreurs.do"
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>
<message-resources parameter="ressources.personneressources"/>
</struts-config>
Wir haben die Änderungen hervorgehoben:
- Es erscheint ein <form-beans>-Abschnitt. Er dient dazu, die Klassen zu definieren, die den einzelnen Formularen der Anwendung zugeordnet sind. Es muss genauso viele <form-bean>-Tags geben, wie es verschiedene Formulare in der Anwendung gibt. Hier haben wir nur ein Formular, daher gibt es nur einen <form-bean>-Abschnitt. Für jedes Formular müssen wir Folgendes definieren:
- seinen Namen (name-Attribut)
- den Namen der von ActionForm abgeleiteten Klasse, die für die Speicherung der Formularwerte zuständig ist (type-Attribut)
Diese beiden Attribute können nicht beliebig gewählt werden. Sie müssen mit denen übereinstimmen, die im <html:form>-Tag im HTML-Code des Formulars verwendet werden. Erinnern Sie sich an den Code für das Formular (name, age):
Das Formular muss in der Datei struts-config.html auf dieselbe Weise deklariert werden. Dies geschieht hier wie folgt:
- Die Konfiguration der Aktion /main hat sich geändert. Diese Aktion ist für die Verarbeitung der Formularwerte zuständig. Daher müssen wir ihr die erforderlichen Informationen zum Formular bereitstellen:
<action
path="/main"
name="frmPersonne"
scope="session"
validate="true"
input="/erreurs.do"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
Das Servlet /main verarbeitet ein Formular, dem ein Name zugewiesen werden muss. Dies wird über das Attribut „name“ geregelt. Dieser Name muss auf das Attribut „name“ eines der <form-bean>-Abschnitte verweisen, in diesem Fall auf frmPersonne.
Das Attribut scope="session" gibt an, dass die Formularwerte in der Sitzung gespeichert werden müssen. Dies ist nicht immer notwendig. Hier ist es jedoch der Fall. Tatsächlich finden wir in den Ansichten /reponse.do und /erreurs.do Links, die zum Formular zurückführen. In beiden Fällen möchten wir das Formular mit den Werten anzeigen, die der Benutzer während eines vorherigen Client-Server-Austauschs eingegeben hat. Daher ist es notwendig, das Formular in der Sitzung zu speichern.
Das Attribut „validate“ gibt an, ob die Methode „validate“ des Objekts „frmPersonne“ aufgerufen werden soll. Diese Methode dient dazu, die Gültigkeit der Formulardaten zu überprüfen. Hier legen wir fest, dass die Daten überprüft werden müssen, was bedeutet, dass wir eine „validate“-Methode in der Klasse „FormulaireBean“ schreiben müssen. Die validate-Methode des Formulars wird vom Struts-Controller aufgerufen, bevor das /main-Servlet aufgerufen wird. Sie gibt ein ActionErrors-Objekt zurück, das einer Fehlerliste entspricht. Wenn diese Liste existiert und nicht leer ist, bricht der Struts-Controller an dieser Stelle ab und sendet die durch das input-Attribut angegebene Ansicht als Antwort. Die Ansicht erhält die ActionErrors-Liste in der Anfrage, die sie mithilfe des Tags <html:errors> anzeigen kann. Oben legen wir fest, dass das /main-Servlet im Falle von Fehlern die Ansicht /errors.do senden muss. Erinnern Sie sich daran, dass diese Ansicht mit der folgenden URL verknüpft ist: /views/errors.response.jsp:
<%@ 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>
Die Ansicht verwendet korrekt das <html:errors>-Tag, das die Liste der Fehler anzeigt. In dieser Fehlerliste finden Sie keine Fehlermeldungen, sondern Meldungskennungen, die in der Datei enthalten sind, auf die das <message-resources>-Tag verweist (Hinweis: Ressourcen mit einem einzigen „s“):
Der folgende Tag gibt an, dass sich die Datei mit den von der Anwendung verwendeten Meldungen in der Datei WEB-INF/classes/ressources/personneressources.properties befindet:
Was steht in dieser Datei? Es handelt sich um eine Properties-Datei, die der Java-Properties-Klasse entspricht, d. h. um eine Reihe von Zeilen im Format Schlüssel=Wert:
errors.header=<ul>
errors.footer=</ul>
personne.formulaire.nom.vide=<li>Vous devez indiquer un nom</li>
personne.formulaire.age.incorrect=<li>L'âge [{0}] est incorrect</li>
Diese Meldungsdatei hat mindestens zwei Funktionen:
- Sie ermöglicht es Ihnen, die Meldungen der Anwendung zu ändern, ohne diese neu kompilieren zu müssen
- sie ermöglicht die Internationalisierung von Struts-Anwendungen. Sie können mehrere Ressourcendateien erstellen, eine pro Sprache. Struts verwendet automatisch die richtige Meldungsdatei, sofern bestimmte Namenskonventionen eingehalten werden.
- Wenn die validate-Methode des Formulars eine leere Fehlerliste zurückgibt, ruft der Struts-Controller die execute-Methode des ForwardAction-Servlets auf. Es ist wichtig zu verstehen, dass die Ausführung der execute-Methode des Servlets bedeutet, dass die Formulardaten als gültig angesehen wurden (vorausgesetzt natürlich, dass sie über validate="true" validiert wurden). Innerhalb der execute-Methode des mit der Aktion verbundenen Servlets verarbeitet der Entwickler das Formular tatsächlich. Hier findet der Kern der Verarbeitung statt (Anwendungslogik, Verwendung von Business-Klassen und Datenzugriffsklassen). Letztendlich gibt die Methode ein ActionForward-Objekt zurück, das dem Renderer mitteilt, welche Ansicht an den Client zurückgesendet werden soll. Hier haben wir die vordefinierte ForwardAction-Aktion von Struts verwendet. Ihre execute-Methode gibt einfach ein ActionForward zurück, das auf die durch das parameter-Attribut angegebene URL verweist:
<action
path="/main"
name="frmPersonne"
validate="true"
input="/erreurs.do"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
Wenn die Formulardaten also gültig sind, gibt die Aktion /main die Ansicht /vues/main.html zurück, die wir bereits verwendet haben.
3.2. Die neue FormBean-Klasse
Wir haben bereits eine erste Version der FormBean-Klasse erstellt, die für die Speicherung der Daten (Name, Alter) aus dem Formular formulaire.personne.jsp zuständig ist. Diese Version hat die Daten nicht validiert. Nun müssen wir dies tun, da wir in der Datei struts-config.xml festgelegt haben, dass die Formulardaten validiert werden müssen (validate="true"), bevor sie an das ForwardAction-Servlet übergeben werden. Der Klassencode sieht nun wie folgt aus:
package istia.st.struts.personne;
import javax.servlet.http.*;
import org.apache.struts.action.*;
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;
}
// validation
public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) {
// error management
ActionErrors erreurs = new ActionErrors();
// name must be non-empty
if (nom == null || nom.trim().equals("")) {
erreurs.add("nomvide", new ActionError("personne.formulaire.nom.vide"));
// age must be a positive integer
}
if (age == null || age.trim().equals("")) {
erreurs.add("agevide", new ActionError("personne.formulaire.age.vide"));
}
else {
// age must be a positive integer
if (!age.matches("^\\s*\\d+\\s*$")) {
erreurs.add("ageincorrect", new ActionError("personne.formulaire.age.incorrect", age));
// return the list of errors
}
} //if
// return the error list
return erreurs;
}
}
Die neue Funktion liegt in der Implementierung der validate-Methode. Diese Methode wird vom Struts-Controller aufgerufen, nachdem er die Attribute name und age der Klasse mit den Werten aus den gleichnamigen Formularfeldern gefüllt hat. Sie muss die Gültigkeit der Attribute name und age überprüfen. Der obige Code ist recht einfach:
- Es wird eine leere Fehlerliste (ActionErrors errors) erstellt
- das Feld „name“ wird überprüft. Ist es leer, wird der Fehlerliste mithilfe der Methode ActionErrors.add("key", ActionError) ein Fehler hinzugefügt.
- Dasselbe geschieht, wenn das Feld „age“ kein Ganzzahlwert ist.
- Die validate-Methode gibt die Fehlerliste (ActionErrors errors) an den Struts-Controller zurück. Ist errors null oder ist errors.size() gleich 0, geht der Controller davon aus, dass keine Fehler aufgetreten sind. Er führt dann die execute-Methode der mit der Aktion verknüpften Action-Klasse (type="org.apache.struts.actions.ForwardAction") aus. Andernfalls gibt er die mit Formularfehlern verknüpfte Ansicht zurück (input="/errors.do").
Ein Fehler wird mithilfe von ActionErrors.add("errorKey", new ActionError("messageKey"[,param0, param1, param2, param3])) zur Liste ActionErrors** hinzugefügt. Der erste Parameter, „errorKey“, dient dazu, ein ActionError-Element in der Liste ActionErrors eindeutig zu identifizieren, ähnlich wie in einem Wörterbuch. Er kann eine beliebige Zeichenfolge sein. ActionError ist ein Objekt, das über seinen Konstruktor ActionError(String errorKey[,String param0, String param1, String param2, String param3]) mit einer Fehlermeldung verknüpft wird, wobei errorKey die Kennung der mit dem Fehler verbundenen Meldung ist und bis zu 4 optionale Parameter enthält. Die Kennung keyMessage ist nicht beliebig. Es handelt sich um eine der Kennungen, die in der Datei zu finden sind, die durch das <message-resources>-Tag in der Datei struts-config.xml** angegeben wird:
Beachten Sie, dass diese Datei (tatsächlich WEB-INF/classes/resources/personneressources.properties) die folgenden Schlüssel enthält:
errors.header=<ul>
errors.footer=</ul>
personne.formulaire.nom.vide=<li>Vous devez indiquer un nom</li>
personne.formulaire.age.incorrect=<li>L'âge [{0}] est incorrect</li>
Wir können überprüfen, ob die von der validate-Methode der FormBean-Klasse verwendeten Meldungsschlüssel tatsächlich in der obigen Datei vorhanden sind. Wir haben für jede Fehlermeldung den HTML-Tag <li> verwendet, damit der <html:errors>-Tag sie als HTML-Liste anzeigt. Wir haben gesehen, dass das ActionError-Objekt nicht nur mit einem Meldungsschlüssel, sondern auch mit zusätzlichen Parametern erstellt werden kann:
Wenn ein ActionError mit zusätzlichen Parametern (maximal vier) erstellt wurde, sind diese im Meldungstext über die Notation {0} bis {3} zugänglich. So erstellt die validate-Methode von FormulaireBean einen ActionError mit dem Schlüssel personne.formulaire.age.incorrect und dem zusätzlichen Parameter param0 age:
Die Meldung, die dem Schlüssel **person.form.age.incorrect** in der .properties-Datei zugeordnet ist, lautet
Das {0} wird durch den Alterswert ersetzt. Schließlich werden die Meldungen mit den Schlüsseln errors.header und errors.footer jeweils vor und nach der Fehlerliste geschrieben. Hier werden diese beiden Schlüssel verwendet, um die HTML-Tags <ul> und </ul> einzufügen, die die <li>-Tags umschließen müssen.
3.3. Formularvalidierungstests
Wir sind bereit, die Gültigkeit des Formulars zu testen. Nachfolgend finden Sie eine Übersicht darüber, wo die verschiedenen Komponenten der Anwendung platziert werden sollten:
 | |
 | |
 | |
 |
3.3.1. Test 1
Starten Sie Tomcat neu, damit die neuen Konfigurationsdateien geladen werden, und geben Sie dann die URL http://localhost:8080/strutspersonne/formulaire.do ein:
Erläuterungen:
- In struts-config.html wurde der folgende Abschnitt verwendet:
<action
path="/formulaire"
parameter="/vues/formulaire.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
Wenn wir uns den HTML-Code der empfangenen Seite ansehen, stellen wir fest, dass der <form>-Tag auf der Seite wie folgt lautet:
Die Schaltfläche [Submit], die vom Typ „submit“ ist, sendet die Formulardaten daher an die URL /strutspersonne/main.do.
3.3.2. Test 2
Verwenden wir die Schaltfläche [Submit], während wir die Eingabefelder leer lassen. Wir erhalten folgende Antwort:
Erläuterungen:
- Wie oben angegeben, wurden die Formulardaten an die URL /strutspersonne/main.do gesendet. Anschließend wurden die folgenden Abschnitte der Datei struts-config.xml verwendet:
<form-bean
name="frmPersonne"
type="istia.st.struts.personne.FormulaireBean"
scope="session"
/>
....
<action
path="/main"
name="frmPersonne"
validate="true"
input="/erreurs.do"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
Die Aktion /main wurde ausgelöst. Sie verwendet das Formular frmPersonne (name="frmPersonne"). Der Struts-Controller hat daher, falls erforderlich, ein Objekt der Klasse FormulaireBean instanziiert (type="istia.st.struts.personne.FormulaireBean" im Form-Bean-Tag). Er hat die Attribute name und age dieses Objekts mit den gleichnamigen Feldern im HTML-Formular gefüllt:
<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>
Sobald dies geschehen ist, ruft der Struts-Controller die validate-Methode des FormBean-Objekts auf, da das validate-Attribut der /main-Aktion in der Konfigurationsdatei auf true gesetzt ist:
<action
path="/main"
name="frmPersonne"
validate="true"
input="/erreurs.do"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
Die validate-Methode der FormBean-Klasse lautet wie folgt:
// validation
public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) {
// error management
ActionErrors erreurs = new ActionErrors();
// name must be non-empty
if (nom == null || nom.trim().equals("")) {
erreurs.add("nomvide", new ActionError("personne.formulaire.nom.vide"));
// age must be a positive integer
}
if (age == null || age.trim().equals("")) {
erreurs.add("agevide", new ActionError("personne.formulaire.age.vide"));
}
else {
// age must be a positive integer
if (!age.matches("^\\s*\\d+\\s*$")) {
erreurs.add("ageincorrect", new ActionError("personne.formulaire.age.incorrect", age));
// return the list of errors
}
} //if
// return the error list
return erreurs;
}
Da die Felder [name] und [age] leer waren, erzeugte die obige Validierungsmethode eine Liste mit zwei Fehlern, die sie an den Struts-Controller zurückgab. Da Fehler vorlagen, gab der Controller daraufhin die mit dem Eingabeattribut verknüpfte Ansicht an den Client zurück. Um festzustellen, um welche Ansicht es sich handelte, verwendete er den folgenden Abschnitt seiner Konfigurationsdatei:
<action
path="/erreurs"
parameter="/vues/erreurs.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
Es hat also letztendlich die Ansicht /views/errors.person.jsp gesendet. Diese Ansicht enthält den folgenden Code:
<%@ 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>
Das <html:errors>-Tag zeigt lediglich die Liste der Meldungen an, die ihm vom Struts-Controller übermittelt wurden. Es verwendet die durch das <message-resources>-Tag angegebene Meldungsdatei:
Sie enthält die folgenden Schlüssel und Meldungen:
personne.formulaire.nom.vide=<li>Vous devez indiquer un nom</li>
personne.formulaire.age.vide=<li>Vous devez indiquer un age</li>
personne.formulaire.age.incorrect=<li>L'âge [{0}] est incorrect</li>
errors.header=<ul>
errors.footer=</ul>
- Die mit dem Schlüssel „errors.header“ verknüpfte Meldung wird geschrieben
- die mit den verschiedenen Schlüsseln in der empfangenen ActionErrors-Liste verbundenen Meldungen werden geschrieben
- Die mit dem Schlüssel „errors.footer“ verknüpfte Meldung wird geschrieben
3.3.3. Test 3
Verwenden wir den Link [Zurück zum Formular] auf der Fehlerseite. Wir erhalten die folgende Seite:
Erläuterungen:
- Der Link [Zurück zum Formular] hat den folgenden HTML-Code:
Der Struts-Controller verwendete den folgenden Abschnitt aus seiner Konfigurationsdatei:
<action
path="/formulaire"
parameter="/vues/formulaire.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
Es wurde daher die Ansicht /views/form.person.jsp zurückgegeben.
3.3.4. Test 4
Wir füllen das folgende Formular aus und klicken dann auf die Schaltfläche [Absenden]:
Wir erhalten die folgende Antwort:
Erläuterungen: Diese entsprechen denen zu Test 2.
3.3.5. Test 5
Wir klicken oben auf den Link [Zurück zum Formular]. Wir sehen die folgende Seite:
Wir sehen, dass sich das Formular im gleichen Zustand befindet wie beim Absenden.
Erläuterungen: Diese entsprechen denen zu Test Nr. 3, mit folgenden zusätzlichen Informationen:
- Das angezeigte HTML-Formular enthält die folgenden Tags:
<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>
Die <html:text>-Tags haben zwei Funktionen:
- Beim Senden von Formularwerten vom Client an den Server werden die Werte der Eingabefelder des Formulars den gleichnamigen Feldern im FormBean-Objekt zugewiesen
- wenn der Server den HTML-Code für das anzuzeigende Formular an den Client zurücksendet, werden die value-Attribute der Eingabefelder, die den <html:text>-Tags zugeordnet sind, mit den Werten der gleichnamigen Felder im FormBean-Objekt initialisiert.
Hier haben wir zwei verschiedene Client-Server-Interaktionen:
- Im ersten Fall hat der Benutzer das Formular ausgefüllt und an den Server gesendet
- In der zweiten hat der Benutzer auf den Link [Zurück zum Formular] geklickt, um zum Formular zurückzukehren.
Die einzige Möglichkeit, das Formular bei der zweiten Interaktion mit seinen ursprünglichen Werten erneut anzuzeigen, besteht darin, diese Werte in der Sitzung des Clients zu speichern. Genau das wurde im Abschnitt zur Konfiguration der Aktion /main festgelegt:
<action
path="/main"
name="frmPersonne"
scope="session"
validate="true"
input="/erreurs.do"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
Hätten wir scope="request" gesetzt, wären die Formulardaten nicht in der Sitzung gespeichert worden, und wir hätten ihre Werte beim zweiten Austausch nicht abrufen können.
3.3.6. Test 6
Kehren wir zum Formular zurück und geben wir diesmal gültige Daten ein:
Senden Sie das Formular ab. Wir erhalten das folgende Ergebnis:
Erläuterungen:
- Da die Schaltfläche [Absenden] die Formularwerte an die URL /strutspersonne/main.do sendet, gelten dieselben Erläuterungen wie in Test 2, bis der Struts-Controller das ActionErrors-Ergebnis von der validate-Methode des FormBean erhält. Hier ist diese Liste jedoch leer. Der Controller nutzt dann einen neuen Teil der /main-Aktionskonfiguration:
<action
path="/main"
name="frmPersonne"
scope="session"
validate="true"
input="/erreurs.do"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
Der Struts-Controller erstellt bei Bedarf ein Objekt des durch das type-Attribut angegebenen Typs. Die execute-Methode dieser Klasse wird ausgeführt und muss ein ActionForward-Objekt zurückgeben, das die Ansicht angibt, die der Controller als Antwort an den Client senden muss. Hier bezieht sich das type-Attribut auf die vordefinierte ForwardAction-Klasse. Die Methode execute dieser Klasse führt keine Aktion aus und gibt lediglich ein ActionForward-Objekt zurück, das auf die durch das Attribut parameter definierte Ansicht verweist, in diesem Fall die Ansicht /vues/main.html. Dies ist tatsächlich die Ansicht, die der Controller zurückgegeben hat.
3.3.7. Test 7
Wir rufen die Ansicht /form.do erneut auf:
Wir sehen das Formular genau so, wie wir es übermittelt haben. Die Erklärung wurde bereits gegeben. Durch die Konfiguration (scope="session") haben wir festgelegt, dass das Formular in der Sitzung verbleiben soll. Seine Werte bleiben daher während des gesamten Client-Server-Austauschs erhalten.
Wir sind fast fertig. Wir müssen noch eine geeignete Aktion für den Fall erstellen, dass die Formulardaten gültig sind. Bislang haben wir die vordefinierte ForwardAction verwendet, um unsere Demonstration zu vereinfachen.
3.4. Neue Konfiguration für die Aktion /main
Wir ändern die aktuelle Konfigurationsdatei struts-config.xml nicht, außer dass wir den Abschnitt /main wie folgt anpassen:
<action
path="/main"
name="frmPersonne"
scope="session"
validate="true"
input="/erreurs.do"
type="istia.st.struts.personne.FormulaireAction"
>
<forward name="reponse" path="/reponse.do"/>
</action>
Das Attribut „type“ verweist nun auf eine andere Klasse namens „FormAction“, die wir implementieren müssen. Es ist die Methode „execute“ dieser Klasse, die aufgerufen wird, wenn die Daten im Formular „frmPersonne“ gültig sind. Wir haben festgelegt, dass die Methode „execute“ ihre Aufgabe ausführt und ein „ActionForward“-Objekt zurückgibt, das die Ansicht angibt, die der Controller an den Client zurücksenden soll. Je nach Ergebnis der Formularverarbeitung gibt es oft mehrere mögliche Ansichten. Die Liste der möglichen Ansichten wird innerhalb der <forward>-Tags angegeben, die im <action>-Tag enthalten sind. Die Syntax für ein solches Tag lautet wie folgt:
beliebiger Name, der eine Ansicht eindeutig identifiziert | |
URL der Ansicht, die mit dem Schlüssel verknüpft ist |
3.5. Die FormAction-Klasse
Das Schreiben der FormAction-Klasse besteht im Wesentlichen darin, ihre execute-Methode zu schreiben:
package istia.st.struts.personne;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import javax.servlet.ServletException;
public class FormulaireAction extends Action {
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws IOException,ServletException {
// we have a valid form, otherwise we wouldn't have got here
FormulaireBean formulaire=(FormulaireBean)form;
request.setAttribute("nom",formulaire.getNom());
request.setAttribute("age",formulaire.getAge());
return mapping.findForward("reponse");
}//execute
}
Die Methode execute benötigt vier Parameter:
- ActionMapping mapping: ein „Image“-Objekt, das die Konfiguration der aktuell ausgeführten Aktion darstellt; in diesem Fall ein Image mit der folgenden Konfiguration:
<action
path="/main"
name="frmPersonne"
validate="true"
input="/erreurs.do"
type="istia.st.struts.personne.FormulaireAction"
>
<forward name="reponse" path="/reponse.do"/>
</action>
Somit hat die Aktion Zugriff auf die Schlüssel, die den Ansichten zugeordnet sind und am Ende der Aktion an den Client zurückgegeben werden können. Die Methode „execute“ muss einen dieser Schlüssel zurückgeben.
- ActionForm form: das Bean-Objekt, das die von der aktuellen Aktion verwendeten Formularwerte enthält. Hier handelt es sich um das Objekt frmPersonne vom Typ FormBean. Somit hat die Aktion Zugriff auf die Formularwerte.
- HttpServletRequest request: die Client-Anfrage, die möglicherweise durch verschiedene Servlets erweitert wurde. Die Aktion hat somit Zugriff auf alle Parameter der ursprünglichen Anfrage (request.getParameter) sowie auf alle Attribute, die dieser ursprünglichen Anfrage hinzugefügt wurden (request.getAttribute). In unserem Beispiel erweitert die Methode `execute` die Anfrage, indem sie den Namen und das Alter hinzufügt. Dies ist hier völlig unnötig, da diese beiden Werte bereits vorhanden sind, allerdings als Parameter und nicht als Attribute. Der Code wird hier nur zur Veranschaulichung aufgeführt.
- HttpServletResponse response: die Antwort, die an den Client gesendet wird. Die Aktion könnte diese Antwort erweitern. Hier tut sie dies jedoch nicht.
Hier haben wir es mit einem Sonderfall zu tun. Die Methode execute hat fast nichts zu tun. Sie muss lediglich angeben, dass die nächste Ansicht /reponse.do ist, und in der Anfrage festlegen, dass diese Ansicht die zur Anzeige benötigten Informationen zu Name und Alter erhält. Dies geschieht mithilfe der Methode findForward der Klasse ActionMapping**, die als Parameter einen der Schlüssel verwendet, die in den forward**-Tags der Konfiguration der Aktion zu finden sind. Hier gibt es nur einen solchen Tag:
Unsere Methode gibt daher ein ActionForward mit „response“ als Schlüssel zurück, um anzugeben, dass die Ansicht /response.do gesendet werden soll.
3.6. FormAction-Tests
Wir kompilieren die vorherige Klasse mit JBuilder und legen die generierte .class-Datei in WEB-INF/classes ab:
Wir ändern die Ansicht /vues/reponse.personne.jsp:
<%
// on récupère les données nom, age
String nom=(String)request.getAttribute("nom");
String age=(String)request.getAttribute("age");
%>
<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>
<html:link page="/formulaire.do">
Retour au formulaire
</html:link>
</body>
</html>
Die Ansicht ruft die Informationen zu Name und Alter aus den empfangenen Anfrageattributen ab. Wir rufen das Formular unter der URL http://localhost:8080/strutspersonne/formulaire.do auf und füllen es dann aus:
Wir klicken auf die Schaltfläche [Absenden] und erhalten die folgende Antwort:
Erläuterungen:
- Für den Beginn des Prozesses verweisen wir auf die Erläuterung zu Test Nr. 2. Sehen wir uns die Konfiguration der Aktion /main noch einmal an:
<action
path="/main"
name="frmPersonne"
scope="session"
validate="true"
input="/erreurs.do"
type="istia.st.struts.personne.FormulaireAction"
>
<forward name="reponse" path="/reponse.do"/>
</action>
- Nachdem das Formular an den Controller unter der URL /main.do übermittelt wurde, erstellte oder verwendete der Controller ein frmPersonne-Objekt vom Typ FormBean und füllte es mit den Formularwerten
- Die validate-Methode des frmPersonne-Objekts wurde aufgerufen. Da die Daten gültig waren, gab die validate-Methode eine leere ActionErrors-Liste zurück.
- Ein FormAction-Objekt wurde erstellt oder wiederverwendet, und seine execute-Methode wurde aufgerufen. Diese Methode gab ein ActionForward-Objekt mit dem Schlüssel „reponse“ zurück.
- Der Controller sendete daraufhin die mit dem Schlüssel „reponse“ verknüpfte Ansicht, d. h. /reponse.do, und somit /vues/reponse.personne.jsp.
- Die Ansicht reponse.personne.jsp wurde mit den Werten angezeigt, die von der execute-Methode des FormAction-Objekts in der Anfrage gesetzt wurden.
3.7. Fazit
Wir haben eine umfassende und dennoch einfache Anwendung erstellt. Bei der tatsächlichen Umsetzung mit Struts, Tomcat und JBuilder gibt es viele Möglichkeiten, Fehler zu machen, insbesondere in den XML-Konfigurationsdateien der Anwendung. Auf den ersten Blick mag es einfacher erscheinen, diese Anwendung ohne Struts zu erstellen, indem man ein Servlet und JSP-Seiten verwendet. Für Anfänger trifft dies wahrscheinlich zu. Mit zunehmender Erfahrung wird die Entwicklung mit Struts jedoch einfacher. Viele Unternehmen schreiben die Struts-Methodik für ihre Webentwicklung aus folgenden Gründen vor:
- Struts folgt dem MVC-Modell
- Wenn alle Entwickler auf die gleiche Weise arbeiten, wird die Wartung der Anwendung einfacher, da sie über eine Standardarchitektur verfügen.