• Cosa è JSP
• Il Container JSP

• Le Direttive
• Scriplet e Azioni

• Gli Oggetti Impliciti
• Le Sessioni

• I JavaBeans
• Il Multithreading

JSP è acronimo di JavaServerPages. La tecnologia JSP viene presentata nel 1998 a San Francisco (USA) in occasione della manifestazione Java One organizzata dalla Sun MicroSystem inc.
JSP utilizza codice Java per creare dinamicamente pagine HTML. Un componente operante sul server chiamato Container si occupa di tradurre le pagine JSP in servlets. Le pagine JSP ereditano tutti i vantaggi dei servlet e quindi sono migliori dei programmi CGI in termini prestazionali perché sono persistenti in memoria e perché permettono il multithreading. Una pagina JSP (nome.jsp) può essere vista come la fusione di parti codice Java e HTML statico e creato dinamicamente. Il paradigma ‘write once, run anywhere’ viene esportato nel Web.
I vantaggi di JSP.
Portabilità. - Completamente multi-piattaforma. Con JSP l’implementazione di applicativi lato server è svincolata dal tipo di sistema operativo e non necessita di modifiche per adeguarsi a server diversi. Basta il solito plug-in Java.
Portabilità lato client. Il codice Java viene interpretato dal server che genera il codice HTML necessario, quindi il browser si limita ad interpretare codice HTML. Non richiedono alcuna impostazione sul client.
Supportato da numerosi Application Server.
Utilizzo di un linguaggio globale quale Java come linguaggio per gli scriptlet.
Riutilizzo del codice. E’ possibile includere, nelle pagine JSP, Javabeans. Miglioramento della modifica e della manutenzione delle pagine.
Aderenza alla piattaforma J2EE perfettamente integrata con JSP.
Persistenza in memoria. Multithreading. Una sola istanza dell'applicazione è presente in memoria, un thread sarà allocato in memoria per ogni richiesta successiva.
Le pagine JSP sono compilate, garantendo generalmente delle ottime prestazioni. Il server compila automaticamente le pagine quando necessario.
Servlet e JSP
L’utilità delle servlet non è messa in discussione. Le pagine JSP sono una evoluzione dei servlet Java. Dal punto di vista architetturale ne sono una astrazione di alto livello.
Anche un servlet è in grado di generare HTML dinamicamente, ma JSP fa una passo in avanti. Le JSP, infatti, costituiscono un insieme di codice HTML, JavaBeans (componenti riusabili), Servlets (applicazioni remote), codice pure-Java, script Java-Like. Sebbene una pagina JSP sia in definitiva trasformata in un servlet, la presenza di elementi di programmazione differenti permette di diversificare i compiti (separazione dei contenuti dalla rappresentazione), rendendo più facile la creazione e la manutenzione di un sito Web.

Il compito del Container è quello di trasformare una pagina .jsp in un servlet Java. Quando un client richiede una pagina .jsp il container determina il nome della classe corrispondente e determina se esiste o se deve essere ricompilata a causa di aggiornamenti effettuati dallo sviluppatore, crea il servlet (sorgente .java) corrispondente alla pagina e lo compila (.class). Successivamente carica la classe del servlet, crea un’istanza sul server e un thread per gestire la richiesta.
Java Server Page (.jsp) --> Java Source Code (.java) --> Java Servlet (.class).
Guarda l'esempio "una semplice pagina JSP"

Le direttive sono istruzioni per il Container JSP.
Direttive standard nella specifica JSP 1.1
- page
-include
-taglib
La direttiva Page.
Specifica gli attributi della pagina JSP, ciò influisce sulla compilazione della pagina.

language: specifica il linguaggio usato negli scriplet e nelle dichiarazioni.
i mport: specifica uno o più nomi di package importati nel servlet.
session: true se la pagina JSP richiede una sessione JSP, in questo caso il servlet conterrà il codice necessario per crearla.
isThreadSafe: true se la pagina è in grado di gestire più richieste provenienti da diversi thread.
errorPage: specifica l’URL di una pagina designata a gestire un’eccezione raccolta.
isErrorPage: true se è designata a gestire eccezioni attraverso la variabile implicita Exception.
La direttiva include.
Specifica un file il cui contenuto deve essere aggiunto allo stream di input prima che la pagina sia compilata.
La direttiva taglib.
Consente azioni personalizzate grazie al caricamento di librerie di tags.
Guarda l'esempio "la direttiva include"

Le espressioni
Le espressioni contenute nelle pagine JSP sono espressioni Java di qualsiasi complessità. Possono calcolare semplici valori, chiamare metodi e creare oggetti.

Gli Scriptlet
Uno scriplet è un insieme di istruzioni Java deleimitato dai tags:

Tutto ciò che si torva tra i delimitatori viene copiato senza modifiche all’interno del metodo _jspService( ) del servlet generato a differenza del codice HTML.

Le dichiarazioni
Una dichiarazione è un insieme di codice Java. La differenza fondamentale rispetto ad uno scriplet è che tale codice viene inserito all’esterno del metodo _jspService( ) come membro di alto livello della classe più generale.

Le variabili contenute in una dichiarazione diventano variabili di istanza. Le stesse variabili contenute in uno scriplet sarebbero inserite all’interno del metodo _jspService( ) e sarebbero locali a tale metodo.
Le dichiarazioni non possono accedere agli oggetti impliciti. E' possibile farlo in maniera indiretta passando gli oggetti come parametri. Di solito vengono utilizzate per dichiarare variabili, metodi o classi interne.
Le azioni
Alcune azioni standard JSP:
All'interno dei tags
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:include page=" " flush="true" / permette di includere risorse aggiuntive di tipo sia statico che dinamico.
jsp:forward page= " " / consente di inviare una pagina ad un’altra pagina.La pagina corrente viene chiusa e la nuova pagina ha accesso agli oggetti della richiesta e della risposta. La pagina che contiene l’azione può passare parametri inserendoli nella richiesta request.setParameter(forward.nome_pagina, parametro). Consente di ottenere la separazione tra contenuto e presentazione.

Gli oggetti impliciti permettono l’accesso all’ambiente operativo JSP, vengono creati nel metodo _jspService() e forniscono il contesto in cui viene servita la richiesta.
HttpServletRequest
La variabile request contiene il riferimento a questo oggetto passato come parametro al metodo _jspService(). Permette di accedere ai dettagli della richiesta HTTP.
String getParameter(String nome)
Enumeration getHeaderNames( )
String getHeader(String nome)
Enumeration getHeaderNames( )
HttpSession getSession(boolean create)
HttpServletResponse.
La variabile response contiene il riferimento a questo oggetto che incapsula l’output restituito al client e permette di impostare le intestazioni e il codice di stato della risposta.
boolean isCommitted( )
void setHeader(String nome, String value)
void setStatus(int s)
PageContext.
Questo oggetto rappresenta il contesto di esecuzione del servlet creato dalla pagina JSP.
Session.
Questo oggetto rappresenta una delle soluzioni fornite all’assenza di stato del protocollo HTTP. Una sessione http è una oggetto HASHTABLE inizializzato nel metodo _jspService( ).
session.setAttribute("nomeUtente", nome) all’ingresso del client nella pagina
session.getAttribute("nomeUtente") restituisce il nome
Application.
Questo oggetto incapsula le risorse che fanno parte di una applicazione Web e consente di accedere alle informazioni dell’applicazione (versione del server, percorsi assoluti delle risorse, etc.) visibili da ogni utente e da ogni pagina.
application.setAttribute("visite",”0”)
application.getAttribute("visite")
Out.
Questo oggetto permette la stampa del contenuto, sia esso HTML o espressioni JSP.
out.println(...)
Config.
Questo oggetto permette di gestire i parametri di inizializzazione dei singoli servlet.
String getInitParameter(String nome) valore del parametro specificato.
Enumeration getInitParameterNames( ) elenco dei parametri di inizializzazione.
ServletContext getServletContext( ) riferimento al contesto del servlet.
Exception.
Questo oggetto, accessibile solo nelle pagine di errore, contiene le informazioni reletive all’eccezione.
getMessage() restituisce una stringa con la descrizione dell'errore.
Guarda l'esempio "gestione di una richiesta"

Un servlet dichiara di volere utilizzare una sessione attraverso la chiamata al metodo: HttpSession session = request.getSession(true).
Tale metodo restituisce un riferimento alla sessione che può essere utilizzato per memorizzare e prelevare gli attributi della sessione.
In Jsp la creazione di una sessione è automatica a meno che non si dichiari il contrario:

Una volta creato il codice della sessione viene inviato al client. Attraverso l’intestazione JSESSIONID nel cookie Set-Cookie. Set-Cookie: JSESSIONID= xxx; Il client restituirà il cookie durante le richieste successive (si connette alla sessione). Se il client non accetta il cookie bisogna utilizzare tecniche diverse come la riscrittura dell’indirizzo URL.
Il metodo isNew( ) permette di testare se il client è connesso.
if (session.isNew( ) { …}
I metodi setAttribute e getAttribute vengono utilizzati per memorizzare e prelevare informazioni da una sessione.
session.setAttribute(“nome_utente”, userID);
session.setAttribute(“pwd_utente”, pwd);
String userID = (String) session.getAttribute(“nome_utente”);
String userID = (String) session.getAttribute(“pwd_utente”);
Un attributo non più necessario può essere eliminato dalla sessione.
session.removeAttribute(“nome_attributo”); Ci sono diversi modi per chiudere una sessione.

I JavaBean sono normali classi Java. Essi permettono tra gli altri:
- Riutilizzo di codice.
- Applicazioni complesse senza conoscenze profonde del linguaggio Java.
- Semplicità nella modifica e manutenzione delle pagine.
L’integrazione di JavaBeans all’interno di pagine JSP avviene attraverso tre azioni:
useBean, setProperty, getProperty
Una classe JavaBean richiede il soddisfacimento di soli due requisiti:
- un costruttore senza argomenti
- persistenza attraverso Serializable o Externalizable
All’interno delle pagine JSP i beans vengono utilizzati come vere e proprie raccolte di attributi detti proprietà, per i quali i beans stessi mettono a disposizione metodi per la lettura e per la scrittura.
getNomeProprietà, setNomeProprietà
La persistenza è garantita dal concetto di serializzazione. In tal senso un bean implementa l’interfaccia Serializable o Extrnalizable.
L'azione

associa l’istanza di un JavaBean ad una variabile script.
id è una variabile script dichiarata all’interno della pagina JSP utilizzata per accedere alle proprietà del bean.
scope ne gestisce la visibilità:
page, request, session, application
L'azione setProperty permette di impostare il valore delle proprietà di un bean.

name identifica il JavaBean (id), property è una proprietà del JavaBean per la quale ci sarà un metodo set.
L’azione getProperty ricava il valore di una proprietà dall’istanza di un bean e lo scrive sullo stream di output.

Un thread è un singolo flusso sequenziale di controllo all’interno di un processo con un proprio stack e un proprio program counter, capace di condividere con altri threads le risorse del processo stesso.
Un thread è un’istanza della classe Java java.lang.Thread.
La creazione e la gestione di un thread prevedono due metodi principali:
start( ) imposta le caratteristiche del thread e chiama automaticamente il metodo run.
run( ) esegue le operazioni.
La classe Thread
Public static void main(String[ ] args) {
…
Thread mythread = new simpleThread( );
myThread.setName(“firstThread”);
myThread.start( );
…
}
public class simpleThread extends Thread {
public simpleThread {
System.out.println(“Avvio un thread”);
}
public void run( ) {
try {
…
sleep(100);
} catch (Interrupted Exception e) {
break;
}
…
} //run
}
Combinare il thread con la main class: Runnable.
public class myClass implements Runnable {
public myClass {
Thread myThread_1 = new Thread(this);
myThread_1.start( );
Thread myThread_2 = new Thread(this);
myThread_2.start( );
}
…
public void run( ) {
…
}
public static void main(String[ ] args) {
new myClass( );
}
}
Sincronizzazione.
Java fornisce una soluzione per proteggere sezioni critiche dall’esecuzione contemporanea di più thread.
Sincronizzare un metodo o parte del suo codice.
Soltanto un thread per volta può accedere ad un metodo o ad un blocco sincronizzato.
synchronized void myFunction ( ) { … }
synchronized(this) {
// sezione critica
}
Una sincronizzazione troppo forte può degenerare le prestazioni.
JSP fornisce due modelli di gestione dei thread:
Standard.
Thread multipli eseguono una istanza del servlet. La servlet engine si preoccupa di assegnare le risorse ai thread. Le variabili di istanza devono essere protette (è preferibile che siano di sola lettura).
Monothread.
Un servlet ha più istanze ognuna delle quali esegue un proprio thread.
//implementa l’interfaccia SingleThreadModel.
Le variabili di istanza sono preservate.