|
Cosa
sono le "Tag Libraries" ?
Le
librerie di tag sono uno strumento messo a disposizione
dalle specifiche JSP 1.1 che permette di costruire
contenitori di tag JSP, e cioè contenitori
di componenti con funzionalità riutilizzabili.
Ma, a questo punto, è lecito chiedersi: Non
è per questo che sono stati introdotti i JavaBeans
? Chiaramente, la risposta è che JavaBeans
e Tag JSP hanno funzionalità e contesti di
utilizzo in generale diversi.
Entrambi, sono componenti Java che permettono di incapsulare
codice riutilizzabile; vediamo però quando
è più opportuno utilizzare gli uni oppure
gli altri.
I JavaBeans server-side, sono componenti non visuali,
e generalmente, vengono destinati al mantenimento
di informazioni di sessione ( Es. lo stato dell'utente
all'interno di un' oggetto User, oppure un carrello
degli acquisti nel caso di applicazioni di e-commerce).
I Tag JSP possono interagire con la pagina e si tende
ad utilizzarli per incapsulare funzionalità
di generazione dinamica di HTML (p.es. la tabella
HTML di visualizzazione del carrello degli acquisti)
oppure di controllo del percorso di navigazione in
base alle informazioni di sessione (p.es. il controllo
del login da inserire in cima alle pagine personali
del sito).
Una delle differenze chiave tra Tag JSP e JavaBeans
consiste nella maggiore interazione che i Tag hanno
con il contesto (la pagina, ma anche l'application
server (tramite l'oggetto ServletContext)) all'interno
del quale vengono utilizzati. Possono utilizzare questa
interazione per accedere ad informazioni di sessione,
per fare uso di JavaBeans contenenti informazioni
sullo stato attuale dell'utente e/o dell'applicazione
e per accedere a risorse esterne come i file.
In
sostanza, i Tag JSP possono:
- Essere
customizzati tramite attributi passati dalla pagina
chiamante* sia staticamente che con valori calcolati
dinamicamente;
- Ottenere
l'accesso a tutti gli oggetti disponibili nelle
pagine JSP come request, response ed out;
- Modificare
la risposta generata dalla pagina chiamante*;
- Comunicare
con altri Tag, creare ed inizializzare componenti
JavaBean, modificare un bean in un tag e poi riutilizzarlo
in un altro tag;
- Essere
nidificati l'uno con l'altro
- Incapsulare
caratteristiche sia semplici che complicate attraverso
una sintassi facile da usare e che semplifica enormemente
la leggibilità di una pagina JSP
(*)N.B.
Per pagina chiamante, intendiamo la pagina JSP all'interno
della quale vengono inseriti
La composizione di un libreria di
Tag (Tag Library)
Una Tag Library, è costituita da due componenti:
un Tag Library descriptor (TLD File) ed il Tag Handler
(la classe Java che ne implementa le funzionalità)
Il file TLD
Un file TLD è un documento XML che descrive
la libreria. Contiene informazioni riguardanti sia
la libreria nel suo complesso che il singolo tag.
Viene utilizzato dal JSP container per effettuare
la validazione dei tag. Tipicamente, troveremo un'intestazione
seguita da elementi di definizione globale della libreria;
tali elementi sono:
- <taglib>
La libreria
- <tlibversion>
La versione della libreria
- <jspversion>
Le specifiche JSP sulla quale la libreria si basa
- <shortname>
Un nome di default semplice e mnemonico. Lo shortname
può essere usato per esempio come prefisso
per i tag contenuti
- <uri>
Una URI opzionale che identifichi univocamente la
libreria
- <info>
Informazioni descrittive sulla libreria
Successivamente,
viene descritto ogni tag contenuto nella libreria.
Una libreria, può contenerne uno o più;
l'unico elemento richiesto obbligatoriamente per ogni
tag ( mi sembra abbastanza ovvio) è la classe
che lo implementa (Handler) inclusa nell'elemento
<tagclass>
Chiaramente, ci sono vari altri elementi utilizzati
per la descrizione di un tag. Se ci sono degli attributi
associati, per ogni attributo, avremo, all' interno
dell'elemento <tag> un elemento del tipo:
<attribute>
<name>tagname</name>
<required>true/false</required>
<rtexpvalue> true/false </rtexpvalue>
</attribute>
Nella
classe "handler", vanno definiti metodi
get/set relativi ad ogni attributo specificato con
le stesse convenzioni usate nei JavaBeans.
Un esempio concreto
Passiamo adesso ad analizzare un esempio concreto
dell'utilizzo di questa tecnologia; Prenderemo in
esame semplice tag che implementa il classico esempio
"Hello World" rivisitato con custom tag.;
successivamente mostreremo come effettuare il deployment
all'interno dell'application server e come utilizzarlo
all'interno delle pagine.
L'Application Server utilizzato per l'esempio è
l'implementazione di riferimento delle specifiche
Servlet/JSP, Tomcat dell'Apache Group ( http://jakarta.apache.org
) ; l'esempio seguente è stato testato sulla
versione 4.0. Per evitare di creare una nuova applicazione,
installeremo ed utilizzeremo il nostro componente
all'interno dell'applicazione di esempio situata nella
directory webapps/examples all'interno del percorso
di installazione di Tomcat (TOMCAT_HOME). Partiamo
dal file TLD per che chiameremo mokalib.tld; il file
deve essere salvato nella directory %TOMCAT_HOME%/webapp/examples/WEB-INF:
<?xml version="1.0" encoding="ISO-8859-1"
?>
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems,
Inc.//DTD JSP Tag Library 1.1//EN"
"http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">
<taglib>
<tlibversion>1.0</tlibversion>
<jspversion>1.1</jspversion>
<shortname>mokalib</shortname>
<uri>http://www.mokabyte.it/taglib</uri>
<info>Mokabyte: Esempio di Tag Library</info>
<!--Un semplice Tag -->
<tag>
<name>wellcome</name>
<tagclass>mokabyte.examples.Wellcome </tagclass>
<!--Body content può avere I seguenti valori:
empty: no body
JSP: Il contenuto di body è valutato dal container
e processato dal Tag Handler
tagdependent: : Il contenuto di body viene processato
solo dal Tag Handler; il codice JSP contenuto in body
non viene valutato dal container .
-->
<bodycontent>empty</bodycontent>
<info>
Il
classico esempio "Hello World" rivisitato
con I Tag.
</info>
<attribute>
<name>name</name>
<required>false</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
</taglib>
Il TAG HANDLER
Il tag viene definito in una classe denominata Handler
che estende la classe base astratta TagSupport. Sarà
chiaramente necessario implementare i metodi non implementati
nella classe astratta e fornire i metodi get/set relativi
alle proprietà che vogliamo attribuire al nostro
oggetto Tag. In sostanza:
Nel
nostro caso, avremo una sola proprietà name
e quindi dovremo implementare i 4 metodi doStartTag,
doEndTag, setName(String value), getName(). Passiamo
adesso ad analizzare il codice Java corrispondente:
Chiamiamo il file Wellcome.java.
Una volta compilato, verrà generato il file
%OUTDIR%/mokabyte/examples/Wellcome.class.
Sarà
necessario copiare l'intera struttura in
%TOMCAT_HOME%/webapp/examples/WEB-INF/classes
affinchè
sia disponibile nel classpath della applicazione examples
di TOMCAT.
package
mokabyte.examples
import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.*;
// Un semplice esempio di Tag JSP per comprendere
cosa viene
// inserito
nello output streamquando il Tag viene inserito
// in una pagina JSP.
public class Wellcome extends TagSupport {
private String name=null;
// Metodi get/set per l'attributo
name come definito nel
// file .tld per questo TAG
public void setName(String value){
name = value;
}
public String getName(){
return(name);
}
// doStartTag viene chiamato dal
JSP container quando
// il TAG viene trovato.
public int doStartTag() {
try {
JspWriter
out = pageContext.getOut();
out.println("<table
border=\"1\">");
if
(name != null)
out.println("<tr><td>
Benvenuto/a " + name
+ "</td></tr>");
else
out.println("<tr><td>
Benvenuto a chi? </td></tr>");
}
catch
(Exception ex) {
throw
new Error("Qualcosa è andato storto.");
}
// Dovrò
ritornare SKIP_BODY perché comunque il body
è vuoto
// come è
stato specificato nel file TLD.
return SKIP_BODY;
}
// doEndTag() viene chiamato dal JSP container quando
viene
// trovato il segno di chiusura
del tag
public int doEndTag(){
try {
JspWriter
out = pageContext.getOut();
out.println("</table>");
}
catch
(Exception ex){
throw
new Error("Qualcosa è andato storto.");
}
}
}
Registrazione
della libreria
L'operazione di registrazione della libreria, permette
di comunicare all' Application Server la uri (in realtà
è sufficiente una URI qualsiasi purché
univoca) e la locazione del file TLD associati con
la libreria.
Nel file web.xml, inseriamo il testo seguente alla
sezione <taglib>:
<taglib>
<taglib-uri>
http://www.mokabyte.it/taglib
</taglib-uri>
<taglib-location>
/WEB-INF/mokalib.tld
</taglib-location>
</taglib>
Scriviamo la pagina wellcome.jsp
<%@
taglib uri="http://www.mokabyte.it/taglib"
prefix="moka" %>
<html>
<head>
<title>Il mio primo Tag JSP</title>
</head>
<body bgcolor="#ffffff">
<hr />
<moka:wellcome name="Michele"/>
<hr />
</body>
</html>
Salviamo
la pagina Wellcome.jsp in
%TOMCAT_HOME%/webapp/examples/.
e proceidamo a far partire l'application Server Tomcat.
Se tutto è andato bene, potrete vedere l'output
alla url
http://localhost:8080/examples/wellcome.jsp
.
Facendo click destro sul browser ed andando a visualizzare
il sorgente HTML, il risultato dovrebbe essere il
seguente
<html>
<head>
<title> Il mio primo Tag JSP </title>
</head>
<body bgcolor="#ffffff">
<hr />
<table border="1">
<tr><td> Benvenuto Michele.</td></tr>
</table>
<hr />
</body>
</html>
Conclusioni
In questo primo articolo , abbiamo introdotto le librerie
di TAG JSP, andando ad analizzare un primo esempio
dell'utilizzo di questa tecnologia. Questo ci ha permesso
di individuare i passi base da compiere per sviluppare
ed utilizzare questi componenti.
Il passo successivo, sarà quello di integrare
le nuove funzionalità nelle nostre applicazioni;
l'obiettivo deve essere quello di incapsulare all'interno
dei tag JSP delle funzionalità di visualizzazione
e rappresentazione dei dati. Quante volte abbiamo
fatto un ciclo per visualizzare una tabella di un
database in una pagina HTML? Perché non farlo
una volta per tutte? Per chi conosce altri linguaggi,
vedremo come sia possibile realizzare per esempio
un componente di visualizzazione di query SQL o di
archivi in formato XML, che magari gestisca anche
la paginazione e l'ordinamento
|
