Den nye versjonen av JavaServer Pages (JSP) inneholder uttrykkespråket (EL) introdusert av JSP Standard Tag Library (JSTL) for å la webdesignere produsere scriptless JSP-sider som ikke inneholder Java-kode. Siden JSP 2.0 gir bakoverkompatibilitet til JSP 1.x, kan du fremdeles inkludere Java-kodestykker på sidene dine, men taggbehandlere og JavaBean-komponenter er mye bedre steder for Java-basert funksjonalitet.
JSP 2.0 gir nye funksjoner for taggbehandlere som dynamiske attributter, Simple Invocation Protocol og .stikkord filer. Du bruker fortsatt de gamle JSP 1.0-standardhandlingene for å opprette JavaBean-forekomster og sette deres egenskaper, men nå kan du få tilgang til bønneegenskaper, forespørselsparametere og JSP-attributter / variabler med det nye uttrykksspråket.
Alle disse forbedringene av JSP-teknologien lar deg oppnå målet om å skille JSP / HTML-markeringen fra Java-koden. En ting mangler imidlertid. JSP 2.0 har ingen syntaks for å kalle en offentlig ikke-statisk JavaBean-metode fra en scriptfri JSP-side. Denne artikkelen løser dette problemet ved å gi en enkel JSP 2.0-tag med dynamiske attributter.
Merk: Du kan laste ned kildekoden til denne artikkelen fra Resources.
Uttrykk språk nødvendig
Anta at du har en java.util.Liste for eksempel må du presentere som en HTML-liste. Her er en rask løsning basert på JSP 1.x:
Eksisterende JSP-baserte webapplikasjoner består av Java-kode blandet med HTML-markering som kodefragmentet ovenfor. Å vedlikeholde hundrevis av sider som det kan være et mareritt hvis du har separate Java-utviklings- og webdesignteam. Løsningen er å flytte Java-koden til tagbiblioteker slik at utviklere kan gjøre jobbene sine uten å lime inn Java-koden på websider, og designere kan redigere nettsidene sine uten å bekymre seg for å bryte Java-koden.
Imidlertid har JSP 1.x flere problemer som ikke lar deg enkelt utvikle skriptløse JSP-sider. Inntil nylig eksisterte ingen standardmetode for tilgang til Java-objekter fra en JSP-side uten bruk av Java-kode. I tillegg var koding av taghåndteringsklasser ikke så enkle som det kunne ha vært.
Følgende kodelinjer er basert på JSTL 1.0, som kan brukes med JSP 1.2. De tag detererer over elementene i det gitte liste og eksporterer elem variabel for hvert element. I stedet for å erklære elem som en lokal variabel, tag oppretter et sideattributt med pageContext.setAttribute (). Denne attributtets verdi skrives ut med JSTL-er stikkord:
JSTL tilbyr standard koder for behandling av XML-dokumenter og tilgang til relasjonsdatabaser, sammen med formateringskoder, internasjonaliseringskoder, betingede koder, iteratorkoder, URL-relaterte koder og andre generelle koder. JSTL har løst mange av JSP 1.xs problemer ved hjelp av et uttrykksspråk som lar deg få tilgang til Java-objekter fra JSP-sider uten å bruke Java-kode. For eksempel i stedet for å lete etter et attributt eller få tilgang til en forespørselsparameter med:
du kan nå bruke:
$ {a} $ {param.p} Du har tilgang til JSP-sidekontekstobjekter, side / forespørsel / økt / applikasjonsattributter (også kjent som JSP-variabler), JavaBean-egenskaper, samlingselementer, forespørselsparametere, initialiseringsparametere, informasjonskapsler og HTTP-overskrifter.
Med JSP 1.2 er uttrykksspråket bare tilgjengelig for JSTL-baserte applikasjoner og tagbiblioteker. JSP 2.0 gjør EL tilgjengelig for alle JSP-applikasjoner og alle tagbiblioteker (inkludert de gamle taglibsene designet for JSP 1.x). JSP 2.0 forenkler også utviklingen av tagbiblioteket, som du vil se senere i denne artikkelen.
Siden den første versjonen har JSP levert standard koder for bruk av JavaBeans på JSP-sider. Du kan opprette eller finne JavaBean-forekomster med , og så kan du få og sette egenskapene deres med og . Med JSP 2.0 kan du også få verdien av en eiendom med:
$ {bean.property} I tillegg til egenskaper har JavaBean-komponenter offentlige metoder som ofte må kalles fra JSP-sider. Resten av denne artikkelen vil presentere tre måter å ringe JavaBean-metoder uten å bruke Java-kode. Den ene er basert på JSP 2.0-støtte for funksjoner, som er EL-konstruksjoner som lar deg ringe Java-klassers statiske metoder. En annen løsning bruker tilpassede koder som får metodeparametrene som tagattributter. Den tredje måten er basert på en generisk tag som lar deg ringe hvilken som helst offentlig metode for alle JavaBean-klasser fra en JSP-side.
Bruk funksjoner
Den første JSTL 1.0 EL manglet støtte for funksjoner. JSP 2.0 EL lar deg ringe en Java-klasses offentlige statiske metode ved hjelp av følgende syntaks:
$ {prefiks: methodName (param1, param2, ...)} JSP-funksjonen må deklareres i en tagbiblioteksbeskrivelse (TLD):
methodName className returnType methodName (param1Type, param2Type, ...)
Java-klassen trenger ikke implementere noe spesielt grensesnitt. Det eneste kravet er å gjøre Java-metoden offentlig og statisk.
TestBean-klassen
De TestBean klasse har en offentlig metode som heter testmetode(), som kalles fra JSP-sidene presentert i de følgende avsnittene. JavaBean har tre egenskaper som heter tekst, Nummer, og logikk. Disse egenskapene er modifisert av testmetode(), som returnerer en streng som inneholder de tre egenskapens modifiserte verdier:
pakke com.devsphere.articles.calltag; offentlig klasse TestBean {privat strengtekst; privat int nummer; privat boolsk logikk; offentlig TestBean () {text = ""; tall = 0; logikk = falsk; } offentlig streng getText () {returtekst; } public void setText (String text) {this.text = text; } offentlig int getNumber () {returnummer; } public void setNumber (int number) {this.number = number; } offentlig boolsk getLogic () {returlogikk; } public void setLogic (boolsk logikk) {this.logic = logikk; } public String testMethod (String text, int number, boolean logic) setText (getText () + text); setNumber (getNumber () + nummer); setLogic (getLogic ()} TestFunction-klassen
Fordi JSP 2.0 EL bare tillater anrop til statiske metoder, TestBeans testmetode() må pakkes inn i en statisk metode. De TestFunction klasse gir en slik statisk innpakning som tar de samme parametrene som bønnemetoden pluss bønneobjektet hvis metode må kalles:
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 kompilerte TestFunction.class filen må plasseres sammen med TestBean.class inn i webapplikasjonene / WEB-INF / klasser katalog. Som et alternativ kan de to klassefilene pakkes i en jar-fil og lagres i / WEB-INF / lib.
TestFunction JSP
Før du ringer til testmetode() funksjon, TestFunction.jsp siden må spesifisere funksjonens prefiks og bibliotekets Uniform Resource Identifier (URI):
De tag oppretter en forekomst av TestBean klasse:
De testmetode() funksjon kalles to ganger. Den første samtalen får noen konstante parametere, mens den andre samtalen får verdiene til bønneegenskapene som parametere:
$ {tf: testMethod (obj, "abc", 123, true)}
$ {tf: testMethod (obj, obj.text, obj.number, obj.logic)} De TestFunction.jsp siden produserer følgende HTML-utdata:
abc 123 sant
abcabc 246 sant
TestFunction TLD
Som nevnt tidligere må JSP-funksjonen deklareres i en tagbiblioteksbeskrivelse. De TestFunction.tld filen definerer noe versjonsnummer, tf kortnavn brukt på JSP-sider som prefiks for testmetode(), bibliotekets URI, funksjonsnavnet, navnet på klassen som inneholder den statiske metoden, og metodens signatur. URI trenger ikke å peke på en eksisterende nettressurs, men den må være unik. Du kan ikke bruke den samme URI for to forskjellige tagbiblioteker.
Her er TestFunction.tld filens innhold:
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)
De TestFunction.tld filen må plasseres i webapplikasjonens / WEB-INF katalog. Den samme katalogen inneholder også web.xml applikasjonsbeskrivelse, som erklærer biblioteket innenfor en element. URI som identifiserer biblioteket på JSP-sider og TLD-filens plassering er spesifisert i to separate XML-elementer, og :
//devsphere.com/articles/calltag/TestFunction.tld /WEB-INF/TestFunction.tld
Bruk egendefinerte koder
Tagbiblioteker ble introdusert av JSP 1.1, som definerte stikkord og BodyTag grensesnitt. JSP 1.2 lagt til IterationTag og støtte for å fange unntak. Disse grensesnittene har behandlingsmetoder som doStartTag (), doInitBody (), doAfterBody (), og doEndTag (). Når du forstår hvordan disse metodene skal implementeres, er det enkelt å lage tagbiblioteker. Imidlertid så mange utviklere JSP 1.xs taghåndteringsmekanisme som unødvendig kompleks.
JSP 2.0 introduserte en mye enklere taghåndteringsprotokoll. Hvis du utvider SimpleTagSupport klasse, må du bare implementere doTag () metode for å håndtere en JSP-tag.
TestMethodTag-klassen
De TestMethodTag.jsp siden kaller testmetode() JavaBean-metoden som bruker følgende syntaks:
Når applikasjonsserveren oversetter JSP-siden til en servlet, erstattes ovenstående tagg med et Java-kodefragment som kaller metodene til en TestMethodTag forekomst opprettet for håndtering av taggen.
Taghåndtereren utvider JSP 2.0 API-ene SimpleTagSupport klasse og definerer ett felt for hvert attributt. Disse feltene opprettholder verdiene for tagattributtene:
pakke com.devsphere.articles.calltag; importere javax.servlet.jsp.JspException; importere javax.servlet.jsp.JspWriter; importere javax.servlet.jsp.tagext.SimpleTagSupport; importere java.io.IOException; offentlig klasse TestMethodTag utvider SimpleTagSupport {privat TestBean-objekt; privat strengtekst; privat int nummer; privat boolsk logikk; For hvert tagattributt må det være en angitt metode som får attributtverdien og lagrer den i et felt slik at tagbehandleren kan bruke den senere:
public void setObject (TestBean object) {this.object = object; } public void setText (String text) {this.text = text; } public void setNumber (int number) {this.number = number; } public void setLogic (boolsk logikk) {this.logic = logikk; } Etter å ha satt taghåndtererens attributter, påkaller Java-fragmentet (som kommer fra JSP-taggen) taghåndtererens doTag () metode, som kaller bønnemetoden. De doTag () metoden skriver ut strengverdien som returneres av testmetode(). Derfor inneholder JSP-utgangen den returnerte verdien:
offentlig ugyldig doTag () kaster JspException, IOException {String ret = object.testMethod (tekst, nummer, logikk); JspWriter ut = getJspContext (). GetOut (); out.println (ret); }} TestMethodTag2-klassen
Anta at du vil bruke verdien som returneres av bønnemetoden i en JSP. Det kan for eksempel hende du må overføre den som en attributtverdi til en annen tag. Eller du vil kanskje kontrollere utdataene på JSP-siden:
... $ {ret} ...
