Présentation de la Java Standard Tag Library (JSTL)

Le but de la JSTL est de simplifier le travail des auteurs de page JSP, c'est à dire la personne responsable de la couche présentation d'une application web J2EE.
En effet, un web designer peut avoir des problèmes pour la conception de pages JSP du fait qu'il est confronté à un langage de script complexe qu'il ne maîtrise pas forcément.

La JSTL permet de développer des pages JSP en utilisant des balises XML, donc avec une syntaxe proche des langages utilisés par les web designers, et leur permet donc de concevoir des pages dynamiques complexes sans connaissances du langage Java.

Sun a donc proposé une spécification pour une librairie de tags standard : la Java Standard Tag Library (JSTL). C'est à dire qu'il spécifie les bases de cette librairie, mais qu'il laisse l'implémentation libre (de la même manière que pour les serveurs J2EE qui sont des implémentations de la spécification J2EE).

Pour plus d'information sur la JSTL vous pouvez consulter la page officielle chez Sun :
http://java.sun.com/products/jsp/jstl/
Ou la page officielle de la spécification de la JSTL :
https://jstl-spec-public.dev.java.net/

Ce tutoriel se base sur l'implémentation du projet Jakarta de la JSTL 1.1, qui est considéré comme l'implémentation de référence de la JSTL. Elle est disponible à l'adresse suivante :
http://jakarta.apache.org/taglibs/doc/standard-doc/intro.html

Enfin, l'API des interfaces et classes de bases de la JSTL est disponible à l'adresse suivante :
http://java.sun.com/products/jsp/jstl/1.1/docs/api/index.html
Et la documentation des différents tags :
http://java.sun.com/products/jsp/jstl/1.1/docs/tlddocs/

Actuellement, deux versions de la JSTL sont disponibles, avec les restrictions suivantes :

• La JSTL 1.0 nécessite au minimum un conteneur JSP 1.2 (J2EE 1.3).
• La JSTL 1.1 nécessite au minimum un conteneur JSP 2.0 (J2EE 1.4).

La JSTL se base sur l'utilisation des Expressions Languages en remplacement des scriptlets Java. Toutefois, ce mécanisme n'est disponible qu'avec le conteneur JSP 2.0. Ainsi, la JSTL 1.0 propose deux implémentations :

L'implémentation de base intègre donc un interpréteur d'Expressions Languages afin de pouvoir utiliser toutes les possibilités des Expressions Languages dans un conteneur JSP 1.1 ou 1.2 :

Ces URI ne doivent pas être utilisées dans une application J2EE 1.4 afin de ne pas rentrer en conflit avec l'interpréteur d'EL intégré dans les JSP 2.0. De plus cela interdit l'utilisation de scriptlets en tant que valeur des attributs des tags (seules les chaines de caractères sont autorisées) :

La seconde version de la JSTL 1.0 n'intègre pas d'interpréteur d'Expressions Languages. Cette implémentation se distingue par l'ajout des caractères "_rt" à la fin de l'URI et du préfixe, qui indique que la gestion des EL est éventuellement laissée au moteur JSP ("runtime") :

Attention, si ces URIs sont utilisées dans des JSP 1.1 ou 1.2, les Expressions Languages ne seront pas interprétées.

La JSTL 1.1 n'apporte pas de changement majeur dans les librairies de tags, mis à part l'ajout d'une nouvelle librairie de fonctions EL.
De plus, comme elle se base sur les JSP 2.0 qui intègre un moteur d'Expressions Languages, elle ne définit donc qu'une seule implémentation avec les URIs suivantes :

Afin de les distinguer des URIs de la JSTL 1.0, la chaîne "/jsp" a été ajoutée afin d'indiquer que cette version se base sur le conteneur JSP pour interpréter les Expressions Languages.

Ce tutoriel est basé sur la JSTL 1.1. Toutefois, mis à part la gestion des Expressions Languages et la librairie de fonctions, les différences entre les deux versions sont minimes...

L'utilisation des Expressions Languages est nécessaire pour une utilisation optimale de la JSTL, consultez le tutoriel dédié aux Expressions Languages pour plus de détails :
https://adiguba.developpez.com/tutoriels/j2ee/jsp/el/

Certaines librairies de la JSTL peuvent nécessiter une configuration propre à une application via le fichier web.xml en utilisant les init-param. Ainsi, pour exemple pour définir la source de donnée à utiliser par défaut, il faut renseigner le paramètre javax.servlet.jsp.jstl.sql.dataSource :

<?xml version="1.0" encoding="ISO-8859-1"?>

<web-app 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 http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
	version="2.4">
	
	<context-param>
		<param-name>javax.servlet.jsp.jstl.sql.dataSource</param-name>
		<param-value>jdbc/data</param-value>
	</context-param>

	...

</web-app>

La classe javax.servlet.jsp.jstl.core.Config comporte la liste des différents paramètres possibles. Chacun de ces paramètres sont détaillés dans la section Configuration de chaque librairie de la librairie.

La valeur de ces paramètres peut être modifiée dynamiquement via la classe Config ou via des tags spécifiques décrits dans la librairie correspondante. La nouvelle valeur est alors stockée dans un des scopes de l'application, avec les influences suivantes :

Lorsqu'une valeur de configuration est nécessaire, elle est d'abord recherchée dans les différents scopes (dans l'ordre naturel : page, request, session puis application). Si la valeur n'existe dans aucun des scopes, la valeur définit dans le web.xml est utilisée, ou une valeur par défaut le cas échéant.

Cette section comporte les actions de base pour la gestion des variables de scope d'une application web :

• L'affichage de variable
• La création/modification/suppression de variable de scope
• La gestion des exceptions

<c:out/> : Afficher une expression▲

<!-- Afficher l'user-agent du navigateur ou "Inconnu" si il est absent : -->
<c:out value="${header['user-agent']}" default="Inconnu"/>

<!-- Même chose en utilisant le corps du tag : -->
<c:out value="${header['user-agent']}">
	Inconnu
</c:out>

<c:set/> : Définir une variable de scope ou une propriété▲

<!-- Mettre ${expression} dans l'attribut "varName" de la session : -->
<c:set scope="session" var="varName" value="${expression}" />

<!-- Changer la propriété "name" de l'attribut "varName" de la session : -->
<c:set target="${session['varName']" property="name" value="new value"/>

<!-- Changer la propriété "name" de l'attribut "varName" de la session en utilisant le corps : -->
<c:set target="${session['varName']" property="name">
	Nouvelle valeur de la propriété "name"
</c:set>

<c:remove/> : Supprimer une variable de scope▲

<!-- Supprime l'attribut "varName" de la session -->
<c:remove var="varName" scope="session"/>

<c:catch/> : Intercepter les exceptions▲

<!-- Ignorer toutes les exceptions d'une partie de la page : -->
<c:catch>
	<c:set target="beans" property="prop" value="1"/>
</c:catch>

<!-- Stocker dans le scope page l'exception intercepté : -->
<c:catch var="varName">
	<c:set target="beans" property="prop" value="1"/>
</c:cath>

Cette section comporte les actions permettant d'effectuer les tests conditionnels de la même manière que les mots-clef if ou switch du langage Java.

<c:if/> : Traitement conditionnel▲

<!-- Afficher un message si le paramètre "page" de la requête HTTP est absent -->
<c:if test="${empty param['page']}">
	Le paramètre page est absent !
</c:if>

<c:choose/> : Traitement conditionnel exclusif▲

<c:when/> : Un cas du traitement conditionnel▲

<!-- Afficher un message différent selon la valeur du bean 'value' : -->
<c:choose>
	<c:when test="${value==1}"> value vaut 1 (Un) </c:when>
	<c:when test="${value==2}"> value vaut 2 (Deux) </c:when>
	<c:when test="${value==3}"> value vaut 3 (Trois) </c:when>	
</c:choose>

<c:otherwise/> : Traitement par défaut▲

<c:choose>
	<c:when test="${value==1}"> value vaut 1 (Un) </c:when>
	<c:when test="${value==2}"> value vaut 2 (Deux) </c:when>
	<c:when test="${value==3}"> value vaut 3 (Trois) </c:when>
	<c:otherwise>
		value vaut ${value} (?)
	</c:otherwise>
</c:choose>

Cette section comporte les actions permettant d'effectuer des boucles de la même manière que les mots-clef for ou while du langage Java.

2-3-1. Attributs standards des boucles▲

<c:forEach/> : Itérer sur une collection▲

<!-- Afficher tous les éléments d'une collection dans le request-->
<c:forEach var="entry" items="${requestScope['myCollection']}" >
	${entry}<br/>
</c:forEach>

<!-- Afficher seulement les 10 premiers éléments -->
<c:forEach var="entry" items="${requestScope['myCollection']}"
	begin="0" end="9">
	${entry}<br/>
</c:forEach>

<!-- Afficher les nombres de 1 à 10 -->
<c:forEach var="entry" begin="1" end="10">
	${entry}, 
</c:forEach>

<!-- Afficher tous les paramètres de la requête HTTP (param est une Map)-->
<c:forEach var="entry" items="${param}" >
	Le paramètre "${entry.key}" vaut "${entry.value}".<br/>
</c:forEach>

<c:forTokens/> : Itérer sur des éléments d'une String▲

<!-- Afficher séparément des mots séparés par un point-virgule -->
<c:forTokens var="p" items="mot1;mot2;mot3;mot4" delims=";">
	${p}<br/>
</c:forTokens>

Cette section décrit quelques tags utiles pour la gestion des URLs :

• Création d'URLs complexes
• Redirection vers une URLs
• Import de ressources locales ou distantes

<c:param/> : Ajouter un paramètre à une URL▲

<!-- La forme suivante : -->
<c:url value="/mapage.jsp?paramName=paramValue"/>

<!-- est equivalente à : -->
<c:url value="/mapage.jsp">
	<c:param name="paramName" value="paramValue"/>
</c:url><br/>

<c:url/> : Créer une URL▲

<!-- Création d'un lien dont les paramètres viennent d'une MAP -->
<c:url value="/index.jsp" var="variableURL">
	<c:forEach items="${parameterMap}" var="entry">
		<c:param name="${entry.key}" value="${entry.value}"/>
	</c:forEach>
</c:url>
<a href="${variableURL}">Mon Lien</a>

<!-- Ainsi le code suivant : -->
<c:url value="/page.jsp?param=value">

<!-- Affichera pour le contexte "contextPath" :
	 /contextPath/page.jsp?param=value
	 ou si les cookies sont désactivé :
	 /contextPath/page.jsp;jsessionid=XXXXXXXXXX?param=value
-->

<!-- Et le code suivant créera une variable "url" dans le scope page -->
<c:url var="url" scope="page" value="/page.jsp?param=value">
	<c:param name="id" value="1"/>
</c:url>
<!-- La variable de scope "url" contiendra donc : 
	/contextPath/page.jsp?param=value&id=1
	 ou si les cookies sont désactivé :
	 /contextPath/page.jsp;jsessionid=XXXXXXXXXX?param=value&id=1
-->

<c:redirect/> : Redirection▲

<!-- Redirection vers le portail de developpez.com : -->
<c:redirect url="http://www.developpez.com"/>

<!-- Redirection vers une page d'erreur avec des paramètres: -->
<c:redirect url="/error.jsp">
	<c:param name="from" value="${pageContext.request.requestURI}"/>
</c:redirect>

<c:import/> : Importer des ressources▲

<!-- Importer un fichier de l'application (similaire à <jsp:include/>) -->
<c:import url="/file.jsp">
	<c:param name="page" value="1"/>
</c:import>

<!-- Importer une ressource distante FTP dans une variable -->
<c:import url="ftp://server.com/path/file.ext"
	var="file" scope="page"/>

<!-- Importe une ressource distante dans un Reader -->
<c:url value="http://www.server.com/file.jsp" var="fileUrl">
	<c:param name="file" value="filename"/>
	<c:param name="page" value="1"/>
</c:url>

<!-- Ouverte d'un flux avec un Reader -->
<c:import url="${fileUrl}" varReader="reader">
	<!-- Utilisation du reader par d'autres tags... -->
	...
	<x:parse doc="${reader}"/>
	...
</c:import>

La JSTL utilise les classes standard de Java pour la gestion de l'internationalisation. Ainsi la classe java.util.Locale permet de représenter les spécificités régionales, ainsi que la classe java.util.ResourceBundle pour accéder aux données des fichiers de localisation.

Un ResourceBundle permet de gérer un ensemble de fichier *.properties contenant les ressources localisées. Par exemple pour gérer les langues françaises, anglaises et italiennes, on pourrait avoir les fichiers suivants :

• Message_fr.properties
• Message_en.properties
• Message_it.properties

Il est également possible d'utiliser un code de pays afin de gérer des différences au sein même d'une langue. Par exemple si on veut pouvoir différencier le français selon que le client soit Français ou Canadien, on pourra utiliser en plus les fichiers suivants :

• Message_fr_FR.properties
• Message_fr_CA.properties

Il est également possible d'utiliser une variante plus spécifique, afin d'apporter une différenciation sur des critères spécifiques (système d'exploitation, variante d'une langue, ...). Par exemple, Message_fr_FR_WIN.properties peut prendre en compte des spécificités du système d'exploitation Windows...

Lorsque un nouvel utilisateur se connecte, la valeur de l'header HTTP "Accept-Language" est utilisée pour rechercher la meilleure Locale à utiliser.

Par exemple, si un utilisateur utilise la Locale "fr_FR", les messages seront recherchés dans les fichiers suivants dans cet ordre :

1. Message_fr_FR.properties
2. Message_fr.properties

Si le fichier "Message_fr_FR.properties" n'existe pas ou qu'il ne possède pas la clef recherchée, on passe au suivant ("Message_fr.properties")...
Si la clef ne peut pas être trouvée un message du style "???clef???" est renvoyé.

Ainsi, le fichier "Message_fr.properties" est à privilégier afin qu'il puisse être utilisé par d'autres francophones (fr_CA, fr_BE,...), alors que le fichier Message_fr_FR.properties servira pour des spécifications franco-françaises...

Les fichiers *.properties comportent un ensemble de couple clef/valeur. On accède aux données localisées grâce aux différentes clefs. Par exemple, le fichier "Message_fr.properties" pourrait contenir :

# Ligne en commentaire
message.hello = Bienvenue
message.title = Titre de la page

Et le code suivant affichera alors la chaîne "Bienvenue" aux utilisateurs francophones :

<fmt:param value="message.hello"/>

3-1-1. Configuration▲

<fmt:setLocale value="fr_FR" scope="session"/>

	<!-- Utilisation de l'anglais comme Locale par défaut -->
	<context-param>
		<param-name>javax.servlet.jsp.jstl.fmt.fallbackLocale</param-name>
		<param-value>en</param-value>
	</context-param>

<fmt:setLocale/> : Définir la Locale▲

<!-- Force l'affichage de la page en anglais : -->
<fmt:setLocale value="en" scope="page"/>

<!-- Force l'affichage en français pour un utilisateur : -->
<fmt:setLocale value="fr" scope="session"/>

<fmt:setBundle/> : Définir le ResourceBundle▲

<!-- Change le ResourceBundle par défaut de la page : -->
<fmt:setBundle basename="package.MyRessource"/>

<!-- Création d'un autre Bundle : -->
<fmt:setBundle basename="package.MyOtherRessource" var="bundleName"/>

<!-- Affichage d'un message du ResourceBundle par défaut : -->
<fmt:message key="keyName"/>

<!-- Affichage d'un message du second Bundle : -->
<fmt:message key="keyName" bundle="${bundleName}"/>

<fmt:bundle/> : Définir un ResourceBundle partiel▲

<!-- Utilisation d'un autre Bundle pour afficher des messages : -->
<fmt:bundle basename="package.MessageResource">
	<fmt:message key="msg.error.key1"/><br/>
	<fmt:message key="msg.error.key2"/><br/>
	<fmt:message key="msg.error.key3"/><br/>
</fmt:bundle>

<!-- Même chose en utilisant un préfixe : -->
<fmt:bundle basename="package.MessageResource" prefix="msg.error."">
	<fmt:message key="key1"/><br/>
	<fmt:message key="key2"/><br/>
	<fmt:message key="key3"/><br/>
</fmt:bundle>

<fmt:message/> : Afficher des messages▲

<!-- Affichage d'un message directement dans le JSP : -->
<fmt:message key="message.key"/>

<!-- Copie d'un message dans une variable pour l'afficher plus tard : -->
<fmt:message key="message.key" var="msg"/>

Le message est : <b>${msg}</b> !

<fmt:param/> : Ajouter un paramètre au message▲

<!-- Affichage d'un message avec deux paramètres -->
<fmt:message key="message.key">
	<fmt:param value="${mailbox.userName}"/>
	<fmt:param value="${mailbox.messageCount}"/>
</fmt:message>

<fmt:requestEncoding/> : Encodage du client▲

<fmt:requestEncoding/>

La JSTL propose des tags facilitant le formatage des données numériques et des dates/heures. Ces tags prennent en compte la Locale de l'utilisateur pour paramétrer l'affichage...

3-2-1. Configuration▲

<fmt:setTimeZone/> : Définir le fuseau horaire▲

<!-- Change le TimeZone par défaut de la page : -->
<fmt:setTimeZone value="GMT-8"/>

<!-- Création d'un autre TimeZone dans une variable : -->
<fmt:setTimeZone value="GMT-1" var="timezone"/>

<fmt:timeZone/> : Utiliser un Timezone▲

<!-- Affichage d'une date GMT : -->
<fmt:timeZone value="GMT">
	<fmt:formatDate value="${myDate}"/>
</fmt:timeZone>

<fmt:parseDate/> : Analyser une date▲

<!-- Créer une date initialisé au premier janvier 2005 : -->
<fmt:parseDate value="01/01/2005" pattern="dd/MM/yyyy" var="date"/><br/>

<fmt:formatDate/> : Formater une date▲

<!-- Afficher une date selon un format spécifique : -->
<fmt:formatDate value="${dateBeans}" pattern="dd/MM/yyyy"/>

<!-- Afficher une date selon un format standard : -->
<fmt:formatDate value="${dateBeans}" style="full"/>

<fmt:parseNumber/> : Analyser un nombre▲

<!-- Créer un objet nombre : -->
<fmt:parseNumber value="1250,00" var="num"/>

<fmt:formatNumber/> : Formater un nombre▲

<!-- Afficher un pourcentage -->
<fmt:formatNumber value="0.25" type="percent"/>

<!-- Afficher une somme en Euros -->
<ftm:formatNumber value="15" type="currency" currencySymbol="&euro;"/>

La librairie SQL permet de configurer le DataSource et le nombre de ligne maximum d'une requête. On peut bien sûr utiliser des valeurs différentes grâce aux attributs du même nom des différents tags...

4-1-1. DataSource▲

	<!-- Utilisation de JNDI : 	-->
	<context-param>
		<param-name>javax.servlet.jsp.jstl.sql.dataSource</param-name>
		<param-value>jdbc/myDataBase</param-value>
	</context-param>
	
	<!-- Utilisation d'une chaîne paramétrée sur une base mySQL : 	-->
	<context-param>
		<param-name>javax.servlet.jsp.jstl.sql.dataSource</param-name>
		<param-value>jdbc:mysql://localhost/base,org.gjt.mm.mysql.Driver,login,password</param-value>
	</context-param>

4-1-2. Nombre de ligne maximum▲

	<!-- Limiter les requêtes à 100 lignes : -->
	<context-param>
		<param-name>javax.servlet.jsp.jstl.sql.maxRows</param-name>
		<param-value>100</param-value>
	</context-param>

Permet de définir le Datasource à utiliser pour les connections à la base de données, ou de créer un objet DataSource.

Corps du tag : Aucun.

<!-- Changer le DataSource a utiliser sur la page (avec JNDI) -->
<sql:setDataSource dataSource="jdbc/myDataBase" scope="page"/>

<!-- Changer le DataSource pour l'utilisateur courant (avec JNDI) -->
<sql:setDataSource dataSource="jdbc/myDataBase" scope="session"/>

<!-- Créer un bean dateSource (avec JNDI) -->
<sql:setDataSource dataSource="jdbc/myDataBase"
	var="monBeanDataSource" scope="page"/>

<!-- Créer un DataSource via un DriverManager (non recommandé) : -->
<sql:setDataSource var="monBeanDataSource" scope="page"
	dataSource="jdbc:mysql://localhost/base,org.gjt.mm.mysql.Driver,login,password"/>

<!-- Même solution décomposé : -->
<sql:setDataSource var="monBeanDataSource" scope="page"
	url="jdbc:mysql://localhost/base"
	driver="org.gjt.mm.mysql.Driver"
	user="login"
	password="password"/>

Permet d'exécuter des requêtes (SELECT) sur la base de données.

Le corps du tag peut contenir la requête SQL à la place de l'attribut sql. De plus elle peut contenir des tags afin de paramétrer la requête SQL (Voir ).

<!-- Rechercher tous les éléments d'une table -->
<sql:query sql="select * from tableName" var="result"/>

<!-- Même chose en utilisant le corps du tag -->
<sql:query var="result">
	select * from tableName
</sql:query>

<!-- Rechercher seulement 10 éléments de la table.
	Le premier élément est défini par la paramètre HTTP start : -->
<sql:query var="result"  maxRows="10" startRow="${param['start']}">
	select * from tableName
</sql:query>

Exception :
Les éventuelles exceptions SQL sont encapsulées dans une JspException...

L'action <sql:query/> stocke le résultat de la requête dans un objet qui implémente l'interface javax.servlet.jsp.jstl.sql.Result qui comporte les propriétés suivantes :

Il est ainsi possible de paramétrer l'affichage des données à sa guise. rowsByIndex permettant d'accéder aux éléments selon leurs index tandis que rows permet d'utiliser le nom du champs SQL.
Par exemple, pour afficher le résultat d'une requête sous forme de tableau HTML, on peut utiliser le code suivant :

<!-- Affichage d'une requête :
	${result} étant la variable de scope crée par <sql:query/>
-->

<table>
	<!-- Affichage de l'entête avec le nom des colonnes -->
	<tr>
	<c:forEach var="name" items="${result.columnNames}">
		<th>${name}</th>
	</c:forEach>
	</tr>
	
	<!-- Affichage des données avec 'rowsByIndex' -->
	<c:forEach var="ligne" items="${result.rowsByIndex}">
	<tr>
		<c:forEach var="valeur" items="${ligne}">
			<td>${valeur}</td>
		</c:forEach>
	</tr>
	</c:forEach>
</table>

Chaque éléments de la requête est un objet de l'instance du type Java associé au type SQL tel que définit par la spécification JDBC et obtenu par la méthode getObject() du ResultSet...

Permet d'exécuter des commandes SQL tel que INSERT, UPDATE ou DELETE ainsi que les commandes SQL qui ne retournent pas de résultats...

Le corps du tag peut contenir la requête SQL à la place de l'attribut sql. De plus elle peut contenir des tags afin de paramétrer la requête SQL (Voir ).

<!-- Supprimer tous les éléments d'une table -->
<sql:query sql="delete from tableName" var="nbRowDeleted"/>

Exception :
Les éventuelles exceptions SQL sont encapsulées dans une JspException...

Permet d'exécuter des commandes SQL tel que INSERT, UPDATE ou DELETE ainsi que les commandes SQL qui ne retournent pas de résultats...

Pour plus d'information sur les transactions, consultez la FAQ JDBC de developpez.com :
https://java.developpez.com/faq/jdbc/?page=transactions#isolationTransactions

Le corps du tag contient un ensemble de tags <sql:query/> et/ou <sql:update/>. Toutes les modifications de la base ne seront pas effectuées si une exception survient pendant la transaction.

<!-- 
<sql:transaction>
	<sql:query sql="requete SQL 1 ... " />
	<sql:query sql="requete SQL 1 ... " />
	<sql:query sql="requete SQL 1 ... " />
</sql:transaction>

Lorsqu'ils sont utilisés à l'intérieur de la balise <sql:transaction/>, <sql:query/> et <sql:update/> utilisent le dataSource du tag <sql:transaction/> et ne doivent donc pas être utilisés avec l'attribut dataSource...

Permet de définir la valeur d'un paramètre d'une requête lorsque le marqueur "?" est utilisé. Il doit obligatoirement être un sous tag de <sql:query/> ou de <sql:update/>.

Le Corps du tag peut être utilisé à la place de l'attribut value afin de définir la valeur du paramètre.

<!-- Exemple de requête paramétrée : -->
<sql:query var="result">
	SELECT * FROM tableName
	WHERE row1 = ?
	WHERE row1 = ?
	
	<sql:param value="valeur1"/>
	<sql:param>
		valeur2
	</sql:param>
</sql:query>

Les différents marqueurs ? de la requête seront remplacés par la valeur des tags <sql:param/> en respectant leurs ordres d'apparitions...

Le type SQL a utilisé dépend du type Java de l'objet passé et dépend donc du mapping JDBC des types Java/SQL.

Ce tag est similaire au tag <sql:param/> mais permet de définir le format exacte de la date. Il doit obligatoirement être un sous tag de <sql:query/> ou de <sql:update/>.

Corps du tag : Aucun.

<!-- Exemple de requête paramétrée avec deux dates : -->
<sql:query var="result">
	SELECT * FROM tableName
	WHERE date BETWEEN ? AND ?
	
	<sql:dateParam value="${startDate}" type="date"/>
	<sql:dateParam value="${endDate}" type="date"/>
	
</sql:query>

Le tag <sql:dateParam/> est identique à l'utilisation du tag <sql:param/> avec comme valeur un objet du type java.sql.Time, java.sql.Date, ou java.sql.Timestamp.
Le tag <sql:dateParam/> permet d'effectuer simplement les conversions entre ces différents types et le type java.util.Date.

Afin d'accéder aux données des documents XML, le langage XPath (XML Path Language) est utilisé. Ce dernier est une recommandation du W3C dont la documentation est accessible à l'adresse suivante :
http://www.w3.org/TR/xpath

Un tutoriel en français est également disponible sur developpez.com. Je vous invite fortement à le consulter :
https://jerome.developpez.com/xmlxsl/xpath/

Afin d'interagir avec les données de l'application web, les expressions XPath peuvent être complétées par des variables correspondant aux différents objets implicites. On peut ainsi utiliser les expressions suivantes à l'intérieur d'une expression XPath :

<!-- Recherche des balises "balise" avec un attribut "attribut"
	dont la valeur est égal au paramètre HTTP name : -->
/root/balise[@attribut=$param:name]

De plus, lorsqu'elles sont utilisées dans un des tags de cette librairie, les expressions XPath doivent être précédées de l'objet représentant le document ou le noeud XML :

<!-- Pour afficher le résultat de l'expression, on pourrait faire : -->
<x:out select="$myXmlDoc/root/balise[@attribut=$param:name]"/>

<!-- "myXmlDoc" étant une variable de scope représentant le document XML -->

Cette section décrit les actions de bases sur les fichiers XML, c'est à dire l'analyse de fichier XML et l'accès à ses valeurs via des expressions XPath.

<x:parse/> : Analyser un XML▲

<!-- Chargement du XML dans un Reader : -->
<c:import url="/docs/myFile.xml" varReader="myFileReader"/>

<!-- Analyse du fichier XML chargé avec c:import -->
<x:parse doc="${myFileReader}" var="parsedDoc"/>


<!-- Analyse d'un XML depuis le corps du tag : -->
<x:parse var="parsedDoc">
	<stock>
		<produit id="01">
			<nom>PC</nom>
			<quantite>3</quantite>
			<min>10</min>
			<commande>10</commande>
		</produit>
		<produit id="02">
			<nom>Mac</nom>
			<quantite>5</quantite>
			<min>10</min>
			<commande>5</commande>
		</produit>
	</stock>
</x:parse>

<x:out/> : Evaluer une expression▲

<!-- Afficher la quantité de PC en stock : -->
<x:out select="$parsedDoc/stock/produit[nom='PC']/quantite"/>

<x:set/> : Créer une variable de scope▲

<!-- Stocker le noeud du PC dans un bean : -->
<x:set select="$parsedDoc/stock/produit[name='PC']" var="pc" />

<!-- Affichage en utilisant le noeud créé -->
<x:out select="$pc/nom"/>

Cette section décrit les actions de contrôle qui peuvent être utilisées sur les documents XML. Ces tags fonctionnent de la même manière que les actions du même nom de la librairie , mis à part qu'ils s'appliquent à une expression XPath sur un document XML.

<x:if/> : Action conditionnelle▲

<!-- Afficher un message si la quantité de PC est inférieur au minimum : -->
<x:if select="$parsedDoc/stock/produit[nom='PC'][quantite<min]">
	Il faut commander des PCs !!!!!
</x:if>

<x:choose/> : Traitement conditionnel exclusif▲

<x:when/> : Un cas du traitement conditionnel▲

<!-- Afficher un message différent selon la quantité en stock : -->
<x:choose>
	<x:when select="parsedDoc/stock/produit[quantite<min]">
		Le stock est en dessous de la quantité minimum !
	</x:when>
	<x:when select="parsedDoc/stock/produit[quantite=0]">
		Il n'y a plus de stock !
	</x:when>
</x:choose>

<x:otherwise/> : Traitement par défaut▲

<code langage="xml" titre="Exemple"><![CDATA[
<!-- Afficher un message différent selon la quantité en stock : -->
<x:choose>
	<x:when select="parsedDoc/stock/produit[quantite<min]">
		Le stock est en dessous de la quantité minimum !
	</x:when>
	<x:when select="parsedDoc/stock/produit[quantite=0]">
		Il n'y a plus de stock !
	</x:when>
	<x:otherwise>
		La quantité en stock est suffisante.
	</x:otherwise>
</x:choose>

<x:forEach/> : Itérer sur le fichier XML▲

<!-- Afficher tous les produits du stock : -->
<x:forEach var="produit" select="$stockXml/stock/produit">
	<b><x:out select="$produit/nom"/></b> :
	<x:out select="$produit/quantite"/> unité(s) en stock.<br/>
</x:forEach>

Cette section décrit l'utilisation de transformation XLS (Stylesheet Language for XML) sur des documents XML. Une bonne connaissance d'XSLT est donc obligatoire.

XSLT est une recommandation du w3c :
http://www.w3.org/TR/xslt

Je vous invite également à consulter les cours de developpez.com pour plus de détail :
https://xml.developpez.com/cours/

<x:transform/> : Appliquer un XSLT▲

<!-- chargement des fichiers XML et XLS : -->
<c:import url="/stock.xml" var="stockXml"/>
<c:import url="/stock.xsl" var="stockXsl"/>

<!-- Transformation XLS : -->
<x:transform doc="${stockXml}" xslt="${stockXsl}"/>

<x:param/> : Ajouter un paramètre XSLT▲

<!-- Transformation XLS avec un paramètre : -->
<x:transform doc="${stockXml}" xslt="${stockXsl}">
	<x:param name="param" value="01"/>
</x:transform>

Vérifie si une chaîne contient une autre chaîne :

fn:contains(string, substring) -> boolean

${ fn:contains("Il était une fois", "une") }
retournera true

Le résultat est équivalent à l'utilisation de la méthode contains() de la classe String.

Vérifie si une chaîne contient une autre chaîne en ignorant la case :

fn:containsIgnoreCase(string, substring) -> boolean

${ fn:containsIgnoreCase("Il était une fois", "Une") }
retournera true

Le résultat est équivalent à l'utilisation de la méthode containsIgnoreCase() de la classe String.

Vérifie si une chaîne se termine par le suffixe indiqué :

fn:endsWith(string, suffix) -> boolean

${ fn:endsWith("Il était une fois", "fois") }
retournera true

Le résultat est équivalent à l'utilisation de la méthode endsWith() de la classe String.

Protège les caractères qui peuvent être interprétés comme des marqueurs XML.

fn:escapeXml(string) -> String

${ fn:escapeXml("les <balises> xml & html") }
retournera "les &lt;balises&gt; xml &amp; html"

Les caractères <, >, &, ', " seront remplacés par leurs codes respectifs : &lt;, &gt;, &amp;, &#039;, &#034;.

Retourne l'index de la sous chaîne dans la chaîne :

fn:indexOf(string, substring) -> int

${ fn:indexOf("Il était une fois", "une") }
retournera 10

Le résultat est équivalent à l'utilisation de la méthode indexOf() de la classe String.

Joint tous les éléments d'un tableau de chaîne dans une unique chaîne.

fn:join(array, separator) -> String

<!-- nameArray est un tableau contenant {"Il","était","une","foie"} -->
${ fn:join( nameArray, " ") }
retournera "Il était une fois"

Indique le nombre d'éléments d'une collection (tableau, List, Set, Map...) ou le nombre de caractères d'une String :

fn:length(input) -> integer

${ fn:length("Il était une fois") }
retournera 17

Retourne la chaîne après avoir remplacé toutes les occurrences d'une chaîne par une autres :

fn:replace(string, before, after) -> String

${ fn:replace("Il Ã©tait une fois", " ", " ") }
retournera "Il était une fois"

Permet de découper une chaîne de caractère en plusieurs sous-chaînes :

fn:split(string, delimiters) -> String[]

${ fn:split("Il était une fois", " ") }
retournera un tableau avec les éléments suivant : {"Il","était","une","foie"}

Le résultat est le même que celui obtenu avec la classe java.util.StringTokenizer.

Vérifie si une chaîne commence par le préfixe indiqué :

fn:startsWith(string, prefix) -> boolean

${ fn:startsWith("Il était une fois", "Il") }
retournera true

Le résultat est équivalent à l'utilisation de la méthode startsWith() de la classe String.

Retourne une partie d'une chaîne de caractère selon deux index :

fn:substring(string, begin, end) -> String

${ fn:substring("Il était une fois", 3, 8) }
retournera "était"

Le résultat est équivalent à l'utilisation de la méthode substring() de la classe String.

Retourne la sous chaîne de caractère situé après la sous chaîne spécifiée :

fn:substringAfter(string, substring) -> String

${ fn:substringAfter("Il était une fois", "était") }
retournera " une fois"

Retourne la sous chaîne de caractère situé avant la sous chaîne spécifié :

fn:substringBefore(string, substring) -> String

${ fn:substringBefore("Il était une fois", "était") }
retournera "Il "

Convertit tous les caractères de la chaîne en minuscule :

fn:toLowerCase(string) -> String

${ fn:toLowerCase("IL ÉTAIT UNE FOIS") }
retournera "il était une fois"

Le résultat est équivalent à l'utilisation de la méthode toLowerCase() de la classe String.

Convertit tous les caractères de la chaîne en majuscule :

fn:toUpperCase(string) -> String

${ fn:toUpperCase("Il était une fois") }
retournera "IL ÉTAIT UNE FOIS"

Le résultat est équivalent à l'utilisation de la méthode toUpperCase() de la classe String.

Supprime les espaces au début et à la fin de la chaîne :

fn:trim(string) -> String

${ fn:trim("   Il était une fois   ") }
retournera "Il était une fois"

Le résultat est équivalent à l'utilisation de la méthode trim() de la classe String.

La classe javax.servlet.jsp.jstl.core.Config définit un certain nombre de méthodes statiques permettant d'accéder/modifier les différents éléments de la configuration.

• Config.find(PageContext,String) recherche la valeur de la configuration dans l'ordre des scopes.
• Config.get(PageContext,String), Config.get(ServletRequest,String), Config.get(HttpSession,String) et Config.get(Servletcontext,String) recherchent la valeur de la configuration dans le scope spécifié.
• Config.set(PageContext,String,Object), Config.set(ServletRequest,String,Object), Config.get(HttpSession,String,Object) et Config.get(Servletcontext,String,Object) permettent de modifier la valeur de la configuration dans le scope spécifié.

Cette classe comporte également des attributs statiques contenant le nom des différents éléments de la configuration.

Par exemple, pour changer la locale de la page courante en anglais, on peut utiliser le code suivant :

Config.set (pageContext, Config.FMT_LOCALE, Locale.ENGLISH );

La classe javax.servlet.jsp.jstl.core.ConditionalTagSupport est une classe abstraite permettant de faire un tag conditionnel simplement. Il suffit ainsi d'implémenter le code de la méthode condition() qui déterminera si le corps doit être affiché ou pas. Il n'y a pas à se soucier du fonctionnement réel du tag.

Par exemple, pour écrire un tag conditionnel qui n'évalue son corps que si la session comporte un attribut "login-info", il suffit d'utiliser le code suivant :

public class LoginConditionalTag extends ConditionalTagSupport {

	protected boolean condition() {
		HttpSession session = pageContext.getSession();
		if (session!=null && session.getAttribute("login-info"))
			return true;
		return false;
	}

}

La classe javax.servlet.jsp.jstl.core.LoopTagSupport est une classe abstraite permettant de faire un tag itératif simplement sans se soucier du fonctionnement réel du tag.

Il suffit d'implémenter les méthodes prepare(), hasNext(), et next() qui permettent respectivement de :

• Préparer les éléments de la boucle.
• Indiquer si il y a encore un élément.
• Accéder à l'élément suivant.

Ainsi, le tag appellera la méthode prepare() à l'initialisation, puis les méthodes hasNext() et next() autant de fois que nécessaire...

Par exemple, pour parcourir les différents caractères d'une chaîne, on peut utiliser le code suivant :

public class StringCharTag extends LoopTagSupport {

	private String string;
	private int position;
	private int length ;
	
	public void setString(String string) {
		this.string = string;
	}

	protected void prepare() {
		this.position = 0;
		
		if (string!=null)
			this.length = string.length();
		else
			this.length = 0;
	}

	protected boolean hasNext() {
		return (this.position < this.length)
	}
	
	protected Object next() {
		Character c = new Character ( string.charAt(position) );
		position++;
		return c;
	}

}

Le principal avantage de cette solution vient du fait qu'il est possible d'apporter un grand nombre de condition sur la boucle. En effet, les tags itératifs de la JSTL sont tous basés sur cette classe. La classe LoopTagSupport gère en effet tous les . Il suffit donc d'assigner les valeurs aux attributs du même nom pour pouvoir en profiter...

Attention, il faut pour cela définir les méthodes getter() et setter() de ces différents attributs de LoopTagSupport, et les déclarer dans le descripteur de taglib...

La classe javax.servlet.jsp.jstl.fmt.LocaleSupport permet elle d'accéder aux données localisées de la même manière que le tag <fmt:message/>. Elle possède en effet plusieurs méthodes statiques getLocalizedMessage() afin d'accéder aux informations des ResourceBundles dans la locale courante en précisant ou non des arguments et/ou le nom du ResourceBundle :

• getLocalizedMessage(PageContext pageContext, String key)
• getLocalizedMessage(PageContext pageContext, key, Object[] args)
• getLocalizedMessage(PageContext pageContext, String key, String basename)
• getLocalizedMessage(PageContext pageContext, key, Object[] args, String basename)

Par exemple, pour accéder à un message du ResourceBundle par défaut, il suffit d'utiliser le code suivant :

String message = LocaleSupport.getLocalizedMessage(pageContext, "message.key");