Den nye version af JavaServer Pages (JSP) indeholder det ekspressionssprog (EL), der er introduceret af JSP Standard Tag Library (JSTL), så webdesignere kan producere scriptfri JSP-sider, der ikke indeholder Java-kode. Da JSP 2.0 giver bagudkompatibilitet til JSP 1.x, kan du stadig medtage Java-uddrag på dine sider, men taghåndterere og JavaBean-komponenter er meget bedre steder for Java-baseret funktionalitet.
JSP 2.0 giver nye funktioner til taghåndterere som dynamiske attributter, Simple Invocation Protocol og .tag filer. Du bruger stadig de gamle JSP 1.0-standardhandlinger til at oprette JavaBean-forekomster og indstille deres egenskaber, men nu kan du få adgang til bønneegenskaber, anmodningsparametre og JSP-attributter / variabler med det nye ekspressionssprog.
Alle disse forbedringer af JSP-teknologien giver dig mulighed for at nå målet om at adskille JSP / HTML-markeringen fra Java-koden. En ting mangler dog. JSP 2.0 har ingen syntaks til at kalde en offentlig ikke-statisk JavaBean-metode fra en scriptfri JSP-side. Denne artikel løser problemet ved at levere et JSP 2.0-enkelt tag med dynamiske attributter.
Bemærk: Du kan downloade denne artikels kildekode fra Resources.
Nødvendigt udtrykssprog
Antag at du har en java.util.Liste eksempel skal du præsentere som en HTML-liste. Her er en hurtig løsning baseret på JSP 1.x:
Eksisterende JSP-baserede webapplikationer består af Java-kode blandet med HTML-markering som ovenstående kodefragment. Vedligeholdelse af hundredvis af sider som det kan være et mareridt, hvis du har separate Java-udviklings- og webdesignteams. Løsningen er at flytte Java-koden til tagbiblioteker, så udviklere kan udføre deres job uden at indsætte Java-kode på websider, og designere kan redigere deres websider uden at bekymre sig om at bryde Java-koden.
JSP 1.x har dog flere problemer, der ikke giver dig mulighed for let at udvikle scriptfri JSP-sider. Indtil for nylig eksisterede der ingen standardmetode til adgang til Java-objekter fra en JSP-side uden brug af Java-kode. Derudover var kodning af taghåndteringsklasser ikke så enkle som det kunne have været.
Følgende kodelinjer er baseret på JSTL 1.0, som kan bruges med JSP 1.2. Det tag itererer over elementerne i det givne liste og eksporterer elem variabel for hvert element. I stedet for at erklære elem som en lokal variabel, tag opretter en sideattribut med pageContext.setAttribute (). Denne attributs værdi udskrives med JSTL'er tag:
JSTL leverer standard tags til behandling af XML-dokumenter og adgang til relationsdatabaser sammen med formateringskoder, internationaliseringskoder, betingede tags, iterator-tags, URL-relaterede tags og andre tags til generelle formål. JSTL har løst mange af JSP 1.x's problemer ved hjælp af et ekspressionssprog, der giver dig adgang til Java-objekter fra JSP-sider uden at bruge Java-kode. For eksempel i stedet for at lede efter en attribut eller få adgang til en anmodningsparameter med:
du kan nu bruge:
$ {a} $ {param.p} Du kan få adgang til JSP-sidekontekstobjekter, side / anmodning / session / applikationsattributter (også kendt som JSP-variabler), JavaBean-egenskaber, samleelementer, anmodningsparametre, initialiseringsparametre, cookies og HTTP-overskrifter.
Med JSP 1.2 er ekspressionssprog kun tilgængeligt for JSTL-baserede applikationer og tagbiblioteker. JSP 2.0 gør EL tilgængelig for alle JSP-applikationer og alle tagbiblioteker (inklusive de gamle taglibs designet til JSP 1.x). JSP 2.0 forenkler også tagbiblioteksudvikling, som du kan se senere i denne artikel.
Siden sin første version har JSP leveret standard tags til brug af JavaBeans på JSP-sider. Du kan oprette eller finde JavaBean-forekomster med , og så kan du hente og indstille deres egenskaber med og . Med JSP 2.0 kan du også få værdien af en ejendom med:
$ {bean.property} Ud over egenskaber har JavaBean-komponenter offentlige metoder, der ofte skal kaldes fra JSP-sider. Resten af denne artikel præsenterer tre måder til at ringe til JavaBean-metoder uden at bruge Java-kode. Den ene er baseret på JSP 2.0-understøttelse af funktioner, som er EL-konstruktioner, der giver dig mulighed for at kalde Java-klassers statiske metoder. En anden løsning bruger brugerdefinerede tags, der får metodeparametrene som tagattributter. Den tredje måde er baseret på et generisk tag, der lader dig kalde en hvilken som helst offentlig metode i enhver JavaBean-klasse fra en JSP-side.
Brug funktioner
Den oprindelige JSTL 1.0 EL manglede support til funktioner. Med JSP 2.0 EL kan du ringe til en Java-klasses offentlige statiske metode ved hjælp af følgende syntaks:
$ {præfiks: methodName (param1, param2, ...)} JSP-funktionen skal erklæres i en tagbiblioteksbeskrivelse (TLD):
methodName className returnType methodName (param1Type, param2Type, ...)
Java-klassen behøver ikke at implementere nogen speciel grænseflade. Det eneste krav er at gøre Java-metoden offentlig og statisk.
TestBean-klassen
Det TestBean klasse har en offentlig metode navngivet testmetode(), som kaldes fra de JSP-sider, der præsenteres i de følgende afsnit. JavaBean har tre navngivne egenskaber tekst, nummerog logik. Disse egenskaber er ændret af testmetode(), som returnerer en streng, der indeholder de tre egenskabers modificerede værdier:
pakke com.devsphere.articles.calltag; offentlig klasse TestBean {privat strengtekst; privat int-nummer; privat boolsk logik; offentlig TestBean () {text = ""; antal = 0; logik = falsk; } offentlig String getText () {returtekst; } public void setText (String text) {this.text = text; } public int getNumber () {returnummer; } public void setNumber (int number) {this.number = number; } offentlig boolsk getLogic () {retur logik; } public void setLogic (boolsk logik) {this.logic = logik; } public String testMethod (String text, int number, boolean logic) setText (getText () + text); setNumber (getNumber () + nummer); setLogic (getLogic ()} TestFunction-klassen
Fordi JSP 2.0 EL kun tillader opkald til statiske metoder, TestBean's testmetode() skal pakkes ind i en statisk metode. Det TestFunktion klasse giver en sådan statisk indpakning, der tager de samme parametre som bønnemetoden plus bønneobjektet, hvis metode skal kaldes:
pakke com.devsphere.articles.calltag; public class TestFunction {public static String testMethod (TestBean object, String text, int number, boolean logic) {return object.testMethod (text, number, logic); }} Den samlede TestFunction.class filen skal placeres sammen med TestBean.class ind i webapplikationerne / WEB-INF / klasser vejviser. Som et alternativ kan de to klassefiler pakkes i en jar-fil og gemmes i / WEB-INF / lib.
TestFunction JSP
Før du ringer til testmetode() funktion, den TestFunction.jsp siden skal specificere funktionens præfiks og bibliotekets Uniform Resource Identifier (URI):
Det tag opretter en forekomst af TestBean klasse:
Det testmetode() funktion kaldes to gange. Det første opkald får nogle konstante parametre, mens det andet opkald får værdierne for bønneegenskaberne som parametre:
$ {tf: testMethod (obj, "abc", 123, true)}
$ {tf: testMethod (obj, obj.text, obj.number, obj.logic)} Det TestFunction.jsp side producerer følgende HTML-output:
abc 123 sandt
abcabc 246 sandt
TestFunction TLD
Som nævnt tidligere skal JSP-funktionen erklæres i en tagbiblioteksbeskrivelse. Det TestFunction.tld filen definerer noget versionsnummer, tf kort navn brugt på JSP-sider som præfiks for testmetode(), bibliotekets URI, funktionens navn, navnet på klassen, der indeholder den statiske metode, og metodens signatur. URI behøver ikke at pege på en eksisterende webressource, men den skal være unik. Du bruger muligvis ikke den samme URI til to forskellige tagbiblioteker.
Her er TestFunction.tld filens indhold:
1.0 tf //devsphere.com/articles/calltag/TestFunction.tld testMethod com.devsphere.articles.calltag.TestFunction java.lang.String testMethod (com.devsphere.articles.calltag.TestBean, java.lang.String, int, boolsk)
Det TestFunction.tld filen skal placeres i webapplikationens / WEB-INF vejviser. Den samme mappe indeholder også web.xml applikationsbeskrivelse, der erklærer biblioteket inden for en element. URI'en, der identificerer biblioteket på JSP-sider og TLD-filens placering, er angivet inden for to separate XML-elementer, og :
//devsphere.com/articles/calltag/TestFunction.tld /WEB-INF/TestFunction.tld
Brug tilpassede tags
Tagbiblioteker blev introduceret af JSP 1.1, som definerede Tag og BodyTag grænseflader. JSP 1.2 tilføjet IterationTag og støtte til at fange undtagelser. Disse grænseflader har håndteringsmetoder som f.eks doStartTag (), doInitBody (), doAfterBody ()og doEndTag (). Når du først har forstået, hvordan disse metoder skal implementeres, er det let at oprette tagbiblioteker. Imidlertid betragtede mange udviklere JSP 1.xs taghåndteringsmekanisme som unødvendigt kompleks.
JSP 2.0 introducerede en meget enklere taghåndteringsprotokol. Hvis du udvider SimpleTagSupport klasse, skal du bare implementere doTag () metode til håndtering af et JSP-tag.
TestMethodTag-klassen
Det TestMethodTag.jsp side kalder testmetode() JavaBean-metode ved hjælp af følgende syntaks:
Når applikationsserveren oversætter JSP-siden til en servlet, erstattes ovenstående tag med et Java-kodefragment, der kalder metoderne til en TestMethodTag forekomst oprettet til håndtering af tagget.
Taghåndtereren udvider JSP 2.0 API'erne SimpleTagSupport klasse og definerer et felt for hver attribut. Disse felter opretholder tagattributternes værdier:
pakke com.devsphere.articles.calltag; import javax.servlet.jsp.JspException; importere javax.servlet.jsp.JspWriter; import javax.servlet.jsp.tagext.SimpleTagSupport; importere java.io.IOException; offentlig klasse TestMethodTag udvider SimpleTagSupport {privat TestBean-objekt; privat strengtekst; privat int-nummer; privat boolsk logik; For hver tagattribut skal der være en sæt metode, der får attributværdien og gemmer den i et felt, så taghåndtereren kan bruge den senere:
public void setObject (TestBean-objekt) {this.object = objekt; } public void setText (String text) {this.text = text; } public void setNumber (int number) {this.number = number; } public void setLogic (boolsk logik) {this.logic = logik; } Efter indstilling af taghåndteringsattributter påkalder Java-fragmentet (som følge af JSP-tagget) taghåndtererens doTag () metode, der kalder bønnemetoden. Det doTag () metode udskriver strengværdien returneret af testmetode(). Derfor indeholder JSP-output den returnerede værdi:
offentlig ugyldighed doTag () kaster JspException, IOException {String ret = object.testMethod (tekst, nummer, logik); JspWriter out = getJspContext (). GetOut (); out.println (ret); }} TestMethodTag2-klassen
Antag, at du vil bruge den værdi, der returneres ved hjælp af bønnemetoden i en JSP. For eksempel skal du muligvis videregive det som en attributværdi til et andet tag. Eller måske vil du kontrollere dens output på JSP-siden:
... $ {ret} ...
