7 custom tags. Marco Tessarotto Programmazione dei Web Server Anno Accademico

Transcript

1 7 custom tags Marco Tessarotto Programmazione dei Web Server Anno Accademico

2 Custom Tags Abbiamo visto i tag (azioni) standard JSP(jsp:useBean, jsp:setproperty, jsp:include ) La tecnologia JSP prevede un meccanismo per incapsulare altre funzionalità nella scrittura di pagine JSP tramite i custom tags (elementi personalizzati) [sintassi XML] Consentono di separare le attività di sviluppo delle library dallo sviluppo dell interfaccia utente; riutilizzo del codice; possono incapsulare codice nascondendone la complessità Portabili: indipendenti dall implementazione del container 2

3 Custom Tags/2 Esempi di applicazione dei custom tags: Operazioni su database Elaborazioni condizionate e/o iterazioni (If/Then/Loop) Validazione di web form Elaborazione di sessione, parametri di web form 3

4 Custom Tags/3 Custom tag: estensione del linguaggio JSP definita dall utente Al momento della traduzione in servlet, il tag è convertito in codice che opera su un oggetto chiamato tag handler Posso passare parametri attraverso gli attributi [invece con JavaBeans uso jsp:setproperty] Possono accedere agli stessi oggetti disponibili nella pagina JSP Possono intervenire sulla risposta [response] 4

5 Custom Tags/4 Possono comunicare tra di loro Possono essere annidati tra di loro per farli interagire tra loro I custom tag sono raccolti in tag libraries Definizione tag library: raccolta di azioni JSP che incapsulano delle funzionalità da utilizzare nelle pagine JSP. 5

6 Usare i tags È necessario: 1. Dichiarare la tag library che implementa i tag 2. Rendere disponibile all applicazione web la tag library <%@ taglib uri= taglibraryuri prefix= tagprefix %> L attributo uri specifica un URI relativo o assoluto che identifica univocamente il descrittore della tag library (Tag Library Descriptor) La direttiva va inserita prima di utilizzare i tag 6

7 Usare i tags/2 Se il JSP container non trova il descrittore, errore di traduzione La stringa tagprefix definisce il prefisso da utilizzare nella scrittura dei tag (prefix:tagname) Ogni Tab Library è descritta tramite il Tag Library Descriptor (TLD); è un documento XML 7

8 Usare i tags/3 Esempio [template5, caltag.jsp]: 1. TLD [taglib61.tld] va messo in <proj>\web\web- INF 2. JAR [caltag.jar] (contiene le classi che implementano la tag library) va messo in <proj>\web\web-inf\lib; [altrimenti WEB- INF\classes] Quando richiamo la tag library con la direttiva taglib, posso specificare l URI in due modi: 1. Direttamente: <%@ taglib uri="/web-inf/taglib61.tld" prefix="cal" %> 8

9 Usare i tags/4 Oppure: <%@ taglib uri="/taglib61" prefix="cal" %> Specificando in web.xml: <taglib> <taglib-uri>/taglib61 </taglib-uri> <taglib-location> /WEB-INF/taglib61.tld </taglib-location> </taglib> 9

10 Usare i tags/5  <%@ taglib uri="/taglib61" prefix="cal" %>   <html><body> Current Month: <cal:calendar /> </body></html> 10

11 Tipi di tag I tag sono scritti seguendo la sintassi XML; devono un tag di inizio ed uno di fine, e possono avere attributi, un body; esempi: <cal:calendar /> <cal:calendar month="3" year="2002" /> <mialib:miotag> corpo </mialib:miotag> Tag semplice: senza corpo, senza attributi È possibile passare informazioni tramite attributi o tramite il corpo del tag 11

12 Tag library

13 Tag library Per definire un custom tag, è necessario: Sviluppare un tag handler (gestore del tag) e le classi necessarie Dichiarare il tag nel descrittore (TLD) Il tag handler è un oggetto invocato dal container per eseguire il custom tag durante l esecuzione della pagina JSP dove è referenziato il tag Il tag handler implementa l interfaccia javax.servlet.jsp.tagext.tag oppure javax.servlet.jsp.tagext.bodytag 13

14 Tag library/2 In alternativa, la classe del tag handler può estendere la classe javax.servlet.jsp.tagext.tagsupport oppure javax.servlet.jsp.tagext.bodytagsupport I metodi della classe che implementa il tag handler sono chiamati dalla servlet della pagina JSP in vari punti durante l esecuzione del tag. 14

15 Tag handler Definizione di un nuovo tag: partiamo dalla classe Java che lo implementa La classe deve implementare l interfaccia javax.servlet.jsp.tagext.tag; questo si effettua estendendo la classe TagSupport o BodyTagSupport Una volta scritta la classe, occorre specificare nel descrittore l associazione tra classe e descrittore Nella pagina JSP: richiamare la library tramite direttiva taglib 15

16 Esempio tag class package corsows.tags; import javax.servlet.jsp.*; import javax.servlet.jsp.tagext.*; import java.io.*; public class SimpleTag extends TagSupport { public int dostarttag() { try { JspWriter out = pagecontext.getout(); out.print("custom tag example " +"(corsows.tags.simpletag)"); } catch(ioexception ioe) { System.out.println("Error in SimpleTag: " + ioe); } return(skip_body); } } 16

17 Esempio descrittore tag <?xml version="1.0" encoding="iso "?> <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" " <taglib> <tlib-version>1.0</tlib-version> <jsp-version>1.2</jsp-version> <short-name>customtag1</short-name> <tag> <name>simpletag</name> <tag-class>corsows.tags.simpletag</tag-class> <body-content>jsp</body-content> <attribute> <name>par1</name> <required>false</required> <rtexprvalue>true</rtexprvalue> </attribute> </tag> </taglib> 17

18 Esempio pagina JSP <html> <body> <H1>Custom tag test</h1> taglib prefix="corsosw" uri="/web-inf/customtag1.tld" %> <! oppure uri= /corsows --> <corsosw:simpletag /> </body> </html> 18

19 Implementazione di un tag Definiamo un custom tag senza attributi e senza corpo; tag del tipo: <prefix:tagname /> Estendiamo la classe javax.servlet.jsp.tagext. TagSupport Importiamo il package javax.servlet.jsp.tagext.* per estendere la nostra classe Importiamo javax.servlet.jsp.* per poter utilizzare gli oggetti impliciti delle pagine JSP Riscriviamo il metodo dostarttag, che viene chiamato al momento dell esecuzione quando si incontra il tag d inizio dell elemento 19

20 Traduzione del tag /* ---- corsosw:simpletag ---- */ corsows.tags.simpletag _jspx_th_corsosw_simpletag_0 = new corsows.tags.simpletag(); _jspx_th_corsosw_simpletag_0.setpagecontext(pagecontext); _jspx_th_corsosw_simpletag_0.setparent(null); try { int _jspx_eval_corsosw_simpletag_0 = _jspx_th_corsosw_simpletag_0.dostarttag(); // end // begin [file="/customtag1.jsp";from=(5,0);to=(5,21)] if (_jspx_th_corsosw_simpletag_0.doendtag() == javax.servlet.jsp.tagext.tag.skip_page) return; } finally { _jspx_th_corsosw_simpletag_0.release(); } 20

21 Implementazione di un tag/2 Per generare output, occorre ottenere un JspWriter tramite pagecontext.getout() [vedi oggetto implicito out] TagSupport ha un campo pagecontext tramite il quale si può avere accesso agli oggetti impliciti della pagina JSP che richiama il tag (out, request, response, session ) Siccome i metodi print di JspWriter possono lanciare una eccezione IOException, occorre incapsulare il codice in un blocco try/catch Se il nostro dostarttag vuole passare un eccezione alla pagina, usare JspException 21

22 Implementazione di un tag/3 Se il tag non ha corpo, allora dostarttag deve restituire la costante SKIP_BODY (un eventuale corpo del tag viene ignorato) Vediamo la classe javax.servlet.jsp.tagext.tagsupport Implementa le interfacce Tag, IterationTag, java.ioserializable protected PageContext pagecontext: consente di accedere a tutte le risorse accessibili dalla pagina JSP; settato tramite public void setpagecontext(pagecontext pc) 22

23 Implementazione di un tag/4 public int dostarttag() throws JspException: invocato dalla servlet della pagina JSP quando viene incontrato il tag iniziale dell elemento; default: restituisce SKIP_BODY (ignora i contenuti del corpo) Possibili valori che può restituire: EVAL_BODY_INCLUDE, EVAL_BODY_BUFFERED (valido solo per BodyTag): il corpo dell elemento va valutato SKIP_BODY: il corpo non va elaborato 23

24 Implementazione di un tag/5 public int doendtag() throws JspException: elabora il tag di chiusura; invocato dalla servlet della pagina JSP; può restituire: EVAL_PAGE: l elaborazione continua con il resto della pagina JSP SKIP_PAGE: il resto della pagina non viene elaborata e la richiesta è completata. Se la richiesta di elaborazione della pagina corrente avviene tramite forward o include, viene terminata solo l elaborazione della pagina corrente 24

25 Implementazione di un tag/6 public int doafterbody() throws JspException: invocato dopo l elaborazione del corpo; non viene chiamato se non c è il corpo; può restituire: EVAL_BODY_AGAIN: il corpo dell elemento va rielaborato ancora una volta SKIP_BODY: fine elaborazione corpo 25

26 Tag Library Descriptor documento XML con dichiarazione DOCTYPE: <?xml version="1.0" encoding="iso "?> <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" " L elemento root è <taglib>; per definire un custom tags, usare <tag> che deve contenere: <name>: nome del tag (come verrà richiamato nelle pagine JSP) <tagclass>: nome della classe Java che implementa il tag 26

27 Tag Library Descriptor/2 <bodycontent>: specifica come trattare il corpo del custom tag; EMPTY: ignorare il corpo (errore se presente); JSP: il corpo segue la normale elaborazione JSP; TAGDEPENDENT: il corpo viene elaborato dal custom tag Se il custom tag prevede attributi, all interno di <tag> usare <attribute> [vedremo tra poco] 27

28 Custom tags con attributi Custom tags del tipo: <prefix:tagname attribute1= value1 attribute2= value /> L uso degli attributi viene tradotto in chiamate a metodi della classe che implementa il tag attribute1 public void setattribute1(string ) Gli attributi vengono passati alla classe del custom tag prima dell esecuzione di dostarttag Esempio: immagazzinare gli attributi per la successiva elaborazione 28

29 Esempio tag con attributi public class AcapoTag extends TagSupport { private int numacapo = 0; public void setnum(string arg) { try { numacapo = Integer.parseInt(arg); } catch(numberformatexception nfe) { numacapo = 0; } } 29

30 Esempio tag con attributi/2 <tag> <name>acapo</name> <tag-class>corsows.tags.acapotag</tag-class> <body-content>empty</body-content> <attribute> <name>num</name> <required>true</required> <rtexprvalue>true</rtexprvalue> </attribute> </tag> 30

31 Custom tags con attributi/3 Per descrivere gli attributi di un custom tag, all interno di <tag> usare l elemento <attribute> con i seguenti elementi annidati: <name>: nome dell attributo <required>true/false</required> <rtexprvalue>true/false</rtexprvalue>: opzionale, default: false, specifica se il valore dell attributo può essere una espressione scriplet ovvero <%= expression %> 31

32 javax.servlet.jsp.tagext Torniamo alle interfacce di javax.servlet.jsp.tagext: [I] Tag: semplice gestore tag (tag handler) che non manipola il corpo del tag; principali metodi: dostarttag, doendtag; dopo la chiamata al costruttore, la pagina JSP chiama setpagecontext, setparent ed i setters degli attributi del tag [I] IterationTag: estende Tag definendo doafterbody che serve a controllare la rielaborazione del corpo del tag 32

33 javax.servlet.jsp.tagext/2 [I] BodyTag: estende IterationTag aggiungendo metodi per gestire l elaborazione del corpo; doinitbody: invocato dalla servlet della pagina JSP prima dell elaborazione del corpo del tag; non è chiamato se il tag è senza corpo o se dostarttag restituisce SKIP_BODY o EVAL_BODY_INCLUDE; è preceduto da una chiamata a: setbodycontent: invocato dalla pagina JSP per passare il corpo del custom tag. 33

34 javax.servlet.jsp.tagext/3 [I] BodyTag: se dostarttag restituisce EVAL_BODY_INCLUDE, allora l elaborazione avviene come in IterationTag; se restituisce SKIP_BODY, il corpo non viene elaborato; se restituisce EVAL_BODY_BUFFERED, si ha l elaborazione tramite BodyContent 34

35 Custom tags con corpo Custom tags del tipo: <prefix:tagname>body</prefix:tagname> Per utilizzare il corpo del custom tag, dostarttag deve restituire EVAL_BODY_INCLUDE oppure EVAL_BODY_BUFFERED Nel TLD, il tag deve avere l elemento <bodycontent> con corpo pari a JSP o TAGDEPENDENT, non EMPTY Se dostarttag restituisce EVAL_BODY_INCLUDE e se il tag ha corpo, allora viene invocato doafterbody 35

36 Manipolazione del corpo di un custom tag La classe che implementa il custom tag estende BodyTagSupport Utilizziamo doafterbody per gestire la manipolazione del corpo del tag, getbodycontent per accedere al corpo del tag (di tipo BodyContent, incapsula il contenuto) La classe BodyContent ha i metodi: getenclosingwriter: restituisce lo stesso oggetto JspWriter usato da dostarttag e doendtag getreader, getstring: restituiscono il corpo del tag [BoldTag.java] 36

37 BodyContent javax.servlet.jsp.tagext.bodycontent: estende javax.servlet.jsp.jspwriter Incapsula il corpo già elaborato di custom tag ovvero contiene il risultato di eventuali altre azioni incorporate public JspWriter getenclosingwriter(): restituisce il JspWriter incapsulato; necessario se si vuole modificare il corpo già elaborato public abstract java.lang.string getstring() 37

38 BodyContent/2 Passi per modificare il corpo elaborato del custom tag in doafterbody: 1. Chiamare getbodycontent() 2. Ottenere il contenuto: getstring() 3. Modificare il contenuto 4. Ottenere il JspWriter con getenclosingwriter 5. Scrivere il corpo modificato 38

39 BodyContent/3 public int doafterbody() { BodyContent body = getbodycontent(); String strbody = "<B>" + body.getstring() + "</B>"; try { JspWriter out = body.getenclosingwriter(); out.print(strbody); } catch (IOException ioe) { System.out.println("Error in BoldTag: " + ioe); } return SKIP_BODY; // EVAL_BODY_AGAIN per ciclare } 39

40 findancestorwithclass public static final Tag findancestorwithclass (Tag from, java.lang.class klass) Metodo della classe TagSupport Restituisce l istanza di una classe specificata (klass) più vicina all istanza from LoopTag parent = (LoopTag) findancestorwithclass(this, LoopTag.class);. 40

41 javax.servlet.jsp.tagext [I] Per accedere al parent del tag, si può utilizzare il metodo: public Tag getparent() 41

42 Java Standard Tag Library

43 Java Standard Tag Library JSTL (Java Standard Tag Library) non fa parte di JSP 1.2; è una specifica a parte Disponibile nei server che supportano Java Servlets 2.3 e JSP 1.2 Il linguaggio per espressioni di JSTL farà parte di JSP 2.0 Implementazione di riferimento: 43

44 JSTL/2 Un insieme di tag libraries che implementano funzionalità che estendono la sintassi JSP Core functions: variabili, I/O, condizioni, iterazioni Formattazione/I18n: internazionalizzazione, formato numeri, date Operazioni XML: parsing, trasformazioni Operazioni su database Inoltre: introduce un nuovo linguaggio per specificare i valori degli attributi dei tag (JSTL Expression Language, EL) 44

45 JSTL/3 I tag JSTL forniscono una implementazione standard di funzionalità usate spesso nelle applicazioni web; riusabilità, evitare di rifare lavoro inutilmente Fornisce un linguaggio di scripting (EL) alternativo a quello standard di JSP, più semplice di Java (versione EL) È possibile usare la sintassi JSP delle scriplet expressions calcolate a run time (versione RT) 45

46 JSTL Expression Language I delimitatori sono ${ e } EL può essere usato solo per specificare valori di attributi nei tag JSTL; esempio: <c:out value= ${user.firstname} /> Espressioni multiple possono essere combinate e mescolate con testo statico; esempio: <c:out value= Hello ${user.firstname} ${user.lastname}! /> 46

47 JSTL Expression Language/2 Le espressioni in EL sono combinazioni di identificatori e operatori JSTL introduce degli oggetti impliciti, diversi da quelli JSP (tranne pagecontext) Quando in EL si richiama un oggetto, l identificatore viene risolto cercando negli scopi JSP in questo ordine (utilizza PageContext.findAttribute(name)): page, request, session, application 47

48 JSTL Expression Language/3 Oggetti impliciti di JSTL: pagecontext: oggetto JSP pagecontext della pagina corrente pagescope: insieme della variabili con scopo pagina requestscope: variabili, scopo richiesta sessionscope: variabili, scopo sessione applicationscope: variabili, scopo applicazione 48

49 JSTL Expression Language/4 param: par. della richiesta come stringhe paramvalues: parametri della richiesta come collezione di stringhe header: headers della richiesta HTTP come stringhe headervalues: headers della richiesta HTTP come collezione di stringhe initparam: parametri applicazione cookie: valori dei cookies 49

50 JSTL Expression Language/5 Le proprietà degli oggetti sono accedute tramite l operatore. ; esempio: ${user.firstname}: rappresenta il valore della proprietà firstname dell oggetto referenziato dall identificatore user operatore [ ] : può essere usato come. : ${user[firstname]} Inoltre l operatore [ ] permette di accedere ad array e oggetti di tipo Map, List; esempi: ${user[1]} ${user[ pippo ]} 50

51 JSTL Expression Language/6 Esempi: ${sessionscope[ username ]} è equivalente a: <%= session.getattribute( userprofile )%> ${param[ keyword ]} è equivalente a: <%= request.getparameter( keyword )%> 51

52 JSTL Expression Language/7 Altri operatori di EL: Operatori aritmetici: +, -, *, / (o div), % (o mod) Operatori di confronto: == (o eq),!= (o ne), < (o lt), > (o gt), <= (o le), >= (o ge) Operatori logici: && (o and), (o or),! (o not) Operatore empty : empty expr indica se expr è null o se expr è un String,Map,List, array vuoto 52

53 Core Library Per poter utilizzare la Core Library nelle pagine JSP, versione EL della library, ${ expr } <%@ taglib uri= prefix= c > Altrimenti, versione JSP expressions (RT), <%= expr %> : <%@ taglib uri= prefix= c_rt > 53

54 Core Library/2 Azioni generiche: <c:out> <c:set> <c:remove> <c:catch> Azioni condizionali: <c:if> <c:choose>, <c:when>, <c:otherwise> 54

55 Core Library/3 Azioni per iterazioni: <c:foreach> <c:fortokens> Azioni su URL: <c:url>, <c:param> <c:redirect>, <c:param> <c:import>, <c:param> 55