Sei sulla pagina 1di 29

Manuale JSP

I servlet.........................................................................................................................................3 Come creare una pagina JSP........................................................................................................3 I tipi primitivi ...............................................................................................................................5 Le istruzioni .................................................................................................................................6 Script, dichiarazione di espressioni..............................................................................................9 Direttive .....................................................................................................................................10 Azioni.........................................................................................................................................10 Request.......................................................................................................................................11 Response, Out ............................................................................................................................12 Session .......................................................................................................................................13 Application.................................................................................................................................14 Utilizzo dei Java Bean................................................................................................................15 Un esempio di Java Bean ...........................................................................................................16 Gestione degli errori in pagine JSP............................................................................................17 Recupero dei dati da un form.....................................................................................................18 JDBC introduzione..................................................................................................................19 JDBC la lettura dei dati da un database ..................................................................................20 JDBC inserimento e modifica .................................................................................................21 Cookies ......................................................................................................................................21 Jallaire Jrun per Win95/98 .........................................................................................................23 Tomkat di Jakarta per NT/Unix .................................................................................................24 Gestire un sondaggio..................................................................................................................25 Gestire un carrello della spesa ...................................................................................................26 Appendice A: stringhe, vettori ed hashtable ..............................................................................27 Appendice B: fondamenti di SQL..............................................................................................28

Manuale JSP

I servlet
Come gi detto i servlet sono uno degli elementi fondamentali da cui deriva e a cui si appoggia la teconogia JSP. Qui di seguito verr fatto un accenno alla natura di tali elementi affinch risultino poi pi chiari alcuni richiami teorici riguardanti le pagine JSP. Un servlet non altro che un'applicazione Java in esecuzione su una JVM (Java Virtual Machine) residente su un server. Questa applicazione tipicamente esegue una serie di operazioni che producono in output un codice HTML che verr poi inviato direttamente al client per venire interpretato da un qualsiasi Browser che non necessita di funzionalit aggiuntive. A differenza di uno script CGI i servlet vengono caricati solo una volta, al momento della prima richiesta, e rimangono residenti in memoria pronti per servire le richieste fino a quando non vengono chiusi, con ovvi vantaggi in fatto di prestazioni (risultano infatti un po' pi lenti in caricamento, ma una volta "aperti" le successive richieste vengono evase molto velocemente). Ciclo di vita di un servlet Il ciclo di vita di un sevlet (cio il tempo che intercorre dal suo caricamento al suo rilascio) si concentra su tre metodi fondamentali: init(), service() e destroy(). Init() Questo metodo segna la vera e propria "nascita" del servlet, viene chiamato una sola volta, subito dopo la sua istanziazione. Attraverso questo metodo il servlet si instanzia tutte le risorse che utilizzer poi per gestire le richieste. Service() Questo metodo incaricato di gestire tutte le richieste effettuate dal client, e ovviamente potr iniziare il suo lavoro esclusivamente dopo la chiamata del metodo init(). Destroy() Questo metodo segna la vera e propria fine del servlet, solitamente a questo punto che si effettuano tutti i salvataggi utili per memorizzare informazioni utili ad un prossimo caricamento del servlet.

Come creare una pagina JSP


Dopo aver fatto gli opportuni riferimenti teorici necessario passare alla parte pratica, spiegando la vera e propria implementazione di una JSP, e i metodi per renderla il pi possibile efficiente e funzionale. Un primo esempio di Java Server Page potrebbe essere rappresentato dalla semplice stampa a video di un messaggio ("PRIMA PROVA JSP"), implementato in questo modo: <!-<HTML> <BODY> PROVA.JSP -->

<%out.println("PRIMA PROVA DI JSP");%> </BODY> </HTML>

Come si pu notare le sezioni racchiuse tra i tag <% e %> sono quelle che contengono le istruzioni in

Manuale JSP

Come creare una pagina JSP


linguaggio Java (gli stessi tag sono utilizzati anche nelle pagine ASP). Da notare che i file per essere riconosciuti dal browser come pagine JSP devono essere salvati con estensione .jsp. La prima volta che volta che si effettua la richiesta di visualizzazione del file, quest'ultimo viene compilato, creando un oggetto servlet, che sar archiviato in memoria (per servire le richieste successive); solo dopo questi passaggi l'output viene mandato al browser, che potr interpretarlo come fosse una semplice pagina HTML. Ad ogni richiesta successiva alla prima il server controlla se sulla pagina .jsp stata effettuata qualche modifica, in caso negativo richiama il servlet gi compilato, altrimenti si occupa di eseguire nuovamente la compilazione e memorizzare il nuovo servlet. Prendendo l'esempio proposto (prova.jsp) il servlet generato sar costituito dal seguente file Java (che comunque varia leggermente in base al motore jsp utilizzato): jrun_provaejspa.java import import import import import javax.servlet.*; javax.servlet.http.*; javax.servlet.jsp.*; javax.servlet.jsp.tagext.*; allaire.jrun.jsp.JRunJSPStaticHelpers;

public class jrun__prova2ejspa extends allaire.jrun.jsp.HttpJSPServlet implements allaire.jrun.jsp.JRunJspPage { private ServletConfig config; private ServletContext application; private Object page = this; private JspFactory __jspFactory = JspFactory.getDefaultFactory(); public void _jspService(HttpServletRequest request, HttpServletResponse response) throws ServletException, java.io.IOException { if(config == null) { config = getServletConfig(); application = config.getServletContext(); }//if response.setContentType("text/html; charset=ISO-8859-1"); PageContext pageContext = __jspFactory.getPageContext(this, request, response, null, true, 8192, true); JspWriter out = pageContext.getOut(); HttpSession session = pageContext.getSession(); try { out.print("<!-- PROVA.JSP -->\r\n\r\n<html>\r\n\r\n<body>\r\n\r\n"); out.println ("PRIMA PROVA JSP"); out.print("\r\n\r\n</body>\r\n\r\n</html>"); } catch(Throwable t) { if(t instanceof ServletException) throw (ServletException) t; if(t instanceof java.io.IOException) throw (java.io.IOException) t; if(t instanceof RuntimeException)

Manuale JSP

I tipi primitivi
throw (RuntimeException) t; throw JRunJSPStaticHelpers.handleException(t, pageContext); } finally { __jspFactory.releasePageContext(pageContext); }

private static final String[] __dependencies__ = {"/prova.jsp",null}; private static final long[] __times__ = {988194570000L,0L}; public String[] __getDependencies() { return __dependencies__; } public long[] __getLastModifiedTimes() { return __times__; } public int __getTranslationVersion(){ return 14; } }

Analizzando il codice riportato si pu notare come il metodo che effettua il servizio vero e proprio il metodo _jspService. Esso in un primo tempo verifica la configurazione del server (se non stata effettuata se ne occupa), per poi settare in maniera adeguata i parametri che permettono la comunicazione dell'output voluto (viene per esempio specificato che il testo in uscita codice HTML). Effettuato il controllo della configurazione vengono eseguite le istruzioni per cui il servlet stato creato (in questo caso la stampa a video del messaggio), tenendo in considerazione gli eventuali errori, creando delle adeguate eccezioni. Con l'ultima istruzione il servlet viene rilasciato. Gli altri metodi servono per fornire alcune informazioni riguardanti il servlet: quando stato modificato l'ultima volta, la versione della traduzione, il nome del file contenente la pagina JSP a cui fa riferimento.

I tipi primitivi
Il Java utilizza i seguenti tipi primitivi: Boolean (1 bit): pu assumere esclusivamente i due valori true e false, l'assegnazione di un valore pu avvenire in modo classico o attraverso una condizione (es: data la variabile b di tipo boolean il valore false gli pu essere assegnato attraverso l'istruzione b=false oppure b=10>1); byte (8 bit): pu memorizzare valori interi compresi tra -128 e 127; short (16 bit): pu memorizzare valori interi compresi tra -32768 e 32767; int (32 bit): pu memorizzare valori interi compresi tra -2147483648 e 2147483647; long int (64 bit): pu memorizzare valori interi compresi tra --9223372036854775808 e 9223372036854775807; float (32 bit): tipo a virgola mobile, pu memorizzare valori sia positivi che negativi (anche decimali) compresi tra 3,4*10-38 e 3.4*1038; double (64 bit): tipo a virgola mobile, pu memorizzare valori sia positivi che negativi (anche decimali) compresi tra 1.7*10-308 e 1.7*10308;

Manuale JSP

Le istruzioni
char (16 bit): pu memorizzare valori positivi interi compresi tra 0 e 65535, di solito utilizzati per la mamorizzazione di caratteri ASCII.

ARRAY MONODIMESIONALI Gli array possono venire dichiarati con l'istruzione: tipo nomeArray[]; dove tipo sar sostituito dal tipo delle variabili formanti l'array e nomeArray dal nome del vettore. Supponendo di avere appena dichiarato un vettore di interi di nome array e di volerlo dimensionare di 10 elementi, la sua allocazione dovr venire specificata con l'istruzione: array = new int[10]; A questo punto per poter accedere all'n-esimo elemento di array baster utilizzare la sintassi: array[n];

ARRAY MULTIDIMENSIONALI Molto simili agli array monodimensionali, gli arrray multidimensionali vengono definiti: tipo nomeArray[][]; e allocati (supponendo sempre di avere dichiarato una matrice di interi di nome arrayMulti): arrayMulti = new int[10][10]; per accedere all'elemento sull'n-esima riga e m-esima colonna baster utilizzare la sintassi: arrayMulti[n][m];

Le istruzioni
ISTRUZIONE IF-ELSE Sintassi: if (cond) { istruzione istruzione ... istruzione } else { istruzione istruzione ... istruzione }//else

1; 2; n; n+1; n+2; m;

Il blocco di istruzioni che vanno da istruzione 1 a istruzione n vengono eseguite esclusivamente se la condizione cond verificata, in caso contrario vengono eseguite le istruzioni che vanno da istruzione n+1 e istruzione m. Da notare che il blocco else opzionale. Esempio:

Manuale JSP

Le istruzioni
... int a=0, b=10; if (a>b){ b = b+a; } else { a = a+b; }//else ...

In questo caso vengono confrontate le due variabili a e b, avendo rispettivamente valore 0 e 10, si pu facilmente constatare che la condizione interna all'istruzione if non verificata; verranno pertanto eseguite le istruzioni interne al blocco else: ad a verr assegnato il valore 10 ( 0+10 ). ISTRUZIONE SWITCH Sintassi: switch (espressione){ case valore1: istruzione 1; ... [break;] case valore2: istruzione 2; ... [break;] ... case valore n: istruzione n; ... [break;] default: istruzione default; ... [break;] }//switch

Questa istruzione effettua un controllo sull'espressione espressione, confrontando il suo valore con i valori contenuti nei case e accedendo al blocco corrispondente, se nessuno dei valori accettabile, verr eseguito il blocco di istruzioni contenute in default (opzionale). L'istruzione break effetto di uscita rispetto all'intero blocco dello switch, se omesso dopo aver eseguito il blocco relativo al case verranno eseguiti anche i controlli relativi ai case rimanenti, compreso il default. Esempio: ... int a=10, b=6; switch (a+b){ case 11: a = 5; break; case 15: a = 9; break; default: b = 0; a = 0;

Manuale JSP

Le istruzioni
break; }//switch ...

In questo caso vengono confrontato il risultato dell'operazione a+b (16) con i valori specificati nei case, verranno quindi saltati i primi due blocchi di istruzioni (il confronto non d infatti esito positivo) e verr eseguito il blocco default: al termine dell'esecuzione dell'istruzione switch le variabili a e b avranno entrambe valore 0. ISTRUZIONE WHILE Sintassi: while (cond) { istruzione 1; istruzione 2; ... istruzione n; }//while

Il blocco di istruzioni che vanno da istruzione 1 a istruzione n verranno eseguiti ripetutamente finch la condizione cond restituir valore true (fintantoch verificata). Esempio: ... int a=0; while (a<10){ a = a+1; }//while ...

In questo caso il ciclo verr ripetuto 10 volte, in quanto ad ogni ripetizione la variabile a sar incrementata: al raggiunto il valore 10 la condizione a<10 non sar pi verificata e restituir quindi valore false, causando l'uscita dal ciclo. ISTRUZIONE FOR Sintassi: for (espressione di assegnazione; condizione; espressione di incremento){ istruzione 1; istruzione 2; ... istruzione n; }//for

L'espressione di assegnazione viene eseguita una sola volta alla prima esecuzione del ciclo; la condizione viene verificata sempre prima di iniziare ad eseguire le istruzioni interne al blocco; l'espressione di incremento viene eseguita alla fine di ogni ripetizione delle istruzioni, prima del controllo sulla condizione. Analogamente a prima quindi il blocco di istruzioni che vanno da istruzione 1 a istruzione n verranno eseguiti ripetutamente finch la condizione condizione restituir valore true (fintantoch verificata), con la modifica che la condizione relativa alla variabile su cui si esegue l'espressione di assegnazione e incremento. Esempio: ... int i, a=10;

Manuale JSP

Script, dichiarazione di espressioni


for (i=0; i<10; i++){ a = a-1; }//for ...

Il ciclo sar ripetuto 10 volte, finch, cio, la variabile i (incrementata dall'istruzione i++ ) non assume valore 10: al fine dell'esecuzione di questa operazione a avr valore 0. ISTRUZIONE DO-WHILE Sintassi: do{

istruzione 1; istruzione 2; ... istruzione n; } while (cond);

La differenza tra un ciclo do-while e un ciclo while sta nel fatto che nel primo la condizione viene controllata dopo aver eseguito le istruzioni interne al blocco, che quindi saranno eseguite almeno una volta. Esempio: ... int a=9; do{ a=0; } while (a<10); ...

In questo caso il ciclo viene ripetuto esclusivamente una volta, con l'effetto di assegnare ad a il valore 0; da notare che nonostante la condizione del ciclo non fosse verificata nemmeno alla prima esecuzione il blocco venga eseguito comunque almeno una volta.

Script, dichiarazione di espressioni


Gli script in JSP sono vere e proprie porzioni di codice inserite all'interno di pagine HTML che possono rappresentare: dichiarazioni, espressioni o scriptler. Il codice java del nostro file jsp va racchiuso come gi detto all'interno dai tag <% %>, mentre per le dichiarazioni la sintassi cambia leggermente. Dichiarazioni la sintassi per le dichiarazioni la seguente: <%! dichiarazione %> sia per la dichiarazioni di variabili, sia per la dichiarazione di metodi. Esempi: <%// dichiarazione di una stringa %> <% ! Sting stringa=new string("ciao a tutti") %> <% // dichiarazione di una funzione che dati due numeri in ingresso // restituisce la loro somma %> <% ! public int somma (int primo, int secondo){ return (primo + secondo); }//somma %>

Manuale JSP

Direttive
Espressioni la sintassi per le espressioni la seguente: <% espressione %>

10

Esempio:

<%= somma (2,3)%>

Questa istruzione se inserita all'interno dei tag <BODY> e </BODY> stamper a video l'output della funzione somma (in questo caso il numero 5, ottenuto dalla somma dei due valori in ingresso 2 e 3).

Direttive
Questo tipo di oggetti specificano le caratteristiche globali della pagina (per esempio le informazioni relative al tipo di compilazione da effettuare o l'eventuale utilizzo di tag personalizzati). Al momento sono definite tre direttive: direttiva page: modifica alcune impostazioni che influiscono sulla compilazione della pagina, attraverso la modifica degli attributi language (specifica il linguaggio da da utilizzare in fase di compilazione, es: language="Java"), import (specifica quali package dovranno venire inclusi nella pagina, es: import="java.util.*"), isThreadSafe (indica se la pagina pu servire pi richieste contemporaneamente, es: isTreadSafe = "true"), info (contiene delle informazioni riguardanti la pagina, consultabili grazie al metodo Servlet.getServletInfo, es: info="Prima prova"), errorPage e isErrorPage (entrambi riguardanti la gestione delle pagine di errore, spiegate approfonditamente pi avanti). Esempio: <%@ page language="java" import="java.sql.*" %> direttiva include: modificando l'attributo file possibile aggiungere dei file sorgenti aggiuntivi da compilare assieme alla pagina (possono per esempio essere file HTML o semplici file di testo); direttiva taglib: permette di utilizzare una libreria di tag personalizzati (basta specificare l'URL della libreria e il prefisso da utilizzare per accedere ai tag, rispettivamente settando i parametri url e prefix).

Azioni
Questi oggetti sono finalizzati ad un migliore incapsulamento del codice (per aderire allo spirito della programmazione ad oggetti Java), generalmente inteso come inclusione e utilizzo di Java Bean. Le azioni standard per le pagine JSP sono: <jsp:useBean> : permette di utilizzare i metodi implementati all'interno di un JavaBean; <jsp:setProperty> : permette di impostare il valore di un parametro di un metodo di un Bean; <jsp:getProperty> : permette di acquisire il valore di un parametro di un Bean; <jsp:param> : permette di dichiarare ed inizializzare dei parametri all'interno della pagina. Sintassi:

Manuale JSP

Request
<jsp:params> <jsp:param name="nomeParametro" value="valore"> </jsp:params> dove i parametri indicano: name: nome del parametro dichiarato; value: valore del parametro appena dichiarato.

11

<jsp:include> : permette di includere risorse aggiuntive di tipo sia statico che dinamico. Il risultato quindi quello di visualizzare la risorsa, oltre alle informazioni gi inviate al client. Sintassi: <jsp:include page="URLRisorsa" flush="true | false" /> dove i parametri indicano: page: URL della risorsa fa includere flush: attributo booleano che indica se il buffer deve essere svuotato o meno. Questa azione pu venire completata con la dichiarazione di eventuali parametri legati agli oggetti inclusi: <jsp:include page="URLRisorsa flush="true|false"> {<jsp:param ... />} </jsp:include>.

<jsp:foward> : consente di eseguire una richiesta di una risorsa statica, un servlet o un'altra pagina JSP interrompendo il flusso in uscita. Il risultato quindi la visualizzazione della sola risorsa specificata Sintassi: <jsp:forward page="URLRisorsa"/> dove page specifica l'URL della risorsa a cui eseguire la richiesta del servizio. Ovviamente questa azione pu anch'essa venire completata con la dichiarazione di parametri: <jsp:forward page="URLRisorsa> {<jsp:param ... />} </jsp:forward>.

Request
Gli oggetti impliciti sono disponibili per la stesura del codice senza particolari inclusioni, per per usufruire delle loro funzionalit quindi sufficiente usare la tipica sintassi nomeOggetto.nomeMetodo . Request L'oggetto request permette di accedere alle informazioni di intestazione specifiche del protocollo http. Al momento della richiesta questo metodo incapsula le informazioni sulla richiesta del client e le rende disponibili attraverso alcuni suoi metodi. L'uso pi comune quello di accedere ai parametri inviati (i dati provenienti da un form per esempio) con il metodo getParameter("nomeParametro"), che restituisce una stringa con il valore del parametro specificato. Alto metodo molto importante getCookies(), che restituisce un array di cookies (vedremo meglio come nella parte relativa ai cookies). Gli altri metodi, i pi importanti, sono: getAttributeNames() restituisce una variabile di tipo Enumeration contenente i nomi di tutti gli attributi coinvolti nella richiesta. getContentLength()

Manuale JSP

Response, Out
restituisce un intero che corrisponde alla lunghezza in byte dei dati richiesti. getContentType() restituisce il tipo MINE della richiesta, cio il tipo di codifica dei dati.

12

getInputStream() restituisce un flusso di byte che corrisponde ai dati binari della richiesta. Particolarmente utile per funzioni di upload di file da client a server. getParameter(String) restituisce una tringa con il valore del parametro richiesto. getParameterNames() restituisce una variabile di tipo Enumeration contente i nomi dei parametri della richiesta. getParameterValues(String) restituisce un array contenente tutti i valori del parametro specificato (nel caso ci siano pi parametri con lo stesso nome). getProtocol() corrisponde alla variabile CGI SERVER_PROTOCOL. Rappresenta il protocollo e la versione della richiesta. getRemoteHost() corrisponde alla variabile CGI REMOTE_HOST. getServerName() corrisponde alla variabile CGI SERVER_NAME e restituisce l'indirizzo IP del server getServerPort() corrisponde alla variabile CGI SERVER_PORT, la porta alla quale in server in ascolto. getRemoteAddr() corrisponde alla variabile CGI REMOTE_ADDR. Restituisce in pratica l'indirizzo IP del visitatore. getRemoteHost() corrisponde alla variabile CGI REMOTE_HOST. getRemoteUser() come per REMOTE_USER restituisce lo username della macchina richiedente getMethod() come per la variabile CGI REQUEST_METHOD e restituisce GET o POST. getPathInfo() restituisce informazioni extra sul path, corrisponde alla varibile CGI PATH_INFO getQueryString() restituisce una stringa contenete l'intera querySting (tutti i caratteri dopo il punto di domanda), come per la variabile CGI QUERY_STRING. request.getServletPath() restituisce il percorso relativo della pagina jsp

Response, Out
Response Questo oggetto fornisce tutti gli strumenti per inviare i risultati dell'esecuzione della pagina jsp. setBufferSize(int)

Manuale JSP

Session
imposta la dimensione in byte del buffer per il corpo della risposta, escuse quindi le intestazioni. setContentType("tipo") imposta il tipo MINE per la risposta al client. flushBuffer() forza l'invio dei dati contenuti nel buffer al client. Questi sono i principali metodi degli oggetti impliciti request e response. Chi fosse eventualmente interessato a conoscere tutti gli altri, pu consultare la documentazione relativa ai servlet e Java Server Page ("Servlet e JavaServer Pages API Documentation") sul sito della Sun.

13

Out Questo oggetto ha principalmente funzionalit di stampa di contenuti. Con il metodo print(oggetto/variabile) possibile stampare qualsiasi tipo di dato, come anche per println() che a differenza del precedente termina la riga andando a capo. Si capisce comunque che l'andare o meno a capo nella stampa dei contenuti serve solo a migliorare la leggibilit del codice HTML. PageContext Questo oggetto rappresenta in pratica il contesto di esecuzione del servlet creato dalla pagina JSP. In pratica poco utilizzato dai programmatori di pagine JSP. Config Permette di gestire tramite i suoi metodi lo startup del servlet associato alla pagina JSP, di accedere quindi a parametri di inizializzazione e di ottenere riferimenti e informazioni sul contesto di esecuzione del servlet stesso. Exception Questo oggetto accessibile solo dalle pagine di errore (dove la direttiva isErrorPage impostata a true). Contiene le informazioni relative all'eccezione sollevata in una pagina in cui il file stato specificato come pagina di errore. Il metodo principale getMessage() che restituisce una stringa con la descrizione dell'errore.

Session
Una delle funzionalit pi richieste per un'applicazione Web mantenere le informazioni di un utente lungo tutto il tempo della sua visita al sito. Questo problema risolto dall'oggetto implicito Session che gestisce appunto le informazioni a livello di sessione, relative ad un singolo utente a partire dal suo ingresso alla sua uscita con la chiusura della finestra del browser. possibile quindi creare applicazioni che riconoscono l'utente nelle varie pagine del sito, che tengono traccia delle sue scelte e dei suoi dati. importante sapere che le sessioni vengono memorizzate sul server e non con dei cookies che devono per essere abilitati per poter memorizzare il cos detto SessionID che consente di riconoscere il browser e quindi l'utente nelle fasi successive. I dati di sessione sono quindi riferiti e riservati ad un utente a cui viene creata un'istanza dell'oggetto Session e non possono essere utilizzati da sessioni di altri utenti. Memorizzare i dati nell'oggetto Session Per memorizzare i dati all'interno dell'oggetto session sufficiente utilizzare il metodo setAttribute specificando il nome dell'oggetto da memorizzare e una sua istanza. Per esempio, per memorizzare il nome dell'utente al suo ingresso alla pagina ed averlo a disposizione i seguito e sufficiente fare session.setAttribute("nomeUtente", nome) a patto che nome sia un oggetto di tipo stringa che contenga il nome dell'utente. Leggere il contenuto di una variabile di sessione La lettura di una variabile di sessione precedentemente memorizzata possibile grazie al metodo getAttribute che ha come unico ingresso il nome della variabile di sessione con cui avevamo memorizzato il

Manuale JSP

Application
dato che ci interessa reperire. Session.getAttribute("nomeUtente") restituisce il nome dell'utente memorizzato come visto in precedenza; se non vengono trovate corrispondenza con il nome dato in ingresso, restituisce null. Queste due sono le operazioni fondamentali e pi utilizzate per la gestione della sessione, a seguito riportiamo altri metodi dell'oggetto Session che in alcuni casi potrebbero essere utili. getAttributeNames() restituisce un oggetto di tipo enumerativo di stringhe contenente i nomi di tutti gli oggetti memorizzati nella sessione corrente. getCreationTime() restituisce il tempo (in millisecondi dalla mezzanotte del primo gennaio del 1970) di quando stata creata la sessione. getId() restituisce una stringa contenente il sessionID che come detto permette di identificare univocamente una sessione. getLastAccesedTime() restituisce il tempo (in millisecondi dalla mezzanotte del primo gennaio del 1970) dall'utima richiesta associata alla sessione corrente. getMaxInactiveInterval() restituisce un valore intero che corrisponde all'intervallo massimo di tempo tra una richiesta dell'utente ad un'altra della stessa sessione. removeAttribute(nome_attributo) rimuove l'oggetto dal nome specificato dalla sessione corrente.

14

Application
L'oggetto implicito application consente di accedere alle costanti dell'applicazione e di memorizzare oggetti a livello di applicazione e quindi accessibili da qualsiasi utente per un tempo che va dall'avvio del motore JSP alla sua chiusura, in pratica fino allo spegnimento del server. Gli oggetti memorizzati nell'oggetto application come appena detto sono visibili da ogni utente e ogni pagina pu modificarli. Memorizzare i dati nell'oggetto application Per memorizzare i dati all'interno dell'oggetto application sufficiente utilizzare il metodo setAttribute specificando il nome dell'oggetto da memorizzare e una sua istanza. Per esempio, per memorizzare il numero di visite alla pagina sufficiente fare application.setAttribute("visite", "0"). Leggere il contenuto di un oggetto contenuto in application La lettura di un oggetto application precedentemente memorizzato possibile grazie al metodo getAttribute che ha come unico ingresso il nome dell'oggetto application con cui avevamo memorizzato il dato che ci interessa reperire. application.getAttribute("visite") restituisce l'oggetto corrispondente, in questo caso semplicemente il valore 0. Se non vengono trovate corrispondenze con il nome viene restituito il valore null. Anche l'oggetto application come session possiede il metodo getAttributeNames() che restituisce un oggetto di tipo enumerativo di stringhe contenente i nomi di tutti gli oggetti memorizzati nell'applicazione in esecuzione. Per rimuovere un oggetto si utilizza il metodo removeAttribute("nomeoggetto"). Infine per accedere alle costanti di applicazioni accennate all'inizio, segnaliamo due metodi: il primo molto utile getRealPath("\") che restituisce (con quella stringa in ingresso) il percorso completo su cui memorizzato il file. Il secondo metodo restituisce delle informazioni, solitamente riguardanti la versione, del motore jsp che si sta utilizzando per l'esecuzione della pagina: application.getServerInfo(). Questi sono i metodi pi utili dell'oggetto application. Chi fosse eventualmente interessato a conoscere tutti gli altri, pu consultare la documentazione relativa ai servlet e Java Server Page ("Servlet e JavaServer Pages API Documentation") sul sito della Sun.

Manuale JSP

Utilizzo dei Java Bean

15

Utilizzo dei Java Bean


JSP E Java Beans Come gi accennato le JSP sono estensioni dei servlet Java, di conseguenza consentono di ottenere tutti i risultati di questi ultimi. Lo svantaggio dei Servlet per rappresentato, come per tutti gli script CGI, dalla difficolt di manutenzione del codice HTML delle applicazioni eccessivamente complesse, in quanto il pi delle volte contengono una quantit di codice scriptler eccessiva per un programmatore non esperto in Java. Soluzione a questo problema rappresentata dai Java Beans, componenti software contenenti una classe Java, che possono venire inclusi in una pagina JSP, permettendo quindi un ottimo incapsulamento del codice, peraltro riutilizzabile. Al programmatore quindi sar pressoch invisibile la sezione di codice puro, sostituito da richiami ai metodi delle classi incluse.
N.B. I Bean sono costituiti esclusivamente da codice Java e possono venire realizzati con un semplice editor di testo (per esempio Blocco note), salvati con estensione .java e compilati (per esempio con il compilatore Java JDK) generando un file di estensione .class. Sar il file .class che dovr venire incluse nella pagina JSP, come vedremo in seguito. Da ricordare che in Java i file devono avere lo stesso nome della classe, lettere maiuscole e minuscole comprese.

Aggiunta di JavaBean Esistono tre azioni standard per facilitare l'integrazione dei JavaBean nelle pagine JSP. <jsp:useBean> Permette di associare un'istanza di un JavaBean (associata ad un determinato ID) ad una variabile script dichiarata con lo stesso ID. In pratica offre la possibilit di associare la classe contenuta nel JavaBean ad un oggetto visibile all'interno della pagina, in modo da poter richiamare i suoi metodi senza dover ogni volta far riferimento al file di origine. Attributi: Id: identit dell'istanza dell'oggetto nell'ambito specificato. Scope: ambito dell'oggetto, le opzioni sono: - page: gli oggetti con questo ambito sono accessibili solo all'interno della pagina in cui sono stati creati, in pratica possono venire paragonati alle variabili locali di un qualsiasi linguaggio di programmazione, vengono distrutte alla chiusura della pagina e i dati saranno persi; - request: gli oggetti con questo ambito sono accessibili esclusivamente nelle pagine che elaborano la stessa richiesta di quella in cui stato creato l'oggetto, quest'ultimo inoltre rimane nell'ambito anche se la richiesta viene inoltrata ad un'altra risorsa; - session: gli oggetti definiti in quest'ambito sono accessibili solo alle pagine che elaborano richieste all'interno della stessa sessione di quella in cui l'oggetto stato creato per poi venire rilasciati alla chiusura della sessione a cui si riferiscono, in pratica restano visibili in tutte le pagine aperte nella stessa istanza (finestra) del Browser, fino alla sua chiusura. Solitamente i bean istanziati in questo modo vengono utilizzati per mantere le informazioni di un utente di un sito; - application: gli oggetti definiti in quest'ambito sono accessibili alle pagine che elaborano richieste relative alla stessa applicazione, in pratica sono validi dalla prima richieta di una pagina al server fino al suo shotdown. class: nome della classe che definisce l'implementazione dell'oggetto beanName: contiene il nome del bean che, come gi accennato deve coincidere con il nome del file .class (senza estensione) Esempio: <jsp:useBean id="nomeBean" scope="session" class="classe" />

Manuale JSP

Un esempio di Java Bean

16

Crea un'istanza della classe classe con ambito session richiamabile attraverso l'id NomeBean: da questo momento sar possibile accedere a metodi e variabili (pubbliche) attraverso la sintassi nomeBean.nomeMetodo e nomeBean.nomeVariabile, rispettivamente per metodi e variabili. <jsp:setProperty> Permette di impostare il valore di una delle propriet di un bean. Attributi: name: nome dell'istanza di bean definita in un'azione property: rappresenta la propriet di cui impostare il valore param: nome del parametro di richiesta il cui valore si vuole impostare value: valore assegnato alla propriet specificata Esempio: <jsp:setProperty name="nome_bean" property="prop" param="nome_parametro" /> permette di assegnare il valore del parametro nome_parametro alla propriet prop del bean di nome nome_bean. <jsp:getProperty> Prende il valore di una propriet di una data istanza di bean e lo inserisce nell'oggetto out implicito (in pratica lo stampa a video). Attributi: name: nome dell'istanza di bean da cui proviene la propriet definita da un'azione property: rappresenta la propriet del bean di cui si vuole ottenere il valore

Un esempio di Java Bean


Vediamo subito un semplice esempio di bean, realizzato per contenere le informazioni di un utente durante la sua permanenza nel sito. InfoUtente.java public class InfoUtente { private String nome = null; private String email = null; private int pagineViste; public InfoUtente() { pagineViste=0; } public aggiornaPV(){ pagineViste++; } public int getPagineViste(){ return pagineViste; } public void setNome(String value) { nome = value; }

Manuale JSP

Gestione degli errori in pagine JSP

17

public String getNome() { return nome; } public void setEmail(String value) { email = value; } public String getEmail() { return email; } public String riassunto(){ String riassunto = null; riassunto = "Il nome dell'utente "+nome+","; riassunto+= "il suo indirizzo e-mail : "+email; riassunto+=" e ha visitato "+pagineViste+" del sito"; return riassunto; } }//InfoUtente Come facile capire, questo bean contiene il nome dell'utente ed i metodi per modificarlo e restituirlo, il suo indirizzo e-mail con i relativi metodi, il numero di pagine viste dall'utente e un metodo che restituisce un riassunto schematico dei dati dell'utente. Ecco come utilizzarli: <html> <head><title>Utilizzo del Bean</title></head> <body> <jsp:useBean id="utente" scope="session" class="InfoUtente"/> Viene creata un'istanza del bean InfoUtente con ambito session, necessario per questo tipo di funzione <jsp:setProperty name="utente" property="nome" value="Zina&Tram"/> La propriet del bean possono essere impostate con l'azione setProperty o agendo direttamente con i metodi creati appositamente. <% utente.setNome("Zina&Tram"); utente.setEmail("ciao@dom.it"); %> Lo stesso vale per la lettura dei bean che puo essere fatta con l'azione <jsp:getProperty name="utente" property="nome"/> o agendo sui metodi creati: <% out.println(utente.getNome()); out.println(utente.riassunto()); %> Per incrementare il numero di pagine viste sufficiente richiamare il metodo aggiornaPV() e per ottenere il valore getPagineViste(). <% utente.aggiornaPV(); out.println(utente.getPagineViste()); %>

Gestione degli errori in pagine JSP


Una delle caratteristiche di Java quella di poter gestire le eccezioni, cio tutti quelli eventi che non dovrebbero accadere in una situazione normale e che non sono causati da errori da parte del programmatore. Dato che JSP deriva esplicitamente da Java, e ne conserva le caratteristiche di portabilit e robustezza, questo argomento non poteva essere trascurato.

Manuale JSP

Recupero dei dati da un form

18

Errori al momento della compilazione Questo tipo di errore si verifica al momento della prima richiesta, quando il codice JSP viene tradotto in servlet. Generalmente sono causati da errori di compilazione ed il motore JSP, che effettua la traduzione, si arresta nel momento in cui trova l'errore ed invia al client richiedente una pagina di "Server Error" (o errore 500) con il dettaglio degli errori di compilazione. Ecco cosa succede quando si richiede una pagina sintatticamente errata: Errori al momento della richiesta Questi altri errori sono quelli su cui ci soffermeremo perch sono causati da errori durante l'esecuzione della pagina e non in fase di compilazione. Si riferiscono all'esecuzione del contenuto della pagina o di qualche altro oggetto contenuto in essa. I programmatori java sono abituati ad intercettare le eccezioni innescate da alcuni tipi di errori, nelle pagine JSP questo non pi necessario perch la gestione dell'errore in caso di eccezioni viene eseguita automaticamente dal servlet generato dalla pagina JSP. Il compito del programmatore si riduce al creare un file .jsp che si occupi di gestire l'errore e che permetta in qualche modo all'utente di tornare senza troppi problemi all'esecuzione dell'applicazione JSP. Creazione di una pagina di errore Una pagina di errore pu essere vista come una normale pagina JSP in cui si specifica, tramite l'opportuno parametro della direttiva page, che si tratta del codice per gestire l'errore. Ecco un semplice esempio: PaginaErrore.jsp <HTML> <BODY> <%@ page isErrorPage = "true" %> <CENTER> Siamo spiacenti, si verificato un errore durante l'esecuzione:<BR><BR> <%= exception.getMessage()%> </CENTER> </BODY> </HTML> A parte la direttiva page il codice Java composto da un'unica riga che utilizza l'oggetto exception (implicitamente contenuto in tutte le pagine di errore) richiamando l'oggetto getMessage() che restituisce il messaggio di errore. Uso delle pagine di errore Perch nelle nostre pagine JSP venga utilizzata una determinata pagina di errore l'unica cosa da fare inserire la seguente direttiva: <% page errorPage = "PaginaErrore.jsp" %> che come facile capire specifica quale pagina di errore deve essere richiamata in caso di errore in fase di esecuzione.

Recupero dei dati da un form


Il modo pi semplice per recuperare i dati da un form o dalla querystring quello di utilizzare l'istruzione Request.getParameter("nome_parametro") che, come gi detto, legge sia i parametri provenienti da un form con metodo POST, sia quelli inviati tramite querystring con metodo get o semplicemente concatenandoli all'url della pagina. Il metodo cerca "nome_parametro" nell'elenco dei parametri contenuti nella richiesta e ne restituisce l'eventuale valore. Se ci troviamo a dover ricevere pi di un parametro con lo stesso nome, cosa pi che legittima e soprattutto molto utile in certe situazioni, si ricorre al metodo getParameterValues("nome_parametro"), sempre dell'oggetto request. GetParameterValues() restituisce un vettore di stringhe con tutti i diversi valori del parametro di cui si specifica il nome. Per accedere al singolo valore sufficiente aggiungere un [n] in questo modo: request.getParameterValues("nome_parametro")[0] per ottenere il primo valore (in java si inizia a contare da 0), request.getParameterValues("nome_parametro")[1] per il secondo e cos via per tutti gli

Manuale JSP

JDBC introduzione
altri.

19

Se per esempio in un form chiediamo all'utente di inserire gli indirizzi di tutti i siti che ha realizzato, sappiamo bene che possiamo ricevere informazioni di persone che hanno creato molti siti ma altri ancora agli inizi con poche pagine all'attivo. Creato il form con una quantit adeguata di input di tipo testo, tutti con lo stesso nome, la lettura dei dati dalla pagina JSP si risolve in poche righe. %< int i=0 while (request.getParameterValues("siti_realizzati")[i].length()==0) { out.println(request.getParameterValues("siti_realizzati")[i]); i++; } %> Se si vuole gestire anche la possibilit che le caselle di testo di input non vengano compilate in ordine, si deve gestire il tutto con un ciclo for. <% for (i=0; i<n; i++){ if (request.getParameterValues("siti_realizzati")[i].length()==0) out.println(request.getParameterValues("siti_realizzati")[i]); } %> dove n contiene il numero di caselle di testo presenti nel form.

JDBC introduzione
JDBC (Java Database Connectivity) un'interfaccia completamente Java utilizzata per eseguire istruzioni SQL. L'implementazione pi utilizzata di questa interfaccia quella detta con "bridge JDBC - ODBC". In questo caso il driver JDBC funge da ponte, per accedere al database attraverso driver ODBC, che deve essere presente e configurato sul server. Esistono per altre implementazioni che differiscono per il modo di operare delle stesse: - Driver API - nativa Questa tecnica si interfaccia direttamente con i database commerciali, convertendo i comandi JDBC in chiamate specifiche del DBMS (Data Base Manage System), il sistema di gestione di basi di dati. - Driver puro Java un driver puro Java che comunica direttamente con il database, convertendo i comandi JDBC nel protocollo del motore di database. Questa senza dubbio la soluzione migliore perch non richiede nessuna traduzione aggiuntiva. In seguito si prender in considerazione il driver del primo tipo (bridge JDBC - ODBC) perch, come gi detto, il pi diffuso e utilizzato anche nelle applicazione puramente Java, il pi semplice e soprattutto disponibile sin dalla prima versione del Jdk. Come gi detto questa interfaccia necessita di un driver ODBC configurato e per farlo necessario operare come segue: 1. dopo aver fatto doppio clic sull'icona "origine dati ODBC" dal pannello di controllo di windows, apparir una finestra dalla quale bisogna scegliere il tipo di base di dati a cui ci si deve connettere. 2. Dopo aver cliccato su aggiungi, viene richiesto di scegliere il tipo di file del nostro database 3. Cliccando su fine, possibile dare un nome all'origine dati e impostare il path del database da utilizzare.

Manuale JSP

JDBC la lettura dei dati da un database

20

Al termine di questa operazione il sistema operativo ha creato un file .dsn con il nome e tutti i riferimenti al nostro database, pronto per essere quindi utilizzato nelle nostre pagine JSP.

JDBC la lettura dei dati da un database


Una volta configurato il driver ODBC possiamo entrare nel vivo dell'argomento con la lettura dei dati contenuti nel nosto database. L'operazione completa per leggere i dati da una o pi tabelle di una base di dati suddivisa in quattro fasi: - apertura connessione al database - esecuzione istruzione - elaborazione risultato - chiusura connessione Ecco il codice che riporta in pratica queste fasi: <%- deve essere importata il package java.sql.* per eseguire le istruzioni SQL -%> <%@ page language="java" import="java.sql.*" %> connection dbconn = null;

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); //carica il file di classe del driver per il collegamento al database con il ponte Odbc dbconn = DriverManager.getConnection("jdbc:odbc:miobd","admin","pwd"); //Apertura connessione con il data base "miodb" Statement statement = dbconn.createStatement(); ResultSet rs = statement.executeQuery("SELECT dato FROM tab1"); //Esecuzione istruzione SQL A questo punto l'oggetto rs contiene il set di risultati ottenuti dall'istruzione SELECT sul database. Ora i singoli campi di ogni record possono essere letti con opportuni metodi. while (rs.next()){ //ottiene il dato dat = rs.getInt("dato"); //stampa a video out.println(dat); }//while //Elaborazione risultati dbconn.close(); //chiude la connessione In questo semplice esempio sono stati prelevati dalla tabella tab1 del database miodb tutti i valori del campo dato. I metodi di lettura dei campi dell'oggetto ResultSet si differenziano in base al tipo campo. Ecco un breve tabella che elenca i tipi di variabile del database e i rispettivi metodi da utilizzare.

Manuale JSP

JDBC inserimento e modifica


Metodo getInt() getFloat() getByte() getlong() getString() getBoolean() getDate() Tipo del campo Numerico intero Numerico con virgola Numerico byte Numerico lungo Stringa Buleano (si/no) Data

21

Per muovere in avanti il cursore resultSet si utilizza la il metodo next() dell'oggetto stesso, che restituisce un valore buleano che indica se il cursore arrivato al termine dalla tabella. sufficiente creare un ciclo while(rs.next()) per scorrere senza ulteriori istruzioni i records della base di dati.

JDBC inserimento e modifica


Se necessario aggiornare, inserire, modificare o eliminare records di un batabase, il codice varia leggermente, infatti l'oggetto ResultSet, come si pu intuire, non pi necessario visto che l'operazione non restituisce pi un riferimento ad una tabella creata con un'istruzione select. sufficiente richiamare il metodo executeUpdate() dell'oggetto Statement precedentemente definito, e dare come ingresso la query SQL (Insert, update, create table). Questo metodo restituisce un valore intero che uguale a 1 se tutto stato eseguito con successo. bene quindi effettuare un controllo sul valore restituito in modo da riuscire a capire se la modifica la batadase sia effettivamente riuscita e comportarci di conseguenza. L'esempio riportato in seguito aggiunge al database un record il cui campo contenuto in una varibile dalle pagina JSP, che pu quindi provenire da un form o da un'elaborazione dati precedente. Visualizza l'esempio in un'altra finestra. Nell'esempio stato inserito nella tabella "tab1", nel campo "dati", il valore della variabile "valore", che era stata definita e inizializzata precedentemente, ma che in pratica proverr quasi sempre da un form di inserimento dati. Ci stato possibile con una semplice operazione di concatenazione di stringhe (per farlo si usa +) per creare la query SQL che si occupa dell'aggiornamento. Si capisce che le atre operazioni, l'eliminazione e l'aggiornamento, vengono eseguite nello stesso modo, scrivendo le adeguate istruzioni SQL.

Cookies
Attorno ai cookies cresciuta col passare del tempo una sorta di cattiva reputazione, dovuta all'uso improprio che ne viene fatto da alcuni progettisti di pagine Web. I cookies non sono altro che quell'insieme di informazioni associate ad un particolare dominio che vengono memorizzate sul client sotto forma di file di solo testo, in modo da poter riconoscere un particolare utente dell'applicazione. Con lo sviluppo di applicazioni sempre pi complesse ed efficienti, l'utilizzo dei cookies diventato indispensabile, come anche far capire agli utenti del sito che, se usati nel modo giusto, non fanno altro che migliorare la loro navigazione. Fatte queste premesse, vediamo quali sono le istruzioni che ci servono. Naturalmente la prima fase quella di scrivere un cookie, compito del metodo addCookie() dell'oggetto response: response.addCookie(cookie) dove il parametro di ingresso cookie non altro che una classe che ha alcuni metodi che ci permettono di impostare le propriet del cookie. Ecco come:

Manuale JSP

Cookies
Cookie mioCookie = new Cookie ("nome", "valore"); definisce un oggetto Cookie con il ripettivo nome e valore mioCookie.setPath("/"); //specifica il percorso che ha il privilegio di scrittura e lettura del cookie //se omesso inteso il percorso corrente mioCookie.setAge(secondiDiVita); //imposta il periodo di vita, espresso in secondi mioCookie.setSecure(false); //indica se il cookie va trasmesso solo su un protocollo sicuro, protetto cio da crittografia response.addCookie(mioCookie); //scrive il cookie

22

A questo punto mioCookie scritto sul client. Per leggerlo l'operazione leggermente pi complicata. L'oggetto request dispone infatti di un metodo getCookies() che restituisce un array di oggetti cookie trovati nel client. Una volta ottenuto l'array, quindi necessario passare in rassegna tutti i suoi elementi fino a trovare quello che ci interessa. Cookie mioCookie = null; //definisce in cookie che verr letto Cookie[] cookiesUtente = request.getCookies(); //definisce l'array di cookie e legge quelli dell'utente int indice = 0; //indice per la gestione del ciclo while (indice < cookiesUtente.length) { //esegue il ciclo fino a quando ci sono elementi in cookieUtente if (cookiesUtente[indice].getName().equals("nomeMioCookie"); break; //se trova un cookie con il nome che stiamo cercando esce dal ciclo indice++; }//while A questo punto controllando il valore dell'indice siamo in grado di capire se abbiamo trovato il nostro cookie. If (indice < cookiesUtente.length) //il cookie stato trovato e viene messo nell'oggetto mioCookie mioCookie = cookiesUtente[indice]; else mioCookie = null; //il cookie non stato trovato Ora, se il cookie stato trovato, possibile accedere ai sui dati con i metodi dell'oggetto stesso, principalmente getValue() per ottenere il valore contenuto.

Manuale JSP

Jallaire Jrun per Win95/98


Valore = mioCookie.getValue() Altri metodi sono: getName(): restituisce il nome getAge(): restituisce il periodo di vita in secondi getPath(): restituisce il percorso che ha il permesso di lettura/scrittura getSecure(): restituisce un buleano che dice se il cookie sicuro oppure no.

23

Jallaire Jrun per Win95/98


Configurazione del server Negli ultimi mesi, la tecnologia JSP sta prendendo sempre pi piede anche in applicazioni di livello medio. Per far fronte a questa diffusione, i produttori di server-web si stanno sempre pi impegnando a sviluppare piattaforme software sempre pi potenti e affidabili. Se meno di un anno fa chi voleva sviluppare una pagina JSP si trovava ad affrontare installazioni e configurazioni davvero ardue anche per persone competenti, oggi si pu scegliere tra decine di soluzioni per ogni tipo di utenza. Sul sito della Sun, nella sezione JSP possibile prendere visione della lista di tutti i prodotti che supportano la tecnologia di Sun per i Servlet e le JSP. All'indirizzo http://java.sun.com/products/jsp/index.html, Home Page del sito Sun per JSP, cliccando su "Indistry Momentum" si ottiene la lista dei server e dei programmi di sviluppo per JSP. Quelli scelti dal sottoscritto sono Jrun 3.0 di Allaire per Windows 95/98 e Tomcat di Apache per sistemi unix o windows NT/2000. Da sottolineare che qualsiasi sia la vostra scelta, sul computer deve essere necessariamente installato il Jdk1.1 o successivo. Windows 95/98: Allaire Jrun 3.0 Per scaricare il prodotto di valutazione (di 30 giorni) dal sito della Allaire (www.allaire.com) necessario registrarsi gratuitamente per ottenere, tramite e-mail la password per avere accesso all'area download del software di valutazione o per gli aggiornamenti. Dopo aver fatto questo quindi possibile entrare nell'area download, scegliere "JrunEvaluation" e procedere scaricando l'Enterprise Edition per windows, dopo aver inserito username e password personali. Una volta terminato il download (13 MByte circa) necessario ricorrere nuovamente alla propria casella di posta in cui nel frattempo dovrebbe essere arrivato il messaggio contente il codice per l'installazione, che sufficientemente guidata da non richiedere particolari spiegazioni, eventualmente portate attenzione al momento di specificare il path del jdk e qunado viene chiesto se si desidera che il server venga avviato automaticamente all'avvio del pc, cosa che sconsiglio visti i tempi richiesti da questa operazione. Al termine il server sar gi configurato e pronto per una prima prova. I file .jsp vanno copiati nella directory x:\programmi\allaire\jrun\servers\default-app che raggiungibile dal browser specificando indirizzo di local loop e numero di porta: http://localhost:8180/. I file .class di eventuali bean realizzati per le pagine JSP vanno copiati nella directory WEB-INF/classes che contiene tutte le risorse collegate all'applicazione ma non disponibili agli utenti. Nella directory WEB-INF/jsp vanno archiviati i servlet e le classi di utilit, infine su WEB-INF/session i file di tipo immagine e genericamente tutti quelli collegati al codice html. Da notare che i servlet generati da motore jsp dalle nostre pagine, possono essere visionati nei file contenuti nella directory WEB-INF/jsp, aprendo con un programma di lettura di file di testo i file.java relativi al nostro codice jsp. Per creare pi applicazioni da far girare sul server necessaria una configurazione, ma non entriamo nell'argomento visto il tempo limitato per la valutazione del prodotto.

Manuale JSP

Tomkat di Jakarta per NT/Unix

24

Tomkat di Jakarta per NT/Unix


Le pagine JSP non possono venire visualizzate mediante l'utilizzo di un normale server web, necessitano infatti di un particolare software in grado di interpretarle. Tale software (jakarta tomcat 3.2.1) pu venire scaricato gratuitamente in versione freeware nel sito del progetto Jakarta ( http://jakarta.apache.org ) e pu venire utilizzato esclusivamente sotto sistemi operativi Unix, Windows NT e Windows 2000 (ma vedi al termine di questo paragrafo), inoltre necessita di un compilatore Java (es. JDK). Eseguita l'installazione, per poter eseguire il test delle proprie Java Server Pages occorre configurare adeguatamente il server web, operazione descritta nei punti qui di seguito: 1. Aprire il file /jakarta-tomcat-3.2.1/bin/tomcat.bat utilizzando un semplice editor di testo; 2. modificare il file settando i parametri TOMCAT_HOME e JAVA_HOME inserendovi le directory che contengono Tomcat e il compilatore Java (JDK). Supponendo di aver installato il server nella directory C:\jakarta-tomcat-3.2.1 e il compilatore Java nella directory C:\jdk, il file dovr essere modificato in questo modo: rem ----- Save Environment Variables That May Change -----set set set set _CP=%CP% TOMCAT_HOME=C:\jakarta-tomcat-3.2.1 JAVA_HOME=C:\jdk _CLASSPATH=%CLASSPATH%

3. creare una propria cartella nella directory contenente Tomcat; 4. aprire con un editor di testo il file jakarta-tomcat-3.2.1/conf/server.xml; 5. scorrere il file fino alla sezione Special Webapps e inserire le righe:

<Context path="/nome" docBase="pathDirectory"> </Context> dove nome dovr venire sostituito dal nome della directory virtuale che verr richiamata nel browser e pathDirectory dal path della directory fisica dove saranno inserite le pagine JSP da visualizzare. Possono naturalmente venire inserite un numero illimitato di directory, basta ripetere questo punto cambiando i nomi della directory virtuale e fisica. A questo punto la configurazione del server ultimata, per poter attivare tomcat basta lanciare l'eseguibile /jakarta-tomcat-3.2.1/bin/startup.exe , per disattivarlo invece bisogna lanciare l'eseguibile /jakarta-tomcat3.2.1/bin/shotdown.exe. Per accedere alla directory personale dal browser si inserire nella barra degli indirizzi l'indirizzo http://localhost:8080/ seguito dal nome della directory virtuale inserito anche nel file server.xml precedentemente modificato. Affinch nelle pagine possano venire inclusi servlet o bean, dovranno venire in un primo tempo compilati (generando il file .class) e poi inseriti nella cartella /pathDirectory/Web-inf/classes (dove al posto di pathDirectory andr inserito il nome della cartella fisica in cui varranno inserite le JSP). Tomcat fornisce inoltre un buon numero di esempi di JSP e servlet a cui si pu accedere automaticamente inserendo nella barra degli indirizzi del browser http://localhost:8080 (senza specificare nessuna directory) e accedendo alla sezione examples. Il server tomcat di Jakarta pu essere installato anche su sistemi operativi Windows 9x e Me, ovviamente con svantaggi dovuti al fatto che stato progettato per sistemi pi propensi alla gestione delle applicazioni

Manuale JSP

Gestire un sondaggio

25

per la rete. La procedura di installazione e configurazione la stessa, l'unica operazione aggiuntiva da eseguire quella di modificare la quantit di memoria di ambiente iniziale nelle propriet dei file tomcat.bat, shutdown.bat e startup.bat, impostandone il valore al massimo (4096).

Gestire un sondaggio
L'applicazione pratica con jsp che viene analizzata in seguito consiste nella creazione di un sondaggio, in cui gli utenti di un sito possono rispondere ad una domanda scegliendo tra le risposte proposte ed eventualmente visualizzare i risultati parziali delle votazioni. Come per tutti i sondaggi seri realizzati per un sito Internet previsto il controllo del doppio voto, reso impossibile dalla memorizzazione degli indirizzi ip degli utenti che votano. L'applicazione costituita da 4 file: - sondaggio.htm, contenente il form da cui l'utente risponde alla domanda - vota.jsp, che esegue la votazione proveniente dal form - risultati.jsp, che visualizza i risultati parziali delle votazioni - sondaggio.mdb, il database che gestisce tutto il sondaggio. Questo costituito da due tabelle. La prima "frequenza" contiene un campo chiamato "risp" di tipo byte che indica il numero della risposta, e un campo "frequenze" di tipo intero che indica il numero di volte che si votato per la rispettiva risposta. Nell'esempio, con 4 possibili risposte al sondaggio, la tabella stata completata inserendo nelle prime 4 righe del campo "risp" i valori 0-1-2-3 e nel campo "frequenze", ovviamente, i valori 0-0-0-0. La seconda tabella si chiama "ip_tab" e contiene in un campo "ip" di tipo testo la lista degli indirizzi ip di tutti gli utenti che hanno effettuato il voto. Vediamo nel dettaglio gli altri 3 file: Sondaggio.htm Visualizza il file sondaggio.htm in un'altra finestra. Il codice contenuto nei tag body del file potr essere copiato in qualsiasi parte di un qualsiasi documento html, e dovr essere personalizzato inserendo tanti radio button quante sono le possibili risposte al quesito e incrementando sempre di uno il valore dell'input eventualmente aggiunto. Vota.jsp Questo file esegue in pratica la votazione, aggiornando il database dopo aver fatto il controllo sull'ip dell'utente. Non deve essere necessariamente modificato. Al limite si possono personalizzare i messaggi di eseguita o fallita votazione. Visualizza il file vota.jsp in un'altra finestra. Risultati.jsp Visualizza il file risultati.jsp in un'altra finestra. Questo il file che esegue il compito pi complicato. Deve estrarre dal database il numero di utenti che hanno votato in totale e per ogni singola risposta, calcolare la percentuale e stampare una breve tabella di riepilogo e un grafico che riassume visivamente l'andamento del sondaggio. Nel file appena visto deve essere modificato il numero di possibili risposte (riga 20) e il valore delle stringhe contenenti le risposte (righe 25-28). Tutto il resto del codice pu rimanere invariato. Il risultato a video della pagina risultati.jsp risulter pressappoco cos:

Manuale JSP

Gestire un carrello della spesa

26

Gestire un carrello della spesa


Come gi detto nell'introduzione, le JSP sono state create anche per facilitare l'implementazione di servizi di commercio elettronico, in rapida via di sviluppo soprattutto di questi tempi. Il pi delle volte per comprare un qualsiasi tipo di oggetto sul web, si utilizza utilizzato quello che viene chiamato carrello della spesa elettronico, che permette di memorizzare gli oggetti che si intende acquistare ed eventualmente annullarne l'ordinazione. Come esempio si supposto di dover creare un carrello della spesa per un negozio di CD musicali. Il progetto che implementa tale servizio formato da tre file: Carrello.jsp: rappresenta il catalogo dei CD disponibili, con la possibilit di ordinazione; visCarr.jsp: visualizza il contenuto attuale del carrello, permettendo l'annullamento di un eventuale acquisto; Carrello.java: bean che contiene tutte le funzioni di memorizzazione, eliminazione e quant'altro, utili allo sviluppo delle pagine JSP. Per prima cosa necessario esaminare il bean, affinch risultino chiare le funzioni utilizzate poi nelle due JSP. Visualizza il file Carrello.java in un'altra finestra. Il codice non presenta particolare difficolt di interpretazione, interessante notare come la classe Hashtable (vedi Appendice A) renda molto semplice la memorizzazione e l'accesso alle informazioni, rendendole molto simili per certi aspetti ad un database. Grazie alla creazione di questo bean la pagina Carrello.jsp (qui di seguito) presenta un buon incapsulamento del codice, facilitando sia l'interpretazione ( fatto prevalentemente a codice HTML) che la modifica. Visualizza il file Carrello.jsp in un'altra finestra.

Manuale JSP

Appendice A: stringhe, vettori ed hashtable


Il codice riportato non necessita di ulteriori commenti, data la sua chiarezza e la quasi totale assenza di codice Java vero e proprio. Da notare per che il bean stato istanziato con ambito session, in modo da non permettere la perdita di informazioni se non dopo la chiusura del browser. Infine vediamo il codice di visCar.jsp Visualizza il file visCar.jsp in un'altra finestra. In questo caso stata utilizzata la direttiva page (spiegata precedentemente) affinch venissero inclusi nella pagina alcuni package di utilit.

27

Per riuscire ad eseguire il test del carrello della spesa bisogna ricordare che necessario compilare il file .java ed inserirlo nella cartella opportuna del server web, in modo che quest'ultimo riesca ad individuarlo ed utilizzarlo. In conclusione si pu dire che stato pienamente dimostrato quanto facile effettivamente sia implementare soluzioni efficaci di e-commerce, che risultano oltre che robuste anche discretamente veloci.

Appendice A: stringhe, vettori ed hashtable


GESTIONE DELLE STRINGHE Java mette a disposizione degli sviluppatori una classe (inclusa nel package java.lang) chiamata string, che permette, appunto, la gestione delle stringhe (da notare che da questa classe non possibile derivare altre sottoclassi). Gli oggetti di tipo string possono essere inizializzati in pi modi, ma normalmente i costruttori pi utilizzati sono due: - public String (): che costruisce una stringa vuota (perch sia allocata necessario utilizzare l'istruzione nomeStringa=new String [ ] ); - public String (string value): che costruisce una stringa contenente la stringa value. I metodi implementati da questa classe pi utilizzati sono: - string.length (): restituisce il numero di caratteri che compongono la stringa escluso il terminatore; - string.charAt (int i): restituisce il carattere della stringa in posizione i; - string.concat (string str): restituisce una nuova stringa ottenuta dalla concatenazione delle stringa string con la stringa str; - string.equals (string str): confronta la stringa string con la stringa str, restituendo true se risultano uguali; - string.equals.IgnoreCase (string str): confronta la stringa string con la stringa str tenendo conto delle lettere minuscole e maiuscole; - string.compareTo (string str): confronta la stringa string con la stringa str, restituendo 0 se risultano uguali, un numero positivo se str precede in ordine alfabetico string e un numero negativo se str anticipa segue in ordine alfabetico string; GESTIONE DEI VETTORI Java oltre all'implementazione di una classe per la gestione delle stringhe, ne fornisce una che permette di gestire i vettori (contenuta nel package java.util): la classe Vector. Un oggetto di tipo vettore fornito di tre costruttori, e pu quindi venire definito in altrettanti modi: - public Vector (): costruisce un vettore vuoto (avente dimesione di default 10); - public Vector (int capacitIniziale): costruisce un vettore di capacit capacitIniziale; - public Vector (int capacitIniziale, int incremento): costruisce un vettore di capacit iniziale capacitIniziale avente come incremento di capacit pari a incremento (quando viene aggiunto un nuovo elemento ad un vettore gi pieno, infatti, la classe Vector alloca un nuovo vettore di capacit uguale alla precedente pi un incremento, che di default uguale a 1). I metodi implementati da Vector pi utilizzati sono: - vector.elementAt (int i): restituisce l'elemento in posizione i; - vector.firstElement (): restituisce il primo elemento di vector; - vector.lastElement (): restituisce l'ultimo elemento di vector; - vector.addElements (Object obj): aggiunge obj dopo l'ultimo elemento del vettore (la classe Object la

Manuale JSP

Appendice B: fondamenti di SQL


radice da cui sono derivate tutte le altre classi Java); - vector.insertElementsAt (Object obj, int i): inserisce nella posizione i di vector l'elemento obj; - vector.setElementsAt (Object obj, int i): sostituisce l'elemento in posizione i con obj; - vector.removeElementAt (int i): rimuove l'elemento in posizione i da vector; - vector.removeElement (Object obj): se vector contiene l'elemento obj, esse verr rimosso e il metodo restituir il valore true, altrimenti verr restituito il valore false; - vector.removeAllElements (): rimuove tutti gli elementi del vettore.

28

LA CLASSE HASHTABLE La classe Hashtable (contenuta nel package java.util e derivata dalla classe astratta Dictionary) permette di memorizzare una collezione di oggetti (pi specificatamente delle coppie oggetto-chiave) avente funzioni molto simili ai database: le chiavi non replicabili permettono infatti un veloce accesso ai dati. Sia le chiavi che gli oggetti devono essere di tipo Object. I metodi pi importanti implementati da Hashtable sono: - hashtable.size(): restituisce un intero contenente il numero di elementi inseriti in hashtable; - hashtable.isEmpty (): restituisce un valore booleano che indica se il dizionario vuoto o meno (il valore true segnala il dizionario vuoto); - hashtable.get (Object chiave): restituisce l'oggetto a cui associata la chiave chiave, se la chiave non viene trovata restituisce null; - hashtable.put (Object chiave, Object elemento): inserisce in hashtable l'elemento elemento e gli associa la chiave chiave, se chiave gi stata inserita viene sostituito l'oggetto a lei associato e viene restituito, altrimenti viene restituito null; - hashtable.remove (Object chiave): rimuove da hashtable l'elemento associato a chiave, se la chiave non esiste viene restituito null. Ad un oggetto di tipo Hashtable pu venire associato un oggetto di tipo Enumeration, che permette di scorrere la collezione di oggetti, utilizzando i metodi: - enumeration.hasMoreElements (): che restituisce il valore booleano true se ci sono ancora elementi da scorrere; - enumeration.nextEle(): si sposta all'elemento successivo.

Appendice B: fondamenti di SQL


Per utilizzare i database con JSP come con anche con gli altri linguaggi per creare pagine dinamiche e necessario conoscere perlomeno un minimo di SQL (Scrtuctured Query Language) cio il linguaggio standard per l'interrogazione, l'inserimento, la modifica e la cancellazione dei dati dei database. Queste quattro operazioni possono essere eseguite in modo molto semplice con le istruzioni principali dell'SQL. Per una conoscenza pi approfondita del linguaggio rimandiamo al corso dedicato all'SQL. Effettuare ricerche: l'istruzione SELECT SELECT dato1, dato2 FROM tabella1 seleziona tutti i valori contenuti nei campi dato1 e dato2 della tabella tabella1. possibile selezionare tutti i campi mettendo un * al posto dei singoli nomi dei campi. SELECT * FROM tabella1 WHERE dato1=5 impone una condizione alla ricerca infatti seleziona solo i record per i quali valida la condizione dato1=5. SELECT * FROM tabella1 ORDER BY dato1 la clausola ORDER BY viene utilizzata per ordinare i valori contenuti in uno o pi campi. Di default l'ordinamento crescente ma possibile specificare l'inverso scrivendo DESC dopo i nomi dei campi su cui effettuare l'ordinamento. Con una serie di funzioni possibile contare, calcolare il totale, la media, il minimo e il massimo da un insieme di dati.

Manuale JSP

Appendice B: fondamenti di SQL


SELECT SUM(dato1) FROM tabella1

29

Restituisce la somma di tutti i valori del campo dato1, a condizione che l'operazione sia possibile sul tipo di dato SELECT AVG(dato1) FROM tabella1 Restituisce la media i valori del campo dato1, a condizione che l'operazione sia possibile sul tipo di dato SELECT MAX(dato1) FROM tabella1 Restituisce il massimo dei valori del campo dato1 a condizione che sul dato sia possibile eseguire l'operazione di ordinamento. SELECT MIN(dato1) FROM tabella1 Restituisce il minimo dei valori del campo dato1 a condizione che sul dato sia possibile eseguire l'operazione di ordinamento. SELECT COUNT(*) FROM tabella1 WHERE data1=5 Questa operazione restituisce il numero di record che soddisfano la condizione imposta. Ovviamente le funzioni viste possono essere combinate tra loro come SELECT MAX(dato1), MIN(dato1), AVG(dato1) FROM tabella1 che restituisce il massimo, il minimo e la media di dato1 Effettuare cancellazioni: l'istruzione DELETE DELETE FROM tabella1 WHERE dato1=5 In questo modo vengono cancellati tutti i record della tabella tabella1 nei quali vera la condizione che dato1=5. Se non si utilizza la clausola WHERE vengono cancellati tutti i record della tabella. Effettuare inserimenti: l'istruzione INSERT INSERT INTO tabella1 (dato1, dato2, dato3) VALUES (valore1, valore2, valore3) Inserisce nella tabella tabella1, nei campi dato1, dato2, dato3 i valori specificati all'interno della parentesi dopo la parola chiave VALUES. Effettuare aggiornamenti: l'istruzione UPDATE UDPATE tabella1 SET dato1 = nuovo_valore WHERE dato1=5 Pone uguali al nuovo valore il campo dato1 di tutti i record di tabella1 che soddisfano la condizione stabilita. Se non viene specificata nessuna condizione l'aggiornamento viene eseguito su tutti i record della tabella. Per tutte le altre istruzioni del linguaggio (JOIN, GROUP BY, HAVING, IN...) rimandiamo al corso dedicato all'SQL.

Manuale JSP