3. Verarbeitung des Formulars durch den Controller
Wir befassen uns nun mit der Verarbeitung der Formularwerte durch den Controller, wenn der Benutzer auf die Schaltfläche [Envoyer] im Formular klickt.
3.1. Die Datei struts-config.xml
Die neue Konfigurationsdatei struts-config.xml des Struts-Controllers sieht nun 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 verschiedene Formulare in der Anwendung. Hier haben wir nur ein Formular, also nur einen <form-bean>-Abschnitt. Für jedes Formular müssen wir Folgendes definieren:
- seinen Namen (Attribut „name“)
- den Namen der von ActionForm abgeleiteten Klasse, die für die Speicherung der Formularwerte zuständig ist (Attribut „type“)
Diese beiden Attribute können nicht beliebig gewählt werden. Sie müssen mit denen übereinstimmen, die im <html:form>-Tag des Codes HTML des Formulars verwendet werden. Zur Erinnerung: Für das Formular (name, age) lautet dieser wie folgt:
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 ist für die Verarbeitung der Formularwerte zuständig. Daher müssen die dafür erforderlichen Informationen im Formular angegeben werden:
<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. Diese Aufgabe übernimmt das Attribut „name“. 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 Werte des Formulars in der Sitzung gespeichert werden sollen. Dies ist nicht immer erforderlich. In diesem Fall ist es jedoch notwendig. Tatsächlich finden wir in den Ansichten /reponse.do und /erreurs.do Links, die zurück zum Formular führen. In beiden Fällen möchten wir das Formular mit den Werten anzeigen, die der Benutzer bei einem vorherigen Client-Server-Austausch 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 oder nicht. Diese Methode dient dazu, die Gültigkeit der Formulardaten zu überprüfen. Hier geben wir an, dass die Daten überprüft werden sollen, 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 Servlet /main aufgerufen wird. Sie gibt als Ergebnis ein Objekt vom Typ ActionErrors zurück, das einer Fehlerliste entspricht. Wenn diese Liste vorhanden und nicht leer ist, bricht der Struts-Controller an dieser Stelle ab und sendet als Antwort die durch das Attribut input angegebene Ansicht. Die Ansicht erhält in der Anfrage die Liste ActionErrors, die sie mit dem Tag <html:errors> anzeigen kann. Oben haben wir festgelegt, dass das Servlet /main im Falle von Fehlern die Ansicht /erreurs.do senden soll. Zur Erinnerung: Diese Ansicht ist mit der folgenden Ansicht „URL /vues/erreurs.reponse.jsp“ verknüpft:
<%@ 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 das Tag <html:errors>, mit dem die Fehlerliste angezeigt wird. In dieser Fehlerliste finden sich keine Fehlermeldungen, sondern Identifikatoren von Meldungen, die in der durch das Tag <message-resources> referenzierten Datei enthalten sind (Achtung: „resources“ mit nur einem „s“):
Das 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 befindet sich in dieser Datei? Es handelt sich um eine Eigenschaftendatei, die der Java-Klasse „Properties“ entspricht, d. h. um eine Reihe von Schlüssel-Wert-Paaren:
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, die Meldungen der Anwendung zu ändern, ohne diese neu kompilieren zu müssen
- sie ermöglicht die Internationalisierung von Struts-Anwendungen. Man kann nämlich mehrere Ressourcendateien erstellen, eine pro Sprache. Struts verwendet automatisch die richtige Meldungsdatei, sofern bestimmte Namenskonventionen bei diesen Dateien eingehalten werden.
- Wenn die Methode „validate“ des Formulars eine leere Fehlerliste zurückgibt, ruft der Struts-Controller die Methode „execute“ des Servlets ForwardAction auf. Es ist wichtig zu verstehen, dass die Ausführung der Methode `execute` des Servlets bedeutet, dass die Formulardaten als gültig angesehen wurden (sofern sie natürlich durch `validate="true"` überprüft wurden). In der Methode `execute` des der Aktion zugeordneten Servlets verarbeitet der Entwickler das Formular tatsächlich. Dort befindet sich der Kern der Verarbeitung (Anwendungslogik, Verwendung von Fachklassen und Datenzugriffsklassen). Letztendlich gibt die Methode ein Ergebnis vom Typ ActionForward zurück, das dem Konstruktor mitteilt, welche Ansicht als Antwort an den Client gesendet werden soll. Hier haben wir die vordefinierte Struts-Aktion ForwardAction verwendet. Ihre Methode `execute` gibt lediglich ein `ActionForward` zurück, das auf das durch das Attribut `parameter` angegebene `URL` verweist:
<action
path="/main"
name="frmPersonne"
validate="true"
input="/erreurs.do"
parameter="/vues/main.html"
type="org.apache.struts.actions.ForwardAction"
/>
Wenn also die Daten des Formulars gültig sind, gibt die Aktion /main die Ansicht /vues/main.html zurück, die wir bereits verwendet haben.
3.2. Die neue Klasse FormulaireBean
Wir haben bereits eine erste Version der Klasse FormulaireBean erstellt, die die Daten (Name, Alter) des Formulars formulaire.personne.jsp speichert. Diese Version überprüfte die Gültigkeit der Daten nicht. Nun müssen wir dies tun, da wir in der Datei struts-config.xml festgelegt haben, dass die Daten des Formulars vor der Übermittlung an das Servlet ForwardAction überprüft werden müssen (validate="true"). Der Code der Klasse 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;
}
// Alter
private String age = null;
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
// Validierung
public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) {
// Fehlerbehandlung
ActionErrors erreurs = new ActionErrors();
// Der Name darf nicht leer sein
if (nom == null || nom.trim().equals("")) {
erreurs.add("nomvide", new ActionError("personne.formulaire.nom.vide"));
// Das Alter muss eine positive ganze Zahl sein
}
if (age == null || age.trim().equals("")) {
erreurs.add("agevide", new ActionError("personne.formulaire.age.vide"));
}
else {
// Das Alter muss eine positive ganze Zahl sein
if (!age.matches("^\\s*\\d+\\s*$")) {
erreurs.add("ageincorrect", new ActionError("personne.formulaire.age.incorrect", age));
// Die Fehlerliste wird ausgegeben
}
} //if
// wird die Fehlerliste ausgegeben
return erreurs;
}
}
Die Neuerung liegt in der Implementierung der Methode „validate“. Diese wird vom Struts-Controller aufgerufen, nachdem dieser die Werte der gleichnamigen Formularfelder in die Attribute „name“ und „age“ der Klasse übertragen hat. Sie muss die Gültigkeit der Attribute „name“ und „age“ überprüfen. Der obige Code ist recht einfach zu verstehen:
- Es wird eine leere Fehlerliste (ActionErrors „Fehler“) angelegt
- das Feld „name“ wird überprüft. Ist es leer, wird mithilfe der Methode ActionErrors.add("Schlüssel", ActionError) ein Fehler zur Fehlerliste hinzugefügt.
- Das Gleiche geschieht, wenn das Feld „age“ keine ganze Zahl ist.
- Die Methode „validate“ übergibt die Fehlerliste (ActionErrors „Fehler“) an den Struts-Controller. Ist „Fehler“ gleich null oder ist erreurs.size() gleich 0, geht der Controller davon aus, dass keine Fehler aufgetreten sind. Er lässt dann die Methode `execute` der mit der Aktion verknüpften Action-Klasse (type="org.apache.struts.actions.ForwardAction") ausführen. Andernfalls gibt er die Ansicht zurück, die für den Fall von Fehlern im Formular vorgesehen ist (input="/erreurs.do").
Ein Fehler wird der Fehlerliste ActionErrors durch ActionErrors.add("cléErreur", new ActionError("cléMessage"[,param0, param1, param2, param3])). Der erste Parameter „cléErreur“ dient dazu, ein Element ActionError in der Liste ActionErrors eindeutig zu bezeichnen, ähnlich wie in einem Wörterbuch. Er kann beliebig sein. ActionError ist ein Objekt, das mithilfe seines Konstruktors ActionError einer Fehlermeldung zugeordnet wird(String cléMessage[,String param0, String param1, String param2, String param3]), wobei cléMessage die Kennung der mit dem Fehler verbundenen Meldung ist und bis zu 4 optionale Parameter übergeben werden können. Die Kennung cléMessage ist nicht beliebig. Es handelt sich um eine der Kennungen, die in der Datei zu finden sind, auf die das Tag <message-resources> in der Datei struts-config.xml verweist:
Zur Erinnerung: Diese Datei (eigentlich WEB-INF/classes/ressources/personneressources.properties) enthält die folgenden Schlüssel:
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>
Man kann überprüfen, ob die von der Methode „validate“ der Klasse FormulaireBean verwendeten Meldungsschlüssel tatsächlich in der oben genannten Datei vorhanden sind. Für jede Fehlermeldung wurde das Tag HTML <li> verwendet, damit das Tag <html:errors> diese als Liste HTML anzeigt. Wir haben gesehen, dass das Objekt ActionError 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 Methode „validate“ von FormulaireBean ein ActionError mit dem Schlüssel personne.formulaire.age.incorrect und dem zusätzlichen Parameter „param0 age“:
Die Meldung, die in der .properties-Datei der Meldungen dem Schlüssel personne.formulaire.age.incorrect zugeordnet ist, lautet
Das {0} wird durch den Wert des Alters ersetzt. Schließlich werden die Nachrichten mit den Schlüsseln errors.header und errors.footer jeweils vor und nach der Fehlerliste geschrieben. Hier dienen diese beiden Schlüssel dazu, die Tags HTML <ul> und </ul> einzufügen, die die Tags <li> umschließen müssen.
3.3. Die Gültigkeitsprüfungen des Formulars
Wir sind bereit für die Validierungstests des Formulars. Nachfolgend fassen wir noch einmal zusammen, wo die verschiedenen Komponenten der Anwendung platziert werden müssen:
 | |
 | |
 | |
 |
3.3.1. Test 1
Starten wir Tomcat neu, damit die neuen Konfigurationsdateien geladen werden, und rufen wir dann die Seite URL http://localhost:8080/strutspersonne/formulaire.do auf:
Erläuterungen:
- In struts-config.html wurde der folgende Abschnitt ausgenutzt:
<action
path="/formulaire"
parameter="/vues/formulaire.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
Wenn wir uns den Code HTML der empfangenen Seite ansehen, stellen wir fest, dass das <form>-Tag der Seite wie folgt lautet:
Die Schaltfläche [Envoyer] vom Typ „submit“ sendet daher die Formulardaten an URL /strutspersonne/main.do.
3.3.2. Test 2
Verwenden wir die Schaltfläche „[Envoyer]“ und lassen die Eingabefelder leer. Wir erhalten folgende Antwort:
Erläuterungen:
- Wie oben erwähnt, wurden die Formulardaten an die Datei URL /strutspersonne/main.do gesendet. Dabei 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 des Formulars HTML 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>
Anschließend hat der Struts-Controller die Methode „validate“ des Objekts „FormulaireBean“ aufgerufen, da das Attribut „validate“ der Aktion „/main“ 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 Validierungsmethode der Klasse FormulaireBean lautet wie folgt:
// Validierung
public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) {
// Fehlerbehandlung
ActionErrors erreurs = new ActionErrors();
// Der Name darf nicht leer sein
if (nom == null || nom.trim().equals("")) {
erreurs.add("nomvide", new ActionError("personne.formulaire.nom.vide"));
// Das Alter muss eine positive ganze Zahl sein
}
if (age == null || age.trim().equals("")) {
erreurs.add("agevide", new ActionError("personne.formulaire.age.vide"));
}
else {
// Das Alter muss eine positive ganze Zahl sein
if (!age.matches("^\\s*\\d+\\s*$")) {
erreurs.add("ageincorrect", new ActionError("personne.formulaire.age.incorrect", age));
// Die Fehlerliste wird ausgegeben
}
} //if
// wird die Fehlerliste ausgegeben
return erreurs;
}
Da die Felder [nom] und [age] leer waren, hat die oben beschriebene Validierungsmethode eine Liste mit zwei Fehlern generiert und diese an den Struts-Controller zurückgegeben. Da Fehler vorlagen, hat der Controller anschließend die dem Attribut „input“ zugeordnete Ansicht an den Client zurückgegeben. Um herauszufinden, um welche Ansicht es sich handelte, verwendete er den folgenden Abschnitt aus seiner Konfigurationsdatei:
<action
path="/erreurs"
parameter="/vues/erreurs.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
Letztendlich hat er also die Ansicht /vues/erreurs.personne.jsp gesendet. Diese hat 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 Tag <html:errors> zeigt lediglich die Liste der Meldungen an, die ihm der Struts-Controller gesendet hat. Es verwendet die durch das Tag <message-resources> angegebene Meldungsdatei:
Darin sind die folgenden Schlüssel und Meldungen enthalten:
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 zum Schlüssel errors.header gehörende Nachricht wird geschrieben
- Die Nachrichten, die den verschiedenen Schlüsseln der empfangenen Liste ActionErrors zugeordnet sind, werden geschrieben
- Die Nachricht, die dem Schlüssel errors.footer zugeordnet ist, wird geschrieben
3.3.3. Test 3
Verwenden wir den Link [Retour au formulaire] auf der Fehlerseite. Wir erhalten die folgende Seite:
Erläuterungen:
- Der Link [Retour au formulaire] hat den folgenden Code: HTML:
Der Struts-Controller hat den folgenden Abschnitt aus seiner Konfigurationsdatei verwendet:
<action
path="/formulaire"
parameter="/vues/formulaire.personne.jsp"
type="org.apache.struts.actions.ForwardAction"
/>
Er hat daher die Ansicht /vues/formulaire.personne.jsp zurückgegeben.
3.3.4. Test 4
Wir füllen das folgende Formular aus und klicken dann auf die Schaltfläche [Envoyer]:
Wir erhalten folgende Antwort:
Erläuterungen: Diese entsprechen denen aus Test Nr. 2.
3.3.5. Test 5
Wir verwenden den oben genannten Link [Retour au formulaire]. Wir erhalten die folgende Seite:
Wir stellen fest, dass das Formular in dem Zustand angezeigt wird, in dem wir es abgesendet haben.
Erläuterungen: Es gelten die Erläuterungen zu Test Nr. 3 mit einer zusätzlichen Information:
- Das angezeigte Formular HTML 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 Tags <html:text> haben zwei Funktionen:
- Beim Senden der Formularwerte vom Client an den Server werden die Werte der Eingabefelder des Formulars den gleichnamigen Feldern des Objekts FormulaireBean
- beim Senden des Codes HTML des anzuzeigenden Formulars vom Server an den Client werden die „value“-Attribute der den <html:text>-Tags zugeordneten Eingabefelder mit den Werten der gleichnamigen Felder des Objekts FormulaireBean initialisiert.
Hier handelt es sich um zwei verschiedene Client-Server-Kommunikationsvorgänge:
- Im ersten Fall hat der Benutzer das Formular ausgefüllt und an den Server gesendet
- im zweiten hat der Benutzer den Link [Retour au formulaire] verwendet, um zum Formular zurückzukehren.
Die einzige Möglichkeit, dass das Formular im zweiten Austausch mit seinen ursprünglichen Werten erneut angezeigt werden kann, besteht darin, diese in der Sitzung des Kunden 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“ angegeben, wären die Formulardaten nicht in der Sitzung gespeichert worden, und wir hätten ihre Werte beim zweiten Datenaustausch nicht wiederfinden können.
3.3.6. Test 6
Kehren wir zum Formular zurück, um diesmal gültige Daten einzugeben:
Senden wir das Formular ab. Wir erhalten folgendes Ergebnis:
Erläuterungen:
- Da die Schaltfläche [Envoyer] die Formularwerte an die Seite URL /strutspersonne/main.do übermittelt, gelten dieselben Erläuterungen wie in Test Nr. 2, bis das Ergebnis ActionErrors der Methode „validate“ von FormulaireBean an den Struts-Controller zurückgegeben wird. Hier ist diese Liste jedoch leer. Der Controller verwendet daher einen neuen Teil der Konfiguration der Aktion /main:
<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 Attribut „type“ angegebenen Typs. Die Methode „execute“ dieser Klasse wird ausgeführt und muss ein Objekt vom Typ „ActionForward“ zurückgeben, das die Ansicht angibt, die der Controller als Antwort an den Client senden soll. Hier bezeichnet das Attribut „type“ die vordefinierte Klasse ForwardAction. Die Methode execute dieser Klasse führt keine Aktion aus und gibt lediglich ein Objekt vom Typ ActionForward 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 fordern die Ansicht /formulaire.do erneut an:
Das Formular wird so angezeigt, wie wir es abgesendet haben. Die Erklärung dazu wurde bereits gegeben. Durch die Konfiguration (scope="session") haben wir festgelegt, dass das Formular in der Sitzung verbleibt. Seine Werte bleiben somit während des gesamten Client-Server-Austauschs erhalten.
Wir sind fast fertig. Nun müssen wir noch eine eigentliche Aktion für den Fall erstellen, dass die Formulardaten gültig sind. Bislang haben wir zur Vereinfachung unserer Demonstration die vordefinierte Aktion ForwardAction verwendet.
3.4. Neue Konfiguration der Aktion /main
Wir ändern die aktuelle Konfigurationsdatei struts-config.xml nicht, außer um ihren Abschnitt /main wie folgt anzupassen:
<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 FormulaireAction, die wir erstellen müssen. Die Methode „execute“ dieser Klasse wird ausgeführt, wenn die Daten des Formulars frmPersonne gültig sind. Wir haben festgelegt, dass die Methode „execute“ ihre Aufgabe erfüllt und ein Objekt vom Typ „ActionForward“ zurückgibt, das die Ansicht angibt, die der Controller an den Client zurückgeben soll. Je nach Ergebnis der Formularverarbeitung gibt es oft mehrere mögliche Ansichten. Die Liste der verschiedenen möglichen Ansichten ist in den <forward>-Tags aufgeführt, die im <action>-Tag enthalten sind. Die Syntax eines solchen Tags lautet wie folgt:
beliebiger Name, der eine Ansicht eindeutig identifiziert | |
URL der dem Schlüssel zugeordneten Ansicht |
3.5. Die Klasse FormulaireAction
Das Schreiben der Klasse FormulaireAction besteht im Wesentlichen darin, ihre Methode „execute“ 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 {
// Das Formular ist gültig, sonst wären wir nicht bis hierher gekommen
FormulaireBean formulaire=(FormulaireBean)form;
request.setAttribute("nom",formulaire.getNom());
request.setAttribute("age",formulaire.getAge());
return mapping.findForward("reponse");
}//ausführen
}
Die Methode „execute“ erhält vier Parameter:
- ActionMapping-Mapping: ein „Bild“-Objekt der Konfiguration der gerade ausgeführten Aktion, also in diesem Fall ein Bild 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>
Auf diese Weise hat die Aktion Zugriff auf die den Ansichten zugeordneten Schlüssel, die nach Abschluss 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, in dem sich die Werte des Formulars befinden, das von der aktuellen Aktion verwendet wird. Hier handelt es sich um das Objekt frmPersonne vom Typ FormulaireBean. Somit hat die Aktion Zugriff auf die Werte des Formulars.
- HttpServletRequest request: Die Anfrage des Clients, 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) hinzugefügt wurden. In unserem Beispiel erweitert die Methode „execute“ die Anfrage, indem sie den Namen und das Alter hinzufügt. Das ist hier völlig unnötig, da diese beiden Werte bereits vorhanden sind, allerdings als Parameter und nicht als Attribute. Der Code dient hier nur als Beispiel.
- HttpServletResponse response: Die Antwort, die an den Client gesendet wird. Die Aktion könnte diese Antwort ergänzen. Hier tut sie dies jedoch nicht.
Hier handelt es sich um einen Sonderfall. Die Methode execute hat so gut wie nichts zu tun. Sie muss lediglich angeben, dass die nächste Ansicht die Ansicht **/reponse.do ist, und in die Anfrage eintragen, dass diese Ansicht die Informationen „Name“ und „Alter“ erhält, die sie anzeigen soll. Dies geschieht mithilfe der Methode „findForward“ der Klasse „ActionMapping“, die als Parameter einen der Schlüssel akzeptiert, 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 dem Schlüssel „reponse“ zurück, um anzugeben, dass die Ansicht /reponse.do gesendet werden soll.
3.6. Tests für FormulaireAction
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:
<%
// Die Daten „Name“ und „Alter“ werden abgerufen
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 „Name“ und „Alter“ aus den Attributen der empfangenen Anfrage ab. Wir fordern das Formular von URL http://localhost:8080/strutspersonne/formulaire.do an und füllen es dann aus:
Wir verwenden die Schaltfläche [Envoyer] und erhalten folgende Antwort:
Erläuterungen:
- Für den Beginn des Prozesses greifen wir auf die Erklärung aus Test Nr. 2 zurück. Zur Erinnerung: Die Konfiguration der Aktion /main lautet wie folgt:
<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>
- Nach dem Absenden des Formulars an den Controller unter URL / main.do hat dieser ein Objekt vom Typ FormulaireBean mit der Kennung frmPersonne angelegt oder wiederverwendet und die Werte des Formulars darin gespeichert
- Die Methode „validate“ des Objekts frmPersonne wurde aufgerufen. Da die Daten gültig waren, gab die Methode „validate“ eine leere Liste ActionErrors zurück.
- Ein Objekt vom Typ FormulaireAction wurde erstellt oder wiederverwendet und seine Methode „execute“ aufgerufen. Diese gab ein Objekt vom Typ ActionForward mit dem Schlüssel „reponse“ zurück.
- Der Controller hat daraufhin die dem Schlüssel „reponse“ zugeordnete Ansicht c.a.d gesendet. /reponse.do und somit /vues/reponse.personne.jsp.
- Die Ansicht reponse.personne.jsp wurde mit den Werten angezeigt, die durch die Methode „execute“ des Objekts FormulaireAction in die Anfrage gesetzt wurden.
3.7. Fazit
Wir haben eine vollständige, aber einfache Anwendung erstellt. Bei der tatsächlichen Umsetzung mit Struts, Tomcat und JBuilder gibt es zahlreiche Möglichkeiten, Fehler zu machen, insbesondere in den Konfigurationsdateien der Anwendung wie XML. Auf den ersten Blick mag es einfacher erscheinen, diese Anwendung ohne Struts mit einem Servlet und JSP-Seiten zu erstellen. Für Anfänger trifft das wahrscheinlich zu. Mit zunehmender Erfahrung wird die Entwicklung mit Struts jedoch einfacher. Viele Unternehmen schreiben die Struts-Methodik für ihre Webentwicklungen aus folgenden Gründen vor:
- Struts entspricht dem Modell MVC
- Wenn alle Entwickler auf die gleiche Weise arbeiten, wird die Wartung der Anwendungen einfacher, da sie eine Standardarchitektur aufweisen.