IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
logo

FAQ Java EEConsultez toutes les FAQ

Nombre d'auteurs : 27, nombre de questions : 85, dernière mise à jour : 3 mai 2015  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums de http://www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez nous aider en devenant rédacteur, lisez ceci.

SommaireJSPJSP TaglibsTaglibs 1.2 (6)
précédent sommaire suivant
 

Il est possible de définir ou de modifier des variables de script via un Tag JSP.
Dans l'exemple précédent, l'interaction entre le Tag et la page JSP se fait en récupérant la référence de l'objet avec un getAttribute().
Afin de permettre l'utilisation d'une variable de script, nous allons créer une classe qui étend TagExtraInfo :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
public class IterateTEI extends TagExtraInfo { 
  
	public VariableInfo[] getVariableInfo(TagData data) { 
		VariableInfo[] info = new VariableInfo[1];  
		info[0] = new VariableInfo ("line", "java.lang.Integer", true, VariableInfo.NESTED); 
		return info;  
	} 
}
Explication :

La méthode getVariableInfo() permet de définir des variables de script créée ou modifiée par le Tag. Elle retourne un tableau de VariableInfo, qui est constitué de quatre éléments :

  • Le nom de la variable de script.
  • Le nom du type de l'objet de la variable.
  • Un booléen indiquant si il s'agit d'une nouvelle variable ou pas (c'est à dire si elle doit être déclaré).
  • Enfin, le dernier argument définit le bloc dans lequel la variable sera accessible, il peut prendre les valeurs suivantes :
    • VariableInfo.AT_BEGIN : La variable est définit au début du tag et accessible jusqu'à la fin du bloc qui contient le tag.
    • VariableInfo.AT_END : La variable est définit à la fin du tag et accessible jusqu'à la fin du bloc qui contient le tag.
    • VariableInfo.NESTED : La variable est définit au début du tag et accessible seulement dans le corps du tag.


Attention, le nom de la variable de script doit correspondre à un élément dans un des scope (dans l'ordre: page, request, session, application).
La variable de script est synchronisée avec son équivalent dans le scope, donc il peut y avoir un conflit si le même nom est utilisé dans deux scopes différents.

Pour pouvoir utiliser cette variable, il faut ajouter la balise <tei-class> dans la définition du tag dans le TLD :

Code xml : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
<tag> 
	<name>iterate</name> 
	<tagclass>IterateTag</tagclass> 
	<teiclass>IterateTEI</teiclass> 
	<bodycontent>JSP</bodycontent> 
	<attribute> 
		<name>count</name> 
		<required>true</required> 
	</attribute> 
</tag>
Pour pouvoir utilisé le code suivant :

Code xml : Sélectionner tout
1
2
3
<p:iterate count="3"> 
	Ligne numéro <%=line%><br/> 
</p:iterate>
Résultat :

Code : Sélectionner tout
1
2
3
Ligne numéro 0  
Ligne numéro 1  
Ligne numéro 2
Note :
La méthode getVariableInfo() possèdent un TagData qui permet d'accéder aux attributs du tag, afin de pourvoir changer dynamiquement le nom de la scriplet selon un attribut par exemple.

Mis à jour le 16 février 2005 adiGuba

On peut donc modifier le corps du Tag avant de l'écrire dans la page JSP.

Par exemple, on va faire un Tag pour empêcher une partie de code HTML d'être interprété par le navigateur (c'est à dire en remplaçant les caractères < et > par < et >...).

On utilisera pour cela la lecture bufférisé de l'interface BodyTag en héritant de son implémentation BodyTagsupport :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class HtmlCodeTag extends BodyTagSupport { 
  
	public int doStartTag() throws JspException { 
		return BodyTag.EVAL_BODY_TAG; 
	} 
  
	public int doAfterBody() throws JspException {  
		try { 
			String bodyString = getBodyContent().getString(); 
			bodyString = bodyString.replaceAll("<", "<"); 
			bodyString = bodyString.replaceAll(">", ">"); 
			bodyString = bodyString.replaceAll("\t", " "); 
			bodyString = bodyString.replaceAll("\n", "<br/>\n"); 
			getPreviousOut().println(bodyString);  
		} catch (IOException e) {  
			throw new JspException (e);  
		} 
		return SKIP_BODY;  
	} 
}
Dans le TLD :

Code xml : Sélectionner tout
1
2
3
4
<tag> 
	<name>htmlCode</name> 
	<tagclass>HtmlCodeTag</tagclass> 
</tag>
Explication : La méthode doStartTag() retourne BodyTag.EVAL_BODY_TAG afin d'utiliser l'évaluation bufférisé du corps du Tag. Dans la méthode doAfterBody(), on récupère le corps du tag évalué en String. On modifie ensuite cette String pour remplacer les caractères "<", ">", "\t" et "\n" par du code HTML. Puis on affiche la chaîne ainsi transformé... Note : Avec les JSP 1.2, BodyTag.EVAL_BODY_TAG est déprécié et est remplacé par BodyTag.EVAL_BODY_BUFFERED. A l'utilisation, cela donne :

Code xml : Sélectionner tout
1
2
3
4
5
6
<p:htmlcode> 
	<h1>Example HTML</h1> 
	<p> 
		Un paragraphe de texte avec des mots en <b>gras</b>, et d'autres en <i>italique</i>...  
	</p> 
</p:htmlcode>
Et on obtient :

Code xml : Sélectionner tout
1
2
3
4
<h1>Example HTML</h1> 
<p> 
	Un paragraphe de texte avec des mots en <b>gras</b>, et d'autres en <i>italique</i>... 
</p>
Le fait de pouvoir modifier le corps du Tag apporte un plus indéniable par rapport à l'interface Tag ou IterationTag. En effet, on peut facilement modifier le corps AVANT de l'écrire sur la page JSP. De ce fait, on peut réellement changer le formatage du corps dans on ensemble...

Mis à jour le 16 février 2005 adiGuba

La classe TagExtraInfo permet également de valider les attributs du tag avant de l'exécuter.
Il faut pour cela redéfinir la méthode isValid() et utiliser le paramètre TagData pour analyser les paramètres.
Si isValid() retourne false une exception sera lancée.

Mis à jour le 16 février 2005 adiGuba

L'exemple précédent permet d'afficher du code HTML, mais on peut également vouloir afficher des scriplets Java ou même des Tag JSP sans qu'ils ne soient interprété.

En effet, le code suivant :

Code xml : Sélectionner tout
1
2
3
4
5
6
7
<p:htmlCode> 
	<h1>Example HTML</h1> 
	<p> 
		Code Java <%=new java.util.Date()%> 
		TagLib : <p:hello/> 
	</p> 
</p:htmlCode>
donnera:

Code html : Sélectionner tout
1
2
3
4
5
<h1>Example HTML</h1> 
<p> 
	Code Java Fri Dec 10 17:45:19 CET 2004  
	TagLib : Hello World ! 
</p>
Il faut spécifier que le corps du tag n'est pas du code JSP afin qu'il ne soit pas interprété.
Pour cela, on va créer un nouveau Tag htmlJspCode qui utilisera la même classe que htmlCode, mais en spécifiant que le corps est dépendant du tag (il ne sera pas interprété) :

Code xml : Sélectionner tout
1
2
3
4
5
<tag> 
	<name>htmlJspCode</name> 
	<tagclass>HtmlCodeTag</tagclass> 
	<bodycontent>tagdependent</bodycontent> 
</tag>
Ainsi le code suivant :

Code xml : Sélectionner tout
1
2
3
4
5
6
7
<p:htmlJspCode> 
	<h1>Example HTML</h1> 
	<p> 
		Code Java <%=new java.util.Date()>  
		TagLib : <p:hello/> 
	</p> 
</p:htmlJspCode>
donnera:

Code xml : Sélectionner tout
1
2
3
4
5
<h1>Example HTML</h1> 
<p> 
	Code Java <%=new java.util.Date()%> 
	TagLib : <p:hello/> 
</p>
Ceci peut également permettre d'insérer d'autre langages de scripts (Perl, Php, Shell Script, etc.) au sein d'une page JSP...

Mis à jour le 16 février 2005 adiGuba

L'API des taglibs propose une interface TryCatchFinally afin de gérer les exceptions générées par un Tag.
Si un tag implémente l'interface TryCatchFinally, il doit implémenter deux nouvelles méthodes :

  • doCatch() qui correspondra au bloc catch.
  • doFinally() qui correspondra au bloc finnaly.

Concrètement, cela signifie que si un tag implémente TryCatchFinally, les appels aux méthodes doXXXX() des interfaces Tag, IterationTag et BodyTag seront exécuté à l'intérieur d'un bloc try/catch de la forme suivante :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
try {  
	...  
	tag.doStartTag(); 
	...  
	tag.doInitBody(); 
	...  
	tag.doAfterBody();  
	...  
	tag.doEndTag();  
	...  
} catch (Throwable t) {  
	tag.doCatch(t);  
} finally { 
	tag.doFinally();  
}

Mis à jour le 16 février 2005 adiGuba

Les tags peuvent communiquer simplement avec le tag parent, c'est à dire le tag qui englobe le tag courant.
Par exemple, dans le code suivant:

Code xml : Sélectionner tout
1
2
3
4
5
6
7
<p:iterate count="3"> 
	<p:htmlCode> 
		<p:hello/> 
	</p:htmlCode> 
	<p:htmlJspCode> 
	</p:htmlJspCode> 
</p:iterate>
Le tag iterate est le parent du tag htmlCode et du tag htmlJspCode.
htmlCode est lui même parent du tag hello...
Mais il n'existe aucune parenté entre htmlCode et htmlJspCode...

La méthode getParent() permet d'accéder au tag parent, pour éventuellement interagir avec ce dernier.

A Noter également l'existence de la méthode statique TagSupport.findAncestorWithClass(Tag,Class) qui permet de rechercher un parent selon son type dans la hiérarchie des tags..

Mis à jour le 16 février 2005 adiGuba

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2024 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.