Chiama i metodi JavaBean dalle pagine JSP 2.0

La nuova versione JSP (JavaServer Pages) incorpora il linguaggio di espressione (EL) introdotto dalla JSP Standard Tag Library (JSTL) per consentire ai web designer di produrre pagine JSP senza script che non contengono codice Java. Poiché JSP 2.0 fornisce la retrocompatibilità con JSP 1.x, puoi ancora includere frammenti Java nelle tue pagine, ma i gestori di tag e i componenti JavaBean sono posti molto migliori per le funzionalità basate su Java.

JSP 2.0 fornisce nuove funzionalità per i gestori di tag come attributi dinamici, Simple Invocation Protocol e .tagfile. Si utilizzano ancora le vecchie azioni standard JSP 1.0 per creare istanze JavaBean e impostare le loro proprietà, ma ora è possibile accedere alle proprietà del bean, ai parametri di richiesta e agli attributi / variabili JSP con il nuovo linguaggio delle espressioni.

Tutti questi miglioramenti della tecnologia JSP consentono di raggiungere l'obiettivo di separare il markup JSP / HTML dal codice Java. Tuttavia manca una cosa. JSP 2.0 non ha una sintassi per chiamare un metodo JavaBean non statico pubblico da una pagina JSP senza script. Questo articolo risolve questo problema fornendo un semplice tag JSP 2.0 con attributi dinamici.

Nota: puoi scaricare il codice sorgente di questo articolo da Risorse.

Linguaggio di espressione necessario

Supponi di avere java.util.Listun'istanza da presentare come elenco HTML. Ecco una soluzione rapida basata su JSP 1.x:

   

Le applicazioni Web esistenti basate su JSP sono costituite da codice Java combinato con markup HTML come il frammento di codice precedente. Mantenere centinaia di pagine in questo modo può essere un incubo se hai team separati di sviluppo Java e web design. La soluzione è spostare il codice Java nelle librerie di tag in modo che gli sviluppatori possano svolgere il proprio lavoro senza incollare il codice Java nelle pagine Web e i progettisti possano modificare le proprie pagine Web senza preoccuparsi di rompere il codice Java.

Tuttavia, JSP 1.x presenta diversi problemi che non consentono di sviluppare facilmente pagine JSP senza script. Fino a poco tempo fa, non esisteva alcun metodo standard per accedere agli oggetti Java da una pagina JSP senza utilizzare codice Java. Inoltre, la codifica delle classi di tag handler non è stata così semplice come avrebbe potuto essere.

Le seguenti righe di codice si basano su JSTL 1.0, che può essere utilizzato con JSP 1.2. Il tag itera sugli elementi del dato listed esporta la elemvariabile per ogni elemento. Invece di dichiarare elemcome una variabile locale, il tag crea un attributo di pagina con pageContext.setAttribute(). Il valore di questo attributo viene stampato con il tag JSTL :

   

JSTL fornisce tag standard per l'elaborazione di documenti XML e l'accesso a database relazionali insieme a tag di formattazione, tag di internazionalizzazione, tag condizionali, tag iteratori, tag relativi a URL e altri tag generici. JSTL ha risolto molti dei problemi di JSP 1.x con l'aiuto di un linguaggio di espressione che consente di accedere agli oggetti Java dalle pagine JSP senza utilizzare il codice Java. Ad esempio, invece di cercare un attributo o accedere a un parametro di richiesta con:


  

ora puoi usare:

$ {a} $ {param.p} 

È possibile accedere agli oggetti contesto della pagina JSP, agli attributi pagina / richiesta / sessione / applicazione (noti anche come variabili JSP), proprietà JavaBean, elementi di raccolta, parametri di richiesta, parametri di inizializzazione, cookie e intestazioni HTTP.

Con JSP 1.2, il linguaggio delle espressioni è disponibile solo per le applicazioni basate su JSTL e le librerie di tag. JSP 2.0 rende EL disponibile per tutte le applicazioni JSP e tutte le librerie di tag (inclusi i vecchi taglib progettati per JSP 1.x). JSP 2.0 semplifica anche lo sviluppo della libreria di tag, come vedrai più avanti in questo articolo.

Dalla sua prima versione, JSP ha fornito tag standard per l'utilizzo di JavaBeans nelle pagine JSP. Puoi creare o trovare istanze JavaBean con , quindi puoi ottenere e impostare le loro proprietà con e . Con JSP 2.0, puoi anche ottenere il valore di una proprietà con:

$ {bean.property} 

Oltre alle proprietà, i componenti JavaBean dispongono di metodi pubblici che spesso devono essere richiamati dalle pagine JSP. Il resto di questo articolo presenterà tre modi per chiamare i metodi JavaBean senza utilizzare il codice Java. Uno si basa sul supporto JSP 2.0 per le funzioni, che sono costrutti EL che consentono di chiamare i metodi statici delle classi Java. Un'altra soluzione utilizza tag personalizzati che ottengono i parametri del metodo come attributi di tag. Il terzo modo si basa su un tag generico che consente di chiamare qualsiasi metodo pubblico di qualsiasi classe JavaBean da una pagina JSP.

Usa le funzioni

Il JSTL 1.0 EL iniziale non aveva il supporto per le funzioni. JSP 2.0 EL consente di chiamare il metodo statico pubblico di una classe Java utilizzando la seguente sintassi:

$ {prefisso: methodName (param1, param2, ...)} 

La funzione JSP deve essere dichiarata in un tag library descriptor (TLD):

 methodName className returnType methodName (param1Type, param2Type, ...)   

La classe Java non deve implementare alcuna interfaccia speciale. L'unico requisito è rendere pubblico e statico il metodo Java.

La classe TestBean

La TestBeanclasse ha un metodo pubblico denominato testMethod(), che viene chiamato dalle pagine JSP presentate nelle seguenti sezioni. Il JavaBean ha tre proprietà denominate text, numbere logic. Queste proprietà vengono modificate da testMethod(), che restituisce una stringa contenente i valori modificati delle tre proprietà:

pacchetto com.devsphere.articles.calltag; public class TestBean {private String text; numero int privato; logica booleana privata; public TestBean () {text = ""; numero = 0; logica = falso; } public String getText () {return text; } public void setText (String text) {this.text = text; } public int getNumber () {numero di ritorno; } public void setNumber (int number) {this.number = number; } public boolean getLogic () {return logic; } public void setLogic (logica booleana) {this.logic = logic; } public String testMethod (String text, int number, boolean logic) setText (getText () + text); setNumber (getNumber () + numero); setLogic (getLogic ()}

La classe TestFunction

Poiché JSP 2.0 EL consente solo chiamate a metodi statici, TestBeanè testMethod()necessario racchiudere in un metodo statico. La TestFunctionclasse fornisce un tale wrapper statico che accetta gli stessi parametri del metodo bean più l'oggetto bean il cui metodo deve essere chiamato:

pacchetto 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); }}

Il TestFunction.classfile compilato deve essere inserito TestBean.classnella /WEB-INF/classesdirectory dell'applicazione Web . In alternativa, i due file di classe possono essere compressi in un file jar e archiviati in /WEB-INF/lib.

Il TestFunction JSP

Before calling the testMethod() function, the TestFunction.jsp page must specify the function's prefix and the library's Uniform Resource Identifier (URI):


  

The tag creates an instance of the TestBean class:


  

The testMethod() function is called twice. The first call gets some constant parameters, while the second call gets the values of the bean properties as parameters:

  ${tf:testMethod(obj, "abc", 123, true)} 
   
${tf:testMethod(obj, obj.text, obj.number, obj.logic)}

The TestFunction.jsp page produces the following HTML output:

  abc 123 true 
   
abcabc 246 true

The TestFunction TLD

As mentioned earlier, the JSP function must be declared in a tag library descriptor. The TestFunction.tld file defines some version number, the tf short name used in JSP pages as prefix for testMethod(), the library's URI, the function's name, the name of the class containing the static method, and the method's signature. The URI doesn't have to point to an existing Web resource, but it must be unique. You may not use the same URI for two different tag libraries.

Here is the TestFunction.tld file's content:

  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, boolean)    

The TestFunction.tld file must be placed into the Web application's /WEB-INF directory. The same directory also contains the web.xml application descriptor, which declares the library within a element. The URI that identifies the library in JSP pages and the TLD file's location are specified within two separate XML elements, and :

  //devsphere.com/articles/calltag/TestFunction.tld   /WEB-INF/TestFunction.tld   

Use custom tags

Tag libraries were introduced by JSP 1.1, which defined the Tag and BodyTag interfaces. JSP 1.2 added IterationTag and support for catching exceptions. These interfaces have handler methods such as doStartTag(), doInitBody(), doAfterBody(), and doEndTag(). Once you understand how these methods should be implemented, it's easy to build tag libraries. However, many developers viewed JSP 1.x's tag-handling mechanism as unnecessarily complex.

JSP 2.0 introduced a much simpler tag-handling protocol. If you extend the SimpleTagSupport class, you just have to implement the doTag() method for handling a JSP tag.

The TestMethodTag class

The TestMethodTag.jsp page calls the testMethod() JavaBean method using the following syntax:


  

When the application server translates the JSP page into a servlet, the above tag is replaced with a Java code fragment that calls the methods of a TestMethodTag instance created for handling the tag.

The tag handler extends the JSP 2.0 API's SimpleTagSupport class and defines one field for each attribute. These fields will maintain the tag attributes' values:

package com.devsphere.articles.calltag; import javax.servlet.jsp.JspException; import javax.servlet.jsp.JspWriter; import javax.servlet.jsp.tagext.SimpleTagSupport; import java.io.IOException; public class TestMethodTag extends SimpleTagSupport { private TestBean object; private String text; private int number; private boolean logic; 

For each tag attribute, there must be a set method, which gets the attribute value and stores it in a field so that the tag handler can use it later:

 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(boolean logic) { this.logic = logic; } 

After setting the tag handler's attributes, the Java fragment (resulting from the JSP tag) invokes the tag handler's doTag() method, which calls the bean method. The doTag() method prints the string value returned by testMethod(). Therefore, the JSP output contains the returned value:

public void doTag () genera JspException, IOException {String ret = object.testMethod (text, number, logic); JspWriter out = getJspContext (). GetOut (); out.println (ret); }}

La classe TestMethodTag2

Supponi di voler utilizzare il valore restituito dal metodo bean in un JSP. Ad esempio, potresti doverlo passare come valore di attributo a un altro tag. Oppure potresti voler controllare il suo output nella pagina JSP:

 ... $ {ret} ...