Qualche articolo fa, ci siamo occupati di spiegare i vantaggi portati dal passaggio della versione Java da 1.4 a 1.5, parlando in particolar modo di Java Annotations. In questo articolo ci occuperemo di un altro passaggio tecnologico molto importante, portato avanti nello stesso periodo dai guru della Sun, nella tecnologia utilizzata per la produzione delle interfacce grafiche nelle applicazioni Web, le JSP.
Il salto dalla versione 1.2 alla versione 2.0 ha portato una serie di novità e un grande beneficio alla produzione di codice, in particolar modo con l'integrazione di un altro strumento, le EL JSTL (Expression Language Jsp Standard Tag Library), molto utilizzato da chi sviluppa in questo campo.
Le EL JSTL (nella loro prima versione, accanto alle JSP 1.2) erano delle librerie con una serie di custom tag utilizzati per la gestione di elementi tipici nelle interfacce grafiche. La presenza di tag estesi rendeva molto più integrato lo sviluppo di codice (X)HTML, ad esempio introducendo semplici comandi per il controllo del flusso (if, for, while, assegnazioni, ...) o comandi per ispezionare lo stato dei Javabean contenuti nella pagina. Essendo uno strumento "terzo" rispetto allo standard JSP, queste librerie dovevano essere opportunamente dichiarate ed importate nell'applicazione. La procedura è la stessa di quello che abbiamo visto nell'articolo dedicato allo sviluppo di un custom tag personalizzato, in quanto proprio di custom tag si trattava.
Il passaggio alla versione 2.0 integra direttamente le EL JSTL e in questo articolo vedremo come poterle utilizzare in maniera facile e immediata. Il beneficio principale dall'introduzione di questo strumento è quello di avere un codice nelle interfacce Web molto più leggibile (come sempre quando parliamo di estensioni dell'HTML) e praticamente fruibile anche dal Web designer. Inoltre l'integrazione nel linguaggio nativo rende lo stesso linguaggio molto più potente ed espressivo con la possibilità di gestire le proprietà della pagina direttamente.
Per poter utilizzare i benefici delle JSP 2.0 è necessario che il container implementi la specifica (Tomcat 5 è la prima versione di questo Web server a supportarla). Per dovere di cronaca diciamo che la versione attuale delle JSP è la 2.1.
Utilizzare le Expression Language integrate nelle JSP
Come introduzione al linguaggio delle EL, vediamo un semplicissimo esempio di quello che veniva fatto prima dell'integrazione:
Listato 1. Semplice esempio del vecchio modo di lavorare
<%@ taglib prefix="c" ...%>
...
<p>
Il valore del parametro x del bean y è <c:out value="${y.x}"/>
</p>
Attraverso questo custom tag veniva fatta la stampa del contenuto del metodo y.getX(). Per fare ciò dovevamo importare il custom tag ed installare la libreria all'interno della nostra applicazione. Non una procedura particolarmente difficile, ma comunque una gestione ed anche un apprendimento della sintassi di ogni tag non immediato.
Attraverso l'integrazione delle EL nelle JSP 2.0, il tutto si traduce in maniera molto più immediata:
Listato 2. Stesso esempio precedente con le EL
<p>
Il valore del parametro x del bean y è ${y.x}
</p>
Come vediamo non c'è più nessuna dichiarazione, e la sintassi delle espressioni è integrata nelle JSP. Inoltre, come vediamo dall'elenco che segue, possiamo richiamare una serie di campi standard all'interno della nostra pagina con un evidente beneficio in termini di rapidità di produzione del codice JSP.
- pageScope;
- requestScope;
- sessionScope;
- applicationScope;
- param;
- paramValues;
- header;
- headerValues;
- cookie;
- initParam;
- pageContext.
Tutti questi elementi, tranne l'ultimo (che è un javax.servlet.jsp.PageContext) restituiscono un riferimento a un java.util.Map, che rappresenta una collezione di attributi specifici.
I primi quattro si riferisco allo scope, cioè al livello che vogliamo utilizzare, rispettivamente pagina, richiesta, sessione e applicazione. Poi avremo un riferimento ai parametri, agli header e ai cookies. Quindi, per fare un esempio, se in una ideale pagina helloWorld.jsp passiamo il parametro nome (../helloWorld.jsp?nome=Pasquale), la pagina potrà presentarsi come di seguito:
Listato 3. Semplice pagina Hello World
//helloWorld.jsp
<html>
...
<body>
<h1>
Hello World Mr ${param.nome}!
</h1>
</body
</html>
La stampa a video sarà proprio "Hello World Mr Pasquale !" o in generale il risultato del parametro passato nella query string.
Non a caso è stato scelto come esempio il tipo param, in quanto come spesso accade, sono questi gli elementi maggiormente utilizzati per la gestione dinamica delle pagine di una applicazione Web based. Allo stesso modo, utilizzando gli elementi listati in precedenza, sarà altresi facile accedere agli attributi di sessione, di richiesta, i cookie o in generale tutto ciò a cui potete accedere dalla JSP.
Ovviamente potete manipolare tutto quanto contenuto all'interno delle parentesi graffe (cioè all'interno dell'espressione) in maniera tradizionale, quindi con gli operatori matematici o quelli di confronto ( ad esempio ${ prezzo + 10} restituirà il valore della variabile prezzo sommata 10).
Un altro costrutto che sicuramente utilizzerete molto è l'if ternario, applicato alle EL:
Listato 4. Piccolo esempio dell'if ternario
<select name="squadra">
<option value="1" ${param.squadra == 1 ? 'selected' : ''}>
Juventus
<option value="2" ${param.squadra == 2 ? 'selected' : ''}>
Milan
<option value="3" ${param.squadra == 3 ? 'selected' : ''}>
Internazionale
...
</select>
L'operatore di uguaglianza == darà un valore booleano, quindi, in generale potranno essere utilizzati gli operatori di confronto (>,<, ecc) o i metodi che restituiscono un booleano (${aBean.check() ? 'selected' : ''}).
Il componente select setterà l'attributo in base al parametro passatogli dalla pagina precedente in maniera dinamica e utilizzando il costrutto di controllo molto semplicemente, e il risultato sarà la selezione dell'elemento scelto nella fase precedente.
Altre caratteristiche di JSP 2.0
Altre importanti innovazioni nella specifica 2.0 riguardano la gestione degli errori e la presenza di nuove regole per la creazione del descrittore di deploy. Per maggiori dettagli potete approfondire il discorso con le tante risorse reperibili sul sito ufficiale della Sun.
La prima caratteristica riguarda una gestione molto più avanzata delle eventuali eccezioni nelle pagine JSP e degli eventi per effettuarne il logging o per gestirli più nello specifico.
La configurazione del nuovo web.xml passa dalla presenza di un DTD alla presenza di un XML Schema che ne definisce le regole formali. Lo schema aggiunge più rigore alla formattazione del documento, permettendo quindi una gestione più precisa dei tag xml. In generale, però questa cosa non influenza in maniera diretta lo sviluppo delle applicazioni, in particolar modo se consideriamo che la gestione di questi documenti viene svolta dai tool di sviluppo.
