|
..Chi controlla il presente controlla il passato. George Orwell
|
|
| Home Page |
|
| Articoli |
|
| News |
|
| Forum |
|
| Classi |
|
|
|
|
|
Guida alle JSP – Lez 4: Gli oggetti impliciti
By
Giuseppe De Pietro
2 luglio 2008
Valutazione Acquisita:
40
|
 |
|
In questa lezione vedremo le differenze tra declaration e scriptlet (accennate nella lezione precedente). Parleremo poi degli oggetti impliciti ovvero tutti gli oggetti messi a disposizione dal contesto di esecuzione (richieste client, risposte del server, informazioni sul Web Server e altro ancora). Per capire meglio cosa sono questi oggetti partiamo dalla Servlet generata dal documento JSP. Questa servlet estende una classe che implementa l’interfaccia javax.servlet.jsp.HttpJspPage (vedi Lezione 1), questo significa poter utilizzare nella pagina, tutte le proprietà della classe estesa. Queste proprietà messe a disposizione, si chiamano oggetti impliciti.
Alcuni li abbiamo già visti nelle lezioni precedenti ma ora esaminiamoli nel dettaglio.
|
|
|
Declaration o scriptlet?
|
top
|
|
Sono due concetti apparentemente simili, ma molto diversi nel modo di funzionare e tutti e due hanno contesti di applicazione diversi.
Abbiamo visto nella Lezione 3 la definizione e la sintassi di base delle dichiarazioni e degli scriptlet, ora vediamo le reali differenze in esempi concreti. Esaminiamo l’esempio 4.1 che utilizza solo scriptlet: <%@ page language="java" session="false" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Esempio di scriptlet</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h1 align='center'>Esempio di scriptlet</h1><br/>
<p>La pagina genera un numero intero casuale da 0 a 99</p>
<%
int numero=(int)Math.floor(Math.random() * 100);
out.write("Numero generato:" + numero);
%>
</body>
</html> La pagina genera un numero intero casuale da 0 a 99, se provate ad aggiornare la pagina noterete che ogni volta verrà generato un nuovo numero. Questo succede perché ogni volta che viene aggiornata la pagina, il JSP container richiamerà ogni volta il metodo _jspService() della servlet, dato che l’istruzione
int numero=(int)Math.floor(Math.random() * 100);
viene inserita in tale metodo (perché è uno scriptlet), verrà eseguita ad ogni aggiornamento. Consideriamo l’esempio 4.2 <%@ page language="java" session="false" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Esempio di scriptlet</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h1 align='center'>Esempio di scriptlet</h1><br/>
<p>La pagina genera un numero intero casuale da 0 a 99</p>
<%!
int numero=(int)Math.floor(Math.random() * 100);
out.write("Numero generato:" + numero);
%>
</body>
</html> Non è cambiato quasi nulla a parte l’inserimento dell’istruzione di generazione del numero casuale in una declaration. Provate ora ad aggiornare la pagina.
Il numero non cambia, questo perché il codice all’interno della dichiarazione è stato inserito al di fuori del metodo, anzi se provate ad aprire altre istanze del browser e richiamare la stessa pagina noterete che il numero è sempre lo stesso. In questo caso il valore resta in memoria finché vi resta la servlet, ovvero fino al blocco del server o a seguito di una modifica della pagina. Le dichiarazioni inoltre sono fondamentali per definire dei metodi da utilizzare nella pagina. Nell’esempio 4.3, si utilizza un metodo di formattazione date usando la classe DateFormat: <%@ page language="java" session="false" %>
<%@ page import="java.util.*, java.text.*" %>
<%!
// dichiarazione costanti per il formato data
private static final int DATA_LONG=0;
private static final int DATA_SHORT=1;
private static final int ORA_LONG=2;
public String formatoData(Date data, int formato)
{
DateFormat dFormat=null;
switch (formato){
case 0:
dFormat=new SimpleDateFormat("EEEE d MMMM yyyy");
break;
case 1:
dFormat=new SimpleDateFormat("d/MM/yyyy");
break;
case 2:
dFormat=new SimpleDateFormat("HH:mm:ss");
break;
}
return dFormat.format(data);
}
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Esempio di dichiarazione</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head> <body>
<h1 align='center'>Esempio 4.3 - dichiarazione</h1><br/>
<p>La pagina dichiara un metodo di formattazione data</p>
<p><b>Data normale : </b></p>
<%
Date data=new Date();
out.write(formatoData(data,DATA_SHORT));
%>
<br/>
<p><b>Data estesa : </b></p>
<%
Date data1=new Date();
out.write(formatoData(data1,DATA_LONG));
%>
<br/>
<p><b>Ora estesa : </b></p>
<%
Date data2=new Date();
out.write(formatoData(data2,ORA_LONG));
%>
</body>
</html>
|
|
Gli oggetti impliciti
|
top
|
|
Passiamo ora agli oggetti impliciti, indispensabili per la gestione dello scambio dati tra client e server.
Per chi conosce già altre tecnologie lato server troverà molte somiglianze con gli oggetti messi a disposizione nelle pagine JSP. Vediamo quali sono.
L’oggetto request
È l’oggetto che contiene le informazioni della richiesta. È il riferimento ad un oggetto di tipo javax.servlet.ServletRequest.
In pratica serve per recuperare i dati della richiesta del browser, tra cui le intestazioni HTTP, i parametri, i cookie e così via.
Vediamo l’esempio 4.4 in cui si visualizzano tutti i dati relativi alle intestazioni della richiesta <%@ page language="java" session="false" import="java.util.*" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Oggetto request - Intestazioni</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h1 align='center'>Esempio 4.4 - Oggetto request</h1><br/>
<p>Intestazioni della richiesta</p>
<%
Enumeration intestazioni=request.getHeaderNames();
while(intestazioni.hasMoreElements()){
String nome=intestazioni.nextElement().toString();
String valore=request.getHeader(nome); %>
<dl><dt><b><%=nome%></b></dt>
<dd><%=valore%></dd></dl>
%>
<p>Altre Informazioni</p>
<%
}
out.write("Path relativo: " + request.getContextPath()+"<br>");
out.write("Metodo submit: " + request.getMethod()+"<br>");
%>
</body>
</html>
Queste informazioni possono essere utili per esempio per sapere la lingua del browser (accept-language) e dare all’utente la pagina nella lingua desiderata, o vedere i tipi MIME supportati dal browser (accept) e quindi a seconda dei plug-in installati personalizzare la pagina (per esempio se il browser non avesse installato flash player si potrebbero evitare automaticamente le animazioni flash).
Comunque è nel recupero dei parametri inviati dal client che l’oggetto request svolge un ruolo fondamentale.
Vediamo l’esempio 4.5 composto da due file, uno HTML con i vari controlli lato client disponibili e uno JSP per intercettare i valori inviati e visualizzarli. Il file HTML conterrà due form per l’invio dei dati sia in modalità GET che POST. Le Java Web Application a differenza delle altre tecnologie non fanno differenza sul recupero dei parametri nelle due differenti modalità.
Tra i due metodi comunque ci sono delle differenze, di default le richieste vengono inviate in modalità GET ed eventuali parametri passati al server vengono accodati all’url separati da un punto interrogativo e compaiono nella barra degli indirizzi del browser. Per esempio una richiesta GET potrebbe avere il seguente formato:
http://www.miosito.it/nomepagina.jsp?nomeParametro=valore&nomeParametro1=valore1
Questa modalità è limitata in lunghezza e inoltre diventa insicura per l’invio di dati particolari come le password che ovviamente sarebbero mostrate in chiaro nell’invio della richiesta. La modalità GET è molto utile quando si vogliono inviare dei valori come semplici link senza l’utilizzo dei form HTML.
La modalità POST invece non ha limiti di lunghezza e i parametri vengono inviati in maniera trasparente come corpo della richiesta, quindi nascosti all’utente .
Si ricorda che l’invio dei dati è sempre fatto utilizzando il protocollo HTTP, i dati anche se nascosti a video sono comunque trasmessi in formato testo e quindi facilmente intercettabili da eventuali sniffer (programmi in grado di prelevare i pacchetti in rete), l’unica modalità sicura è l’utilizzo di connessioni criptate (SSL).
Ecco il file Esempio4_5.html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Lezione 4 - Recupero dei parametri</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h1 align="center">Oggetto Request</h1>
<form method="post" action="esempio4_5.jsp" name="nomeform">
<fieldset>
<legend>Dati da inviare in modalità POST</legend>
<label for="userid">User ID : </label>
<input type="text" NAME="userid"><br>
<label for="pwd">Password:</label>
<input type="password" NAME="pwd"><br>
<br>
<label for="sel">Selezione multipla:</label>
<select multiple NAME="sel">
<option value="voce1">Voce 1</option>
<option value="voce2">Voce 2</option>
<option value="voce3">Voce 3</option>
<option value="voce4">Voce 4</option>
</select>
<br/>
Opzione 1:<input type="radio" name="check" value="1" checked><br/>
Opzione 2:<input type="radio" name="check" value="2"><br/>
Opzione 3:<input type="radio" name="check" value="3"><br/>
<br><br>
<input type="submit" value="Invia dati">
</fieldset><br>
</form>
<form method="get" action="esempio4_5.jsp" name="FormGet">
<fieldset>
<legend>Dati da inviare in modalità GET</legend>
<label for="userid">User ID : </label>
<input type="text" NAME="userid"><br/>
<label for="pwd">Password:</label>
<input type="password" NAME="pwd"><br/>
<br>
<label for="sel">Selezione multipla:</label>
<select multiple NAME="sel">
<option value="voce1">Voce 1</option>
<option value="voce2">Voce 2</option>
<option value="voce3">Voce 3</option>
<option value="voce4">Voce 4</option>
</select>
<br>
Opzione 1:<input type="radio" name="check" value="1" checked><br/>
Opzione 2:<input type="radio" name="check" value="2"><br/>
Opzione 3:<input type="radio" name="check" value="3"><br/>
<br><br>
<input type="submit" value="Invia dati" >
</fieldset><br/>
</form>
</body>
</html> Mentre il file esempio4_5.jsp sarà così composto: <%@ page language="java" session="false" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Oggetto request - Recupero dei parametri</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h1 align='center'>Esempio 4.5 - Oggetto request</h1><br/>
<p>Recupero dei parametri</p>
<%
out.write("Invio dei dati in modalità " + request.getMethod());
String userID=request.getParameter("userid");
String password=request.getParameter("pwd");
String[] selezioni=request.getParameterValues("sel");
String check=request.getParameter("check");
%>
<ul>
<li><b>Nome Utente : </b><%=userID%></li>
<li><b>Password : </b><%=password%></li>
<li><b>Valori selezionati : </b><%
if (selezioni!=null){
for(int i=0;i<selezioni.length;i++){
out.write(selezioni[i]+"<br>");
}
}
%></li>
<li><b>Check : </b><%=check%></li>
</ul>
</body>
</html>
Da far notare che il codice JSP si astrae completamente dalla modalità di invio dei dati (get e post).
Il recupero dei parametri avviene con il metodo getParameter(“nomeParametro”). In caso di più valori associati allo stesso parametro si utilizza il metodo getParameterValues(“nomeParametro”) che ritorna un array di stringhe. Grazie alla proprietà length è possibile recuperare il numero dei valori e si utilizza un ciclo for per la loro visualizzazione. Unica particolarità è il controllo sull’array, se è nullo (caso in cui l’utente non effettua alcuna selezione) non esegue il ciclo altrimenti verrebbe generata una eccezione di tipo nullPointerException. Volendo è possibile anche recuperare tutti i valori inviati senza bisogno di conoscere i nomi dei controlli, usando il metodo getParameterNames() che restituisce un oggetto Enumeration con tutti i nomi dei parametri ricevuti. L’esempio 4.6 mostra una pagina JSP che è in grado di leggere i parametri inviati da qualsiasi form, senza conoscerne il numero, né il nome. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Oggetto request - Recupero dei parametri</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h1 align='center'>Esempio 4.6 - Oggetto request</h1><br/>
<p>Recupero dei parametri inviati da un qualsiasi form</p>
<% String nomeParam;
out.write("Invio dei dati in modalità " + request.getMethod());
Enumeration parametri=request.getParameterNames();
out.write("<ul>");
while (parametri.hasMoreElements()){
nomeParam=parametri.nextElement().toString();
out.write("<li><b>"+nomeParam+" : </b>");
String[] valori=request.getParameterValues(nomeParam);
if (valori!=null){
for(int i=0;i<valori.length;i++){
out.write(valori[i]+"<br/>");
}
}
out.write("</li>");
}%>
</ul>
</body>
</html>
L’oggetto request può essere utilizzato anche per ricavare informazioni aggiuntive sul computer remoto che ha effettuato la richiesta, come l’indirizzo IP e il nome identificativo. L’esempio 4.7 mostra come visualizzare tali informazioni: <%@ page language="java" session="false" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Oggetto request - Informazioni aggiuntive</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h1 align='center'>Esempio 4.7 - Oggetto request</h1><br/>
<p>Recupero di informazioni aggiuntive sul client</p>
<%
out.write("<BR/>Porta Server: " + request.getServerPort());
out.write("<BR/>Nome Server: " + request.getServerName());
out.write("<BR/>Protocollo: " + request.getProtocol());
out.write("<BR/>Codifica caratteri: " + request.getCharacterEncoding());
out.write("<BR/>Content Type: " + request.getContentType());
out.write("<BR/>Lunghezza contenuto: " + request.getContentLength());
out.write("<BR/>Indirizzo Remoto: " + request.getRemoteAddr());
out.write("<BR/>Host remoto: " + request.getRemoteHost());
out.write("<BR/>Schema: " + request.getScheme());
%>
</ul>
</body>
</html>
|
|
Gli oggetti response e out
|
top
|
|
Sono due oggetti che si occupano di inviare dati dal Server al client. In un certo senso l’oggetto out appartiene all’oggetto response, infatti nelle Servlet c’è il tipo javax.servlet.ServletResponse il cui metodo getWriter() permette di ottenere un oggetto di tipo PrintWriter che rappresenta il riferimento allo stream di uscita delle servlet (la modalità per inviare al client il codice HTML). Nelle pagine JSP, response e out sono separati, ma guardando la natura dell’oggetto out scopriamo che è di tipo JspWriter ovvero una classe che estende l’interfaccia java.io.Writer, proprio come il PrintWriter delle servlet. Quindi l’oggetto out in JSP, semplifica la scrittura dei dati sul client. Eviteremo degli esempi su questo oggetto perché abbiamo già visto il suo utilizzo sin dalle prime pagine JSP (ci sarebbero i metodi di gestione del buffer flush(), clearBuffer(), getBufferSize() ed altri, ma si consiglia la gestione automatica del buffer come illustrato nella Lezione 3). Vedremo invece alcuni utilizzi dell’oggetto response. Uno dei più usati è il reindirizzamento ad un’altra risorsa.
Con il metodo sendRedirect(), il Web Server invia uno speciale messaggio al client di richiesta di un’altra pagina.
Nell’esempio 4.8 (composto da due pagine JSP) viene illustrato un form di login in cui si richiedono il nome utente e la password. I dati inviati vengono intercettati e verificati dalla stessa pagina e in caso di valori corretti (come esempio ho impostato userid=admin e password=segreta) l’utente viene reindirizzato alla pagina registrato.jsp, mentre in presenza di valori diversi si viene reindirizzati alla stessa pagina di login.
Di seguito viene mostrato il codice del file esempio4_8.jsp, con il form di login:
<%@ include file="/Lezione3/Include/funzioni.jsp" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Oggetto response - Metodo sendRedirect</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h1 align='center'>Esempio 4.8 - Oggetto response</h1><br/>
<p>Metodo sendRedirect per il reindirizzamento delle richieste</p>
<form method="post">
<fieldset>
<legend>Login Utente</legend>
<label for="userid">User ID : </label>
<input type="text" NAME="userid"><br>
<label for="pwd">Password:</label>
<input type="password" NAME="pwd">
<br/><br/>
<input type="submit" value="Invia dati">
</fieldset>
</form>
<%
String user=nn(request.getParameter("userid"));
String password=nn(request.getParameter("pwd"));
if (user.equals("admin") && password.equals("segreta")){
response.sendRedirect("registrato.jsp");
}
%>
</body>
</html> L’inclusione del file funzioni.jsp viene utilizzato per il metodo nn(object) che restituisce una stringa vuota in caso di oggetto nullo (evita la generazione dell’eccezione NullPointerException al primo caricamento della pagina). Per la comparazione delle stringhe in Java si utilizza il metodo equals() della classe String. In caso di valori esatti la richiesta del client viene trasferita alla pagina registrato.jsp altrimenti viene visualizzata sempre la pagina di login.
Il lettore attento potrebbe aver notato che se si digita direttamente il nome della pagina registrato.jsp nell’url, si bypassa l’autenticazione dell’utente. Effettivamente è così, il problema lo si corregge con la gestione delle sessioni utente. Nelle lezioni successive verrà mostrato come creare delle pagine protette in un sito.
L’oggetto response permette inoltre di poter generare degli errori e quindi inviare al client la pagina con il codice di errore (errori HTTP) ed un messaggio personalizzato. Per esempio la seguente riga inserita in una pagina jsp:
response.sendError(response.SC_CONFLICT, "Conflitto di risorse.");
mostra la seguente schermata:
Per concludere vediamo ora un caso particolare di utilizzo dell’oggetto out. Supponiamo di dover realizzare un applicativo di tipo chat o forum in cui un utente digita del testo e poi lo invia agli altri utenti, provate ad immaginare se l’utente dovesse inserire del codice pericoloso, se non c’è alcun trattamento del testo esso verrebbe visualizzato e di conseguenza eseguito su tutti i client connessi con l’applicativo. È opportuno creare quindi un metodo che trasforma tutto il codice HTML e di scripting in semplice testo. Vediamo l’esempio 4.10 che mostra i vantaggi dell’utilizzo di questa funzione:
<%@ page language="java" session="false" %>
<%!
public static String codificaTagHtml(String tag) {
if (tag==null)
return null;
int nCaratteri = tag.length();
StringBuffer tagCodificato = new StringBuffer(2 * nCaratteri);
for (int i=0; i<nCaratteri; i++) {
char c = tag.charAt(i);
switch (c){
case '<':
tagCodificato.append("<");
break;
case '>':
tagCodificato.append(">");
break;
case '&':
tagCodificato.append("&");
break;
case '"':
tagCodificato.append(""");
break;
case ' ':
tagCodificato.append(" ");
break;
default:
tagCodificato.append(c);
}
}
return tagCodificato.toString();
}
%> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Oggetto response - Codifica tag HTML</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h1 align='center'>Esempio 4.10 - Oggetto response</h1><br/>
<p>Codifica dei tag HTML</p>
<form method="post">
<fieldset>
<legend>Inserimento testo</legend>
<label for="testo">Testo: </label>
<textarea rows="5" cols="40" name="testo" id="testo"><h1>Ho inserito dei tag di formattazione e uno script</h1><script language=javascript>alert('Simulazione di uno Script pericoloso')</script></textarea>
<br/><br/>
<input type="submit" value="Invia dati" name="invia">
</fieldset>
</form>
<%
if (request.getParameter("invia")!=null){
out.write("<h2>Visualizzo i dati inviati senza trattare i caratteri speciali</h2>");
out.write(request.getParameter("testo"));
out.write("<h2>Rendo innocui eventuali script pericolosi</h2>");
out.write(codificaTagHtml(request.getParameter("testo")));
}
%>
</body>
</html>
La funzione codificaTagHtml riceve una stringa come parametro e la elabora utilizzando la classe StringBuffer che ha la particolarità di implementare una sequenza variabile di caratteri. Viene creata una nuova istanza della classe StringBuffer impostando inizialmente una grandezza doppia rispetto alla stringa, poi ogni carattere viene confrontato con quelli particolari da sostituire (costrutto switch()), se il carattere non necessita di codifica, viene semplicemente aggiunto all’istanza di StringBuffer per poi essere restituita come stringa alla fine del ciclo (costrutto for()).
|
|
L’oggetto pageContext
|
top
|
|
È un oggetto di tipo javax.servlet.jsp.PageContext, praticamente rappresenta la pagina JSP corrente e contiene tutti gli oggetti impliciti relativi alla pagina.
Il suo utilizzo potrebbe sembrare superfluo visto che se vogliamo accedere per esempio all’oggetto request facciamo riferimento alla sua istanza diretta anziché ottenerlo con pageContext.getRequest().
La sua utilità verrà messa in risalto in seguito quando si parlerà dei custom tag, per ora vediamo un semplice esempio in cui ci servirà tale oggetto: accedere alle proprietà della pagina in una dichiarazione. Se vi ricordate nelle lezioni precedenti è stato detto che il codice inserito in una dichiarazione viene scritto all’esterno del metodo _jspService() della servlet corrispondente. Gli argomenti passati a tale metodo sono gli oggetti impliciti HttpServletRequest e HttpServletResponse (gli altri oggetti impliciti sono ricavati tramite l’istruzione _jspxFactory.getPageContext). Questo significa che gli oggetti relativi alla pagina esistono solo all’interno del metodo _jspService() e non saranno assolutamente visibili all’esterno di tale metodo e quindi nelle dichiarazioni. La soluzione a tale limite è il passaggio dell’oggetto pageContext al metodo inserito nella dichiarazione, così da poter accedere a tutte le funzionalità messe a disposizione dagli oggetti impliciti. Vediamo l’esempio 4.11 che chiarisce meglio il concetto sopra esposto:
<%@ page language="java" session="false" %>
<%@ page import="java.io.*" %>
<%!
public static void metodoEsterno(PageContext pagina) throws IOException{
JspWriter mioOut=pagina.getOut();
ServletRequest requ=pagina.getRequest();
mioOut.write( "Indirizzo Host: " + requ.getRemoteHost());
}
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Oggetto pageContext</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h1 align='center'>Esempio 4.11 - Oggetto pageContext</h1><br/>
<p>Recupero degli oggetti impliciti in una dichiarazione</p>
<%
metodoEsterno(pageContext);
%>
</body>
</html> Il metodoEsterno() accetta un oggetto di tipo PageContext e permette di prelevare un oggetto out (JspWriter) per inviare al client i messaggi, e un oggetto di tipo ServletRequest che utilizziamo per prendere l’indirizzo IP del client. Ovviamente dobbiamo gestire le eccezioni per l’invio dei dati al canale out. Nel nostro caso con throws IOException dichiariamo al compilatore che siamo a conoscenza che l’istruzione write potrebbe generare un eccezione di tipo IOException ma non vogliamo gestirla (le eccezioni si gestiscono con try…catch).
Mentre negli scriptlet c’è una gestione automatica degli errori (creata nel metodo _jspService() della servlet), nelle dichiarazioni siamo obbligati a gestire tutto come se fosse una normale classe Java.
|
|
L’oggetto session
|
top
|
|
Nella Lezione 3 abbiamo visto cosa sono le sessioni utente e come disabilitarle nelle pagine JSP (di default sono abilitate), ora vedremo alcuni utilizzi pratici dell’oggetto session.
Quando una sessione utente viene creata, il Web Server crea un identificativo univoco che verrà associato all’utente e permetterà al server di poterlo riconoscere durante la navigazione.
La sessione utente permette di creare un ambiente in cui potranno essere memorizzati degli oggetti appartenenti, e quindi visibili, solo a quello specifico utente.
Lo sviluppatore non si deve preoccupare né di generare il codice identificativo, né di associare ogni richiesta ad un determinato utente, né di gestire la sessione in maniera alternativa se il client non accetta i cookie. Tutto questo sarà fatto dal Web Server facilitando il compito dello sviluppatore che avrà semplicemente un oggetto a cui potrà aggiungere dei parametri (nomeChiave=valore).
È importante essere a conoscenza del ciclo di vita di una sessione. Essa viene creata alla prima richiesta dell’utente ma la sua eliminazione non è altrettanto repentina, ci sarà un tempo di inattività massimo concesso al visitatore. Questo tempo di default varia in base all’application server (in genere 30 minuti), ma è possibile modificarlo con l’istruzione:
session.setMaxInactiveInterval(int secondi);
L’esempio 4.12 mostra come ricavare informazioni sulla sessione utente creata:
<%@ page language="java" %>
<%@ page import="java.util" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Oggetto session</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h1 align='center'>Esempio 4.12 - Oggetto session</h1><br/>
<p>Recupero delle informazioni</p>
<%
out.write("ID di sessione: " +session.getId());
String creazione=new Date(session.getCreationTime()).toString();
String ultAccess=new Date(session.getLastAccessedTime()).toString();
out.write("<br/>Tempo di creazione: " + creazione);
out.write("<br/>Ultimo accesso: " + ultAccess);
out.write("<br/>Tempo massimo di inattività (secondi): " +session.getMaxInactiveInterval());
%>
</body>
</html> È possibile creare una variabile di sessione con l’istruzione:
session.setAttribute(String chiave,Object valore);
Il nome della chiave è case-sensitive quindi è importante fare attenzione alle minuscole e maiuscole (come per i nomi delle variabili). Come valore accetta qualsiasi elemento di tipo Object (la classe da cui derivano tutte le altre in Java).
Per il recupero di un valore si utilizza:
session.getAttribute(String chiave)
che restituisce un Object.
Quindi è preferibile ricordarsi il tipo di valore memorizzato per poter effettuare un casting del valore (una conversione esplicita nel tipo desiderato). Per esempio per poter recuperare un valore di tipo stringa:
String valore=(String)session.getAttribute(“nomeChiave”);
La scrittura di una chiave esistente comporta la sostituzione del vecchio valore memorizzato con il nuovo passato al metodo setAttribute().
Per poter eliminare un valore si utilizza l’istruzione:
session.removeAttribute("nomeChiave");
Se si vuole terminare una sessione utente prima della scadenza predefinita si potrà utilizzare il metodo:
session.invalidate();
Vediamo un esempio pratico di utilizzo dell’oggetto session. Nella pagina esempio4_13.jsp l’utente avrà la possibilità di creare delle variabili di sessione che poi potranno essere visualizzate nella pagina leggiSession.jsp. Memorizzate dei valori e poi aprite un’altra finestra del browser e andate direttamente alla pagina leggiSession.jsp, noterete che non verranno visualizzati i valori precedentemente memorizzati. Questo perché aprendo un’altra istanza del browser avete creato una nuova sessione utente e quindi non potrete avere accesso ai valori memorizzati con l’altra finestra.
La pagina esempio4_13.jsp
<%@ page language="java" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Oggetto session</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h1 align='center'>Esempio 4.13 - Oggetto session </h1><br/>
<h3>Creazione delle variabili di sessione</h3>
<form method="post" action="leggiSession.jsp">
<fieldset>
<legend>Creazione variabili</legend>
<label for="chiave">Nome chiave: </label>
<input type="text" name="chiave"><br>
<label for="valore">Valore:</label>
<input type="text" name="valore">
<br/><br/>
<input type="submit" value="Aggiungi variabile">
</fieldset>
</form><br/>
<p><a href="leggiSession.jsp" title="Leggi le variabili di sessione">Leggi le variabili di sessione</a></p>
</body>
</html> La pagina leggiSession.jsp <%@ page language="java" import="java.util.*" %>
<%@ include file="/Lezione3/Include/funzioni.jsp" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Oggetto session</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h1 align='center'>Esempio 4.13 - Oggetto session</h1><br/>
<p>Recupero delle variabili</p>
<%String chiave=nn(request.getParameter("chiave"));
String valore=nn(request.getParameter("valore"));
if (!chiave.equals("")){
session.setAttribute(chiave,valore);
}
//recupero variabili di sessioni
out.write("Variabili di sessione memorizzate<br/>");
Enumeration chiavi=session.getAttributeNames();
while(chiavi.hasMoreElements()){
String nomeChiave=(String)chiavi.nextElement();
out.write("<b>Nome chiave:</b>" + nomeChiave+"<br/>");
out.write("<b>Valore:</b>" + session.getAttribute(nomeChiave)+"<br/><br/>");
}%>
</body>
</html>
|
|
L’oggetto application
|
top
|
|
È un oggetto di tipo javax.servlet.ServletContext. Il contesto della Servlet altro non è che l’ambiente in cui sono eseguite le servlet, quindi questo oggetto permette di leggere o impostare proprietà comuni a tutte le servlet e le JSP della stessa Web Application.
Per creare variabili application si usano gli stessi metodi cha abbiamo visto per l’oggetto session, l’unica differenza è che questa variabile può essere vista e condivisa da tutti gli utenti della nostra applicazione.
Creazione di una variabile:
application.setAttribute(String chiave,Object valore);
Recupero di un valore:
application.getAttribute(String chiave)
che restituisce un Object.
Per poter eliminare un valore si utilizza l’istruzione:
application.removeAttribute("nomeChiave");
Inoltre questo oggetto è utile per poter risalire al percorso assoluto dei file:
application.getRealPath(String nomeFile)
O poter ricavare le informazioni sul Web Server:
application.getServerInfo()
La pagina esempio4_14.jsp mostra come visualizzare queste informazioni: <%@ page language="java" %>
<%@ page import="java.util.*" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Oggetto application</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h1 align='center'>Esempio 4.14 - Oggetto application</h1><br/>
<%
Enumeration attributes = application.getAttributeNames();
while (attributes.hasMoreElements()) {
String attribute = (String) attributes.nextElement();
out.println("Attribute name : " + attribute+"<br/>");
out.println("Attribute value : " +
application.getAttribute(attribute) +"<br/><br/>");
}
out.write("Versione servlet API supportate dal container (major): " +application.getMajorVersion()+"<br/>");
out.println("Versione servlet API supportate dal container (minor): " + application.getMinorVersion()+"<br/>");
out.println("Server info : " + application.getServerInfo()+"<br/>");
out.println("Percorso assoluto : " + application.getRealPath("Lezione4/esempio4_14.jsp") +"<br/>");
%>
</body>
</html>
|
|
Gli oggetti config, page, exception
|
top
|
|
L’oggetto config
Questo oggetto è poco utilizzato e permette di avere dei riferimenti alle informazioni di configurazione della Servlet (tra cui alcuni ottenibili anche con l’oggetto application). È di tipo javax.servlet.ServletConfig.
L’oggetto page
In java per poter fare riferimento alla classe corrente si usa la parola chiave this. Essa viene utilizzata per poter accedere a metodi o proprietà interne alla classe.
Nelle pagine JSP invece per poter fare riferimento alla pagina si utilizza la parola page, di fatto questo oggetto non viene mai utilizzato.
L’oggetto exception
Rappresenta l’oggetto che contiene l’eventuale eccezione sollevata. Abbiamo visto il suo utilizzo nella Lezione 3 quando si parlava di gestione delle pagine di errore personalizzate.
|
|
|
Eccetto dove diversamente specificato, i contenuti di questo sito sono rilasciati sotto licenza Creative Commons
|
|
|
Documentazione
>
