JavaServer Pages (JSP) (folytatás) Felhasználó-definiált akcióelemek A szabványos JSTL elemei mellett a felhasználó maga is létrehozhat akcióelemeket, ún. custom tag-eket Ezt már a JSTL megjelenése előtt is megtehette a JSP 1.1 változatától kezdve Egy custom tag használatához a következők szükségesek tag handler Java class, amely implementálja a custom tag által megvalósítandó viselkedést tagkönyvtár leíró (tag library descriptor) a JSP konténerrel való együttműködéshez tartalmazza a custom tag nevét, az implementáló osztály nevét, a jellemzők leírását, stb. több tagkönyvtár leíró egy ún. tagkönyvtár leíró fájlban helyezendő el az alkalmazás telepítési leírójában (WEB-INF/web.xml) egy elemnek tartalmazni kell a tagkönyvtár leíró fájl helyét a JSP oldalon a használat előtt azonosítani kell a használandó custom tag-et Tag handlerek: megfelelő interfészeket implementálnak vagy az ezeket implementáló osztályokat bővítik JSP 1.1 : Tag és BodyTag interfész, TagSupport, BodyTagSupport, BodyContent és TagExtraInfo osztályok JSP 1.2 : IterationTag interfész és TagSupport osztály JSP 2.0 : SimpleTag és JspFragment interfész, SimpletagSupport osztály JSP 1.1 és 1.2 tag handlerek használata igen összetett a handler és a törzs szkripting elemei együttműködésének biztosításához több metódus szükségszerű használata: dostarttag(), doafterbody(), doendtag() stb. JSP 2.0 használata egyszerű egyetlen metódust kell csak implementálni, akár feldolgozandó a törzs akár nem de a törzs szkript elemeket (<%, <%!, <%@) nem tartalmazhat, HTML elemeket, EL kifejezéseket, akciós elemeket viszont igen Bevezető példa: Fix üzenetet generáló akcióelem http://localhost:8080/eloadasjsp/50.jsp a tag handler // Kötelező csomagbeli elhelyezés package customtags; // A szükséges csomagok importálása import javax.servlet.jsp.tagext.*; import javax.servlet.jsp.*; import java.io.*; // A SimpleTagSupport osztály bővítése public class EgyszeruUzenet extends SimpleTagSupport { // A dotag() metódus felüldefiniálása public void dotag() throws JspException, IOException { // Referencia a kimeneti folyamba író objektumra JspWriter out = getjspcontext().getout(); // Írás a kimeneti folyamba out.println("jó napot, Hölgyeim és Uraim"); 1
a tagkönyvtár leíró fájl, s benne az akcióselemünket leírótag elem <?xml version="1.0" encoding="utf-8"?> <taglib xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xsi:schemalocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd" version="2.0"> <tlib-version>1.2</tlib-version> <short-name>eloadasjsp</short-name> <name>udvozlet</name> <tag-class>customtags.egyszeruuzenet</tag-class> <body-content>empty</body-content> <!-- egyéb akcióelemek tagkönyvtár leírói --> </taglib> a tagkönyvtár leíró fájl azonosítása az alkalmazás WEB-INF/web.xml -ben <?xml version="1.0" encoding="iso-8859-1"?> <web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xsi:schemalocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4"> <jsp-config> <taglib> <taglib-uri> http://shogun.aut.bme.hu/gal-taglib </taglib-uri> <taglib-location> /WEB-INF/eloadasJSP.tld </taglib-location> </taglib> </jsp-config> a jsp-config elem azonosít egy tagkönyvtár leíró fájlt az azonosítás a taglib-uri elemmel történik - erre kell majd hivatkozni az akcióelemünket használó JSP oldalon a taglib-location elem pedig a tagkönyvtár helyét adja meg az akcióelem használata a JSP oldalon prefix="msg" %> A következő üzenetet saját akcióelemmel írjuk ki:<br> <center style="font-size:24; color:red"> <msg:udvozlet /> </center> a használandó akcióelemet leíróját tartalmazó tld importálása a taglib direktívával az uri jellemzővel azonosítjuk a tld-t, ugyanez az uri szerepel a WEB-INF/web.xml telepítési leíróban a prefix jellemzővel adjuk meg, hogy milyen előtaggal használjuk a hivatkozott tagkönyvtár elemeit az előtag most msg az elem neve padig a tld-ben megadott udvozlet Jellemzőt tartalmazó akcióelem: a jellemzőben megadott adatokkal táblázat generálása http://localhost:8080/eloadasjsp/51.jsp a JSP oldal prefix="tb" %> A következõ táblázatot saját akcióelemmel generáltuk: <center> <tb:table1 adatok="elso oszlop;masodik oszlop;harmadik oszlop;;1;2;3;;a;b;c;;a;b;c" /> </center> az adatok jellemző értéke tartalmazza a megjelenítendő táblázat elemeit a sorokat ;; választja el, a cellákat pegi; table1 az akcióelem neve a tld-ben az újabb akcióelemünk tagkönyvtár leíróját ugyanabban a tld-ben helyezzük el, mint a korábbiét, ezért az alkalmazás telepítés leírójában újabb bejegyzésre nincs szükség 2
a tag handler // Kötelező csomagbeli elhelyezés package customtags; // A szükséges csomagok importálása import javax.servlet.jsp.tagext.*; import javax.servlet.jsp.*; import java.io.*; // A SimpleTagSupport osztály bővítése public class Tablazat1 extends SimpleTagSupport { // A jellemző értékét tároló privát stringobjektum private String adatok; // A jellemző értékét beolvasó metódus - mint JavaBeans // esetén public void setadatok(string adatok) { this.adatok = adatok; // A tényleges viselkedést specifikáló dotag() metódus // felüldefiniálása public void dotag() throws JspException, IOException { // Referencia a kimeneti folyamba író objektumra JspWriter out = getjspcontext().getout(); // Az adatok jellemző értékének szétválasztása a ;; // határolók mentén String[] t = adatok.split(";;"); out.println("<table border='1'>"); for(int i=0; i<t.length; i++){ out.println("<tr>"); // Egy sor celláinak szétválasztása a ; határoló mentén String[] tt = t[i].split(";"); // A táblázat egy sorának generálása a kimeneten for(int j=0; j<tt.length; j++) out.println("<td>"+ tt[j] + "</td>"); out.println("</tr>"); out.println("</table>"); a tagkönyvtár leíró fájban a korábbi akcióelem leírója mellett az új akcióelem leírója, az újabb tag elem <name>udvozlet</name> <tag-class>customtags.egyszeruuzenet</tag-class> <body-content>empty</body-content> <name>table1</name> <tag-class>customtags.tablazat1</tag-class> <body-content>empty</body-content> <attribute> <name>adatok</name> <required>yes</required> <rtexprvalue>true</rtexprvalue> </attribute> a tag új gyermekeleme az attribute elem, amely a jellemzőt írja le, ebben name a jellemző neve requiredyes vagy no értéke a kötelező használatra vonatkozik rtexprvaluetrue vagy false azt specifikálja, hogy értékeként futásidőben kiértékelendő kifejezés használható-e Törzset tartalmazó akcióelem: a törzsben megadott adatokkal táblázat generálása http://localhost:8080/eloadasjsp/52.jsp a JSP oldal prefix="tb" %> A következő táblázatot saját akcióelemmel generáltuk: <center> <tb:table2> Elso oszlop;masodik oszlop; Harmadik oszlop;; 1;2;3;;a;b;c;; A;B;C;; x;y;z </tb:table2> </center> az adatokat most az akcióelem törzse tartalmazza 3
a tag handler // Kötelező csomagbeli elhelyezés package customtags; // A szükséges csomagok importálása import javax.servlet.jsp.tagext.*; import javax.servlet.jsp.*; import java.io.*; // Ettől kezdve a program azonos a Table1 programmal, // hiszen az adatok most már az adatok objektumban // vannak // Egyetlen eltérés, hogy az adatok most StringWriter // típusú, ami a tostring() metódussal String típusba // alakítandó JspWriter out = getjspcontext().getout(); // A SimpleTagSupport osztály bővítése public class Tablazat2 extends SimpleTagSupport { public void dotag() throws JspException, IOException { // Refrenecia az elem törzsére JspFragment body = getjspbody(); // Egy StringWriter objektum létrehozása StringWriter adatok = new StringWriter(); // A törzs tartalmának beolvasása a létrehozott // StringWriter objektumba // Ha az argumentum null lenne, akkor a törzs tartalma // közvetlenül, feldolgozás nélkül kerülne a kimenetre body.invoke(adatok); String[] t = (adatok.tostring()).split(";;"); out.println("<table border='1'>"); for(int i=0; i<t.length; i++){ out.println("<tr>"); String[] tt = t[i].split(";"); for(int j=0; j<tt.length; j++) out.println("<td>"+ tt[j] + "</td>"); out.println("</tr>"); out.println("</table>"); a tagkönyvtár leíró fájban a korábbi akcióelemek leírói mellett az új akcióelem leírója, az újabb tag elem <name>udvozlet</name> <tag-class>customtags.egyszeruuzenet</tag-class> <body-content>empty</body-content> <name>table1</name> <tag-class>customtags.tablazat1</tag-class> <body-content>empty</body-content> <attribute> <name>adatok</name> <required>yes</required> <rtexprvalue>true</rtexprvalue> </attribute> <name>table2</name> <tag-class>customtags.tablazat2</tag-class> <body-content>scriptless</body-content> a body-content tartalma most nem empty, hanem scriptless, azaz Java szkripteken kívül mindent tartalmazhat A törzs számára hozzáférhető, változót exportáló akcióelem: szövegfájl olvasása, s az olvasott sorokhoz hozzáférés a törzsben akcióelemekkel vagy EL kifejezésekkel http://localhost:8080/eloadasjsp/55.jsp a JSP oldal prefix="k" %> <k:readline realfilepath= '<%=application.getrealpath("data/1.txt")%>'> ${line<br> </k:readline> a readline akcióelem soronként olvassa a realfilepath jellemzőjében specifikált fájlt, s az egyes sorokat a törsz számára egy line változóban exportálja a törzsben ennek a line változónak a tartalmát kivisszük a kimenetre a ${line EL kifejezéssel a fájl valóságos elérési útját, melyet az alkalmazás gyökeréhez képest ad meg a data/1.txt, a pagecontext.getservletcontext().getrealpath() állítja elő 4
a tag handler package customtags; import javax.servlet.jsp.tagext.*; import javax.servlet.jsp.*; import java.io.*; public class ReadFile extends SimpleTagSupport { private String realfilepath; public void setrealfilepath(string realfilepath) {this.realfilepath = realfilepath; public void dotag() throws JspException, IOException { try { FileReader fr = new FileReader(realFilePath); BufferedReader br = new BufferedReader(fr); String s; while((s=br.readline())!=null) { // Az aktuális olvasott sor beírása line // változónéven a pagecontext objektumba, hogy az // hozzáférhető legyen a JSP oldalon getjspcontext().setattribute("line",s+"\n"); a tag handler (folytatás) // Az akcióelem törzsét végrehajtó utasítás // végrehajtása getjspbody().invoke(null); fr.close(); catch (IOException e) { Megjegyzés: a setattribute() metódusnak lehet egy harmadik argumentuma, amellyel a hatáskör állítható be. Ezek a következők lehetnek: PageContext.APPLICATION_SCOPE PageContext.SESSION_SCOPE PageContext.REQUEST_SCOPE PageContext.PAGE_SCOPE (ez a default). A fentiek az exportált változóhoz való hozzáférést rendre az alkalmazásban, a munkafolyamatban, a kérelem oldalain és végül magán az aktuális oldalon teszik lehetővé. a tagkönyvtár leíró fájban a korábbi akcióelemek leírói mellett az új akcióelem leírója, az újabb tag elem <name>readline</name> <tag-class>customtags.readfile</tag-class> <body-content>scriptless</body-content> <attribute> <name>realfilepath</name> <required>yes</required> <rtexprvalue>true</rtexprvalue> </attribute> Kiegészítés A tag handlerben közvetlenül nem férhetők hozzá a pagecontext, request, session, application objektumok metódusai. Ha mégis szeretnénk ezeket használni, akkor ezt a következőképpen megtehetjük: // a JSP oldalon <% pagecontext.setattribute("pc",pagecontext); %> <% pagecontext.setattribute("sc",application); %> // a tag handlerben PageContext pagecontext = (PageContext)getJspContext().getAttribute("pC"); ServletContext servletcontext = (ServletContext)getJspContext().getAttribute("sC"); Az előzőek valamelyikét használva, már elegendő lenne a fájl alkalmazásbeli útjának a megadása, s a tag handlerben előállítható lenne a valóságos elérési út a következőképpen: pagecontext.getservletcontext().getrealpath() // vagy servletcontext.getrealpath() 5
Fájl írása a jellemzőben megadott tartalommal http://localhost:8080/eloadasjsp/56.jsp a JSP oldal prefix="k" %> <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <c:set var="s" value=""/> <k:readline realfilepath= '<%=application.getrealpath("data/1.txt")%>'> <c:set var="s" value="${s${line"/> </k:readline> <k:writefile realfilepath= '<%=application.getrealpath("data/2.txt")%>' text='${s' /> Az 1.txt fájlból rendre beolvasott sorokat hozzáfűzzük a kinullázotts EL változóhoz, majd az s változó tartalmát beírjuk a 2.txt fájlba. a tag handler package customtags; import javax.servlet.jsp.tagext.*; import javax.servlet.jsp.*; import java.io.*; public class WriteFile extends SimpleTagSupport { private String realfilepath; private String text; public void setrealfilepath( String realfilepath){this.realfilepath = realfilepath; public void settext(string text){this.text = text; public void dotag() throws JspException, IOException { try { FileWriter fw = new FileWriter(realFilePath,false); BufferedWriter bw = new BufferedWriter(fw); bw.write(text); bw.close(); fw.close(); catch (IOException e) { a tagkönyvtár leíró fájban a korábbi akcióelemek leírói mellett az új akcióelem leírója, az újabb tag elem <name>writefile</name> <tag-class>customtags.writefile</tag-class> <body-content>scriptless</body-content> <attribute> <name>realfilepath</name> <required>yes</required> <rtexprvalue>true</rtexprvalue> </attribute> <attribute> <name>text</name> <required>yes</required> <rtexprvalue>true</rtexprvalue> </attribute> Fájl írása hozzáfűzéssel (append) a jellemzőben megadott tartalommal http://localhost:8080/eloadasjsp/57.jsp <%@ a taglib JSP oldal uri="http://shogun.aut.bme.hu/gal-taglib" prefix="k" %> <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <c:set var="apppath" value='<%=application.getrealpath("/")%>' /> <k:readline realfilepath='${apppathdata/1.txt'> <k:appendfile realfilepath='${apppathdata/3.txt' text='${line'/> </k:readline> A valóságos utat most kétszer is elő kellene állítani, ezért először előállítottuk az alkalmazás valóságos útját, majd ehhez rendre hozzáfűztük a relatív utakat A tag handler csak annyiban különbözik a előzőekben megadottól, hogy a FileWriter konstruktorban a második argumentum nem false, hanem true 6
Fájl olvasása és írása hozzáférési zárolással http://localhost:8080/eloadasjsp/58.jsp a JSP oldal <c:set var="s" value=""/> <c:set var="d" value='<%=new java.util.date()+"\n"%>' /> <c:set var="text" value=""/> <c:set var="apppath" value='<%=application.getrealpath("/")%>'/> <k:readwritefile realfilepath='${apppathdata/4.txt'> <c:choose> <c:when test="${readready!='yes'" > <c:set var="s" value="${s${line"/> </c:when> <c:otherwise> <c:set var="text" value='${s${d'/> </c:otherwise> </c:choose> </k:readwritefile> a tag handler package customtags; import javax.servlet.jsp.tagext.*; import javax.servlet.jsp.*; import java.io.*; public class ReadWriteFile extends SimpleTagSupport { private String realfilepath; private String readready = "no"; public void setrealfilepath( String realfilepath){this.realfilepath=realfilepath; public synchronized void dotag() throws JspException, IOException { try { FileReader fr = new FileReader(realFilePath); BufferedReader br = new BufferedReader(fr); String s; a tag handler (folytatás) while((s=br.readline())!=null) { getjspcontext().setattribute("line",s+"\n"); getjspbody().invoke(null); fr.close(); catch (IOException e) { getjspcontext().setattribute("readready","yes"); getjspbody().invoke(null); try{ FileWriter fw = new FileWriter(realFilePath,false); BufferedWriter bw = new BufferedWriter(fw); String text = (String)getJspContext().getAttribute("text"); bw.write(text); bw.close(); fw.close(); catch (IOException e) { Megjegyzés: A tag handlerek class fájljait egyetlen jar fájlba tömörítve az alkalmazás lib könyvtárában is tárolhatjuk. A jar fájl előállítása - Hozzunk létre egy tmp/customtags nevű üres mappát - Töltsük be a handlerek class fájljait a customtags mappába - A tmp mappában hajtsuk végre a következő parancsot jar cf k.jar customtags/*.class - A keletkezett k.jar fájlt másoljuk be az alkalmazás lib könyvtárába 7
Az értékelés webalkalmazás megoldása fájl alapon http://localhost:8080/eloadasjsp/ertekelesfilejstl.html az űrlapot megjelenítő oldal változatlan, csak az action jellemző értéke változtatandó meg ertekeles1filejstl.jsp -re az adatokat fogadó jsp oldal (ertekeles1filejstl.jsp) prefix="k" %> <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <html> <body> <head> <style type=text/css> td{font-size:18pt;color:white; font-weight:bold; </style> </head> // '\n' nem írható be közvetlenül egy EL kifjezésbe <% pagecontext.setattribute("lf","\n"); %> <c:set var="apppath" value= '<%=application.getrealpath("/")%>'/> <k:appendfile realfilepath='${apppathdata/ertekeles.txt' text='${param.t1${param.t2${param.t3${lf'/> <h2>köszönjük, hogy értékelte az oktatót!</h2> Ha megkivánja tekinteni az eddigi értékelések átlagát, akkor <a href="ertekeles2filejstl.jsp">kattintsonide.</a> </html> Az átlagot megjelenítő oldal prefix="k" %> <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %> <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %> <html> <body> <head> <style type=text/css> td{font-size:18pt;color:white; font-weight:bold; </style> </head> <c:set var="sum1" value="${0" /> <c:set var="sum2" value="${0" /> <c:set var="sum3" value="${0" /> <c:set var="n" value="${0" /> <c:set var="apppath" value= '<%=application.getrealpath("/")%>'/> <k:readline realfilepath='${apppathdata/ertekeles.txt'> <c:set var="x" value="${line" /> <c:set var="sum1" value="${sum1+fn:substring(x,0,1)" /> <c:set var="sum2" value="${sum2+fn:substring(x,1,2)" /> <c:set var="sum3" value="${sum3+fn:substring(x,2,3)" /> <c:set var="n" value="${n+1" /> </k:readline> <fmt:setlocale value="hu" /> <center> <table bgcolor=black> <tr> <td colspan=2> <h2 style='background-color:red;color:white; font-weight:bold'> Az eddigi eredmények értékelése </h2> </td> </tr> 8
<tr> <td>a beküldött értékelések száma:</td> <td><c:out value="${n" /></td> </tr> <tr> <td>az eloadó felkészültsége:</td> <td><fmt:formatnumber value="${sum1/n" pattern="#.##" var="s1"/> <c:out value="${s1" /> </td> </tr> <tr> <td>az eloadó tárgyi tudása:</td> <td><c:out value="${sum2/n" /></td> </tr> <tr> <td>az eloadás érthetosége:</td> <td><c:out value="${k:format(sum3/n,2)" /></td> </tr> </table> </center> </html> Felhasználó-definiált EL függvények Lehetővé teszik felhasználó-definiált statikus metódusok hívását EL kifejezésekben. A statikus metódusokat definiáló osztály vagy osztályokat a tag handler osztályokkal azonos módon lehet tárolni Egy osztály akárhány metódust definiálhat A tld-ben minden metódust egy <function> bejegyzéssel azonosítunk Példa konverziós függvényekre http://localhost:8080/eloadasjsp/functiontest.jsp package customtags; public class Conversions { //számot jelentő stringben a tizedspont helyettesítése //tizedesvesszővel, s max. n tizedesjegy meghagyása public static String format(string x, int n) { String y = x.replace('.',','); int i = y.indexof(','); if(i == -1) return y; return y.substring(0,i+n+1); // string átalakítása lebegőpontos számmá public static float stringtofloat(string x){ float y = 0; try{ y = Float.parseFloat(x); catch(exception e){ return y; Használat a JSP oldalon prefix="mf" %> 123.4567<br> ${mf:format("123.4567",1)<br> ${mf:format("123.4567",3) Bejegyzés a tld-ben <function> <description>fixing decimal numbers</description> <name>format</name> <function-class>customtags.conversions</function-class> <function-signature> java.lang.string format(java.lang.string, int) </function-signature> </function> <function> <description>string to float</description> <name>stringtofloat</name> <function-class>customtags.conversions</function-class> <function-signature> float stringtofloat(java.lang.string) 9
Tag fájlok Tag fájlok Forrásfájl, amely egy JSP kódrészletet tartalmaz, s mint felhasználó definiált tag újrafelhasználható Lehetővé teszi felhasználó definiált tag-ok definiálását JSP szintaxissal Az eddigieknél hatékonyabb eszköz az oldalak szerzői számára Gyorsabbá teszi a fejlesztést Tag handlerbe transzformálódnak, s azután lefordítódnak Nem igényelnek TLD-t Egyszerűbb, mégis rugalmas becsomagolás A.tag fájlt egyszerűen a /WEB-INF/tags könyvtárban kell tárolni Az implicit tag könyvtár automatikusan generálódik De egy.tld is megírható a rugalmasság növelésére Vagy egy JAR fájlba is csomagolható egy.tld-vel Egy tag könyvtár deklarálása a JSP oldalon: a taglib direktívában a tagdir jellemzővel A taglib direktíva: A tagkönyvtárat azonosítja és specifikálja a JSP oldalon használandó prefixet. Kötelező jellemzői: tagdir= /WEB-INF/tags[/subdir]+ prefix= mytagfile Példák: <%@ taglib prefix="t1" tagdir=/web-inf/tags %> <%@ taglib prefix="t2" tagdir=/web-inf/tags/dir %> Tag fájl direktívák tag A felhasználói tag tulajdonságait deklarálja. Hasonló a JSP page direktívájához, de csak tag fájlokban használható Szintaxisa (piros színnel a default jellemzőértékek): <%@ tag [display-name="name of tag the file display-name"] [body-content="scriptless tagdependent empty"] [dynamic-attributes="page-scoped attribute"] [small-icon="relativeurl"] [large-icon="relativeurl"] [decription="text"] [example="text"] [language="java"] [import="{package.class package.*,"] [pageeencoding="{characterset ISO-8859-1"] iselignored="true false"] %> 10
A tag direktíva fontosabb jellemzői: body-content scriptless: default érték, ekkor a hívó oldalon az elem tartalma sablon szöveg, EL kifejezések szabványos akciók felhasználó definiált akciók lehet (tehát csak szkript elemek nem!) Az elem tartalmát a tag fájl a <jsp:dobody /> hatására értékeli ki, s küldi a kimenetre vagy tárolja egy EL változóban empty: a hívó oldalon az elem tartalma üres kell legyen tagdependent: az elem tartalomban mindent sablon szövegnek tekint a fordító dynamic-attributes: Ha jelen van, akkor elfogad járulékos jellemzőket dinamikus nevekkel. Lásd később. Attributum: hívó tag file communikáció Az attribute direktíva lehetővé teszi, hogy a hívó JSP oldal adatokat adjon át a tag fájlnak. Az adat vagy normális (hívás előtt a konténer által kiértékelendő nemprimitív típusú adat) vagy fragment (a tag fájl által kiértékelendő kódrészlet) lehet. Az utóbbi esetben a tag fájlban a <jsp:invoke> hatására értékelődik ki a fragment attributum. Szintaxis a tag oldalon: <%@ attribute name="attribute-name" [required="true false"] [fragment="true false"] [rtexprvalue="true false"] [type="java.lang.string a non-primitive type"] [decription="text"] %> Ha fragment="true", akkor rtexprvalue és type nem adandó meg, ezek értékét a konténer true és javax.servlet.jsp.tagext.jspfragment értékre állítja be. 1.példa: normál attribútumok használata http://localhost:8080/eloadasjsp/szinvaltas.jsp <!-- tag file, melynek neve szinvaltas.tag --> <%@ attribute name="szin" required="true" %> <font color="${szin"> <jsp:dobody /> </font> <!-- hívó jsp fájl --> <%@ taglib prefix="t1" tagdir="/web-inf/tags" %> <t1:szinvaltas szin="red" > Ez a szöveg vörös színnel fog megjelenni. </t1:szinvaltas> <t1:szinvaltas szin="${request.preferaltszin" > Ez a szöveg a felhasználó által megadott, preferált színnel fog megjelenni. </t1:szinvaltas> 2.példa: fragment attributum használata - a tag fájl <%@ attribute name="bookdb" required="true" type="database.bookdb" %> <%@ attribute name="color" required="true" %> <%@ attribute name="normalprice" fragment="true" %> <%@ attribute name="onsale" fragment="true" %> <%@ variable name-given="price" %> <%@ variable name-given="saleprice" %> <center><table> <c:foreach var="book" begin="0" items="${bookdb.books"> </c:foreach> <c:set var="saleprice" value="${book.price *.85" /> <c:set var="price" value="${book.price" /> <c:choose> <c:when test="${book.onsale" > <jsp:invoke fragment="onsale" /> </c:when> <c:otherwise> <jsp:invoke fragment="normalprice" /> </c:otherwise> </c:choose> </table></center> 11
2.példa (folyt.) - a hívó jsp oldal <sc:catalog bookdb="${bookdb" color="#cccccc"> <jsp:attribute name="normalprice"> <fmt:formatnumber value="${price" type="currency"/> </jsp:attribute> <jsp:attribute name="onsale"> <strike> <fmt:formatnumber value="${price" type="currency"/> </stike> <br/> <font color="red"> <fmt:formatnumber value="${saleprice" type="currency"/> </font> </jsp:attribute> </sc>catalog> A tag direktíva dynamic-attributes jellemzője lehetővé teszi járulékos jellemzők elfogadását dinamikus nevekkel. Példa: http://localhost:8080/eloadasjsp/szinteszt.jsp <!-- a tag file melynek neve szinteszt.tag --> <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <%@ tag dynamic-attributes="szinek"%> <ul> <c:foreach var="szin" begin="0" items="${szinek"> <li> ${szin.key = <font color="${szin.value">${szin.value</font> </li> </c:foreach> </ul> <!-- a hívó JSP oldal --> <%@ taglib prefix="t1" tagdir=/web-inf/tags %> <t1:szinteszt szin1="red" szin2="yellow" szin3="green"/> Variable: tag file hívó communikáció A variable direktíva lehetővé teszi, hogy a tag fájlban beállított EL változó értékéhez a hívó JSP oldal hozzáférjen. Szintaxis: <%@ variable {name-given="scripting variable" (name-from-attribute="scripting variable" alias="(locally-scoped attribute") [variable-class="java.lang.string var. class name"] [declare="true false"] [scope="at_begin AT_END NESTED"] [decription="text"] %> A scope értelmezése AT_BEGIN a változó hozzáférhető a hívó oldalon a tag nyitóelemétől kezdve AT_END a változó hozzáférhető a hívó oldalon a tag záróelemétől kezdve NESTED esetén a változó csak az elem törzsében férhető hozzá Példa <!-- a.tag --> <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> <%@ variable name-given="x" scope="at_end" %> <c:set var="x" value="hello" /> <!-- b.jsp --> <%@ taglib prefix="tags" tagdir="/web-inf/tags" %> ${x <tags:a /> ${x A fenti példában az első hivatkozás az x változóra undefined értéket ad, mivel a változó még nincs deklarálva. Miután azonban a tag fájl meghívása megtörtént és a változó így értéket kapott, a második hivatkozás már a Hello stringet írja ki. 12
Példa: fájl olvasása http://localhost:8080/eloadasjsp/readfileteszt.jsp <!-- readfile.tag file hivasa --> <%@ taglib prefix="tag1" tagdir="/web-inf/tags" %> <tag1:readfile fname='<%=application.getrealpath("data/1.txt")%>' > ${line<br> </tag1:readfile > <!-- readfile.tag file --> <%@ tag import="javax.servlet.jsp.*,java.io.*" %> <%@ attribute name="fname" required="true" %> <%@ variable name-given="line" %> <% int i = 1; try { FileReader fr = new FileReader(fname); BufferedReader br = new BufferedReader(fr); String s; while((s=br.readline())!=null) { session.setattribute("line", "<font color=red><b>"+i++ +":</b></font> " + s + "\n"); %> <jsp:dobody /> <% fr.close(); catch (IOException e) { %> Fontosabb elemek részletei <jsp:dobody> Ez az elem a tag fájlban kiértékeli a hívó jsp oldalon az elem tartalmát, s azt vagy a kimenetnek adja át, vagy egy EL változóban tárolja. Szintaxis: <jsp:dobody ({var="scopedattributename" varreader="scopedatributename" [scope="page request session application"]>) /> Ha a var jellemző jelen van, akkor az elem tartalma ebben tárolódik String formájában Ha a varreader jellemző jelen van, akkor az elem tartalma ebben tárolódik java.io.reader objektum formájában A fenti két jellemző közül legfeljebb az egyik lehet jelen Ha egyik sincs jelen, akkor az elem tartalma a kimenetnek (JspWriter) adódik át A scope értéke a var vagy varreader hatáskörét állítja be <jsp:invoke> Ez az elem kiértékeli a fragment attributumot. Szintaxisa: <jsp:invoke fragment="fragmentname" ({var="scopedattributename" varreader="scopedatributename" [scope="page request session application"]>) /> A fragment attribútum értéke azonosítja a kiértékelendő attribútumot Ha a var jellemző jelen van, akkor a kiértékelés eredménye ebben tárolódik String formájában Ha a varreader jellemző jelen van, akkor a kiértékelés eredménye ebben tárolódik java.io.reader objektum formájában A fenti két jellemző közül legfeljebb az egyik lehet jelen Ha egyik sincs jelen, akkor az elem tartalma a kimenetnek (JspWriter) adódik át A scope értéke a var vagy varreader hatáskörét állítja be 13
Tag fájlok becsomagolása Egy vagy több tag fájl becsomagolgató egy jar fájlba, de ekkor már egy tagkönyvtár leírót is létre kell hozni. Ebben az uri elem az egyértelmű azonosításra szolgál Minden tag számára most a tag elem helyett egy tag-file elemnek kell szerepelni a leíróban. Minden tag-file elemnek két gyermekeleme van: name és path. name: a tag nevét specifikálja, egyedi kell legyen az alkalmazásban path: a teljes elérési út, amely /META-INF/tags sztringgel kezdődik Példa: egy encode.tag tag fájl becsomagolása Legyen a tagkönyvtár leíró neve mytld2.tld, ennek alakja <?xml version="1.0" encoding="utf-8"?> <taglib xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi= "http://www.w3.org/2001/xmlschema-instance" xsi:schemalocation= "http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd" version="2.0"> <description>jsp 2.0 tag files</description> <tlib-version>1.0</tlib-version> <short-name>my Tag Files</short-name> <uri>http://maci.laci.com/tagfiles</uri> <tag-file> <name>encode</name> <path>/meta-inf/tags/encode.tag</path> </tag-file> </taglib> Hozzuk létre az alábbi könyvtárstruktúrát Lépjünk be a deploy könyvtárba, és hajtsuk végre az alábbi parancsot jar cvf mytagfiles.jar * Ez létrehozza a maytagfiles.jar fájlt. Másoljuk be ezt a fájlt az alkalmazás WEB-INF/lib könyvtárába Indítsuk újra a web konténert. Ekkor a következő JSP oldal hozzá fog férni az encode tag fájlhoz: <%@ taglib prefix="easy" uri="http://maci.laci.com/tagfiles" %> <easy:encode input="<br/> hatása soremelés" /> 14