6. MVC-Webanwendung [person] – Version 2

Wir werden nun Varianten der vorherigen Anwendung [/person1] einführen, die wir [/person2, /person3, ...] nennen werden. Diese Varianten ändern nichts an der ursprünglichen Architektur der Anwendung, die wie folgt bleibt:

Für diese Varianten werden wir uns bei den Erläuterungen kurz fassen. Wir werden lediglich die Änderungen gegenüber der vorherigen Version vorstellen.

6.1. Einführung

Wir werden nun unserer Anwendung eine Sitzungsverwaltung hinzufügen. Lassen Sie uns die folgenden Punkte noch einmal durchgehen:

Der Client-Server-HTTP-Dialog besteht aus einer Reihe von Anfrage-Antwort-Sequenzen, die voneinander unabhängig sind
Die Sitzung dient als Speicherpuffer zwischen verschiedenen Anfrage-Antwort-Sequenzen desselben Benutzers. Bei N Benutzern gibt es N Sitzungen.

Die folgende Bildschirmsequenz zeigt, was nun im Betrieb der Anwendung gewünscht ist:

Austausch Nr. 1

`Anfrage`	`Antwort`

Die neue Funktion ist der Link zurück zum Formular, der zur Ansicht [Fehler] hinzugefügt wurde.

Austausch Nr. 2

`Anfrage`	`Antwort`

Im Austausch Nr. 1 hat der Benutzer die Werte (xx, yy) für das Paar (Name, Alter) angegeben. Wenn der Server diese Werte während des Austauschs erfasst hat, „vergisst“ er sie am Ende des Austauschs. Wir können jedoch sehen, dass er während des Austauschs Nr. 2 in der Lage ist, diese Werte in seiner Antwort erneut anzuzeigen. Es ist das Konzept einer Sitzung, das es dem Webserver in diesem Fall ermöglicht, Daten über aufeinanderfolgende Client-Server-Austausche hinweg zu speichern. Es gibt andere mögliche Lösungen für dieses Problem.

Während Austausch Nr. 1 speichert der Server das vom Client gesendete (Name, Alter)-Paar in der Sitzung, damit er es während Austausch Nr. 2 anzeigen kann.

Hier ist ein weiteres Beispiel für die Implementierung einer Sitzung zwischen zwei Austauschvorgängen:

Austausch Nr. 1

`Anfrage`	`Antwort`

Neu ist der Link zurück zum Formular, der auf der Antwortseite hinzugefügt wurde.

Austausch Nr. 2

`Anfrage`	`Antwort`

6.2. Das Eclipse-Projekt

Um das Eclipse-Projekt [mvc-personne-02] für die Webanwendung [/personne2] zu erstellen, duplizieren wir das Eclipse-Projekt [mvc-personne-01], um den vorhandenen Code wiederzuverwenden. Führen Sie dazu die folgenden Schritte aus:

[Rechtsklick auf das Projekt mvc-personne-01 -> Kopieren]:

dann [Rechtsklick im Paket-Explorer -> Einfügen]:

- Geben Sie den Namen des neuen Projekts in [1] und den Namen eines vorhandenen, aber leeren Ordners in [2] ein

Das Projekt [mvc-personne-02] wird dann erstellt:

Derzeit ist es identisch mit dem Projekt [mvc-personne-01]. Wir müssen einige manuelle Änderungen vornehmen, bevor wir es verwenden können. Wechseln Sie zur Ansicht [Servers] und versuchen Sie, diese neue Anwendung zu den von Tomcat verwalteten hinzuzufügen:

Wir sehen, dass in [1] das neue Projekt [mvc-personne-02] von Tomcat nicht erkannt wird. Damit Tomcat es erkennt, muss eine Konfigurationsdatei für das Projekt [mvc-personne-02] geändert werden. Öffnen Sie die Datei [<mvc-personne-02>/.settings/.component] über die Option [Datei / Datei öffnen]:


<?xml version="1.0" encoding="UTF-8"?>
<project-modules id="moduleCoreId">
<wb-module deploy-name="mvc-personne-01">
<wb-resource deploy-path="/" source-path="/WebContent"/>
<wb-resource deploy-path="/WEB-INF/classes" source-path="/src"/>
<property name="java-output-path" value="/build/classes/"/>
<property name="context-root" value="personne1"/>
</wb-module>
</project-modules>

Zeile 3 gibt den Namen des Webmoduls an, das in Tomcat bereitgestellt werden soll. Hier entspricht dieser Name dem des Projekts [mvc-personne-01]. Wir ändern ihn in [mvc-personne-02]:


<wb-module deploy-name="mvc-personne-02">

Zudem können wir diese Gelegenheit nutzen, um in Zeile 7 den Namen des Anwendungskontexts [mvc-personne-02] zu ändern, der mit dem des Projekts [mvc-personne-01] in Konflikt steht:


<property name="context-root" value="personne2"/>

Diese zweite Änderung hätte direkt in Eclipse vorgenommen werden können. Ich wusste jedoch nicht, wie ich die erste Änderung vornehmen sollte, ohne die Konfigurationsdatei zu bearbeiten.

Sobald dies erledigt ist, speichern wir die neue [.content]-Datei, beenden dann Eclipse und starten es neu, damit die Änderungen wirksam werden.

Nachdem Eclipse neu gestartet wurde, versuchen wir den Vorgang, der zuvor fehlgeschlagen ist:

Diesmal wird das Projekt [mvc-personne-02] erkannt. Wir fügen es zu den Projekten hinzu, die für die Ausführung auf Tomcat konfiguriert sind:

6.3. Konfigurieren der Webanwendung [personne2]

Die Datei web.xml für die Anwendung /personne2 sieht wie folgt aus:


<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4"
    xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <display-name>mvc-personne-02</display-name>
    <!--  ServletPersonne -->
    <servlet>
        <servlet-name>personne</servlet-name>
        <servlet-class>
            istia.st.servlets.personne.ServletPersonne
        </servlet-class>
        <init-param>
            <param-name>urlReponse</param-name>
            <param-value>
                /WEB-INF/vues/reponse.jsp
            </param-value>
        </init-param>
        <init-param>
            <param-name>urlErreurs</param-name>
            <param-value>
                /WEB-INF/vues/erreurs.jsp
            </param-value>
        </init-param>
        <init-param>
            <param-name>urlFormulaire</param-name>
            <param-value>
                /WEB-INF/vues/formulaire.jsp
            </param-value>
        </init-param>
        <init-param>
            <param-name>urlControleur</param-name>
            <param-value>
                main
            </param-value>
        </init-param>
        <init-param>
            <param-name>lienRetourFormulaire</param-name>
            <param-value>
                Retour au formulaire
            </param-value>
        </init-param>
    </servlet>
    <!--  Mapping ServletPersonne-->
    <servlet-mapping>
        <servlet-name>personne</servlet-name>
        <url-pattern>/main</url-pattern>
    </servlet-mapping>
    <!--  welcome files -->
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

Diese Datei ist identisch mit der in der vorherigen Version, mit der Ausnahme, dass sie zwei neue Initialisierungsparameter deklariert:

Zeile 6: Der Anzeigename der Webanwendung wurde in [mvc-personne-02] geändert
Zeilen 31–36: Definieren Sie den Konfigurationsparameter [urlController], bei dem es sich um die [Haupt-]URL handelt, die zum Servlet [ServletPersonne] führt
Zeilen 37–42: Definieren Sie einen Konfigurationsparameter namens [lienRetourFormulaire], der den Text des Links zurück zum Formular auf den JSP-Seiten [erreurs.jsp] und [reponse.jsp] angibt.

Die Startseite [index.jsp] ändert sich:


<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<%
  response.sendRedirect("/personne2/main");
%>

Zeile 5: Die Seite [index.jsp] leitet den Client zur URL des Controllers [ServletPersonne] in der Anwendung [/personne2] weiter.

6.4. Der View-Code

6.4.1. Die [form]-Ansicht

Diese Ansicht ist identisch mit der der vorherigen Version:

Sie wird von der folgenden JSP-Seite [formulaire.jsp] generiert:


<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<%
    // on récupère les données du modèle
  String nom=(String)session.getAttribute("nom");
  String age=(String)session.getAttribute("age");
  String urlAction=(String)request.getAttribute("urlAction");
%>
    
<html>
    <head>
      <title>Personne - formulaire</title>
  </head>
  <body>
      <center>
        <h2>Personne - formulaire</h2>
      <hr>
      <form action="<%=urlAction%>" method="post">
          <table>
            <tr>
              <td>Nom</td>
            <td><input name="txtNom" value="<%= nom %>" type="text" size="20"></td>
          </tr>
          <tr>
              <td>Age</td>
            <td><input name="txtAge" value="<%= age %>" type="text" size="3"></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" value="Effacer"></td>
          </tr>
        </table>
        <input type="hidden" name="action" value="validationFormulaire"> 
      </form>
    </center>
  </body>
</html>

Was gibt's Neues:

Zeile 19: Das Formular verfügt nun über ein [action]-Attribut, dessen Wert die URL ist, an die der Browser die Formularwerte sendet, wenn der Benutzer auf die Schaltfläche [Submit] klickt. Die Variable [urlAction] erhält den Wert action="main". Die Ansicht [form] wird angezeigt, nachdem der Benutzer die folgenden Aktionen ausgeführt hat:
Erstanfrage: GET /person2/main
Klick auf den Link [Zurück zum Formular]: GET /person2/main?action=retourFormulaire

Da das Attribut [action] keine absolute URL (die mit / beginnt), sondern eine relative URL (die nicht mit / beginnt) angibt, verwendet der Browser den ersten Teil der URL der aktuell angezeigten Seite [/person2] und hängt die relative URL daran an. Die POST-URL lautet daher [/person2/main], was der URL des Controllers entspricht. Dieser POST-Request wird von den Parametern [txtName, txtAge, action] aus den Zeilen 23, 27 und 38 begleitet.

Zeile 8: Wir rufen den Wert des Elements [urlAction] aus dem Modell ab. Er wird aus den Attributen der aktuellen Anfrage abgerufen. Er wird in Zeile 19 verwendet.
Zeilen 6–7: Wir rufen die Werte der Elemente [name, age] aus dem Modell ab. Sie werden aus den Session-Attributen abgerufen und nicht, wie in der vorherigen Version, aus den Request-Attributen. Dies dient dazu, die Anfrage [GET /person2/main?action=returnToForm] aus dem Link in den Ansichten [response] und [errors] zu berücksichtigen. Vor der Anzeige dieser beiden Ansichten speichert der Controller die im Formular eingegebenen Daten in der Sitzung, sodass er sie abrufen kann, wenn der Benutzer in den Ansichten [response] und [errors] auf den Link [Zurück zum Formular] klickt.

6.4.2. Die Ansicht [response]

Diese Ansicht zeigt die im Formular eingegebenen Werte an, sofern diese gültig sind:

Im Vergleich zur vorherigen Version ist der Link [Zurück zum Formular] eine neue Funktion. Die Ansicht wird von der folgenden JSP-Seite [response.jsp] generiert:


<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
 
<%
    // on récupère les données du modèle
  String nom=(String)request.getAttribute("nom");
  String age=(String)request.getAttribute("age");
  String lienRetourFormulaire=(String)request.getAttribute("lienRetourFormulaire");
%>
 
<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>
    <a href="?action=retourFormulaire"><%= lienRetourFormulaire %></a>
  </body>
</html>

Zeile 31: Der Link zurück zum Formular. Dieser Link besteht aus zwei Komponenten:

das Ziel [href="?action=retourFormulaire"]. Die Ansicht [response] wird angezeigt, nachdem das Formular [formulaire.jsp] per POST an die URL [/personne2/main] gesendet wurde. Es ist daher diese URL, die im Browser angezeigt wird, wenn die Ansicht [response] angezeigt wird. Ein Klick auf den Link [Zurück zum Formular] löst dann eine GET-Anfrage des Browsers an die durch das [href]-Attribut des Links angegebene URL aus, in diesem Fall „?action=retourFormulaire“. Ist in [href] keine URL angegeben, verwendet der Browser die URL der aktuell angezeigten Ansicht, d. h. [/personne2/main]. Letztendlich löst das Klicken auf den Link [Zurück zum Formular] eine GET-Anfrage vom Browser an die URL [/person2/main?action=retourFormulaire] aus, d. h. an die URL des Anwendungscontrollers, ergänzt um den Parameter [action], der angibt, was zu tun ist.
der Linktext. Dieser ist Teil der Vorlage, die vom Controller an die Seite gesendet und in Zeile 10 abgerufen wird.

6.4.3. Die Ansicht [errors]

Diese Ansicht zeigt Eingabefehler im Formular an:

Im Vergleich zur vorherigen Version ist der Link [Zurück zum Formular] eine neue Funktion. Die Ansicht wird von der folgenden JSP-Seite [errors.jsp] generiert:


<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<%@ page import="java.util.ArrayList" %>
 
<%
// on récupère les données du modèle
  ArrayList erreurs=(ArrayList)request.getAttribute("erreurs"); 
  String lienRetourFormulaire=(String)request.getAttribute("lienRetourFormulaire");
%>
 
<html>
    <head>
      <title>Personne</title>
  </head>
  <body>
      <h2>Les erreurs suivantes se sont produites</h2>
    <ul>
        <%
          for(int i=0;i<erreurs.size();i++){
            out.println("<li>" + (String) erreurs.get(i) + "</li>\n");
        }//for
      %>
    </ul>
    <br>
    <a href="?action=retourFormulaire"><%= lienRetourFormulaire %></a>
  </body>
</html>

Zeile 26: Der Link zurück zum Formular. Dieser Link ist identisch mit dem in der Ansicht [response]. Der Leser wird gebeten, bei Bedarf die Erläuterungen zu dieser Ansicht nachzulesen.

6.5. Testen der Ansichten

Um die vorherigen Ansichten zu testen, duplizieren wir ihre JSP-Seiten im Ordner /WebContent/JSP des Eclipse-Projekts:

Anschließend werden die Seiten im JSP-Ordner wie folgt geändert:

[form.jsp]:


...
<%
  // -- test : on crée le modèle de la page
  session.setAttribute("nom","tintin");
  session.setAttribute("age","30");
  request.setAttribute("urlAction","main");
%>
 
<%
    // on récupère les données du modèle
  String nom=(String)session.getAttribute("nom");
  String age=(String)session.getAttribute("age");
  String urlAction=(String)request.getAttribute("urlAction");
%>

Die Zeilen 4–5 wurden hinzugefügt, um das von der Seite in den Zeilen 11–13 benötigte Modell zu erstellen.

[response.jsp]:


 
<%
  // -- test : on crée le modèle de la page
  request.setAttribute("nom","milou");
  request.setAttribute("age","10");
  request.setAttribute("lienRetourFormulaire","Retour au formulaire");
%>
 
<%
    // on récupère les données du modèle
  String nom=(String)request.getAttribute("nom");
  String age=(String)request.getAttribute("age");
  String lienRetourFormulaire=(String)request.getAttribute("lienRetourFormulaire");
%>

Die Zeilen 4–6 wurden hinzugefügt, um die Vorlage zu erstellen, die von der Seite in den Zeilen 11–13 benötigt wird.

[errors.jsp]:


 
<%
  // -- test : on crée le modèle de la page
  ArrayList<String> erreurs1=new ArrayList<String>();
  erreurs1.add("erreur1");
  erreurs1.add("erreur2");
  request.setAttribute("erreurs",erreurs1);
  request.setAttribute("lienRetourFormulaire","Retour au formulaire");
%>
 
<%
// on récupère les données du modèle
  ArrayList erreurs=(ArrayList)request.getAttribute("erreurs"); 
  String lienRetourFormulaire=(String)request.getAttribute("lienRetourFormulaire");
%>

Die Zeilen 4–8 wurden hinzugefügt, um das von der Seite in den Zeilen 13–14 benötigte Modell zu erstellen.

Starten wir Tomcat, falls es noch nicht läuft, und rufen wir dann die folgenden URLs auf:

Wir erhalten die erwarteten Aufrufe.

6.6. Der [ServletPersonne]-Controller

Der [ServletPersonne]-Controller der Webanwendung [/personne2] wird die folgenden Aktionen verarbeiten:

Nr.	Anfrage	Herkunft	Verarbeitung
1	[GET /person2/hand]	Vom Benutzer eingegebene URL	- die leere [form]-Ansicht senden
2	[POST /person2/hand] mit den Parametern [txtName, txtAge, action]	klicken Sie auf die [Absenden]-Schaltfläche im [Formular]	- Überprüfe die Werte der Parameter [txtName, txtAge] - Wenn sie falsch sind, sende die Ansicht [errors(errors)] - wenn sie korrekt sind, sende die Ansicht [response(name,age)]
3	[GET /person2/main? action=returnForm]	Klicken Sie auf das Formular [Zurück zum Formular] der Ansichten Antwort] und [Fehler].	- Sende die Ansicht [Formular] vorausgefüllt mit den zuletzt eingegebenen Werten

Wir haben also eine neue Aktion zu behandeln: [GET /person2/main?action=returnForm].

6.6.1. Controller-Skelett

Das Controller-Gerüst [ServletPersonne] ist fast identisch mit dem der vorherigen Version:

package istia.st.servlets.personne;

...
import javax.servlet.http.HttpSession;

@SuppressWarnings("serial")
public class ServletPersonne extends HttpServlet {
    ...

    // init
    @SuppressWarnings("unchecked")
    public void init() throws ServletException {
        ...
    }

    @SuppressWarnings("unchecked")
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws IOException, ServletException {
...
    }

    // empty form display
    void doInit(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
        ...
    }

    // display pre-filled form
    void doRetourFormulaire(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
        ...
    }

    // form validation
    void doValidationFormulaire(HttpServletRequest request,
    ...
    }

    // post
    public void doPost(HttpServletRequest request, HttpServletResponse response)
    ...
    }
}

Was ist neu:

Zeile 4: Für die Verwendung einer Sitzung muss das Paket [HttpSession] importiert werden
Zeilen 28–30: Die neue Methode [doRetourFormulaire] verarbeitet die neue Aktion: [GET /personne2/main?action=retourFormulaire].

6.6.2. Initialisierung des [init]-Controllers

Die Methode [init] ist identisch mit der der vorherigen Version. Sie überprüft die Datei [web.xml] auf die im Array [parameters] deklarierten Elemente:

public class ServletPersonne extends HttpServlet {
    // instance parameters
    private String urlErreurs = null;
    private ArrayList erreursInitialisation = new ArrayList<String>();
    private String[] paramètres={"urlFormulaire","urlReponse","urlControleur","lienRetourFormulaire"};
  private Map params=new HashMap<String,String>();

Zeile 5: Die Parameter [controllerUrl] (Controller-URL) und [formBackLink] (Linktext für die Ansichten [response] und [errors]) wurden hinzugefügt.

6.6.3. Die [doGet]-Methode

Die Methode [doGet] muss die Aktion [GET /person2/main?action=formSubmit] verarbeiten, die zuvor nicht existierte:

        @SuppressWarnings("unchecked")
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws IOException, ServletException {

        // check how the servlet was initialized
        if (erreursInitialisation.size() != 0) {
            // we hand over to the error page
            request.setAttribute("erreurs", erreursInitialisation);
            request.setAttribute("lienRetourFormulaire", "");
            getServletContext().getRequestDispatcher(urlErreurs).forward(
                    request, response);
            // end
            return;
        }
        // retrieve the request sending method
        String méthode=request.getMethod().toLowerCase();
        // retrieve the action to be executed
        String action=request.getParameter("action");
        // action?
        if(action==null){
            action="init";
        }
        // execution action
        if(méthode.equals("get") && action.equals("init")){
            // start application
            doInit(request,response);
            return;
        }
        if(méthode.equals("post") && action.equals("validationFormulaire")){
            // validate input form
            doValidationFormulaire(request,response);
            return;
        }
        if(méthode.equals("get") && action.equals("retourFormulaire")){
            // back to input form
            doRetourFormulaire(request,response);
            return;
        }
        // other cases
        doInit(request,response);
    }

Zeilen 6–14: Wir prüfen, ob die Liste der Initialisierungsfehler leer ist. Ist dies nicht der Fall, zeigen wir die Ansicht [errors(initializationErrors)] an, die die Fehler meldet.

Um diesen Code zu verstehen, müssen Sie sich an die Vorlage für die Ansicht [errors] erinnern:


<%
// on récupère les données du modèle
  ArrayList erreurs=(ArrayList)request.getAttribute("erreurs"); 
  String lienRetourFormulaire=(String)request.getAttribute("lienRetourFormulaire");
%>

Die Ansicht [errors] erwartet ein Schlüsselelement namens „errors“ in der Anfrage. Der Controller erstellt dieses Element in Zeile 8. Außerdem erwartet sie ein Schlüsselelement namens „formSubmitLink“. Der Controller erstellt dieses Element in Zeile 9. Hier bleibt der Linktext leer. Daher wird in der gesendeten [errors]-Ansicht kein Link enthalten sein. Wenn während der Initialisierung der Anwendung Fehler aufgetreten sind, muss die Anwendung neu konfiguriert werden. Es besteht keine Notwendigkeit, dem Benutzer die Möglichkeit zu bieten, die Anwendung über einen Link fortzusetzen.

Zeilen 34–37: Verarbeitung der neuen Aktion [GET /person2/main?action=returnForm]

6.6.4. Die Methode [doInit]

Diese Methode verarbeitet die Anfrage Nr. 1 [GET /person2/main]. Für diese Anfrage muss sie die leere Ansicht [form(name,age)] zurückgeben. Der Code lautet wie folgt:

    // empty form display
    void doInit(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
        // retrieve the user's session
        HttpSession session = request.getSession(true);        
        // send the empty form
        session.setAttribute("nom", "");
        session.setAttribute("age", "");
        request.setAttribute("urlAction", (String)params.get("urlControleur"));
        getServletContext().getRequestDispatcher((String)params.get("urlFormulaire")).forward(
                request, response);
        return;
    }

Zeile 4: Die aktuelle Sitzung wird abgerufen, sofern sie existiert; andernfalls wird sie erstellt (Parameter getSession auf true gesetzt).
Zeilen 9–10: Die Ansicht [form] wird angezeigt. Erinnern Sie sich an die von dieser Ansicht erwartete Vorlage:


<%
    // on récupère les données du modèle
  String nom=(String)session.getAttribute("nom");
  String age=(String)session.getAttribute("age");
  String urlAction=(String)request.getAttribute("urlAction");
%>

Zeilen 6–7: Die Elemente [name, age] des View-Modells [form] werden mit leeren Zeichenfolgen initialisiert und in die Sitzung gestellt, da die Ansicht sie dort erwartet.
Zeile 8: Das Element [urlAction] des Modells wird mit dem Wert des Parameters [urlController] aus der Datei [web.xml] initialisiert und in die Anfrage aufgenommen.

6.6.5. Die Methode [doValidationFormulaire]

Diese Methode verarbeitet die Anfrage Nr. 2 [POST /person2/main], bei der die übermittelten Parameter [action, txtName, txtAge] lauten. Ihr Code lautet wie folgt:

    // form validation
    void doValidationFormulaire(HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException{
        // parameters are retrieved
        String nom = request.getParameter("txtNom");
        String age = request.getParameter("txtAge");
        // stored in the session
        HttpSession session = request.getSession(true);        
        session.setAttribute("nom", nom);
        session.setAttribute("age", age);
        // parameter verification
        ArrayList<String> erreursAppel = new ArrayList<String>();
        // name must be non-empty
        nom = nom.trim();
        if (nom.equals(""))
            erreursAppel.add("Le champ [nom] n'a pas été rempli");
        // age must be an integer >=0
        if (!age.matches("^\\s*\\d+\\s*$"))
            erreursAppel.add("Le champ [age] est erroné");
        // errors in the parameters?
        if (erreursAppel.size() != 0) {
            // send error page
            request.setAttribute("erreurs", erreursAppel);
            request.setAttribute("lienRetourFormulaire", (String)params.get("lienRetourFormulaire"));
            getServletContext().getRequestDispatcher(urlErreurs).forward(
                    request, response);
            return;
        }
        // parameters are correct - send response page
        request.setAttribute("nom", nom);
        request.setAttribute("age", age);
        request.setAttribute("lienRetourFormulaire", (String)params.get("lienRetourFormulaire"));
        getServletContext().getRequestDispatcher((String)params.get("urlReponse")).forward(request,
                response);
        return;
    }

Zeilen 5–6: Wir rufen die Werte der Parameter „txtNom“ und „txtAge“ aus der Anfrage des Clients ab.
Zeilen 8–10: Diese Werte werden in der Sitzung gespeichert, damit sie abgerufen werden können, wenn der Benutzer in den Ansichten [response] und [errors] auf den Link [Zurück zum Formular] klickt.
Zeilen 12–19: Die Gültigkeit der Werte für beide Parameter wird überprüft.
Zeilen 21–28: Ist einer der Parameter ungültig, wird die Ansicht [errors(errors,returnToFormLink)] angezeigt. Erinnern Sie sich an die Vorlage für diese Ansicht:


<%
// on récupère les données du modèle
  ArrayList erreurs=(ArrayList)request.getAttribute("erreurs"); 
  String lienRetourFormulaire=(String)request.getAttribute("lienRetourFormulaire");
%>

Zeilen 30–34: Wenn die beiden abgerufenen Parameter „txtName“ und „txtAge“ gültige Werte haben, zeigen wir die Ansicht [response(name, age, formSubmitLink)] an. Erinnern Sie sich an die Vorlagenansicht [response]:


<%
    // on récupère les données du modèle
  String nom=(String)request.getAttribute("nom");
  String age=(String)request.getAttribute("age");
  String lienRetourFormulaire=(String)request.getAttribute("lienRetourFormulaire");
%>

6.6.6. Die Methode [doRetourFormulaire]

Diese Methode verarbeitet die Anfrage Nr. 3 [GET /person2/main?action=formSubmit]. Der Code lautet wie folgt:

// display pre-filled form
    void doRetourFormulaire(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
        // retrieve the user's session
        HttpSession session = request.getSession(true);        
        // prepare the form template
        // name present in the session?
        String nom = (String) session.getAttribute("nom");
        if (nom == null)
            session.setAttribute("nom", "");
        // age present in the session?
        String age = (String) session.getAttribute("age");
        if (age == null)
            session.setAttribute("age", "");
        // urlAction
        request.setAttribute("urlAction", (String)params.get("urlControleur"));
        // the form is displayed
        getServletContext().getRequestDispatcher((String)params.get("urlFormulaire")).forward(
                request, response);
        return;
    }

Nachdem diese Methode ausgeführt wurde, sollte die [form]-Ansicht angezeigt werden, die bereits mit den letzten Eingaben des Benutzers vorbelegt ist. Hier ist die [form]-Ansichtsvorlage:


<%
    // on récupère les données du modèle
  String nom=(String)session.getAttribute("nom");
  String age=(String)session.getAttribute("age");
  String urlAction=(String)request.getAttribute("urlAction");
%>

Die Methode [doRetourFormulaire] muss daher das vorherige Modell erstellen.

Zeile 4: Wir rufen die Sitzung ab, in der der Controller die eingegebenen Werte (Name, Alter) gespeichert hat.
Zeile 7: Wir rufen den Namen aus der Sitzung ab
Zeilen 8–9: Ist er nicht vorhanden, fügen wir ihn mit einem leeren Wert hinzu. Dieses Szenario sollte im normalen Anwendungsbetrieb nicht auftreten, da die Aktion [returnForm] immer nach der Aktion [validateForm] stattfindet, die ausgeführt wird, nachdem die eingegebenen Daten in der Sitzung gespeichert wurden. Eine Sitzung kann jedoch ablaufen, da sie eine begrenzte Lebensdauer hat, oft einige Dutzend Minuten. In diesem Fall hat Zeile 4 eine neue Sitzung erstellt, in der der Name nicht gefunden wird. Wir setzen daher einen leeren Namen in der neuen Sitzung.
Zeilen 11–13: Wir verfahren ebenso mit dem Alter
Wenn wir das Problem der abgelaufenen Sitzung außer Acht lassen, sind die Zeilen 3–13 überflüssig. Die Elemente [name, age] des Modells befinden sich bereits in der Sitzung. Daher besteht keine Notwendigkeit, sie dort erneut einzufügen.
Zeile 15: Wir setzen den Wert des Elements [urlAction] im Modell

6.7. Tests

Starten oder starten Sie Tomcat neu. Rufen Sie die URL [http://localhost:8080/personne2] auf und wiederholen Sie dann die in Abschnitt 6.1 gezeigten Tests.