JSP - techniques avancées

Chapitres traités    Langage d'expressions - EL Les constantes littérales Les opérateurs Conversions et valeurs par défaut Les objets implicites Utilisation des expression EL Actions personnalisées Les actions personnalisées Les gestionnaires de balises Descripteur de bibliothèque de balises Structure de l'application Web pour intéger des actions personnalisées Importer une bibliothèque de balises et utilisation de ces balises dans la page JSP JSP Standard Tag Library - JSTL Obtention d'une implémentation Contenu de la bibliothèque JSTL Les actions fondamentales Utilisation de la JSTL

Dans l'étude précédente, nous avons présenté les pages JSP et nous en avons suffisament appris pour commencer à écrire des pages et à les utiliser pour construire des applications Web. Cette étude va nous aider à concevoir des pages JSP de façon beaucoup plus agréables. En effet, il faut reconnaître que pour l'instant, nous trouvons encore trop de code Java au milieu du balisage HTML et JSP.

Effectivement, il faut se mettre à la place du webmaster qui ne possède pas spécialement des connaissances en Java, mais par contre, il est particulièrement efficace dans la manipulation des balises. Nous allons faire en sorte d'aider au maximum le webmaster en lui proposant des éléments adaptés à la situation. Les techniques que nous allons mettre en oeuvre pour cela sont les suivantes :

1. Langage d'expressions - permet de manipuler des données de façon plus naturelle. Ce langage permet, par exemple, l'accès aux propriétées des objets placés en attribut des scopes, aux paramètres de la requête sans passer par la syntaxe des expressions classiques de jSP <%= %> qui est un peu délicate à manipuler et d'une syntaxe toujours plus longue.
2. Actions personnalisées - Les actions standards permettent d'encapsuler le code Java de façon à ce qu'il soit invisible dans les pages JSP. Les développeurs des pages n'ont ainsi à connaître que la syntaxe des actions, et non la syntaxe Java. Mais les actions standards peuvent accomplir un nombre de tâches limité. Heureusement, il est possible de créer de nouvelles actions, appelées actions personnalisées. Les balises utilisées pour définir ces actions sont appelées balises étendues.
3. JSTL - Plutôt que des développeurs créent des actions personnalisées chacun de leur côté pour des tâches courantes, la spécification JSTL (JSP Standard Tag Library - bibliothèque standard de balises JSP) a été développée pour répondre à la plupart des besoins et procure déjà un grand nombre d'actions très utiles et très intéressantes.

Avec les actions JSP, les actions JSTL, les actions personnalisées, les Javabeans, il est possible de construire un site n'utilisant qu'une syntaxe XML.
.

Langage d'expressions - EL

Dans l'étude précédente, nous avons vu comment créer des éléments de script pouvant être utilisés pour placer du code Java dans les pages JSP. Ces éléments sont les déclarations, les scriptlets et les expressions :

<%! int a = 5; %> <%-- déclaration --%>
<% while (x<10) { out.write("x="+x); } %> <%-- srciptlet --%>
<%= utilisateur.getPrénom() %> <%-- expression --%>

La spécification JSP 2.0 a ajouté le langage d'expressions (Expression Language, ou EL) à la panoplie des outils JSP. Les instructions de ce langage sont d'une syntaxe plus simple tout en permettant d'obtenir les mêmes résultats que les éléments de script.

Une expression en EL débute par ${ et se termine par } . La syntaxe fondamentale est donc la suivante :

${une expression}

L'expression ne s'imprime pas à l'écran sans être traitée. Ainsi :

${utilisateur}

peut être une variable par exemple. Mais elle peut être aussi le résultat d'une opération. Ainsi :

${1+2} imprime 3 sur la page HTML envoyée

Ce trois correspond d'ailleurs au caractère '3' ce qui veut dire que le changement de type est automatiquement réalisé. Par ailleurs, les caractères spéciaux sont interprétés comme du code HTML. Si une variable contient " é ", elle s'exprimera &eacute ; . Ainsi l'expression :

${prénom} (ou prénom est égal à "rené") imprime sur la page HTML " ren&eacute ; "

Les expressions peuvent comporter des constantes littérales, des opérateurs, des références vers des variables ou vers des objets implicites, et des appels de fonctions.
.

Les constantes littérales

La syntaxe EL comporte plusieurs types de constantes littérales qui peuvent être employées dans les expressions :

1. Les valeur booléennes - true, false.
2. Les chaînes de caractères - N'importe quelle suite de caractères placées entre guillemets ou entre apostrophes. La barre oblique inverse peut être utilisée comme caractère d'échappement pour les guillemets et les apostrophes. Par exemple : 'Cette chaîne contient un exemple d\'apostrophe avec deux caractères d\'échappement' ou : "le dossier est c:\\Mes documents\\Travail". Le caractère d'échappement est uniquement nécessaire pour les caractères identiques aux délimiteurs de la chaîne. Du coup, puisque nous avons le choix, il suffit de prendre les bons délimiteurs. Le caractère d'échappement n'est pas nécessaire dans l'exemple suivant : "Cette chaîne contient un exemple d'apostrophe sans caractère d'échappement".
3. Les valeurs entières - N'importe quel nombre entier, positif ou négatif : -13, 45, 2374, etc.
4. Les valeurs réelles - N'importe quelle valeur numérique exprimée en virgule flottante (mais en remplaçant la virgule par un point !) : -1.3E-30, 3.14159, .45, etc.
5. La valeur null.

En voici quelques exemples :

${true}
${"Les apostrophes à l'intérieur des guillemets n'ont pas besoin de caractères d'échappement"}
${2*4} --> 8
${(2*4)+3} --> 11

Les opérateurs

La plupart des opérateurs Java sont disponibles dans le langage d'expressions :

La plupart des opérateurs nous sont familiers. Notez toutefois que de nombreux opérateurs disposent d'une notation symbolique et d'une variante littérale, tels / et div, ou && et and. Ces équivalents sont utiles si vos pages JSP doivent être conformes à la norme XML. Cela évite d'avoir à utiliser des entités, tel < à la place de <. Dans un document XML, une expression EL signifiant " plus petit que " peut être codé :

${2 lt 3} plutôt que ${2 < 3}

Voici quelques exemples :

${(2*4)+3} --> 11
${2*(3+4)} --> 14
${maListe[1] > monTableau[2] and test == false}

L'opérateur empty

L'opérateur empty permet de tester différentes conditions. L'expression :

${empty nom}

retourne true si nom est null, ou s'il référence une instance vide de String, List, Map, ou encore un tableau vide. Dans le cas contraire, empty retourne la valeur false. L'objet référencé par nom peut se trouver dans un des objets implicites page, request, session ou application. Par exemple :

<% Vector vec = new Vector();	// Crée un vecteur vide							
	pageContext.setAttribute("nom", vec); %>// Place le vecteur dans pageContext
...
${empty nom}	// Evalué à true ; notez que l'opérateur prend pour opérande l'attribut nom, et non la valeur vec

1. N'oubliez pas que cette technique fonctionne pour tous les objets présents dans un des contextes, et non pas seulement pour ceux qui y sont ajoutés explicitement, par exemple à l'aide de la méthode setAttribute( ).
2. Comme nous le verrons plus loin, les actions personnalisées peuvent créer des variables accessibles grâce à des expressions EL. L'opérateur empty peut être appliqué à ces variables.
3. Les JavaBeans sont également un moyen d'ajouter des objets aux contextes. Les JavaBeans sont stockés dans le contexte correspondant à l'attribut scope de l'action <jsp:useBean>. L'important est que l'opérateur empty peut être appliqué à tous les objets se trouvant sur un des contextes et pouvant être référencé par un nom.

Les opérateurs . et [ ]

Les deux derniers opérateurs sont le point ( . ) et l'opérateur d'indexation ( [ ] ). Ils sont utilisés pour accéder aux attributs d'un objet de la page. La valeur située à gauche de l'opérateur est interprétée comme représentant un objet de la page. La valeur située à droite est une propriété, une clé, ou un index. Par exemple, si vous avez défini un bean à l'aide de l'action standard <jsp:useBean>, vous pouvez accéder à ses propriétés en utilisant ces deux notations. Si un bean utilisateur possède deux propriétés nom et prénom, celles-ci sont accessibles en utilisant les notations suivantes :

${utilisateur.prénom}
${utilisateur[prénom]}

Ces deux notations sont équivalents pour accéder aux propriétés d'un objet. Dans les deux cas, la page tente de trouver l'objet utilisateur et d'appeler sa méthode getPrenom( ).

Ces deux opérateurs peuvent également être employés avec des objets de type Map ou List, ou encore avec des tableaux. Si l'objet est une Map, la valeur de droite est utilisée comme une clé. ainsi le code suivant :

${unObjet[nom]} ou ${unObjet.nom}

est équivalent à :

unObjet.get("nom") ;

Si l'opérateur est appliqué à une List ou à un tableau, la page tente de convertir la valeur de droite en index, et accède au résultat en utilisant les méthodes get( ) adaptée à la circonstance :

unObjet.get(nom) ; // unObjet est une List --- appel de la méthode get(int)
Array.get(unObjet, nom) ; // unObjet est un tableau --- appel de la méthode get(Object, int)

Conversions et valeurs par défaut

EL peut effectuer un certain nombre de conversions de façon implicite. Parmi les conversions, il y a bein entendu les conversions déjà supportées par Java comme les conversions d'une valeur entière en valeur double, mais aussi la conversion des types objet encapsulant des valeurs scalaires vers ces valeurs scalaires.

Ansi, si x est une référence sur une instance de java.lang.Integer, l'expression :

${x+3} // est acceptée par EL. Son évaluation extrait la valeur entière encapsulée par l'objet référencé par x, et ajoute 3 à cette valeur.

De plus, les conversions automatiques sont faites aussi sur les chaînes de caractères. Ainsi :

${param.x+2} converti la chaine param.x en valeur entière.

Au passage, remarquons que le symbole + dénote toujours l'addition. En effet, param.x est une chaîne de caractère puisque c'est la valeur du paramètre x de la requête. En java pur, le symbole + serait interprété, dans ce cas là, comme la concaténation de cette chaîne avec la chaine "2". En EL, au contraire, le symbole + est ici compris comme l'addition de la conversion de param.x en entier de 2. Cette expression invoque donc implicitement la méthode Integer.parseInt().

Gestion des exceptions à l'intérieur d'une expression

Une expression EL fournit toujours une valeur, même lorque une exception raisonnable survient. Il s'agit, à ce moment là, d'une valeur par défaut. Par exemple, si nous essayons d'accéder à une propriété d'un objet via une référence nulle, EL traite l'exception java.lang.NullPointerException et renvoie la valeur null. A son tour, la valeur null est remplacée par la chaîne vide si le contexte attend une chaîne, 0 si le contexte attend une valeur numérique.

Ainsi, l'expression ${ param.x + 15 } vaut 15 si la requête http ne possède pas de paramètres x.

De même, l'expression ${ unTableau[5] } renvoie null si la variable unTableau vaut null ou si elle référencie un tableau ou une liste ayant moins de six éléments.

Les objets implicites

Les expressions EL ont accès à des objets implicites. La plupart sont les mêmes que ceux disponibles dans les scriptlets et les expressions JSP. Grâce à ces objets, les expressions EL permettent de réaliser la plupart des tâches qui peuvent être effectuées par ces dernières. Les objets implicites sont les suivants :

1. pageContext - L'objet de type javax.servlet.jsp.PageContext correspond à la page. Il peut être employé pour accéder ensuite aux objets implicites utilisés par les pages JSP : request, response, session, out, etc. Par exemple, ${pageContext.request} renvoie l'objet request de la page.
2. pageScope - Une Map permettant d'accéder aux objets dont la portée est page. Ainsi, si un objet est placé dans la page avec le nom monObjet, une expression EL est en mesure d'y accéder grâce à la syntaxe ${pageScope.monObjet}. Pour accéder à une des propriétés de l'objet, il suffit d'utiliser la syntaxe ${pageScope.monObjet.nomPropriété}.
3. requestScope - Une Map permettant d'accéder aux objets dont la portée est request. Cet objet permet d'accéder aux attributs de l'objet request.
4. sessionScope - Une Map permettant d'accéder aux objets dont la portée est session. Cet objet permet d'accéder aux attributs de l'objet session.
5. applicationScope - Une Map permettant d'accéder aux objets dont la portée est application. Cet objet permet d'accéder aux attributs de l'objet application.
6. param - Une Map contenant les valeurs des paramètres de la requête sous forme de paires formées d'un nom de paramètre et de la représentation de sa valeur sous forme d'une chaîne de caractères. Souvenez-vous que l'objet request contient les données envoyées par le client. La méthode getParameter(String) retourne la valeur du paramètre dont le nom est indiqué. L'expression ${param.nom} est équivalente à request.getParameter(nom). (Notez que nom n'est pas la chaîne 'nom', mais le nom du paramètre).
7. paramValues - Une Map mettant en relation le nom de chaque paramètre avec un tableau de String représentant ses valeurs (obtenues en appelant la méthode ServletRequest.getParameterValues(String nom)). La différence avec l'objet précédent est que le résultat est un tableau de valeurs et non une valeur unique. Par exemple, ${paramValues.nom} est équivalent à request.getParameterValues(nom).
8. header - Une Map contenant les en-têtes HTTP et leurs valeurs (obtenues grâce à la méthode ServletRequest.getHeader(String nom)). Les requêtes contiennent toujours un certain nombre d'en-têtes : type de contenu, longueur, cookies, URL référente, etc. L'expression ${header.nom} est équivalente à request.getHeader(nom).
9. headerValues - Une Map mettant en relation le nom de chaque en-tête avec un tableau de String représentant ses valeurs (obtenues grâce à la méthode ServletRequest.getHeaders(String nom)). Cet objet est semblable à l'objet implicite header. L'expression ${headerValues.nom} est équivalente à request.getHeaderValues(nom).
10. cookie - Une Map associant les objets Cookie à leurs noms. Un client peut envoyer un ou plusieurs cookies au serveur avec sa requête. L'expression ${cookie.nom.value} retourne la valeur du premier cookie portant le nom indiqué. Si la requête est susceptible de contenir plusieurs cookies de même nom, il faut utiliser la méthode ${headerValues.nom}.
11. initParam - Une Map associant les noms des paramètres d'initialisation et leur valeurs (obtenues grâce à la méthode ServletRequest.getInitParameter(String nom)). Pour accéder à un paramètre d'initialisation, utilisez ${initParam.nom}.

Contexte de page

Le contexte de page est une référence sur l'objet décrivant le contexte d'exécution de la page. Il est représenté par l'objet implicite pageContext.

ATTENTION, les variables déclarées dans les scripts de déclaration <%= variable %> ne sont pas accessibles directement par les expressions. Il faut placer les variables qui seront ensuite exploitées par les expressions EL au moyen de la méthode setAttribute() de l'objet implicite pageContext.

La méthode setAttribute() attend deux paramètres : Une chaîne de caractères qui correspond au nom donné à l'attribut suivi de la valeur à stocker (doit être également une chaîne de caractères). En fait, cet attribut reprend la philosophie du couple nom/valeur comme pour un paramètre de requête. C'est pour cette raison que nous ne devons avoir que des chaînes de caractères. Une fois que cette opération est réalisée, nous pouvons récupérer la valeur stockée à l'aide de l'expression EL en spécifiant juste le nom de l'attribut.

<% String message = "Mon message";	/						
	pageContext.setAttribute("texte", message); %>// Place message dans le contexte de page : pageContext
...
${ texte}	//utilisation  de l'attribut texte à l'aide de l'expression EL. ATTENTION, c'est le nom de l'attribut qu'il faut prendre et pas la variable message.

Quelques exemples qui exploitent ces objets implicites.

${pageContext.request.remoteHost} // Récupérer l'adresse IP du client :

Dans le code suivant, le bean a la portée page et possède une propriété prénom :

<jsp:useBean id = "utilisateur"  scope = "page" class = "Personne">
	<jsp:setProperty name = "utilisateur" property = "prénom" />
</jsp:useBean>
...
${pageScope.utilisateur.prénom} // Renvoie la propriété prénom du bean utilisateur.

<% session.put("adresse", "12, rue de Java."); %>
${sessionScope.adresse} // renvoie '12, rue de Java'
<%= session.get("adresse") %>  // expression JSP équivalente

${header["accept-encoding"]}

L'objet implicite initParam désigne la table des paramètres d'initialisation de l'application Web :

${initParam.couleurFond}

Paramètres de la requête

EL désigne donc les paramètres de la requête au moyen de l'objet implicite param. Cet objet est une collection (Map) dont les éléments peuvent être désignés via les opérateurs [ ] et . :

Les JavaBeans

Les expressions EL offre un accès direct à tous les objets placés en attributs dans l'un des quatre scopes standard :

<jsp:useBean id="compteur" class="Compteur" scope="application" />
...
${compteur.valeur+1}

Dans cet exemple, EL résoud l'identificateur compteur en retrouvant le bean placé en attribut de l'application puis résoud l'identificateur valeur comme étant une propriété de ce bean. Le message getValeur() est alors envoyé au bean. Au besoin, le résultat de celle-ci est utilisé par le contexte (la page).

Attention, EL ne peut pas accéder aux variables Java définies dans la page JSP, EL n'accède qu'aux attributs des quatre scopes standard.
.

Utilisation des expression EL

Les expressions EL peuvent être utilisées comme attributs des actions standards et personnalisées. Elles peuvent aussi être palacées ailleurs dans le texte de la page, c'est-à-dire dans le code HTML. Le code suivant montre l'utilisation d'une expression EL comme attribut d'une action standard <jsp:forward> :

<jsp:forward page=" ${param.nextPage}"  />

Dans cet exemple, l'action <jsp:forward> transmet la requête à l'URL spécifiée par le paramètre de la requête nextPage. Si le paramètre n'existe pas ou si la valeur n'est pas une URL valide, la page produit une erreur.

Modification de notre application Web messagerie afin de tenir compte des expressions EL

Nous allons juste montrer le changement obtenu avec l'utilisation des expressions EL sur deux pages JSP : le fragment de page <navigation.jspf> et la page <validerutilisateur.jsp> :

 1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 2 
 3 <%@ page errorPage = "/WEB-INF/erreur.jsp" import="bd.*" %>
 4 
 5 <%! int idPersonne = 1; %>
 6 
 7 <% 
 8     String identité = "A tout le monde";
 9     Personne opérateur = (Personne) session.getAttribute("utilisateur"); 
10     if (opérateur != null) {
11         idPersonne = opérateur.identificateur();
12         identité = opérateur.getPrénom()+" "+opérateur.getNom();
13     }
14     pageContext.setAttribute("personne", identité);
15 %>   
16    
17 <html>
18   <head><title>Messages</title></head>
19   <body bgcolor="#${initParam.couleurFond}">
20     <font face="Arial">
21         <h2 align="center">Messages</h2>
22         <hr>
23         <table bgcolor="1" cellpadding="3" cellspacing="2" width="90%" align="center">
24             <tr bgcolor="#FF9900">
25                 <th align="left"><a href="bienvenue">Sujets</th>
26                 <th align="right">
27                     <% if (idPersonne == 1) { %>
28                         <a href="utilisateur?authentification=personnel">Identification</a>
29                         <a href="utilisateur?authentification=nouveau">Inscription</a>
30                     <% } 
31                        else { %>     
32                          <a href="#">Nouveau</a>
33                          <a href="#">Modifier</a>
34                          <a href="#">Enlever</a>
35                     <% } %>   
36                 </th>
37             </tr>
38             <tr>
39                 <th align="left">${personne}</th>
40                 <th align="right">${pageContext.request.remoteHost}</th>
41             </tr>
42         </table>
43

Ligne 8 :

Cette fois-ci la chaîne identité n'est plus déclarée dans un script de type déclaration mais dans une scriptlet classique. Toutefois, identité va être utilisée ultérieurement dans la page, mais cette fois-ci par une expression EL. Hors, cette dernière ne peut pas accéder directement aux scripts de type déclaration.

Ligne 14 :

Pour pouvoir récupérer l'identité de la personne, il faut la placer dans le contexte de page afin qu'elle soit accessible par les expressions EL. Ici, le nom de l'attribut est personne, et c'est lui qu'il faudra solliciter pour récupérer effectivement la valeur de l'identité de la personne.

Lignes 19 :

Récupération du paramètre d'intitialisation couleurFond de l'application Web.

Lignes 39 :

Récupération de l'attribut personne préalablement stockée dans le contexte de page.

Ligne 40 :

Récupération de l'adresse IP de l'ordinateur client.

 1 <%@ include file = "/WEB-INF/jspf/navigation.jspf" %>
 2 
 3 <h3 align="center">Confirmation de votre demande d"inscription</h3>
 4 
 5 <jsp:useBean id="utilisateur" class="bd.Personne" scope="session">
 6     <jsp:setProperty name="utilisateur" property="*" />
 7 
 8     <p><table border="1" cellpadding="3" cellspacing="2" width="90%" align="center">
 9         <tr>
10             <td bgcolor="#FF9900" width="100"><b>Nom</b</td>
11             <td>${utilisateur.nom}</td>
12         </tr>
13         <tr>
14             <td bgcolor="#FF9900" width="100"><b>Prénom</b></td>
15             <td>${utilisateur.prénom}</td>
16         </tr>
17         <tr>
18             <td bgcolor="#FF9900" width="100"><b>Mot de passe</b></td>
19             <td>${utilisateur.motDePasse}</td>
20         </tr>
21     </table></p>
22 </jsp:useBean>    
23     
24 <h3 align="center">
25 <% if (!utilisateur.enregistrer()) {  %>
26      <font color="red">ATTENTION : Utilisateur déja enregistré</font>
27 <% 
28         session.removeAttribute("utilisateur");
29     } else { 
30 %>
31      <font color="green">Nouvel utilisateur enregistré</font>    
32 <% } %>
33 </h3>
34 
35 <%@ include file = "/WEB-INF/jspf/pieds.jspf" %>

Ligne 11, 15, 19 :

Récupération des propriétés nom, prénom et motDePasse du bean utilisateur.

 

Les bibliothèques de balises personnalisées

A plusieurs reprises, aux cours des études précédentes, nous avons évoqué la possibilité de débarrasser les pages JSP de tout code Java, de façon à séparer autant que possible l'affichage de la logique métier. En fait, il ne s'agit pas vraiment de supprimer le code Java, mais de le masquer de façon qu'il soit invisible pour les développeurs des pages. Par exemple, dans notre application Web, nous avons employé certaines actions standards définies par la spécification. Les actions standards sont des actions qui doivent être implémentées par tous les conteneurs JSP.

Une action standard est notée sous la forme d'éléments délimités par des balises XML. Voici l'élément correspondant à l'action useBean. Il contient lui-même une action setProperty :

<jsp:useBean id="utilisateur" class="bd.Personne">
	<jsp:setProperty name="utilisateur" property="*" />
</jsp:useBean>

Une balise commence par le préfixe d'espace de noms jsp (les espaces de nom sont l'équivalent XML des packages Java). Le préfixe est suivi du nom de l'action. Les actions standards peuvent avoir un certain nombre d'attributs, et certianes ont un contenu, placé entre la balise d'ouverture et la balise de fermeture. Le contenu peut inclure d'autres balises, comme dans l'exemple ci-dessus, ou du texte ou du code HTML. Ces balises utilisent la syntaxe XML.

Le traducteur JSP voit les balises sous un angle un peu différent. De son point de vue, il s'agit de marqueurs devant être remplacés par du code Java implémentant la fonctionnalité de la balise. Ainsi, le code Java n'est pas retiré des pages, il est simplement encapsulé dans les balises. Lorsque le traducteur de JSP rencontre la première balise de l'exemple précédent, il la remplace par :

utilisateur = (bd.Personne) java.beans.Beans.instanciate(this.getClass().getClassLoader(), "bd.Personne") ;

Si les actions disponibles étaient les actions standards, nous ne pourrions pas nous passer de code Java dans les pages JSP. Heureusement, la spécification prévoit un moyen pour les développeurs de créer de nouvelles actions, appelées actions personnalisées. Ces actions sont déployées à l'aide des bibliothèques de balises personnalisées (custom tag libraries). Le mécanisme consistant à définir, implémenter, déployer et exécuter les actions personnalisées est appelé extension de balises (tag extension). A l'aide des actions standards et des actions personnalisées, un concepteur de pages Web peut créer des pages dynamiques sans avoir la moindre connaissance de Java.

Différentes phases dans la création de balises personnalisées

La création de balises Java passe par les étape suivantes :

1. Ecriture des classes Java implémentant les balises à créer,
2. Création des fichiers de description des différentes balises (bibliothèques de balises personnalisées),
3. Modification du descripteur de déploiement <web.xml> pour que l'application Web connaisse ces balises aux démarrages.
4. Utilisation de ces balises dans les pages JSP.

Dans la suite de ce chapitre, nous allons commencer par la fin, c'est-à-dire par l'utilisation des balises qui représentent les actions personnalisées.

Les actions personnalisées

Le terme action personnalisée (et action standard) fait généralement référence à une balise dans une page JSP. Les actions personnalisées peuvent être employée dans les pages JSP comme des balises ordinaires. Elles sont identifiées par un préfixe et un nom :

<préfixe:nom />

Le préfixe permet d'éviter les conflits de noms entre les balises de différentes bibliothèques. Il est choisi par le développeur de pages, bien que le développeur de la bibliothèque de balises puisse suggérer un nom. Le préfixe est suivi du nom de l'action, qui est choisi par le développeur de la bibliothèque.

Les actions personnalisées peuvent être vides :

<x:actionPersonnalisée /> // Balise d'ouverture et de fermeture combinées en une seule
<x:actionPersonnalisée></x:actionPersonnalisée> // balises séparées

Elles peuvent avoir un corps :

<x:actionPersonnalisée> 
	Corps de l'action 
</x:actionPersonnalisée>

Le code Java implémentant la balise peut évaluer le corps de l'action, ou au contraire l'ignorer. Les actions peuvent être imbriquées, comme pour les beans :

<jsp:useBean id="utilisateur" class="bd.Personne">
	<jsp:setProperty name="utilisateur" property="*" />
</jsp:useBean>

Comme le montre les exemples de <jsp:useBean> et <jsp:setProperty>, les actions peuvent avoir des attributs qui spécifient les détails de leur comportement. Elles ont accès aux objets implicites (request, response, session, etc.) et peuvent les utiliser pour modifier la réponse renvoyée au client. Les actions personnalisées peuvent créer des objets qui pourront ensuite être manipulés par d'autres actions ou des scriptlets.

Le comportement d'une action est défini lors de l'exécution par une instance d'une classe Java. Cette classe est appelée gestionnaire de balises.
.

Afin de bien maîtriser tous ces concepts, nous allons nous servir de l'applications Web Messagerie à l'intérieur de laquelle nous allons définir un certain nombre de balises personnalisées qui va permettre d'alléger considérablement le code des pages JSP.

Balise personnalisée <:date> pour notre application Web Messagerie

A titre d'exemple, nous allons créer plusieurs balises personnalisées qui vont nous permettre de simplifier considérablement l'écriture des pages JSP du site de la messagerie. La première balise à fabriquer consiste à afficher la date du jour avec le format français adapté, tel que nous l'avons déjà mis en oeuvre dans le pieds de page <pieds.jspf> :

<%@page import="java.util.Date, java.text.DateFormat" %>

<%!
    DateFormat formatDate = DateFormat.getDateInstance(DateFormat.FULL);
 %> 
        <br><hr>
        <h4 align="right"><%= formatDate.format(new Date()) %></h4>
     </font>
   </body>
</html>

Vous remarquez que sur cette simple petite page JSP (fragment), nous avons pas mal de code Java intégré. L'investissement qui consiste à créer une nouvelle balise personnalisée vaut le coup ici. Surtout que ce type de balise peut être utilisé pour bien d'autres applications Web. Ainsi, il serait judicieux de nommer cette balise <:date> ou éventuellement <util:date> si nous utilisons le préfixe correspondant à l'espace de nom (le " : " est de toute façon nécessaire). Voici du coup le changement obtenu avec l'utilisation d'une telle balise :

        <br><hr>
        <h4 align="right"><:date></h4>
     </font>
   </body>
</html>

Le changement est ici considérable. La page gagne largement en clarté avec en plus, très peu de lignes de code. Même pour un développeur Java, sans parler du webmaster, il est préférable de travailler de cette façon. Il est en effet fréquent de ne plus se souvenir des classes et des méthodes à utiliser pour réaliser une opération particulière, comme ici, le formatage d'une date. Une simple balise nous permet de réaliser l'opération souhaitée.

Balises personnalisées permettant d'afficher la liste des messages de notre application Web

Passons maintenant à la deuxième page que je désire modifier. Il s'agit de la page <bienvenue.jsp> qui propose entre autre le listing des messages associés à la personne. Je rappelle, ci-dessous, l'affichage de cette page :

 2 <%@ include file = "/WEB-INF/jspf/navigation.jspf" %>
 3 
 4 <font face="Arial">
 5 
 6 <p><table border="1" cellpadding="3" cellspacing="2" width="90%" align="center">    
 7     <tr bgcolor="#FF6600">
 8         <th>Sujet</th>
 9         <th>Message</th>
10     </tr>
11     <%   
12         ListeMessages listeMessages = new ListeMessages(idPersonne);
13         int ligne = 0;
14         while (listeMessages.suivant()) {
15     %>
16     <tr bgcolor="<%= ligne++ % 2 == 0 ? "#FFFF66" : "#FFCC00" %>">
17         <td><b><%= listeMessages.sujet() %></b></td>
18         <td><%= listeMessages.texte() %></td>
19     </tr>
20     <%
21         }
22         listeMessages.arrêt();
23     %>
24 </table></p>
25 </font>
26 
27 <%@ include file = "/WEB-INF/jspf/pieds.jspf" %>

Le but ici est de créer des actions imbriquées afin de représenter un tableau avec toutes les colonnes désirées de n'importe quelle table issue de n'importe quelle base de données. Ainsi, les balises personnalisées que nous allons mettre en oeuvre pourront être déployées sur d'autres applications Web. Le nom de l'utilisateur de la base de données ainsi que son mot de passe ne doivent pas apparaître, ils seront collectés à partir des paramètres d'initialisation de l'application Web, qu'il faut définir dans le descripteur de déploiement. Voici, ce que nous pourrions obtenir en prenant en compte toutes ces considérations :

 2 <%@ include file = "/WEB-INF/jspf/navigation.jspf" %>
 3 
 4 <font face="Arial">
 5 
 6 <p><util:tableau bd="messagerie" table="message" identificateur="idPersonne" valeur="${idPersonne}" couleur="#FF6600" largeur="90%">
 7    <util:colonne titre="sujet">Sujet</util:colonne>
 8    <util:colonne titre="texte">Message correspondant</util:colonne>
 9 </util:tableau></p>
25 </font>
26 
27 <%@ include file = "/WEB-INF/jspf/pieds.jspf" %>

Encore une fois, le changement est considérable. Ici aussi, la page gagne largement en clarté avec très très peu de lignes de code. La première balise <util:tableau> permet de régler le tableau dans son entier afin qu'il soit en correspondance directe avec la base de données en précisant tous les critères nécessaires afin de collecter toutes les informations à afficher. L'apparence est également prise en compte en spécifiant la taille désirée ainsi que la couleur de fond de la première ligne du tableau correspondant aux intitulés. Les intitulés sont spécifiés par l'intermédiaire des balises <util:colonne>. L'attribut "titre" de la balise <util:colonne> indique la colonne de la table de la base de données à prendre en compte.

Changement de comportement de la balise personnalisée <:date>

Nous pouvons proposer une autre alternative dans l'utilisation de la balise <:date>. Cette fois-ci en effet, l'action personnalisée consistera à créer des attributs de page afin de laisser au webmaster le libre choix de la représentation de la date. En voici d'ailleurs un exemple ci-dessous :

 1 <%@taglib uri="/util" prefix="u" %> <u:date /> 
 2 
 3         <br><hr>       
 4         <h4 align="right">
 5             Aujourd"hui ${jourSemaine}, dans ce mois de ${mois} et en cette année ${année}
 6         </h4>
 7         <h4 align="right">${date}</h4>
 8      </font>
 9    </body>
10 </html>
11

Le code reste clair. Nous utilisons juste des expressions EL. La particularité cette fois-ci, c'est que lorsque nous plaçons la balise <u:date />, aucun affichage n'est proposé. Cette balise s'occupe essentiellement de créer des attributs de pages que nous pouvons utiliser par la suite où bon nous semble (sur toute la page). Nous utilisons dans cet exemple quatre attributs : jourSemaine qui retourne 'mardi', mois qui retourne 'décembre', année qui retourne '2005' et date qui retourne la date complète.

Contrôle du type d'authentification <:authentification> de notre application Web

Les balises que nous venons de voir pour l'instant peuvent s'appliquer quel que soit l'application Web. Elles sont suffisament génériques pour cela. Il est toute fois possible de créer des balises qui ne seront utiles que pour cette application Web. Le but est le même, il s'agit de faire en sorte que les pages JSP soient faciles à construire, sans trop de lignes de code, pour que par la suite elles soient plus faciles à lire. De toute façon, l'investissement vaut le coup. Il faut toujours penser à la suite. Plus les pages sont concises, plus elles sont faciles à maintenir ou à mettre à jour. Cela permet de bien partager les compétences.

Nous allons donc mettre en oeuvre une balise spécifique qui ne fonctionnera que pour cette application Web. Souvenez-vous que la première page de notre application nous dirige en fonction de l'authentification réalisée par l'opérateur. Si nous souhaitons nous inscrire ou consulter nos propres messages, nous passons systématiquement par la page <utilisateur.jsp>. Du coup, il est nécessaire de connaître quel est le type d'authentification afin d'avoir, d'une part la bonne visualisation en conséquence, et d'autre part de connaitre la prochaine page à afficher. Voici la page JSP que nous possédons à l'heure actuelle :

 1 <%@ page errorPage = "/WEB-INF/erreur.jsp" import = "bd.*" %>
 4 <%@ include file = "/WEB-INF/jspf/navigation.jspf" %>
 5 
 6 <%! boolean nouveau; %> 
 7 <% nouveau = request.getParameter("authentification").equals("nouveau"); %>
 8 
 9 <h3 align="center">
10     <font color="green"><%= (nouveau ? "Demande d"inscription" : "Vos références") %></font>
11 </h3>
12 
13 <form action="<%= (nouveau ? "validerutilisateur.jsp": "controleidentite.jsp") %>" method="post">
14     <p><table border="1" cellpadding="3" cellspacing="2" width="90%" align="center">
15         <tr>
16             <td bgcolor="#FF9900" width="100"><b>Nom</b</td>
17             <td><input type="text" name="nom"></td>
18         </tr>
19         <tr>
20             <td bgcolor="#FF9900" width="100"><b>Prénom</b></td>
21             <td><input type="text" name="prénom"></td>
22         </tr>
23         <tr>
24             <td bgcolor="#FF9900" width="100"><b>Mot de passe</b></td>
25             <td><input type="password" name="motDePasse"></td>
26         </tr>
27     </table></p>
28     <p align="center"><input type="submit" value="Valider"></p>
29 </form>
30 
31 <%@ include file = "/WEB-INF/jspf/pieds.jspf" %>

Dans cette page, nous trouvons des déclarations ainsi que des expressions. Il peut être alors judicieux de proposer une balise <:authentification> qui permet d'enlever tout ce code Java et donc de rendre la page plus claire.

 1 <%@ include file = "/WEB-INF/jspf/navigation.jspf" %>
 2 <%@taglib uri="/personnel" prefix="personnel" %>
 3 
 4 <h3 align="center">
 5     <font color="green"><personnel:authentification /></font>
 6 </h3>
 7 
 8 <form action="${prochainePage}" method="post">
 9   <p><table border="1" cellpadding="3" cellspacing="2" width="90%" align="center">
10     <tr>
11        <td bgcolor="#FF9900" width="100"><b>Nom</b</td>
12        <td><input type="text" name="nom"></td>
13     </tr>
14     <tr>
15        <td bgcolor="#FF9900" width="100"><b>Prénom</b></td>
16        <td><input type="text" name="prénom"></td>
17     </tr>
18     <tr>
19        <td bgcolor="#FF9900" width="100"><b>Mot de passe</b></td>
20        <td><input type="password" name="motDePasse"></td>
21     </tr>
22   </table></p>
23