Présentation des JSP Tag Libraries (Taglibs).

Le descripteur de taglib est un fichier XML décrit par un fichier DTD (Document Type Definition) fournit par Sun.

Il prend donc la forme suivante :

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
	"http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">

<taglib>
	 ...
</taglib>

La balise taglib de base du descripteur de taglibs accepte les balises suivantes :

La balise tag permet de faire un mapping entre un nom de balise et une classe Java (à l'instar de web.xml qui permet la même chose entre une URL et une Servlet).
Elle accepte les balises suivantes :

La balise attribute permet de définir les attributs du tag JSP. Seul les attributs décrits dans le TLD seront acceptés. L'utilisation de nom d'attribut inéxistant dans le TLD provoquera une exception à la compilation.

La balise attribute accepte les balises suivantes :

Si un attribut required est absent, une exception sera lancée.
L'utilisation de rtexprvalue permet d'utiliser le résultat d'une expression de scriptlet comme valeur d'attribut (par exemple <%=monObjet%>).

Tous les attributs utilisés dans le tag de la page JSP seront passés à la classe qui représente le tag via leurs mutateurs respectifs (méthode setNomDeL'Attribut()).
Pour chaque attribut, il faut donc que le mutateur correspondant soit présent dans la classe Java. Par exemple, si on définit un attribut valeur, son mutateur pourrait être :

public void setValeur (String valeur) {
	this.valeur = valeur;
}

On peut également utiliser des types primaires (int, long, double, boolean, etc.) en paramètre du mutateur de l'attribut.
Dans ce cas, une exception peut être lancée si la valeur est incorrecte (par exemple, NumberFormatException).

Si rtexprvalue vaut true (ou yes), l'attribut n'est pas forcement du type String, mais peut être n'importe quel objet Java ...
Attention aux ClassCastException que cela peut engendrer ...

Comme bien souvent, le premier exemple est un simple "Hello world" ...
Notre tag va donc se contenter d'afficher le texte "Hello World" dans la page JSP.
Il ne possèdera donc ni contenu, ni attribut.

public class HelloTag extends TagSupport {
	
	public int doStartTag() throws JspException {
		try {
			pageContext.getOut().println ("Hello World !");
		} catch (IOException e) {
			throw new JspException ("I/O Error", e);
		}
		return SKIP_BODY;
	}
}

Explication :

• On étend TagSupport afin de bénéficier des implémentations par défaut des méthodes de Tag.
• On surcharge doStartTag(), dans lequel on se contente d'écrire la chaîne "Hello World" dans la sortie de la page courante (pageContext est initialisé par l'implémentation par défaut de setPageContext()).
• On retourne Tag.SKIP_BODY car on ne veut pas traiter le corps de la balise.

Le mapping de notre tag dans le fichier de descripteur correspond à ceci :

<tag>
	<name>hello</name>
	<tagclass>tutoriel.taglib.HelloTag</tagclass>
	<bodycontent>empty</bodycontent>
</tag>

Ainsi, dans une page JSP, le code suivant :

<tag11:hello/>

affichera dans le navigateur :

Hello World !

Nous allons améliorer notre tag précédent en lui ajoutant un attribut name. Si l'attribut name est présent, on devra afficher "Hello" suivi de la valeur de l'attribut name, sinon on affiche "Hello World".
Nous devront pour cela modifier le mapping du tag afin de spécifier qu'il peut avoir un attribut name optionnel (voir la section pour plus de détail) :

<tag>
	<name>hello</name>
	<tagclass>tutoriel.taglib.HelloTag</tagclass>
	<bodycontent>empty</bodycontent>
	<attribute>
		<name>name</name>
	</attribute>
</tag>

La balise <attribute> accepte également deux autres balises :
<required> permet d'indiquer que l'attribut est requis (son absence provoquera une erreur de compilation).
<rtexprvalue> indique que la valeur de l'attribut peut être le résultat d'une expression ( <%=expression%> ).

Si l'attribut name est présent, sa valeur sera passée à la classe HelloTag grâce à son mutateur setName(). Il est donc obligatoire d'implémenter cette méthode.
Au final, notre classe HelloTag pourrait ressembler à ceci :

public class HelloTag extends TagSupport {
	private String name = null;
	
	public void setName (String string) {
		this.name = string;
	}
	
	public int doStartTag() throws JspException {
		if (this.name==null)
			this.name = "World";
		try {
			pageContext.getOut().println ("Hello " + this.name + " !");
		} catch (IOException e) {
			throw new JspException ("I/O Error", e);
		}
		return SKIP_BODY;
	}
}

Ainsi, dans la page JSP :

<tag11:hello/><br/>
<tag11:hello name="Fred"/>

donnera l'affichage suivant :

Hello World !
Hello Fred !

Si le nom de l'attribut n'est pas spécifié dans le TLD ou qu'aucun mutateur (setXXX()) n'est implémenté, une exception sera lancée lors de la compilation de la page JSP ...

Un tag peut également posséder un corps. Étant donné que l'évaluation du corps dépend du retour de la méthode doStartTag(), on peut facilement évaluer ou non le corps du tag selon une condition quelconque ...

Nous allons écrire un tag qui affichera son contenu seulement si le paramètre désigné par l'attribut name est présent dans le request de la page courante.
Le code de ce tag pourrait être :

public class ParamPresentTag extends TagSupport {
	private String name = null;
	
	public void setName (String string) {
		this.name = string;
	}

	public int doStartTag() throws JspException {
		String value = pageContext.getRequest().getParameter(this.name);
		if (value!=null)
			return EVAL_BODY_INCLUDE;
		return SKIP_BODY;
	}
}

Nous utiliserons le mapping suivant dans notre fichier de description :

	<tag>
		<name>paramPresent</name>
		<tagclass>tutoriel.taglib.ParamPresentTag</tagclass>
		<bodycontent>JSP</bodycontent>
		<attribute>
			<name>name</name>
			<required>true</required>
		</attribute>
	</tag>

L'attribut name est requis, ainsi un oubli de l'attribut et une exception sera levée à la compilation de la page JSP. Enfin, le corps du tag possède un contenu JSP, c'est à dire qu'il sera interprété comme du code JSP (il s'agit du fonctionnement par défaut).

Le code suivant :

<tag11:paramPresent name="page">
	Le paramètre page vaut : <%=request.getParameter("page")%>.
</tag11:paramPresent>

N'affichera rien si la page JSP est appelée sans paramètre "page". Mais si elle est appelée avec page=valeur, on obtiendra le résultat suivant :

Le paramètre page vaut : valeur.

L'interface Tag définit les méthodes setParent() et getParent() afin de renseigner le tag sur son tag parent (si il existe).
Cela permet une collaboration entre différents tags. Nous allons voir comment utiliser la méthode getParent() afin de simuler un switch/case grâce à des simples tags.

Ainsi, la classe qui représente le tag 'switch' pourrait correspondre à :

public class SwitchTag extends TagSupport {

	private Object test = null;
	
	public void setTest (Object obj) {
		this.test = obj;
	}
	
	public int doStartTag() throws JspException {
		return EVAL_BODY_INCLUDE;
	}

	public boolean isValid (Object caseValue) {
		if (this.test==caseValue) return true;
		if (this.test!=null && this.test.equals(caseValue)) return true;
		return false;
	}
}

Explication :
La classe SwitchTag se contente d'évaluer son corps. Par contre, elle possède une méthode isValid() qui permettra de savoir si un objet est égal à son attribut test. Cette méthode sera utilisée par les tags 'case' :

public class CaseTag extends TagSupport {

	public Object value = null;
	
	public void setValue (Object object) {
		this.value = object;
	}

	public int doStartTag() throws JspException {
		
		if ( getParent() instanceof SwitchTag ) {
			SwitchTag parent = (SwitchTag) getParent();
			if (parent.isValid(this.value))
				return EVAL_BODY_INCLUDE;
			return SKIP_BODY;
		}
		throw new JspException ("Le tag case doit être à l'intérieur du tag swith.");
	}
}

Explication :
La classe CaseTag récupère son tag parent et vérifie qu'il est bien du type de SwitchTag (sinon, cela signifie que le tag est mal utilisé, donc on peut lancer une exception).
Il utilise ensuite la méthode isValid() de son parent afin de déterminer si il doit afficher son contenu ou pas.

Ainsi, le code suivant :

<tag11:switch test="2">
	<tag11:case value="0">Zéro</tag11:case>
	<tag11:case value="1">Un</tag11:case>
	<tag11:case value="2">Deux</tag11:case>
	<tag11:case value="3">Trois</tag11:case>
</tag11:switch>

affichera le résultat suivant :

Deux

La classe TagSupport propose la méthode statique findAncestorWithClass() qui permet de retrouver un tag parent de plus haut niveau selon son type.

Afin de comprendre le fonctionnement d'un tag itératif, nous allons écrire un tag qui effectuera un certain nombre de boucles selon un paramètre count.
Son code pourrait ressembler à cela :

public class IterateTag extends BodyTagSupport {
   
    private int count = 0;
    private int current;

    public void setCount(int i) {
        count = i;
    }

    public int doStartTag() throws JspException {
        current = 0;
        if (current < count)
            return Tag.EVAL_BODY_TAG;
        return Tag.SKIP_BODY;
    }
   
    public int doAfterBody() throws JspException {
        current++;
        if (current < count)
            return IterationTag.EVAL_BODY_TAG;
        return Tag.SKIP_BODY;
    }
}

Explication :
L'attribut count contiendra la valeur de l'attribut de la balise. Il n'y a pas de conversion String/int à effectuer car elle est automatique puisque la méthode setCount() prend un int en paramètre. En cas de valeur incorrecte, une exception sera lancée ...

Dans doStartTag(), on initialise current qui contiendra le nombre de lignes déjà affichées. Il est important de l'initialiser dans doStartTag() car la même instance de Tag peut être utilisée plusieurs fois.

Enfin, à chaque passage dans doAfterBody(), on évalue la condition de fin afin de retourner le code correspondant ...

Ainsi, le code suivant :

<tag11:iterate count="3">
	Cette ligne sera affichée trois fois<br/>
</tag11:iterate>

Donnera bien le résultat suivant :

Cette ligne sera affichée trois fois<br/>
Cette ligne sera affichée trois fois<br/>
Cette ligne sera affichée trois fois<br/>

Le fonctionnement des itérations avec la classe BodyTag est similaire à celui de la classe IterationTag des taglibs 1.2.
Je vous invite donc à consulter le passage sur .

En utilisant BodyTag.EVAL_BODY_TAG, le corps des tags n'est pas écrit directement dans la sortie de la page JSP mais dans un buffer. Le premier intérêt de cette méthode est de pouvoir modifier dynamiquement ce corps avant de l'envoyer vers la sortie de la page.

Par exemple, le tag suivant permet de mettre le texte du corps du tag en majuscule :

public class UpperCaseTag extends BodyTagSupport {

	public int doStartTag() throws JspException {
		return EVAL_BODY_TAG;
	}

	public int doAfterBody() throws JspException {
		
		try {
			if ( getBodyContent()!=null ) {
				String bodyString = getBodyContent().getString();
				bodyString = bodyString.toUpperCase();
				getBodyContent().getEnclosingWriter().println( bodyString );
			}
		} catch (IOException e) {
			throw new JspException (e);
		}
		
		return EVAL_PAGE;
	}
}

Explication :
On se contente dans doAfterbody() de récupérer l'objet BodyContent sous forme de String que l'on passe en majuscule.
getBodyContent().getEnclosingWriter() permettant d'accéder au JspWriter de la page JSP.

Ainsi, le code suivant :

<tag11:upperCase>Ce texte sera mis en majuscule, ainsi que le résultat de ce <%="scriptlet"%>.</tag11:upperCase>

affichera le texte en majuscule :

CE TEXTE SERA MIS EN MAJUSCULE, AINSI QUE LE RÉSULTAT DE CE SCRIPTLET.

L'interface BodyTag nous permet également d'utiliser d'autres langages de script au sein d'une page JSP. En effet, le corps du tag n'étant plus directement écrit dans la page JSP, on peut très bien l'envoyer à un interpréteur et n'afficher que le résultat ...

Ainsi, ce tag envoie le contenu de son corps à l'interpréteur PERL :

public class PerlTag extends BodyTagSupport {
	
	private Process process = null;

	protected void startProcess () throws JspException {
		try {
			process = Runtime.getRuntime().exec("perl");
		} catch (IOException e) { 
			throw new JspException ("Erreur de creation du process 'perl'.", e);
		}
	}
	
	protected void writeBody () throws JspException {
		// On recupere les flux STDIN du process 'perl'
		OutputStream stdin = process.getOutputStream();
		OutputStreamWriter stdinWriter = new OutputStreamWriter (stdin);
		
		try {
			// On écrit dans le STDIN du process le contenu du tag :
			getBodyContent().writeOut( stdinWriter );
		} catch (IOException e) { 
			throw new JspException ("Erreur d'ecriture du body.", e);
		} finally {
			// Fermeture des flux ...
			try { stdinWriter.close(); } catch (IOException e) {}
			try { stdin.close(); } catch (IOException e) {}
		}
	}
	
	protected void readErrors () throws JspException {
		// On recupere les flux STDERR du process 'perl'
		InputStream stdout = process.getErrorStream();
		InputStreamReader stdoutReader = new InputStreamReader (stdout);
		BufferedReader stdoutBuffer = new BufferedReader (stdoutReader);
		StringBuffer errorBuffer = null;
	
		try {
			// On récupère chaque ligne du STDERR dans un buffer :
			String line = null;
			while ( ( line = stdoutBuffer.readLine() ) != null ) {
				if (errorBuffer==null)
					errorBuffer = new StringBuffer ();
				errorBuffer.append(line);
			}
		} catch (IOException e) {
			throw new JspException ("Erreur de lecture du résultat.", e);
		} finally {
			// Fermeture des flux ...
			try { stdoutBuffer.close(); } catch (IOException e) {}
			try { stdoutReader.close(); } catch (IOException e) {}
			try { stdout.close(); } catch (IOException e) {}
		}
		
		// Si le buffer n'est pas vide, on envoi une exception
		if (errorBuffer!=null)
			throw new JspException ("Perl Script Error : " + errorBuffer);
	}
	
	protected void readResult () throws JspException {
		// On recupere les flux STDOUT du process 'perl'
		InputStream stdout = process.getInputStream();
		InputStreamReader stdoutReader = new InputStreamReader (stdout);
		BufferedReader stdoutBuffer = new BufferedReader (stdoutReader);
		
		try {
			// On récupère chaque ligne du STDOUT et on l'affiche :
			String line = null;
			while ( ( line = stdoutBuffer.readLine() ) != null ) {
				getPreviousOut().print(line);
			}
		} catch (IOException e) {
			throw new JspException ("Erreur de lecture du résultat.", e);
		} finally {
			// Fermeture des flux ...
			try { stdoutBuffer.close(); } catch (IOException e) {}
			try { stdoutReader.close(); } catch (IOException e) {}
			try { stdout.close(); } catch (IOException e) {}
		}
	}
	
	public int doStartTag() throws JspException {
		return EVAL_BODY_TAG;
	}
	
	public int doAfterBody() throws JspException {
		startProcess();
		writeBody ();
		readErrors ();
		readResult ();

		return SKIP_BODY;
	}
}

Explication :
doStartTag() renvoie EVAL_BODY_TAG afin que le contenu du corps soit écrit dans un buffer.
Une fois dans doAfterBody() :

• startProcess() lance le processus "perl" (l'interpréteur perl installé sur le système).
• writeBody() écrit le contenu du corps dans le flux stdin du processus "perl".
• readErrors() récupère le flux stderr du processus "perl" afin de lancer une exception en cas d'erreur dans le script.
• readResult() récupère le flux stdout du processus "perl" et le copie dans la page JSP.

Et le code suivant :

<tag11:perl> 
$lang = "perl";
printf ( "Utilisation du langage %s dans une page JSP", $lang );
</tag11:perl>

Affiche correctement le résultat du script PERL :

Utilisation du langage perl dans une page JSP

Pour cet exemple, il est préférable d'utiliser dans le descripteur de taglib la valeur tagdependent pour le <bodycontent>.
Ceci afin d'éviter que des éléments du script PERL soient interprétés par le JSP ...

Il est possible de créer une variable de script dans la page JSP depuis un tag. Nous allons donc modifier le tag paramPresent (voir la section ) afin qu'il déclare une variable de script nommée "value" dans la page JSP. Cette variable devra contenir la valeur du paramètre.

Nous allons commencer par modifier le code du tag afin qu'il place la valeur du paramètre dans le scope "page" de la JSP :

public class ParamPresentTag extends TagSupport {
	private String name = null;
	
	public void setName (String string) {
		this.name = string;
	}

	public int doStartTag() throws JspException {
		String value = pageContext.getRequest().getParameter(this.name);
		if (value!=null) {
			pageContext.setAttribute("value", value);
			return EVAL_BODY_INCLUDE;
		}
		return SKIP_BODY;
	}
	
	public int doEndTag() throws JspException {
		pageContext.removeAttribute("value");
		return EVAL_PAGE;
	}
}

L'attribut "value" est donc placé dans le scope "page" au début du tag et il est effacé à la fin du tag. On peut désormais utiliser le code suivant pour afficher la valeur du paramètre :

<tag11:paramPresent name="page">
	Le paramètre page vaut : <%=pageContext.getAttribute("value")%>.
</tag11:paramPresent>

Pour le moment, cela apporte peu d'intérêt, mais c'est nécessaire car la variable de script sera automatiquement mise à jour avec le contenu de l'attribut du même nom dans le scope "page"
Nous allons donc déclarer une variable de script. Pour cela, nous avons besoin d'écrire une classe qui hérite de la classe javax.servlet.jsp.tagext.TagExtraInfo en surchargeant la méthode getVariableInfo() :

public class ParamPresentTEI extends TagExtraInfo {

	public VariableInfo[] getVariableInfo(TagData tagData) {
		VariableInfo[] vi = new VariableInfo[1];
		vi[0] = new VariableInfo("value", "java.lang.String", true, VariableInfo.NESTED);	
		return vi;
	}
}

La méthode getVariableInfo() retourne un tableau de VariableInfo. Chaque élément du tableau définit une variable de script. Le constructeur de VariableInfo prend les quatre paramètres suivant :

1. Le nom de la variable de script
2. Le nom du type de la variable
3. Un booléen qui indique si la variable doit être déclarée (true) ou si on doit réutiliser une variable déjà déclarée (false).
4. Enfin, on définit la zone de portée de la variable, qui peut prendre les valeurs suivantes :

• VariableInfo.AT_BEGIN : La variable est déclarée au début du tag et reste valable jusqu'a la fin du bloc contenant le tag.
• VariableInfo.AT_END : La variable est déclarée à la fin du tag et reste valable jusqu'a la fin du bloc contenant le tag.
• VariableInfo.NESTED : La variable est déclarée au début du tag et n'est valable qu'à l'intérieur du tag.

Les différentes déclarations correspondent au code suivant :

<%
//
// Les variables AT_BEGIN sont déclarées ici
//
{ // Début du bloc du tag
	//
	// Les variables NESTED sont déclarées ici
	//
	 ...
	tag.doStartTag();
	 ...
		tag.doInitBody();
	 ...
		tag.doAfterBody();
	 ...
	tag.doEndTag();
	 ...
} // Fin du bloc du tag
//
// Les variables AT_END sont déclarées ici
//
%>

Il faut ensuite déclarer cette classe dans le descripteur de taglib grâce à la balise teiclass :

	<tag>
		<name>paramPresent</name>
		<tagclass>tutoriel.taglib.ParamPresentTag</tagclass>
		<teiclass>tutoriel.taglib.ParamPresentTEI</teiclass>
		<bodycontent>JSP</bodycontent>
		<attribute>
			<name>name</name>
			<required>true</required>
		</attribute>
	</tag>

Désormais, la classe ParamPresentTEI sera utilisée pour définir les variables de script du tag paramPresent. On peut donc désormais utiliser le code suivant :

<tag11:paramPresent name="page">
	Le paramètre page vaut : <%=value%>.<br/>
	En Majuscule : <%=value.toUpperCase()%>.
</tag11:paramPresent>

Explication :
Une variable de script nommé "value" est crée dans la page à l'intérieur du corps du tag. Son contenu est mis à jours selon le contenu du scope "page" lorsque c'est nécessaire.
Cette variable de script est bien du type java.lang.String, comme indiqué par le retour de la méthode getVariableInfo() (comme le montre l'appel de la méthode toUpperCase()).

Le nom de la variable de script peut être également 'dynamique'. On peut par exemple utiliser le paramètre TagData de getVariableInfo() afin d'accéder aux attributs du tag.
Toutefois, étant donné que la classe TagExtraInfo est utilisée à la compilation, on ne peut pas accéder aux attributs dont la valeur est le résultat d'une scriptlet (<%=object%> avec rtexprvalue=true).

En réalité, la variable de script est mise à jours avec l'attribut du même nom existant dans le premier scope dans l'ordre suivant : "page", "request", "session", et "application"
Il est ainsi possible d'utiliser un autre scope que "page" mais cela peut poser des conflits si un attribut du même nom existe dans une scope précédent ...

La méthode isValid() permet de valider dynamiquement les attributs du tag avant qu'il ne soit exécuté.

Toutefois, la méthode isValid() étant appelée à la compilation, elle ne permet pas de vérifier la valeur des attributs dont la valeur est le résultat d'une scriptlet (<%=object%> avec rtexprvalue=true).

Nous allons ainsi surcharger la méthode isValid() de la classe ParamPresentTEI afin de vérifier que son attribut name ne soit pas vide :

	public boolean isValid(TagData tagData) {
		if (tagData.getAttributeString("name").trim().equals(""))
			return false;
		return true;
	}

Désormais, si on utilise le code suivant :

<tag11:paramPresent name="">corps</tag11:paramPresent>

Nous aurons bien une exception à la compilation ...

Cette validation par la classe TagExtraInfo a deux intérêts :

• La validation est effectuée pour tous les tags à la compilation. Les tags non évalués lors de l'affichage de la JSP (par exemple : si ils se trouvent dans un autre tag qui n'évalue pas son corps) seront quand même validés ...
• La vérification peut très bien être longue, elle ne sera effectuée qu'à la compilation ...

Le descripteur de taglib est un fichier XML décrit par un fichier DTD (Document Type Definition) fournit par Sun.

Le doctype d'une taglib 1.2 doit avoir le doctype suivant :

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
	"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
	 ...
</taglib>

Avec la version 1.2, les noms de balise ont été normalisés : les termes des noms de balises sont séparés par des tirets (exemple: jspversion devient jsp-version. Les anciens noms de balises sont indiqués entre parenthèses.

La balise taglib de base du descripteur de taglibs 1.2 accepte les balises suivantes :

Les Taglibs 1.2 permettent de valider le format de la page JSP lors de sa compilation. Cette validation n'est effectuée que pendant la compilation de la JSP.
La déclaration d'un validator accepte les éléments suivants :

Si un validateur est spécifié dans le descripteur de taglib, l'attribut validator-class doit correspondre au nom d'une classe qui étend la classe javax.servlet.jsp.tagext.TagLibraryValidator.
Cette classe possède la méthode suivante :

public ValidationMessage[] validate(String prefix, String uri, PageData page);

Lors de la compilation d'une page JSP qui utilise la taglib, la méthode validate() ci dessus est appelée avec les paramètres suivant :

• prefix : La valeur de l'attribut prefix de la directive taglib.
• uri : La valeur de l'attribut uri de la directive taglib.
• page : Un objet PageData qui permet d'accéder à un InputStream sur la vue XML de la JSP.

Cette méthode validate() permet donc de valider le format XML de la JSP à la compilation.
Si la méthode retourne un tableau non-null et non-vide (length>0), une erreur de compilation sera générée avec les messages contenus dans les différents ValidationMessage du tableau retourné ...

Le validateur permet donc de vérifier le format XML de la JSP.
En particulier, on pourra vérifier que les tags collaboratifs sont correctement utilisés ...

L'instance du validateur peut être réutilisée plusieurs fois par le conteneur de JSP. Toutefois, la méthode release() sera appelée avant de détruire l'instance du validateur ...

Les listeners permettent de surveiller certains aspects de l'application web. Il s'agit des mêmes listeners que ceux qui peuvent être définit dans le fichier web.xml de votre application.

Afin de déclarer un listener dans le descripteur de taglib, on utilise le même code que dans le fichier web.xml, c'est à dire les balises suivantes :

	<listener>
		<listener-class>package.ListenerClassName</listener-class>
	</listener>

où package.ListenerClassName correspond à une classe qui implémente l'une des interfaces suivantes :

• javax.servlet.ServletContextListener afin de surveiller la création/destruction du ServletContext.
• javax.servlet.ServletContextAttributesListener afin de surveiller l'ajout/modification/suppression des attributs du ServletContext.
• javax.servlet.http.HttpSessionListener afin de surveiller la création/destruction des HttpSession.
• javax.servlet.http.HttpSessionAttributeListener afin de surveiller l'ajout/modification/suppression des attributs des HttpSession.

J2EE 1.4 ajoute deux nouveaux listeners : javax.servlet.ServletRequestListener et javax.servlet.ServletRequestAttributesListener qui permettent de surveiller toutes les requests de l'application web...

Le fonctionnement est identique aux listeners déclarés dans le web.xml. Cela permet simplement de regrouper des listeners propres à une taglib dans son propre descripteur afin de faciliter son déploiement.
On peut naturellement définir plusieurs listeners ...

Les listeners sont initialisés au démarrage de l'application : le serveur d'application recherche donc tous les descripteurs de taglib lors de la séquence de démarrage. C'est pourquoi le descripteur de taglib doit se situer dans le répertoire WEB-INF ou l'un de ses sous-répertoires, ou dans un fichier jar du répertoire WEB-INF/lib.
Si le descripteur de taglib se situe dans un autre répertoire de l'application web, les listeners ne pourront pas être chargés ...

La balise tag du descripteur de taglibs 1.2 accepte les balises suivante (les noms entre parenthèses correspondent aux noms dans le TLD de la version 1.1, si il existe) :

La balise attribute permet de définir les attributs du tag JSP. Seul les attributs décrits dans le TLD seront acceptés. L'utilisation d'attribut non-indiqué dans le TLD provoquera une exception à la compilation.

La balise attribute du descripteur de taglibs 1.2 accepte les balises suivantes (les noms entre parenthèses correspondent aux noms dans le TLD de la version 1.1, si il existe) :

Si un attribut required est absent, une exception sera lancée.
L'utilisation de rtexprvalue permet d'utiliser le résultat d'une expression de scriptlet comme valeur d'attribut (par exemple <%=monObjet%>).

La balise variable permet de déclarer des variables de script depuis le descripteur de taglib, tout comme la méthode getVariableInfo() de la classe TagExtraInfo associé au tag (voir la section Création de variable de script).

On ne peut toutefois pas cumuler les deux méthodes. Si une variable de script est déclarée dans le descripteur de taglib et qu'une classe TagExtraInfo est associée au tag, sa méthode getVariableInfo() devra obligatoirement retourner null.

Les variables de script du tag sont donc déclarées dans le descripteur de taglib. La balise variable accepte les balises suivantes :

Ainsi, pour le tag suivant, qui se contente de placer un objet dans le scope "page" :

public class BeanTag extends TagSupport {
	public String name = null;
	public Object value= null;
	
	public void setName(String string) {
		name = string;
	}
	public void setValue(Object object) {
		value = object;
	}
	
	public int doStartTag() throws JspException {
		pageContext.setAttribute(name,value);
		return SKIP_BODY;
	}
}

Le mapping suivant permet de déclarer des variables de script dans la page JSP :

	<tag>
		<name>bean</name>
		<tag-class>tutoriel.taglib_1_2.BeanTag</tag-class>
		<bodycontent>empty</bodycontent>
		<attribute>
			<name>name</name>
			<required>true</required>
			<rtexprvalue>false</rtexprvalue>
		</attribute>
		<attribute>
			<name>value</name>
			<required>true</required>
			<rtexprvalue>true</rtexprvalue>
		</attribute>
		<variable>
			<name-from-attribute>name</name-from-attribute>
			<variable-class>java.lang.Object</variable-class>
			<declare>true</declare>
			<scope>AT_END</scope>
		</variable>
	</tag>

Ainsi, le code suivant :

<tag11:bean name="date" value="<%=new java.util.Date()%>"/>
<tag11:bean name="text" value="Un simple message"/>
<%=date + ": " + text%>

affichera le résultat suivant :

Sun Dec 26 20:18:32 CET 2004: Un simple message

L'interface IterationTag a le même fonctionnement que l'interface BodyTag lorsque doStartTag() retourne EVAL_BODY_INCLUDE.
Les seules différences viennent du fait que la méthode doAfterBody() doit retourner EVAL_BODY_AGAIN afin de réévaluer le corps du tag.

Le code du tag iterate avec BodyTag avec les taglibs 1.1 (voir devient donc en utilisant l'interface IterationTag :

public class NewIterateTag extends TagSupport {
   
    private int count = 0;
    private int current;

    public void setCount(int i) {
        count = i;
    }

    public int doStartTag() throws JspException {
        current = 0;
        if (current < count)
            return Tag.EVAL_BODY_INCLUDE;
        return Tag.SKIP_BODY;
    }
   
    public int doAfterBody() throws JspException {
        current++;
        if (current < count)
            return IterationTag.EVAL_BODY_AGAIN;
        return Tag.SKIP_BODY;
    }
}

En utilisant des variables de script avec un tag itératif, on peut manipuler des Collections ou des tableaux très simplement.

Nous allons écrire un tag pour parcourir toutes les propriétés du système (avec la méthode System.getProperties()) afin de les afficher à sa guise dans le corps du tag.

Par exemple :

public class SystemPropertiesTag extends TagSupport {
   
   	private Enumeration propertyName = null;

	public boolean doNext () {
		if ( propertyName.hasMoreElements() ) {
			String name = (String) propertyName.nextElement();
			String value = System.getProperty(name);
			pageContext.setAttribute("name", name);
			pageContext.setAttribute("value", value);
			return true;
		}
		return false;
	}

	public int doStartTag() throws JspException {
		
		// Iterateur sur les propriétés
		propertyName = System.getProperties().propertyNames();
		
		if (doNext())
			return EVAL_BODY_INCLUDE;
		return SKIP_BODY;
	}
	
	public int doAfterBody() throws JspException {
		if (doNext())
			return EVAL_BODY_AGAIN;
		return SKIP_BODY;
	}
	

	public int doEndTag() throws JspException {
		pageContext.removeAttribute("name");
		pageContext.removeAttribute("value");
		return EVAL_PAGE;
	}
}

Nous utilisons une Enumeration pour parcourir la liste des noms des propriétés. Notre méthode doNext() nous permet de savoir si il y a encore des éléments à afficher.
Elle s'occupera également de stocker le couple name/value dans le scope page (nécessaire pour mettre à jour la variable de script).

Bien entendu, il faut déclarer les variables de script en étendant la classe TagExtraInfo (voir la section ) :

public class SystemPropertiesTEI extends TagExtraInfo {

	public VariableInfo[] getVariableInfo(TagData tagData) {
		return new VariableInfo[] {
			new VariableInfo("name", "java.lang.String",true,VariableInfo.NESTED),
			new VariableInfo("value","java.lang.String",true,VariableInfo.NESTED)	
		};
	}
}

Ainsi, le code suivant affichera toutes les propriétés du système dans un tableau HTML :

<table>
	<tr><td>Nom</td><td>Valeur</td></tr>
<tag12:systemProperties>
	<tr><td><%=name%></td><td><%=value%></td></tr>
</tag12:systemProperties>
</table>

Les Taglibs 2.0 n'utilisent plus de fichier DTD (Document Type Definition) pour définir le descripteur de taglib.
Désormais le format des descripteurs de taglib est défini par un fichier XSD (XML Schema Description). Le 'Doctype' pour les Taglibs 2.0 devient donc :

<?xml version="1.0" encoding="ISO-8859-1" ?>
<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
	      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	      xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
	      version="2.0">
	       ...
</taglib>

La nouvelle balise tag-file permet de déclarer un tag à partir d'un fichier *.tag (Voir la section ).

La balise attribute permet de définir les attributs du tag JSP. Seul les attributs décrits dans le TLD seront acceptés. L'utilisation d'attribut non indiqué dans le TLD provoquera une exception à la compilation.

La balise attribute du descripteur de taglibs 1.2 accepte les balises suivante (les noms entre parenthèses correspondent aux noms dans le TLD de la version 1.1, si il existe) :

Si un attribut required est absent, une exception sera lancée.
L'utilisation de rtexprvalue permet d'utiliser le résultat d'une expression de scriptlet comme valeur d'attribut (par exemple <%=monObjet%>).

L'itération sur le contenu du tag devient une simple boucle. L'utilisation du corps comme un objet permet d'éviter la multiplication de variables d'instances utilisées dans les différentes méthodes :

public class SimpleIterateTag extends SimpleTagSupport {

	private int count = 0;
	
	public void setCount (int value) {
		this.count = value;
	}

	public void doTag() throws JspException, IOException {
		for (int i=0; i<count; i++)
			getJspBody().invoke(null);		
	}
}

Et la déclaration dans le TLD reste identique :

<tag>
	<name>simpleIterate</name>
	<tag-class>com.developpez.adiguba.tutorial.taglibs_20.SimpleIterateTag</tag-class>
	<body-content>scriptless</body-content>
	<attribute>
		<name>count</name>
		<required>true</required>
		<rtexprvalue>true</rtexprvalue>
	</attribute>
</tag>

Les SimpleTag n'accepte pas de contenu de type JSP.
En fait, les objets JspFragment ne gèrent pas les scriptlets (<% ... %>), il faut donc utiliser à la place la valeur scriptless en remplacement...

L'utilisation d'attributs dynamiques est particulièrement utilise si l'on désire remplacer des balises HTML par des tags JSP afin d'y ajouter un traitement coté serveur.

Par exemple, si l'on désire associer des champs INPUT avec des beans afin qu'ils soient automatiquement renseignés, par exemple afin que le code suivant :

<tag20:input type="text" name="nomDuBean"/>

Donne le résultat suivant :

<input type="text" name="nomDuBean" value=valeurDuBean"/>

Le code du tag en lui même n'est pas compliqué, mais le problème vient du fait que dans les spécifications HTML, la balise INPUT accepte 12 attributs (accept, align, alt, checked, disabled, maxlength, name, readonly, size, src, type et value).
Pour pouvoir utiliser ces attributs dans notre tag, il faudrait les définir dans le TLD et ajouter leurs variables et mutateurs dans le source Java du tag.
De même, la balise INPUT accepte également 16 attributs d'évenement (tabindex, accesskey, onfocus, onblur, onselect, onchange, onclick, ondblclick, onmousedown, onmouseup, onmouseover, onmousemove, onmouseout, onkeypress, onkeydown et onkeyup).
Au final, cela reviendrait à gérer une trentaine de variables alors que seulement quelques unes sont utiles ...

En implémentant l'interface DynamicAttributes, on peut simplement réécrire directement les attributs inutiles :

public class InputTag extends SimpleTagSupport implements DynamicAttributes {
	
	private Map attributes = new HashMap();
	private String type = null;
	private String name = null;
	private String value = null;
	
	public void setType(String string) {
		type = string;
	}
	public void setName(String string) {
		name = string;
	}
	public void setValue(String string) {
		value = string;
	}
	
	public void setDynamicAttribute(String uri, String localName, Object value)
		throws JspException {
		// On place chaque attribut/valeur dans la Map attributes
		attributes.put (localName, value);
	}
	
	public void doTag() throws JspException, IOException {
		JspWriter out = getJspContext().getOut();
						
		out.print ("<input type='" + type + "' name='" + name + "' ");
		if (value==null) {
			// On recherche un attribut avec le même nom dans les != scopes
			Object o = getJspContext().findAttribute(name);
			value = o==null ? "" : o.toString();
		}
		out.print ("value='" + value + "' ");
	
		Iterator iterator = attributes.entrySet().iterator();
		while ( iterator.hasNext() ) {
			Map.Entry entry = (Map.Entry) iterator.next();
			out.print ( entry.getKey() + "='" + entry.getValue() + "' ");
		}
		out.print ("/>");
	}
}

Explications :
Le tag gère trois attributs :

• type qui permet de s'assurer que le type du champs INPUT est bien présent.
• name qui correspond à la fois au nom du champs INPUT et du bean coté serveur.
• value qui permet d'associer une autre valeur que celle du bean (si value est absent, on utilise le bean).

Tous les autres attributs qui seront passés au tag seront envoyés à la méthode setDynamicAttribute() qui se contentera de les placer dans une Map.
Les attributs type et name sont obligatoire. Dans la méthode doTag(), on utilise getJspContext().findAttribute() pour rechercher le bean si l'attribut value est absent, puis on affiche tous les attributs de la Map remplie par les appels succéssif à setDynamicAttribute().

Ainsi, avec le mapping suivant :

	<tag>
		<name>input</name>
		<tag-class>com.developpez.adiguba.tutorial.taglibs_20.InputTag</tag-class>
		<body-content>empty</body-content>
		<attribute>
			<name>name</name>
			<required>true</required>
			<rtexprvalue>true</rtexprvalue>
		</attribute>
		<attribute>
			<name>type</name>
			<required>true</required>
			<rtexprvalue>true</rtexprvalue>
		</attribute>
		<attribute>
			<name>value</name>
			<rtexprvalue>true</rtexprvalue>
		</attribute>
		<dynamic-attributes>true</dynamic-attributes>
	</tag>

Le code suivant :

<jsp:useBean id="input3" scope="page" class="java.util.Date"/>
	
	Input1 : <tag20:input type="text" name="input1" class="green" readonly="true" value="statique"/><br/>
	Input2 : <tag20:input type="text" name="input2" class="red" onfocus="methodeJavascript();"/><br/>
	Input3 : <tag20:input type="text" name="input3" class="blue"/><br/>

permet de conserver les autres attributs dans le code HTML généré :

	Input1 : <input type='text' name='input1' value='statique' readonly='true' class='green' /><br/>
	Input2 : <input type='text' name='input2' value='' class='red' onfocus='methodeJavascript();' /><br/>
	Input3 : <input type='text' name='input3' value='Thu Dec 30 16:17:38 CET 2004' class='blue' /><br/>

L'interface DynamicAttributes peut également être appliquée à des classes qui implémentent l'interface Tag ou ses interfaces filles ...

La déclaration des attributs d'un tag d'un fichier *.tag est décrite directement dans ce dernier avec la directive <%@ attribute %>. Elle accepte les mêmes valeurs que dans le descripteur de taglib (Voir ).

Cette directive à la forme suivante :

<%@ attribute name="attribute-name"
	required="true | false"
	fragment="true | false"
	rtexprvalue="true | false"
	type="java.lang.String | a non-primitive type"
	description="text"
%>

Le tag comportera alors une variable de script locale du même nom que l'attribut et qui contiendra la valeur de celui-ci.

De même, il est possible de déclarer les variables de scripts créées par le tag directement dans le fichier *.tag avec la directive suivantes :

<%@ variable
{ 	name-given="scripting variable"
	| (name-from-attribute="scripting variable" alias="locally-scoped attribute") }
[ variable-class="java.lang.String | name of the variable class" ]
[ declare="true | false" ]
[ scope="AT_BEGIN | AT_END | NESTED" ]
[ description="text" ]
%>

Le fonctionnement est le même que la balise variable du descripteur de taglib (Voir ).
La seule différence intervient si l'on utilise name-from-attribute, on est alors obligé d'utiliser un alias pour l'attribut du même nom afin d'éviter un conflit de nom de variable, étant donné qu'une variable locale est créée pour chaque attribut du tag.

Enfin, on a à notre disposition le tag <jsp:doBody/> qui permet d'évaluer le corps du tag. Ce tag peut avoir trois comportement :

• <jsp:doBody/> affichera l'évaluation du corps du tag directement dans la page.
• <jsp:doBody var="nom" scope="page"/> créera une String "nom" dans le scope "page" qui contient l'évaluation du corps.
• <jsp:doBody varReader="nom" scope="page"/> créera un StringReader "nom" dans le scope "page" qui contient l'évaluation du corps.