2. Die Struts-Anwendung „personne“
Wir haben mit der klassischen Methode – Servlet und JSP-Seiten – eine Personenanwendung behandelt. Wir möchten nun Struts anhand derselben Anwendung einführen.
2.1. Die Funktionsweise der Anwendung
Lassen Sie uns hier noch einmal die Funktionsweise der von uns entwickelten „Personen“-Anwendung in Erinnerung rufen. Sie besteht aus:
- einem Haupt-Servlet. Dieses übernimmt die gesamte Logik der Anwendung.
- aus drei Seiten JSP: formulaire.personne.jsp, reponse.personne.jsp, erreurs.personne.jsp
Die Anwendung funktioniert wie folgt: Sie ist über die URL URL http://localhost:8080/personne/main erreichbar. Unter dieser URL wird ein Formular angezeigt, das von der Seite formulaire.personne.jsp bereitgestellt wird:
Der Benutzer füllt das Formular aus und klickt auf die Schaltfläche [Envoyer] vom Typ „Submit“. Die Schaltfläche [Rétablir] ist vom Typ „Reset“ und setzt das Dokument in den Zustand zurück, in dem es empfangen wurde. Die Schaltfläche [Effacer] ist vom Typ „Button“. Der Benutzer muss einen gültigen Namen und ein gültiges Alter angeben. Ist dies nicht der Fall, wird ihm über die Seite JSP erreurs.personne.jsp eine Fehlerseite angezeigt. Hier einige Beispiele:
Austausch Nr. 1
 |  |
Wenn man dem Link [Retour au formulaire] folgt, findet man diesen in dem Zustand vor, in dem man ihn zurückgelassen hat:
Austausch Nr. 2
 |  |
Wenn der Benutzer korrekte Daten übermittelt, sendet die Anwendung ihm eine Antwort über die Seite JSP reponse.personne.jsp.
Austausch Nr. 1
 |  |
Wenn man dem Link [Retour au formulaire] folgt, findet man diesen in dem Zustand vor, in dem man ihn zurückgelassen hat:
Austausch Nr. 2
 |  |
2.2. Die Struts-Architektur der Anwendung
Wir werden die folgende Struts-Architektur verwenden:
 |
- Es wird drei Ansichten geben
- Der Controller wird der von Struts bereitgestellte sein
- FormulaireBean ist die Klasse, die für die Speicherung der Werte des von der Ansicht formulaire.personne.jsp angezeigten Formulars zuständig ist
- FormulaireAction ist die Klasse, die für die Verarbeitung der Werte von FormulaireBean zuständig ist und die zu sendende Antwortseite angibt:
- die Ansicht erreurs.personne.jsp, wenn die Formulardaten fehlerhaft sind
- die Ansicht reponse.personne.jsp andernfalls
Für den Entwickler besteht die Aufgabe darin, den Code zu schreiben:
- der drei Ansichten
- des dem Formular zugeordneten Beans FormulaireBean
- der Klasse FormulaireAction, die für die Verarbeitung des Formulars zuständig ist
2.3. Kompilieren der für die Struts-Anwendung erforderlichen Klassen
Um die für unsere Anwendung erforderlichen Klassen zu kompilieren, verwenden wir JBuilder. Dieser arbeitet mit einer JDK-Datei, in der sich die für Struts-Anwendungen erforderlichen Klassen nicht befinden. JBuilder lässt sich wie folgt konfigurieren:
- Option „Tools“ (Werkzeuge) / „Configure JDKs“ (JDK konfigurieren)
- Verwenden Sie die Schaltfläche „[Add/Ajouter]“, um die von Struts bereitgestellten .jar-Dateien zu den Klassenarchiven von JBuilder hinzuzufügen. Wenn Sie das Struts-Archiv auf der Festplatte entpackt haben, können Sie alle .jar-Dateien aus dem Ordner <struts>/lib zu JBuilder hinzufügen:
Man kann alle oben genannten .jar-Dateien zu den JBuilder-Archiven hinzufügen. Wir haben bereits gesehen, dass auch Tomcat Zugriff auf die Struts-Archive benötigt. Für Tomcat 4.x können die Struts-.jar-Dateien in <tomcat4>\common\lib abgelegt werden. Für Tomcat 5.x können sie in <tomcat5>\shared\lib abgelegt werden. Anschließend kann festgelegt werden, dass JBuilder die Struts-JAR-Dateien am selben Ort wie Tomcat findet. Genau das wurde in dem etwas weiter oben gezeigten Screenshot mit den JBuilder-JAR-Dateien getan. Sie wurden aus dem Verzeichnis <tomcat5>\shared\lib übernommen.
Wenn JBuilder also beim Kompilieren einer Klasse meldet, dass er eine Struts-Klasse nicht findet, überprüfen Sie zwei Dinge:
- die Schreibweise der Klasse
- die von JBuilder verwendeten .jar-Dateien. Alle Struts-.jar-Dateien müssen dabei enthalten sein.
2.4. Die Ansichten der Anwendung „strutspersonne“
Die drei Ansichten der Anwendung sind folgende:
- formulaire.personne.jsp: Zeigt das Formular zur Eingabe von Name und Alter einer Person an
- reponse.personne.jsp: Zeigt die eingegebenen Werte an, sofern sie gültig sind
- erreurs.personne.jsp: Zeigt gegebenenfalls Fehler an
2.4.1. Die Ansicht erreurs.personne.jsp
Diese Ansicht, die eine Fehlerliste anzeigt, wird wie folgt definiert:
<%@ 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>
Dieser Code enthält zwei Neuerungen:
- das Vorhandensein von Tags <html:XX/>, die keine HTML-Tags sind. Man kann nämlich Tag-Bibliotheken mit dem Namen JSP erstellen, die bei der Umwandlung der Seite JSP in ein Servlet in Java-Code umgewandelt werden.
- Die Seite JSP muss die von ihr verwendeten Tag-Bibliotheken deklarieren. Dies geschieht hier mit der Zeile
Diese Zeile enthält zwei Angaben:
- uri: Der Speicherort der Datei, die die Regeln für die Verwendung der Bibliothek festlegt. Die Datei struts-html.tld ist im Struts-Paket enthalten. Im obigen Beispiel wird sie im Ordner WEB-INF abgelegt.
- prefix: Die Kennung, die im Code verwendet wird, um den Tags der Bibliothek ein Präfix voranzustellen. Dadurch lassen sich Namenskonflikte vermeiden, die bei der gleichzeitigen Verwendung mehrerer Tag-Bibliotheken auftreten könnten. Es wäre möglich, dass zwei Tags mit demselben Namen in zwei verschiedenen Bibliotheken vorkommen. Indem jeder Bibliothek ein anderes Präfix zugewiesen wird, werden jegliche Mehrdeutigkeiten beseitigt.
- Das Tag <html:errors> zeigt die Liste der Fehler an, die ihm der Struts-Controller übermittelt.
- Das Tag <html:link> generiert einen Link, der auf /C/page verweist, wobei
- C der Anwendungskontext ist
- „page“ die im Attribut „page“ des Tags angegebene URL ist
Das Tag
erzeugt den folgenden Code: HTML:
wobei C der Anwendungskontext ist
2.4.2. Test der Ansicht erreurs.personne.jsp
- Die Datei erreurs.personne.jsp befindet sich im Ordner „vues“ der Anwendung „strutspersonne“:
- Die Datei „struts-html.tld“ wird aus der Struts-Distribution (<struts>/lib) entnommen und in „WEB-INF“ abgelegt:
- Die Datei „struts-config.xml“ wird wie folgt geändert:
<?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>
Wir erstellen in der Konfigurationsdatei eine neue Fehleransicht „URL“, die vom Struts-Controller verarbeitet werden soll. Die Datei URL /erreurs.do wird an die Ansicht /vues/erreurs.personne.jsp weitergeleitet. Die Datei struts-config.xml wird im Ordner WEB-INF abgelegt.
- Wir starten Tomcat neu, damit die neue Datei struts-config.xml berücksichtigt wird, und rufen dann die URL http://localhost:8080/strutspersonne/erreurs.do auf:
Das Tag <html:errors/> hat nichts ausgegeben. Das ist normal, da die Aktion ForwardAction nicht die vom Tag erwartete Fehlerliste generiert hat. Dennoch zeigt die obige Antwort, dass unsere Ansicht JSP zumindest syntaktisch korrekt ist – andernfalls hätten wir eine Fehlerseite erhalten. Überprüfen wir den vom Browser empfangenen Code HTML (Ansicht/Quelltext):
<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>
Beachten Sie den durch das Tag <html:link> erzeugten Link. Der Kontext /strutspersonne wurde automatisch in den Link aufgenommen. Dadurch kann die Anwendung von einem Kontext in einen anderen verschoben werden (z. B. bei einem Rechnerwechsel), ohne dass die von <html:link> generierten Links geändert werden müssen.
2.4.3. Die Ansicht reponse.personne.jsp
Diese Ansicht, die die im Formular eingegebenen Werte bestätigt, sieht wie folgt aus:
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%
// Die Daten „name“ und „age“ werden abgerufen
//String name = (String)request.getAttribute("name");
String nom="jean";
//String name = (String)request.getAttribute("name");
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>
Die Seite zeigt zwei Informationen an: [nom] und [age], die ihr vom Controller im vordefinierten Objekt „request“ übergeben werden. Hier führen wir einen Test durch, bei dem der Controller keine Gelegenheit hat, die Werte von [nom] und [age] festzulegen. Daher initialisieren wir diese beiden Informationen mit beliebigen Werten. Außerdem wird auch hier der Link zurück zum Formular durch ein <html:link>-Tag generiert.
2.4.4. Test der Ansicht reponse.personne.jsp
- Die Datei reponse.personne.jsp wird im Ordner „vues“ der Anwendung „strutspersonne“ abgelegt:
- Die Datei struts-config.xml wird wie folgt geändert:
<?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>
Wir erstellen in der Konfigurationsdatei eine neue Antwort „URL“, die vom Struts-Controller verarbeitet werden soll. Die Datei URL /reponse.do wird an die Ansicht /vues/reponse.personne.jsp weitergeleitet. Die Datei struts-config.xml wird im Ordner WEB-INF abgelegt.
- Wir starten Tomcat neu, damit die neue Datei struts-config.xml berücksichtigt wird, und rufen anschließend die URL http://localhost:8080/strutspersonne/erreurs.do auf:
Wir erhalten genau das erwartete Ergebnis.
2.4.5. Die Ansicht formulaire.personne.jsp
Diese Ansicht zeigt das Formular zur Eingabe von Name und Alter des Benutzers. Der Code JSP lautet wie folgt:
<%@ 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>
Wir finden die in der Fehleransicht verwendete Tag-Bibliothek struts-html.tld wieder. Es tauchen neue Tags auf:
dient sowohl zur Generierung des Tags HTML <form> als auch zur Bereitstellung von Informationen für das Steuerelement, das dieses Formular verarbeiten wird:
Es ist zu beachten, dass die Methode zum Senden der Formularparameter (GET/POST) an den Controller nicht angegeben ist. Dies könnte mit dem Attribut „method“ erfolgen. Fehlt dieses, wird standardmäßig die Methode POST verwendet. | |||||||
dient zur Generierung des Tags <input type="text" value="...">:
| |||||||
dient zur Generierung des Tags HTML <input type="submit"...> | |||||||
dient zur Generierung des Tags HTML <input type="reset"...> | |||||||
dient zur Generierung des Tags HTML <input type="button"...> |
2.4.6. Die dem Formular zugeordnete Bean formulaire.personne.jsp
- Bei Struts muss jedes Formular einem Bean zugeordnet sein, der dafür zuständig ist, die Werte des Formulars zu speichern und diese in der aktuellen Sitzung zu behalten. Ein Bean ist eine Java-Klasse, die einer bestimmten Syntax entsprechen muss. Der einem Formular zugeordnete Bean muss von der Klasse ActionForm abgeleitet sein, die in den Struts-Bibliotheken definiert ist:
- Die Namen der Attribute der Bean müssen mit den Feldern des Formulars übereinstimmen (property-Attribute der HTML-Tags „text“ des Formulars). Gemäß dem Code des vorherigen Formulars muss die Bean daher zwei Felder namens „nom“ und „age“ haben.
- Für jedes Feld XX des Formulars muss die Bean zwei Methoden definieren:
- public void setXX(Type valeur): um dem Attribut XX einen Wert zuzuweisen
- Type getXX(): zum Abrufen des Werts des Felds XX
Die dem vorherigen Formular zugeordnete Bean könnte wie folgt aussehen:
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;
}
// Alter
private String age = null;
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
}
Diese Klasse wird mit JBuilder kompiliert.
2.4.7. Test der Ansicht formulaire.personne.jsp
Die Datei „formulaire.personne.jsp“ wird im Ordner „vues“ der Anwendung „strutspersonne“ abgelegt:
- Die Datei „struts-config.xml“ wird wie folgt geändert:
<?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>
Wir erstellen in der Konfigurationsdatei ein neues Formular „URL“, das vom Struts-Controller verarbeitet werden soll. Das Formular URL /formulaire.do wird an die Ansicht /vues/formulaire.personne.jsp weitergeleitet. Die Datei struts-config.xml wird im Ordner WEB-INF abgelegt.
- Wir legen die Klasse FormulaireBean in WEB-INF/classes ab:
- Wir starten Tomcat neu, damit die neue Datei „struts-config.xml“ berücksichtigt wird, und rufen dann die URL „http://localhost:8080/strutspersonne/formulaire.do“ auf:
Das Formular wird korrekt angezeigt. Vielleicht möchten wir nun einen Blick darauf werfen, wie die Tags <html:XX>, die im JSP-Code des Formulars verstreut waren, „übersetzt“ wurden:
<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>
In dem angezeigten Formular funktionieren die Schaltflächen [Zurücksetzen] und [Effacer]. Die Schaltfläche [Envoyer] vom Typ „Submit“ leitet zur Seite URL /strutspersonne/main.do weiter. Laut der Datei web.xml der Anwendung wird der Struts-Controller diese übernehmen. Laut der Datei struts-config.html muss der Controller die Anfrage an die Ansicht /vues/main.html weiterleiten. Versuchen wir es:
Alles läuft wie erwartet. Nun müssen wir die Werte des Formulars noch tatsächlich verarbeiten, c.a.d. Dazu schreiben wir eine Action-Klasse, die die Formulardaten in einem Objekt FormulaireBean empfängt.