Appel des méthodes JavaBean à partir des pages JSP 2.0

La nouvelle version de JavaServer Pages (JSP) intègre le langage d'expression (EL) introduit par la bibliothèque de balises standard JSP (JSTL) pour permettre aux concepteurs Web de produire des pages JSP sans script qui ne contiennent pas de code Java. Étant donné que JSP 2.0 offre une compatibilité descendante avec JSP 1.x, vous pouvez toujours inclure des extraits de code Java dans vos pages, mais les gestionnaires de balises et les composants JavaBean sont de bien meilleurs endroits pour les fonctionnalités basées sur Java.

JSP 2.0 fournit de nouvelles fonctionnalités pour les gestionnaires de balises telles que les attributs dynamiques, le protocole d'appel simple et les .tagfichiers. Vous utilisez toujours les anciennes actions standard JSP 1.0 pour créer des instances JavaBean et définir leurs propriétés, mais vous pouvez désormais accéder aux propriétés du bean, aux paramètres de requête et aux attributs / variables JSP avec le nouveau langage d'expression.

Toutes ces améliorations de la technologie JSP vous permettent d'atteindre l'objectif de séparer le balisage JSP / HTML du code Java. Une chose manque cependant. JSP 2.0 n'a pas de syntaxe pour appeler une méthode JavaBean non statique publique à partir d'une page JSP sans script. Cet article résout ce problème en fournissant une balise simple JSP 2.0 avec des attributs dynamiques.

Remarque: vous pouvez télécharger le code source de cet article à partir de Resources.

Langue d'expression nécessaire

Supposons que vous ayez une java.util.Listinstance que vous devez présenter sous forme de liste HTML. Voici une solution rapide basée sur JSP 1.x:

   

Les applications Web existantes basées sur JSP se composent de code Java mélangé avec du balisage HTML comme le fragment de code ci-dessus. La maintenance de centaines de pages comme celle-ci peut être un cauchemar si vous avez des équipes de développement Java et de conception Web distinctes. La solution consiste à déplacer le code Java dans des bibliothèques de balises afin que les développeurs puissent faire leur travail sans coller de code Java dans les pages Web et que les concepteurs puissent modifier leurs pages Web sans se soucier de casser le code Java.

Cependant, JSP 1.x a plusieurs problèmes qui ne vous permettent pas de développer facilement des pages JSP sans script. Jusqu'à récemment, aucune méthode standard n'existait pour accéder aux objets Java à partir d'une page JSP sans utiliser de code Java. De plus, le codage des classes de gestionnaires de balises n'était pas aussi simple qu'il aurait pu l'être.

Les lignes de code suivantes sont basées sur JSTL 1.0, qui peut être utilisé avec JSP 1.2. La balise itère sur les éléments du donné listet exporte la elemvariable pour chaque élément. Au lieu de déclarer elemcomme variable locale, la balise crée un attribut de page avec pageContext.setAttribute(). La valeur de cet attribut est imprimée avec la balise JSTL :

   

JSTL fournit des balises standard pour le traitement des documents XML et l'accès aux bases de données relationnelles ainsi que des balises de mise en forme, des balises d'internationalisation, des balises conditionnelles, des balises d'itérateur, des balises liées aux URL et d'autres balises à usage général. JSTL a résolu de nombreux problèmes de JSP 1.x à l'aide d'un langage d'expression qui vous permet d'accéder aux objets Java à partir de pages JSP sans utiliser de code Java. Par exemple, au lieu de rechercher un attribut ou d'accéder à un paramètre de requête avec:


  

vous pouvez maintenant utiliser:

$ {a} $ {param.p} 

Vous pouvez accéder aux objets de contexte de page JSP, aux attributs de page / demande / session / application (également appelés variables JSP), aux propriétés JavaBean, aux éléments de collection, aux paramètres de requête, aux paramètres d'initialisation, aux cookies et aux en-têtes HTTP.

Avec JSP 1.2, le langage d'expression n'est disponible que pour les applications basées sur JSTL et les bibliothèques de balises. JSP 2.0 rend l'EL disponible pour toutes les applications JSP et toutes les bibliothèques de balises (y compris les anciennes balises conçues pour JSP 1.x). JSP 2.0 simplifie également le développement de bibliothèques de balises, comme vous le verrez plus loin dans cet article.

Depuis sa première version, JSP a fourni des balises standard pour l'utilisation de JavaBeans dans les pages JSP. Vous pouvez créer ou rechercher des instances JavaBean avec , puis obtenir et définir leurs propriétés avec et . Avec JSP 2.0, vous pouvez également obtenir la valeur d'une propriété avec:

$ {bean.property} 

En plus des propriétés, les composants JavaBean ont des méthodes publiques qui doivent souvent être appelées à partir de pages JSP. Le reste de cet article présente trois façons d'appeler des méthodes JavaBean sans utiliser de code Java. L'une est basée sur le support JSP 2.0 pour les fonctions, qui sont des constructions EL qui vous permettent d'appeler les méthodes statiques des classes Java. Une autre solution utilise des balises personnalisées qui obtiennent les paramètres de méthode en tant qu'attributs de balise. La troisième méthode est basée sur une balise générique qui vous permet d'appeler n'importe quelle méthode publique de n'importe quelle classe JavaBean à partir d'une page JSP.

Utiliser les fonctions

Le JSTL 1.0 EL initial manquait de support pour les fonctions. Le JSP 2.0 EL vous permet d'appeler la méthode statique publique d'une classe Java à l'aide de la syntaxe suivante:

$ {préfixe: methodName (param1, param2, ...)} 

La fonction JSP doit être déclarée dans un descripteur de bibliothèque de balises (TLD):

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

La classe Java n'a pas à implémenter d'interface spéciale. La seule exigence est de rendre la méthode Java publique et statique.

La classe TestBean

La TestBeanclasse a une méthode publique nommée testMethod(), qui est appelée à partir des pages JSP présentées dans les sections suivantes. Le JavaBean a trois propriétés nommées text, numberet logic. Ces propriétés sont modifiées par testMethod(), qui renvoie une chaîne contenant les valeurs modifiées des trois propriétés:

package com.devsphere.articles.calltag; public class TestBean {private String text; numéro int privé; logique booléenne privée; public TestBean () {text = ""; nombre = 0; logique = faux; } public String getText () {texte de retour; } public void setText (String text) {this.text = text; } public int getNumber () {numéro de retour; } public void setNumber (nombre entier) {this.number = number; } public boolean getLogic () {logique de retour; } public void setLogic (logique booléenne) {this.logic = logic; } public String testMethod (String text, nombre int, logique booléenne) setText (getText () + text); setNumber (getNumber () + number); setLogic (getLogic ()}

La classe TestFunction

Étant donné que JSP 2.0 EL autorise uniquement les appels à des méthodes statiques, celles TestBean-ci testMethod()doivent être encapsulées dans une méthode statique. La TestFunctionclasse fournit un tel wrapper statique qui prend les mêmes paramètres que la méthode bean plus l'objet bean dont la méthode doit être appelée:

package com.devsphere.articles.calltag; public class TestFunction {public static String testMethod (objet TestBean, String text, nombre int, logique booléenne) {return object.testMethod (texte, nombre, logique); }}

Le TestFunction.classfichier compilé doit être placé avec TestBean.classdans le /WEB-INF/classesrépertoire de l'application Web . Comme alternative, les deux fichiers de classe peuvent être compressés dans un fichier jar et stockés dans /WEB-INF/lib.

Le JSP TestFunction

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 () jette JspException, IOException {String ret = object.testMethod (texte, nombre, logique); JspWriter out = getJspContext (). GetOut (); out.println (ret); }}

La classe TestMethodTag2

Supposons que vous souhaitiez utiliser la valeur renvoyée par la méthode bean dans une JSP. Par exemple, vous devrez peut-être le transmettre en tant que valeur d'attribut à une autre balise. Ou, vous pouvez contrôler sa sortie dans la page JSP:

 ... $ {ret} ...