JSP - techniques avancées Langage d`expressions

JSP - techniques avancées
Chapitres traités Langage d'expressions - EL
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 3sur 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 :
Type Opérateurs
Arithmétique
+ - * / div % mod
Relationnels
==
et
eq
!=
et
ne
<
et
lt
>
et
gt
<=
et
le
>=
et
ge
Logiques
&&
et
and
||
et
or
!
et
not
Autre
( ) empty [ ] .
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 xest 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 xde 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, 0si 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.
Si vous avez placé un objet dans la session, vous pouvez y accéder de la manière suivante :
<% session.put("adresse", "12, rue de Java."); %>
${sessionScope.adresse} // renvoie '12, rue de Java'
<%= session.get("adresse") %> // expression JSP équivalente
Nous pouvons obtenir la valeur d'un champ d'en-tête de la requête par l'objet implicite header :
${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
.
:
expression valeur
${empty param}vaut true si aucun paramètre
${empty param["x"]} true si le paramètre xest absent, false sinon.
${empty param.x} true si le paramètre xest absent, false sinon.
${param["x"]}valeur du paramètre xs'il est présent, chaîne vide sinon.
${param.x}valeur du paramètre xs'il est présent, chaîne vide sinon.
${param[1]}valeur du paramètre xs'il est présent, chaîne vide sinon.
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> :
navigation.jspf
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.
validerutilisateur.jsp
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,