6. Applicazione Web MVC [person] – Versione 2

Introdurremo ora delle varianti dell'applicazione precedente [/person1], che chiameremo [/person2, /person3, ...]. Queste varianti non alterano l'architettura originale dell'applicazione, che rimane la seguente:

Per queste varianti, le nostre spiegazioni saranno brevi. Presenteremo solo le modifiche apportate rispetto alla versione precedente.

6.1. Introduzione

Aggiungeremo ora la gestione delle sessioni alla nostra applicazione. Rivediamo i seguenti punti:

Il dialogo HTTP client-server è una serie di sequenze richiesta-risposta indipendenti l'una dall'altra
la sessione funge da buffer di memoria tra le diverse sequenze richiesta-risposta provenienti dallo stesso utente. Se ci sono N utenti, ci sono N sessioni.

La seguente sequenza di schermate mostra ciò che ora si desidera nel funzionamento dell'applicazione:

Scambio n. 1

`richiesta`	`Risposta`

La nuova funzionalità è il link di ritorno al modulo, che è stato aggiunto alla vista [errori].

Scambio n. 2

`richiesta`	`risposta`

Nello scambio n. 1, l'utente ha fornito i valori (xx, yy) per la coppia (nome, età). Se il server è venuto a conoscenza di questi valori durante lo scambio, li "dimentica" al termine dello stesso. Tuttavia, possiamo notare che durante lo scambio n. 2, è in grado di visualizzarne nuovamente i valori nella sua risposta. È il concetto di sessione che, in questo caso, consente al server web di memorizzare i dati durante gli scambi client-server successivi. Esistono altre possibili soluzioni a questo problema.

Durante lo scambio n. 1, il server memorizzerà nella sessione la coppia (nome, età) che il client gli ha inviato, in modo da poterla visualizzare durante lo scambio n. 2.

Ecco un altro esempio di implementazione di una sessione tra due scambi:

Scambio n. 1

`richiesta`	`risposta`

La novità è il link che rimanda al modulo, che è stato aggiunto alla pagina di risposta.

Scambio n. 2

`richiesta`	`risposta`

6.2. Il progetto Eclipse

Per creare il progetto Eclipse [mvc-personne-02] per l'applicazione web [/personne2], duplicheremo il progetto Eclipse [mvc-personne-01] per riutilizzare il codice esistente. A tal fine, procedere come segue:

[Fare clic con il tasto destro del mouse sul progetto mvc-personne-01 -> Copia]:

quindi [fare clic con il tasto destro del mouse in Package Explorer -> Incolla]:

- inserisci il nome del nuovo progetto in [1] e il nome di una cartella esistente ma vuota in [2]

Viene quindi creato il progetto [mvc-personne-02]:

Per ora, è identico al progetto [mvc-personne-01]. Dovremo apportare alcune modifiche manuali prima di poterlo utilizzare. Vai alla vista [Servers] e prova ad aggiungere questa nuova applicazione a quelle gestite da Tomcat:

Possiamo vedere che in [1], il nuovo progetto [mvc-personne-02] non viene riconosciuto da Tomcat. Affinché Tomcat lo riconosca, è necessario modificare un file di configurazione per il progetto [mvc-personne-02]. Utilizza l'opzione [File / Apri file] per aprire il file [<mvc-personne-02>/.settings/.component]:


<?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>

La riga 3 specifica il nome del modulo web da distribuire all'interno di Tomcat. In questo caso, il nome è lo stesso del progetto [mvc-personne-01]. Lo modifichiamo in [mvc-personne-02]:


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

Inoltre, possiamo cogliere l'occasione per modificare, alla riga 7, il nome del contesto dell'applicazione [mvc-personne-02], che è in conflitto con quello del progetto [mvc-personne-01]:


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

Questa seconda modifica avrebbe potuto essere effettuata direttamente all'interno di Eclipse. Tuttavia, non ho capito come effettuare la prima senza passare dal file di configurazione.

Una volta fatto ciò, salviamo il nuovo file [.content], quindi usciamo e riavviamo Eclipse affinché le modifiche abbiano effetto.

Una volta riavviato Eclipse, proviamo l'operazione che prima non era andata a buon fine:

Questa volta, il progetto [mvc-personne-02] viene riconosciuto. Lo aggiungiamo ai progetti configurati per l'esecuzione su Tomcat:

6.3. Configurazione dell'applicazione web [personne2]

Il file web.xml per l'applicazione /personne2 è il seguente:


<?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>

Questo file è identico a quello della versione precedente, tranne per il fatto che dichiara due nuovi parametri di inizializzazione:

riga 6: il nome visualizzato dell'applicazione web è stato modificato in [mvc-personne-02]
righe 31–36: definiscono il parametro di configurazione denominato [urlController], che è l'URL [principale] che porta al servlet [ServletPersonne]
righe 37–42: definiscono un parametro di configurazione denominato [lienRetourFormulaire], che è il testo del link di ritorno al modulo nelle pagine JSP [erreurs.jsp] e [reponse.jsp].

La pagina iniziale [index.jsp] cambia:


<%@ 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");
%>

Riga 5: La pagina [index.jsp] reindirizza il client all'URL del controller [ServletPersonne] nell'applicazione [/personne2].

6.4. Il codice della vista

6.4.1. La vista [form]

Questa vista è identica a quella della versione precedente:

È generata dalla seguente pagina JSP [formulaire.jsp]:


<%@ 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>

Novità:

Riga 19: Il modulo ora ha un attributo [action] il cui valore è l'URL a cui il browser invierà i valori del modulo quando l'utente clicca sul pulsante [Invia]. La variabile [urlAction] avrà il valore action="main". La vista [form] viene visualizzata dopo che l'utente ha eseguito le seguenti azioni:
richiesta iniziale: GET /person2/main
clic sul link [Torna al modulo]: GET /person2/main?action=retourFormulaire

Poiché l'attributo [action] non specifica un URL assoluto (che inizia con /) ma un URL relativo (che non inizia con /), il browser utilizzerà la prima parte dell'URL della pagina attualmente visualizzata [/person2] e vi aggiungerà l'URL relativo. L'URL POST sarà quindi [/person2/main], che è l'URL del controller. Questa richiesta POST sarà accompagnata dai parametri [txtName, txtAge, action] delle righe 23, 27 e 38.

Riga 8: recuperiamo il valore dell'elemento [urlAction] dal modello. Viene recuperato dagli attributi della richiesta corrente. Verrà utilizzato alla riga 19.
Righe 6–7: Recuperiamo i valori degli elementi [name, age] dal modello. Vengono recuperati dagli attributi della sessione piuttosto che dagli attributi della richiesta, come nella versione precedente. Questo per gestire la richiesta [GET /person2/main?action=returnToForm] proveniente dal link nelle viste [response] e [errors]. Prima di visualizzare queste due viste, il controller inserisce i dati inseriti nel modulo nella sessione, il che gli consente di recuperarli quando l'utente fa clic sul link [Torna al modulo] nelle viste [response] ed [errors].

6.4.2. La vista [response]

Questa vista visualizza i valori inseriti nel modulo quando sono validi:

Rispetto alla versione precedente, la novità è rappresentata dal link [Torna al modulo]. La vista è generata dalla seguente pagina JSP [response.jsp]:


<%@ 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>

Riga 31: il link di ritorno al modulo. Questo link è composto da due parti:

la destinazione [href="?action=retourFormulaire"]. La vista [response] viene visualizzata dopo che il modulo [formulaire.jsp] è stato inviato tramite POST all'URL [/personne2/main]. È quindi quest'ultimo URL che viene visualizzato nel browser quando viene visualizzata la vista [response]. Cliccando sul link [Torna al modulo] verrà quindi inviata una richiesta GET dal browser all'URL specificato dall'attributo [href] del link, in questo caso "?action=retourFormulaire". Se non è specificato alcun URL in [href], il browser utilizzerà l'URL della vista attualmente visualizzata, ovvero [/personne2/main]. In definitiva, cliccando sul link [Torna al modulo] si attiverà una richiesta GET dal browser all'URL [/person2/main?action=retourFormulaire], ovvero l'URL del controller dell'applicazione accompagnato dal parametro [action] per indicargli cosa fare.
il testo del link. Questo farà parte del modello inviato alla pagina dal controller e recuperato alla riga 10.

6.4.3. La vista [errors]

Questa vista visualizza gli errori di immissione nel modulo:

Rispetto alla versione precedente, la novità è il link [Torna al modulo]. La vista è generata dalla seguente pagina JSP [errors.jsp]:


<%@ 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>

Riga 26: il link di ritorno al modulo. Questo link è identico a quello nella vista [response]. Si invita il lettore a consultare le spiegazioni fornite per quella vista, se necessario.

6.5. Test delle viste

Per testare le viste precedenti, duplichiamo le relative pagine JSP nella cartella /WebContent/JSP del progetto Eclipse:

Quindi, nella cartella JSP, le pagine vengono modificate come segue:

[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");
%>

Le righe 4–5 sono state aggiunte per creare il modello richiesto dalla pagina nelle righe 11–13.

[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");
%>

Le righe 4–6 sono state aggiunte per creare il modello richiesto dalla pagina nelle righe 11–13.

[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");
%>

Le righe 4–8 sono state aggiunte per creare il modello richiesto dalla pagina nelle righe 13–14.

Avviamo Tomcat se non è già in esecuzione, quindi richiediamo i seguenti URL:

Otteniamo le visualizzazioni previste.

6.6. Il controller [ServletPersonne]

Il controller [ServletPersonne] dell'applicazione web [/personne2] gestirà le seguenti azioni:

No.	richiesta	origine	elaborazione
1	[GET /person2/hand]	URL inserito dall'utente	- invia la vista [form] vuota
2	[POST /person2/hand] con i parametri [txtName, txtAge, action]	fare clic sul pulsante [Invia] nel [form]	- controlla i valori dei parametri [txtName, txtAge] - se non sono corretti, inviare la vista [errors(errors)] - se sono corretti, inviare la vista [response(name,age)]
3	[GET /person2/main? action=returnForm]	fare clic sul [Torna al modulo] delle viste risposta] e [errori].	- Invia la vista [form] precompilata con gli ultimi valori inseriti

Quindi abbiamo una nuova azione da gestire: [GET /person2/main?action=returnForm].

6.6.1. Scheletro del controller

Lo scheletro del controller [ServletPersonne] è quasi identico a quello della versione precedente:

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)
    ...
    }
}

Novità:

riga 4: l'utilizzo di una sessione richiede l'importazione del pacchetto [HttpSession]
Righe 28–30: il nuovo metodo [doRetourFormulaire] gestisce la nuova azione: [GET /personne2/main?action=retourFormulaire].

6.6.2. Inizializzazione del controller [init]

Il metodo [init] è identico a quello della versione precedente. Controlla il file [web.xml] alla ricerca degli elementi dichiarati nell'array [parameters]:

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>();

Riga 5: sono stati aggiunti i parametri [controllerUrl] (URL del controller) e [formBackLink] (testo del link per le viste [response] e [errors]).

6.6.3. Il metodo [doGet]

Il metodo [doGet] deve gestire l'azione [GET /person2/main?action=formSubmit], che prima non esisteva:

        @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);
    }

righe 6–14: verifichiamo che l'elenco degli errori di inizializzazione sia vuoto. Se non lo è, visualizziamo la vista [errors(initializationErrors)], che segnalerà gli errori.

Per comprendere questo codice, è necessario richiamare il modello di visualizzazione [errors]:


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

La vista [errors] si aspetta un elemento chiave denominato "errors" nella richiesta. Il controller crea questo elemento alla riga 8. Si aspetta inoltre un elemento chiave denominato "formSubmitLink". Il controller crea questo elemento alla riga 9. In questo caso, il testo del link sarà vuoto. Pertanto, non ci sarà alcun link nella vista [errors] che viene inviata. Infatti, se si sono verificati errori durante l'inizializzazione dell'applicazione, l'applicazione deve essere riconfigurata. Non è necessario offrire all'utente la possibilità di continuare l'applicazione tramite un link.

Righe 34–37: elaborazione della nuova azione [GET /person2/main?action=returnForm]

6.6.4. Il metodo [doInit]

Questo metodo gestisce la richiesta n. 1 [GET /person2/main]. Per questa richiesta, deve restituire la vista vuota [form(name,age)]. Il suo codice è il seguente:

    // 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;
    }

Riga 4: La sessione corrente viene recuperata se esiste; altrimenti, viene creata (parametro getSession impostato su true).
Righe 9–10: Viene visualizzata la vista [form]. Ricordiamo il modello previsto da questa vista:


<%
    // 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");
%>

Righe 6-7: Gli elementi [name, age] del modello di vista [form] vengono inizializzati con stringhe vuote e inseriti nella sessione perché è lì che la vista li prevede.
Riga 8: L'elemento [urlAction] del modello viene inizializzato con il valore del parametro [urlController] dal file [web.xml] e inserito nella richiesta.

6.6.5. Il metodo [doValidationFormulaire]

Questo metodo elabora la richiesta n. 2 [POST /person2/main], in cui i parametri inviati sono [action, txtName, txtAge]. Il suo codice è il seguente:

    // 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;
    }

Righe 5–6: Recuperiamo i valori dei parametri "txtNom" e "txtAge" dalla richiesta del client.
Righe 8–10: Questi valori vengono memorizzati nella sessione in modo da poter essere recuperati quando l'utente fa clic sul collegamento [Torna al modulo] nelle viste [response] e [errors].
Righe 12–19: viene verificata la validità dei valori di entrambi i parametri.
Righe 21-28: se uno dei due parametri non è valido, viene visualizzata la vista [errors(errors,returnToFormLink)]. Ricordiamo il template per questa vista:


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

Righe 30–34: Se i due parametri recuperati "txtName" e "txtAge" hanno valori validi, visualizziamo la vista [response(name, age, formSubmitLink)]. Ricordiamo il modello di vista [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. Il metodo [doRetourFormulaire]

Questo metodo gestisce la richiesta n. 3 [GET /person2/main?action=formSubmit]. Il suo codice è il seguente:

// 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;
    }

Una volta completato questo metodo, dovrebbe essere visualizzata la vista [form], precompilata con gli ultimi dati inseriti dall'utente. Ecco il modello della vista [form]:


<%
    // 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");
%>

Il metodo [doRetourFormulaire] deve quindi ricostruire il modello precedente.

Riga 4: recuperiamo la sessione in cui il controller ha memorizzato i valori inseriti (nome, età).
Riga 7: recuperiamo il nome dalla sessione
Righe 8–9: se non è presente, lo aggiungiamo con un valore vuoto. Questo scenario non dovrebbe verificarsi durante il normale funzionamento dell'applicazione, poiché l'azione [returnForm] ha sempre luogo dopo l'azione [validateForm], che avviene dopo che i dati inseriti sono stati salvati nella sessione. Tuttavia, una sessione può scadere perché ha una durata limitata, spesso di poche decine di minuti. In questo caso, la riga 4 ha creato una nuova sessione in cui il nome non sarà trovato. Impostiamo quindi un nome vuoto nella nuova sessione.
Righe 11–13: Facciamo lo stesso per l'età
Se ignoriamo il problema della sessione scaduta, le righe 3-13 non sono necessarie. Gli elementi [name, age] del modello sono già presenti nella sessione. Pertanto, non è necessario reinserirli.
Riga 15: Impostiamo il valore dell'elemento [urlAction] nel modello

6.7. Test

Avviare o riavviare Tomcat. Richiedere l'URL [http://localhost:8080/personne2] e poi ripetere i test mostrati nell'esempio nella sezione 6.1.