Rufen Sie JavaBean-Methoden von JSP 2.0-Seiten auf

Die neue JSP-Version (JavaServer Pages) enthält die Ausdruckssprache (EL), die von der JSP Standard Tag Library (JSTL) eingeführt wurde, damit Webdesigner skriptlose JSP-Seiten erstellen können, die keinen Java-Code enthalten. Da JSP 2.0 Abwärtskompatibilität mit JSP 1.x bietet, können Sie weiterhin Java-Snippets in Ihre Seiten aufnehmen, aber Tag-Handler und JavaBean-Komponenten sind viel bessere Orte für Java-basierte Funktionen.

JSP 2.0 bietet neue Funktionen für Tag-Handler wie dynamische Attribute, das Simple Invocation Protocol und .tagDateien. Sie verwenden weiterhin die alten JSP 1.0-Standardaktionen zum Erstellen von JavaBean-Instanzen und zum Festlegen ihrer Eigenschaften. Jetzt können Sie jedoch mit der neuen Ausdruckssprache auf Bean-Eigenschaften, Anforderungsparameter und JSP-Attribute / -Variablen zugreifen.

Mit all diesen Verbesserungen der JSP-Technologie können Sie das Ziel erreichen, das JSP / HTML-Markup vom Java-Code zu trennen. Eines fehlt jedoch. JSP 2.0 hat keine Syntax zum Aufrufen einer öffentlichen nicht statischen JavaBean-Methode von einer skriptlosen JSP-Seite. Dieser Artikel löst dieses Problem, indem ein einfaches JSP 2.0-Tag mit dynamischen Attributen bereitgestellt wird.

Hinweis: Sie können den Quellcode dieses Artikels von Resources herunterladen.

Ausdruckssprache benötigt

Angenommen, Sie haben eine java.util.ListInstanz, die Sie als HTML-Liste präsentieren müssen. Hier ist eine schnelle Lösung, die auf JSP 1.x basiert:

   

Bestehende JSP-basierte Webanwendungen bestehen aus Java-Code, der mit HTML-Markup wie dem obigen Codefragment gemischt ist. Das Verwalten von Hunderten solcher Seiten kann ein Albtraum sein, wenn Sie separate Java-Entwicklungs- und Webdesign-Teams haben. Die Lösung besteht darin, den Java-Code in Tag-Bibliotheken zu verschieben, damit Entwickler ihre Arbeit erledigen können, ohne Java-Code in Webseiten einzufügen, und Designer ihre Webseiten bearbeiten können, ohne sich Gedanken über das Brechen des Java-Codes machen zu müssen.

JSP 1.x weist jedoch einige Probleme auf, mit denen Sie skriptlose JSP-Seiten nicht einfach entwickeln können. Bis vor kurzem gab es keine Standardmethode für den Zugriff auf Java-Objekte von einer JSP-Seite ohne Verwendung von Java-Code. Darüber hinaus war das Codieren von Tag-Handler-Klassen nicht so einfach, wie es hätte sein können.

Die folgenden Codezeilen basieren auf JSTL 1.0, das mit JSP 1.2 verwendet werden kann. Das Tag durchläuft die Elemente des angegebenen Elements listund exportiert die elemVariable für jedes Element. Anstatt elemals lokale Variable zu deklarieren , erstellt das Tag ein Seitenattribut mit pageContext.setAttribute(). Der Wert dieses Attributs wird mit dem JSTL- Tag gedruckt :

   

JSTL bietet Standard-Tags für die Verarbeitung von XML-Dokumenten und den Zugriff auf relationale Datenbanken sowie Formatierungs-Tags, Internationalisierungs-Tags, bedingte Tags, Iterator-Tags, URL-bezogene Tags und andere Allzweck-Tags. JSTL hat viele Probleme von JSP 1.x mithilfe einer Ausdruckssprache gelöst, mit der Sie von Java-Seiten aus auf Java-Objekte zugreifen können, ohne Java-Code zu verwenden. Anstatt beispielsweise nach einem Attribut zu suchen oder auf einen Anforderungsparameter zuzugreifen mit:


  

Sie können jetzt verwenden:

$ {a} $ {param.p} 

Sie können auf die JSP-Seitenkontextobjekte, Seiten- / Anforderungs- / Sitzungs- / Anwendungsattribute (auch als JSP-Variablen bezeichnet), JavaBean-Eigenschaften, Auflistungselemente, Anforderungsparameter, Initialisierungsparameter, Cookies und HTTP-Header zugreifen.

Mit JSP 1.2 ist die Ausdruckssprache nur für JSTL-basierte Anwendungen und Tag-Bibliotheken verfügbar. JSP 2.0 stellt die EL allen JSP-Anwendungen und allen Tag-Bibliotheken zur Verfügung (einschließlich der alten Taglibs für JSP 1.x). JSP 2.0 vereinfacht auch die Entwicklung von Tag-Bibliotheken, wie Sie später in diesem Artikel sehen werden.

Seit seiner ersten Version stellt JSP Standard-Tags für die Verwendung von JavaBeans in JSP-Seiten bereit. Sie können JavaBean-Instanzen mit erstellen oder finden und dann ihre Eigenschaften mit und abrufen und festlegen . Mit JSP 2.0 erhalten Sie möglicherweise auch den Wert einer Eigenschaft mit:

$ {bean.property} 

Zusätzlich zu den Eigenschaften verfügen JavaBean-Komponenten über öffentliche Methoden, die häufig von JSP-Seiten aufgerufen werden müssen. Der Rest dieses Artikels enthält drei Möglichkeiten zum Aufrufen von JavaBean-Methoden ohne Verwendung von Java-Code. Eine basiert auf der JSP 2.0-Unterstützung für Funktionen, bei denen es sich um EL-Konstrukte handelt, mit denen Sie die statischen Methoden von Java-Klassen aufrufen können. Eine andere Lösung verwendet benutzerdefinierte Tags, die die Methodenparameter als Tag-Attribute abrufen. Der dritte Weg basiert auf einem generischen Tag, mit dem Sie eine beliebige öffentliche Methode einer JavaBean-Klasse von einer JSP-Seite aus aufrufen können.

Verwenden Sie Funktionen

Die anfängliche JSTL 1.0 EL hatte keine Unterstützung für Funktionen. Mit der JSP 2.0 EL können Sie die öffentliche statische Methode einer Java-Klasse mit der folgenden Syntax aufrufen:

$ {Präfix: Methodenname (param1, param2, ...)} 

Die JSP-Funktion muss in einem Tag Library Descriptor (TLD) deklariert werden:

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

Die Java-Klasse muss keine spezielle Schnittstelle implementieren. Die einzige Voraussetzung ist, die Java-Methode öffentlich und statisch zu machen.

Die TestBean-Klasse

Die TestBeanKlasse hat eine öffentliche Methode mit dem Namen testMethod(), die von den in den folgenden Abschnitten vorgestellten JSP-Seiten aufgerufen wird. Die JavaBean hat drei Eigenschaften genannt text, numberund logic. Diese Eigenschaften werden geändert durch testMethod(), wodurch eine Zeichenfolge zurückgegeben wird, die die geänderten Werte der drei Eigenschaften enthält:

Paket com.devsphere.articles.calltag; öffentliche Klasse TestBean {privater String-Text; private int number; private boolesche Logik; public TestBean () {text = ""; Zahl = 0; Logik = falsch; } public String getText () {Rückgabetext; } public void setText (String text) {this.text = text; } public int getNumber () {return number; } public void setNumber (int number) {this.number = number; } public boolean getLogic () {Rückgabelogik; } public void setLogic (boolesche Logik) {this.logic = Logik; } public String testMethod (String text, int number, boolesche Logik) setText (getText () + text); setNumber (getNumber () + number); setLogic (getLogic ()}

Die TestFunction-Klasse

Da der JSP 2.0 EL ruft erlaubt nur auf statische Methoden, TestBean‚s testMethod()muss in einer statischen Methode gewickelt werden. Die TestFunctionKlasse stellt einen solchen statischen Wrapper bereit, der dieselben Parameter wie die Bean-Methode sowie das Bean-Objekt verwendet, dessen Methode aufgerufen werden muss:

Paket com.devsphere.articles.calltag; öffentliche Klasse TestFunction {public static String testMethod (TestBean-Objekt, String-Text, int-Nummer, boolesche Logik) {return object.testMethod (Text, Nummer, Logik); }}

Die kompilierte TestFunction.classDatei muss zusammen mit TestBean.classim /WEB-INF/classesVerzeichnis der Webanwendung abgelegt werden . Alternativ können die beiden Klassendateien in eine JAR-Datei gepackt und in gespeichert werden /WEB-INF/lib.

Die 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 () löst JspException, IOException aus {String ret = object.testMethod (Text, Nummer, Logik); JspWriter out = getJspContext (). GetOut (); out.println (ret); }}

Die TestMethodTag2-Klasse

Angenommen, Sie möchten den von der Bean-Methode zurückgegebenen Wert in einer JSP verwenden. Beispielsweise müssen Sie es möglicherweise als Attributwert an ein anderes Tag übergeben. Oder Sie möchten die Ausgabe auf der JSP-Seite steuern:

 ... $ {ret} ...