5. Applicazione web MVC [personne] – versione 1
5.1. Le viste dell’applicazione
L’applicazione riprende il modulo utilizzato negli esempi precedenti. La prima pagina dell’applicazione è la seguente:
Chiameremo questa vista «[formulaire]». Se si effettuano inserimenti corretti, questi vengono visualizzati in una vista che chiameremo «[réponse]»:
Se i dati inseriti non sono corretti, gli errori vengono segnalati in una vista denominata [erreurs]:
5.2. Architettura dell’applicazione
L’applicazione web [personne1] avrà la seguente architettura:
Si tratta di un'architettura a 1 livello: non sono presenti i livelli [métier] o [dao], ma solo il livello [web]. [ServletPersonne] è il controller dell'applicazione che gestisce tutte le richieste dei client. Per rispondere a tali richieste, utilizza una delle tre viste [formulaire, réponse, erreurs].
Dobbiamo determinare in che modo il controller [ServletPersonne] stabilisce l’azione da intraprendere alla ricezione di una richiesta da parte di un utente. Una richiesta del cliente è un flusso HTTP che varia a seconda che sia effettuata con un comando GET o POST.
Richiesta GET
In questo caso, il flusso HTTP si presenta come segue:
La riga 1 specifica l’URL richiesto, ad esempio:
È possibile utilizzare questo URL per specificare l'azione da eseguire. Si possono utilizzare diversi metodi:
- un parametro dell'URL specifica l'azione, ad esempio [/appli?action=ajouter&id=4]. In questo caso, il parametro [action] indica al controller l'azione che gli viene richiesta.
- l'ultimo elemento dell'URL specifica l'azione, ad esempio [/appli/ajouter?id=4]. In questo caso, l'ultimo elemento dell'URL [/ajouter] viene utilizzato dal controller per determinare l'azione che deve eseguire.
Sono possibili altre soluzioni. Le due precedenti sono quelle più comuni.
Richiesta POST
In questo caso, il flusso HTTP è simile al seguente:
La riga 1 specifica l'URL richiesto, ad esempio:
È possibile utilizzare questo URL per specificare l'azione da eseguire, come nel caso di GET. Nel caso di GET, il parametro [action] era integrato in URL. Ciò può verificarsi anche in questo caso, come in:
Ma il parametro [action] può essere incluso anche nei parametri inviati (riga 15 sopra) come in:
Di seguito utilizzeremo queste diverse tecniche per indicare al controller cosa deve fare:
- inserire il parametro action nell'URL richiesto:
- inviare il parametro action:
- utilizzare l'ultimo elemento dell'URL come nome dell'azione:
5.3. Il progetto Eclipse
Per creare il progetto Eclipse [mvc-personne-01] dell'applicazione web [personne1], seguire la procedura descritta al paragrafo 3.1.
Non si manterrà il contesto [mvc-personne-01] proposto di default. Si sceglierà [personne1] come indicato di seguito:
Il risultato ottenuto è il seguente:
Se, per caso, si desidera modificare il contesto dell'applicazione web, si utilizzerà l'opzione [clic droit sur projet -> Properties -> J2EE]:
Si indicherà il nuovo contesto in [1].
Creeremo una sottocartella [vues] all’interno della cartella [WEB-INF]: [clic droit sur WEB-INF -> New -> Folder]:
 |  |
Il nuovo progetto è ora questo:
Una volta completato, il progetto sarà il seguente:
- il controller [ServletPersonne] si trova nella cartella [src]
- le pagine JSP delle viste [formulaire, réponse, erreurs] si trovano nella cartella [WEB-INF/vues], il che impedisce all'utente di richiederle direttamente, come mostra l'esempio qui sotto:
Descriviamo ora i diversi componenti dell’applicazione web [/personne1]. Il lettore è invitato a crearli man mano che procede nella lettura.
5.4. Configurazione dell’applicazione web [personne1]
Il file web.xml dell’applicazione /personne1 sarà 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-01</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>
</servlet>
<!-- Mappatura ServletPersonne-->
<servlet-mapping>
<servlet-name>personne</servlet-name>
<url-pattern>/main</url-pattern>
</servlet-mapping>
<!-- file di benvenuto -->
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
Cosa dice questo file di configurazione?
- righe 34-37: il file URL /main viene gestito dal servlet denominato «persona»
- righe 10-13: il servlet denominato «personne» è un'istanza della classe [ServletPersonne]
- righe 14-19: definiscono un parametro di configurazione denominato [urlReponse]. Si tratta dell'URL della vista [réponse].
- righe 20-25: definiscono un parametro di configurazione denominato [urlErreurs]. Si tratta dell’URL della vista [erreurs].
- righe 26-31: definiscono un parametro di configurazione denominato [urlFormulaire]. Si tratta dell'URL della vista [formulaire].
- riga 40: [index.jsp] sarà la pagina iniziale dell'applicazione.
Gli URL delle pagine JSP delle viste [formulaire, réponse, erreurs] sono oggetto, ciascuno, di un parametro di configurazione. Ciò consente di spostarli senza dover ricompilare l’applicazione.
Quando l’utente richiederà l’URL [/personne1], sarà il file [index.jsp] a inviare la risposta (file di benvenuto, riga 40). Questo file si trova nella directory principale della cartella [WebContent]:
Il suo contenuto è il seguente:
<%@ 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("/personne1/main");
%>
La pagina [index.jsp] si limita a reindirizzare il client all’URL [/personne1/main]. Pertanto, quando il browser richiede l'URL [/personne1], [index.jsp] gli invia la seguente risposta HTTP:
- riga 1: risposta HTTP/1.1 per indicare al server di reindirizzarsi verso un altro URL
- riga 4: l'URL verso cui il browser deve essere reindirizzato
Dopo questa risposta, il browser richiederà quindi l'URL [/personne1/main] come gli è stato indicato (riga 4). Il file [web.xml] dell’applicazione [/personne1] indica che questa richiesta verrà gestita dal controller [ServletPersonne] (righe 35-36).
5.5. Il codice delle viste
Iniziamo a scrivere l’applicazione web partendo dalle sue viste. Queste consentono di definire le esigenze dell’utente in termini di interfaccia grafica e possono essere testate senza la presenza del controller.
5.5.1. La vista [formulaire]
Questa vista corrisponde al modulo per l’inserimento del nome e dell’età:
tipo HTML | nome | ruolo | |
<input type="text"> | txtNom | inserimento del nome | |
<input type="text"> | txtAge | inserimento dell'età | |
<input type="submit"> | invio dei valori inseriti al server all'URL /personne1/main | ||
<input type="reset"> | per riportare la pagina allo stato in cui è stata inizialmente ricevuta dal browser | ||
<input type="button"> | per cancellare il contenuto dei campi di immissione [1] e [2] |
Viene generata dalla pagina JSP [formulaire.jsp]. Il suo modello è costituito dai seguenti elementi:
- [nom]: un nome (String) presente negli attributi di sessione associati alla chiave "nom"
- [age]: un'età (String) presente negli attributi di sessione associati alla chiave "age"
La vista [formulaire] viene ottenuta quando l'utente richiede l'URL [/personne1/main], c.a.d. L'URL del controller è [ServletPersonne]. Il codice della pagina JSP [formulaire.jsp] che genera la vista [formulaire] è il seguente:
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<%
// si recuperano i dati dal modello
String nom=(String)request.getAttribute("nom");
String age=(String)request.getAttribute("age");
%>
<html>
<head>
<title>Personne - formulaire</title>
</head>
<body>
<center>
<h2>Personne - formulaire</h2>
<hr>
<form 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>
- righe 6-7: la pagina JSP inizia recuperando dalla richiesta [request] gli elementi [nom, age] del proprio modello. Nel normale funzionamento dell’applicazione, sarà il controller [ServletPersonne] a costruire questo modello.
- righe 18-38: la pagina JSP genererà un modulo HTML (tag <form>)
- riga 18: il tag <form> non presenta l'attributo action per indicare l'URL che dovrà elaborare i valori inviati tramite il pulsante [Envoyer] di tipo submit (riga 32). I valori del modulo verranno quindi inviati all'URL da cui è stato ottenuto il modulo, ovvero l'URL del controller [ServletPersonne]. Pertanto, quest’ultimo viene utilizzato sia per generare il modulo vuoto richiesto inizialmente da un GET, sia per elaborare i dati inseriti che gli verranno inviati tramite il pulsante [Envoyer].
- I valori inviati sono quelli dei campi HTML, [txtNom] (riga 22), [txtAge] (riga 26) e [action] (riga 37). Quest’ultimo parametro consentirà al controllore di sapere cosa deve fare.
- Alla visualizzazione iniziale del modulo, i campi di immissione [txtNom, txtAge] vengono inizializzati rispettivamente con le variabili [nom] (riga 22) e [age] (riga 26). Queste variabili ottengono i valori dei propri attributi dalla richiesta (righe 6-7), attributi che, come sappiamo, vengono inizializzati dal servlet. È quindi quest’ultimo a determinare il contenuto iniziale dei campi di immissione del modulo.
- riga 33: il pulsante [Rétablir] di tipo [reset] consente di riportare il modulo allo stato in cui si trovava quando è stato ricevuto dal browser.
- riga 34: il pulsante [Effacer] di tipo [reset] non ha, per il momento, alcuna funzione.
In seguito, chiameremo questa vista «vista [formulaire(nom, age)]» quando vorremo specificare sia il nome della vista che il suo modello. Inoltre, ricordiamo che quando l’utente clicca sul pulsante [Envoyer], i parametri [txtNom, txtAge] vengono inviati all’URL [/personne1/main].
5.5.2. La vista [reponse]
Questa vista visualizza i valori inseriti nel modulo quando questi sono validi:
Viene generata dalla pagina JSP [reponse.jsp]. Il suo modello è costituito dai seguenti elementi:
- [nom]: un nome (String) che si troverà negli attributi di sessione, associato alla chiave "nom"
- [age]: un'età (String) che si troverà negli attributi di sessione, associata alla chiave "età"
Il codice della pagina JSP [reponse.jsp] è il seguente:
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<%
// si recuperano i dati dal modello
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>
</body>
</html>
- righe 6-7: la pagina JSP inizia recuperando dalla richiesta [request] gli elementi [nom, age] del proprio modello. Nel normale funzionamento dell’applicazione, sarà il controller [ServletPersonne] a costruire questo modello.
- Gli elementi [nom, age] del modello vengono quindi visualizzati alle righe 20 e 24
Successivamente, chiamiamo questa vista «[réponse(nom, age)]».
5.5.3. La vista [erreurs]
Questa vista segnala gli errori di inserimento nel modulo:
Viene generata dalla pagina JSP [erreurs.jsp]. Il suo modello è costituito dai seguenti elementi:
- [erreurs]: un elenco (ArrayList) di messaggi di errore che si troverà negli attributi della richiesta, associato alla chiave "errori"
Il codice della pagina JSP [erreurs.jsp] è il seguente:
<%@ 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" %>
<%
// si recuperano i dati dal modello
ArrayList erreurs=(ArrayList)request.getAttribute("erreurs");
%>
<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");
}//per
%>
</ul>
</body>
</html>
- riga 8: la pagina JSP inizia recuperando dalla richiesta [request] l’elemento [erreurs] del proprio modello. Questo elemento rappresenta un oggetto di tipo ArrayList composto da elementi di tipo String. Questi elementi sono messaggi di errore. Nel normale funzionamento dell’applicazione, sarà il controller [ServletPersonne] a costruire questo modello.
- righe 18-22: visualizzano l’elenco dei messaggi di errore. A tal fine, è necessario scrivere codice Java nel corpo HTML della pagina. Si deve sempre cercare di ridurlo al minimo per non appesantire il codice HTML. Vedremo in seguito che esistono soluzioni che consentono di ridurre la quantità di codice Java nelle pagine JSP.
- riga 4: da notare il tag di importazione dei pacchetti necessari alla pagina JSP
Successivamente, chiameremo questa vista «[erreurs(erreurs)]».
5.6. Test delle viste
È possibile verificare la validità delle pagine JSP senza aver ancora scritto il controller. A tal fine sono necessarie due condizioni:
- è necessario poterle richiedere direttamente all’applicazione senza passare attraverso il controller
- la pagina JSP deve inizializzare autonomamente il modello che normalmente verrebbe costruito dal controller
Per eseguire questi test, duplichiamo le pagine JSP delle viste nella cartella [/WebContent/JSP] del progetto Eclipse:
Quindi, nella cartella JSP, le pagine vengono modificate come segue:
[formulaire.jsp]:
...
<%
// -- test: si crea il modello della pagina
request.setAttribute("nom","tintin");
request.setAttribute("age","30");
%>
<%
// si recuperano i dati dal modello
String nom=(String)request.getAttribute("nom");
String age=(String)request.getAttribute("age");
%>
<html>
<head>
...
Le righe 3-7 sono state aggiunte per creare il modello necessario alla pagina delle righe 11-12.
[reponse.jsp]:
...
<%
// -- test: si crea il modello della pagina
request.setAttribute("nom","milou");
request.setAttribute("age","10");
%>
<%
// si recuperano i dati dal modello
String nom=(String)request.getAttribute("nom");
String age=(String)request.getAttribute("age");
%>
<html>
<head>
...
Le righe 3-7 sono state aggiunte per creare il modello richiesto dalla pagina alle righe 11-12.
[erreurs.jsp]:
...
<%
// -- test: si crea il modello della pagina
ArrayList<String> erreurs1=new ArrayList<String>();
erreurs1.add("erreur1");
erreurs1.add("erreur2");
request.setAttribute("erreurs",erreurs1);
%>
<%
// si recuperano i dati dal modello
ArrayList erreurs=(ArrayList)request.getAttribute("erreurs");
%>
<html>
<head>
...
Le righe da 3 a 9 sono state aggiunte per creare il modello necessario alla pagina della riga 13.
Avvia Tomcat, se non l’hai già fatto, quindi richiedi i seguenti URL:
 |  |
 |
Otteniamo effettivamente le visualizzazioni previste. Ora che abbiamo una ragionevole fiducia nelle pagine JSP dell'applicazione, possiamo passare alla scrittura del relativo controller [ServletPersonne].
5.7. Il controller [ServletPersonne]
Resta da scrivere il cuore della nostra applicazione web, il controller. Il suo ruolo consiste nel:
- recuperare la richiesta del client,
- elaborare l’azione richiesta dal cliente,
- inviare in risposta la vista appropriata.
Il controller [ServletPersonne] gestirà le seguenti azioni:
n. | richiesta | origine | elaborazione |
1 | [GET /personne1/main] | URL digitato dall'utente | - inviare la vista [formulaire] vuota |
2 | [POST /personne1/main] con parametri [txtNom, txtAge, azione] pubblicati | cliccando sul pulsante [Envoyer] della vista [formulaire] | - verificare i valori dei parametri [txtNom, txtAge] - se non sono corretti, inviare la vista [erreurs(erreurs)] - se sono corretti, inviare la vista [reponse(nom,age)] |
L'applicazione si avvia quando l'utente richiede l'URL [/personne1/main]. In base al file [web.xml] dell'applicazione (cfr. paragrafo 5.4), questa richiesta viene elaborata da un'istanza di tipo ServletPersonne che descriviamo ora.
5.7.1. Struttura del controller
Il codice del controller [ServletPersonne] è il seguente:
- righe 20-22: il metodo [init] eseguito al caricamento iniziale del servlet
- righe 25-28: il metodo [doGet] chiamato dal server web quando viene effettuata una richiesta di tipo GET all’applicazione
- righe 42-46: il metodo [doPost] viene chiamato dal server web quando viene inviata all’applicazione una richiesta di tipo POST. Come mostrato, anche questa verrà gestita dal metodo [doGet] (riga 45).
- righe 31-33: il metodo [doInit] gestisce l’azione n. 1 [GET /personne1/main]
- righe 36-39: il metodo [doValidationFormulaire] elabora l’azione n. 2 [POST /personne1/main] con i parametri inviati tramite POST [txtNom, txtAge, action].
Descriviamo ora i diversi metodi del controller
5.7.2. Inizializzazione del controller
Quando la classe del controller viene caricata dal contenitore di servlet, viene eseguito il suo metodo [init]. Ciò avverrà una sola volta. Una volta caricato in memoria, il controller vi rimarrà e gestirà le richieste dei diversi client. Ogni client è gestito da un thread di esecuzione e i metodi del controller vengono quindi eseguiti simultaneamente da thread diversi. Si ricorda che, per questo motivo, il controller non deve avere campi che i suoi metodi potrebbero modificare. I suoi campi devono essere di sola lettura. Essi vengono inizializzati dal metodo [init], il cui ruolo principale è proprio questo. Questo metodo ha infatti la particolarità di essere eseguito una sola volta da un unico thread. Non sussistono quindi problemi di accesso concorrente ai campi del controller in questo metodo. Il metodo [init] ha lo scopo di inizializzare gli oggetti necessari all’applicazione web, che saranno condivisi in sola lettura da tutti i thread client. Questi oggetti condivisi possono essere collocati in due posizioni:
- i campi privati del controller
- il contesto di esecuzione dell’applicazione (ServletContext)
Il codice del metodo [init] del controller [ServletPersonne] è il seguente:
- riga 16: si recupera la configurazione dell’applicazione web, c.a.d. Il contenuto del file [web.xml]
- righe 19-29: si recuperano i parametri di inizializzazione del servlet, i cui nomi sono definiti nella tabella [paramètres] alla riga 9
- riga 21: viene recuperato il valore del parametro
- riga 25: se il parametro è assente, l’errore viene aggiunto all’elenco degli errori [erreursInitialisation] inizialmente vuoto (riga 8).
- riga 28: se il parametro è presente, viene memorizzato con il suo valore nel dizionario [params], inizialmente vuoto (riga 10).
- righe 31-35: il parametro [urlErreurs] deve essere obbligatoriamente presente poiché indica l'URL della vista [erreurs] in grado di visualizzare eventuali errori di inizializzazione. Se non esiste, l’applicazione viene interrotta avviando una [ServletException] (riga 33).
5.7.3. Il metodo [doGet]
Il metodo [doGet] gestisce sia le richieste GET che quelle POST al servlet, poiché il metodo [doPost] rimanda al metodo [doGet]. Il suo codice è il seguente:
- righe 18-25: si verifica che l'elenco degli errori di inizializzazione sia vuoto. In caso contrario, viene visualizzata la vista [erreurs(erreursInitialisation)] che segnalerà l'errore o gli errori.
Per comprendere questo codice, occorre ricordare il modello della vista [erreurs]:
<%
// si recuperano i dati dal modello
ArrayList erreurs=(ArrayList)request.getAttribute("erreurs");
%>
La vista [erreurs] richiede un elemento chiave "errori" nella richiesta. Il controller crea questo elemento alla riga 20.
- riga 28: si recupera il metodo [get] o [post] che il cliente ha utilizzato per effettuare la richiesta
- riga 30: si recupera il valore del parametro [action] della richiesta. Ricordiamo che nella nostra applicazione solo la richiesta n. 2 [POST /personne1/main] presenta il parametro [action]. In questa richiesta, il suo valore è [validationFormulaire].
- righe 31-34: se il parametro [action] non è presente, gli viene assegnato il valore "init". Questo accadrà nella richiesta iniziale n. 1 [GET /personne1/main].
- righe 36-40: elaborazione della richiesta n. 1 [GET /personne1/main].
- righe 41-45: elaborazione della richiesta n. 2 [POST /personne1/main].
- riga 47: se non ci si trova in uno dei due casi precedenti, si procede come se ci si trovasse nel caso n. 1
5.7.4. Il metodo [doInit]
Questo metodo elabora la richiesta n. 1 [GET /personne1/main]. Per questa richiesta, deve inviare la vista [formulaire(nom,age)] vuota. Il suo codice è il seguente:
- righe 18-19: viene visualizzata la vista [formulaire]. Ricordiamo il modello previsto da questa vista:
<%
// si recuperano i dati dal modello
String nom=(String)request.getAttribute("nom");
String age=(String)request.getAttribute("age");
%>
- righe 16-17: il modello [nom,age] della vista [formulaire] viene inizializzato con stringhe vuote.
5.7.5. Il metodo [doValidationFormulaire]
Questo metodo elabora la richiesta n. 2 [POST /personne1/main] in cui i parametri inviati sono [action, txtNom, txtAge]. Il suo codice è il seguente:
- righe 16-17: si recuperano dalla richiesta del cliente i valori dei parametri "txtNom" e "txtAge".
- righe 19-26: viene verificata la validità di questi due parametri
- righe 28-33: se uno dei parametri è errato, viene visualizzata la vista [erreurs(erreursAppel)]. Ricordiamo il modello di questa vista:
<%
// si recuperano i dati dal modello
ArrayList erreurs=(ArrayList)request.getAttribute("erreurs");
%>
- righe 35-38: se i due parametri "txtNom" e "txtAge" recuperati hanno valori validi, viene visualizzata la vista [reponse(nom,age)]. È necessario ricordare il modello della vista [reponse]:
<%
// si recuperano i dati dal modello
String nom=(String)request.getAttribute("nom");
String age=(String)request.getAttribute("age");
%>
5.8. Tests
Includiamo il progetto [mvc-personne-01] nelle applicazioni di Tomcat seguendo la procedura descritta nel paragrafo 3.3:
Avviare Tomcat. Una volta fatto ciò, sarà possibile riprendere i test illustrati a titolo di esempio nel paragrafo 5.1. Sarà possibile aggiungerne altri. Ad esempio, è possibile rimuovere uno dei parametri di configurazione urlXXX da web.xml e osservare il risultato. Come illustrato di seguito, uno dei parametri è stato messo tra commenti in [web.xml]:
<!--
<init-param>
<param-name>urlFormulaire</param-name>
<param-value>
/WEB-INF/vues/formulaire.jsp
</param-value>
</init-param>
-->
Si avvia o si riavvia Tomcat e si richiede l'URL [http://localhost:8080/personne1/main]. Si ottiene la seguente risposta:
