La Faq Java Ee

La FAQ Java EE
Date de publication : 17/05/2003
Dernière mise à jour : 17/05/2009
Cette faq a été réalisée à partir des questions fréquemment posées sur les forums de
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.
Sur ce, nous vous souhaitons une bonne lecture.
L'équipe Java
Ont contribué à cette FAQ :
L'équipe Java - Stessy - adiGuba - bahamouth - christopheJ

- lunatix - syj - Righetto Dominique - draken - SnorkyBZH
- Didier - vedaer - duj - request - SEMPERE Benjamin -
Jaxofun - willy78 - Sniper37 - X-plode : Mike François -
La FAQ Java EE
1. Informations générales (5) .........................................................................................................................................................4

2. Définitions (14) ..........................................................................................................................................................................6
3. Java EE (4) .............................................................................................................................................................................. 12
3.1. Généralités (4) .................................................................................................................................................................13
4. JSP (26) ....................................................................................................................................................................................14
4.1. Généralités (6) .................................................................................................................................................................15
4.2. JSTL (Java Standard Tag Library) (2) ........................................................................................................................... 18
4.2.1. Librairie de base (1) .............................................................................................................................................. 19
4.3. JSP Taglibs (18) ............................................................................................................................................................. 20
4.3.1. Taglibs 1.1 (11) ..................................................................................................................................................... 21
4.3.2. Taglibs 1.2 (6) ....................................................................................................................................................... 30
5. Servlets (18) .............................................................................................................................................................................35
5.1. Généralités (15) ...............................................................................................................................................................36
5.2. Session (3) ...................................................................................................................................................................... 43
6. Frameworks Web (2) ...............................................................................................................................................................45
7. Conteneurs Web et Serveurs d'Application (2) .......................................................................................................................46
7.1. Serveurs d'application (0) ............................................................................................................................................... 47
7.1.1. Glassfish (0) ...........................................................................................................................................................48
7.1.2. JBoss (0) ................................................................................................................................................................ 49
7.1.3. Weblogic (0) .......................................................................................................................................................... 50
7.1.4. JOnAS (0) .............................................................................................................................................................. 51
7.1.5. Websphere (0) ........................................................................................................................................................52
7.2. Conteneurs Web (2) ........................................................................................................................................................53
7.2.1. Tomcat (2) ............................................................................................................................................................. 54
-3-
Les sources présentées sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation de ces sources
constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2003 - 2009 Developpez LLC. Tout 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'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://java.developpez.com/faq/javaee/
La FAQ Java EE
Sommaire > Informations générales

Comment bien utiliser cette faq ?
Auteurs : L'équipe Java ,
Le but : Cette faq a été conçue pour être la plus simple possible d'utilisation. Elle tente d'apporter des réponses simples
et complètes aux questions auxquelles sont confrontés tous les débutants (et les autres).
L'organisation : Les questions sont organisées par thème, les thèmes pouvant eux-même contenir des sous-thèmes.
Lorsqu'une question porte sur plusieurs thèmes, celle-ci est insérée dans chacun des thèmes rendant la recherche plus
facile.
Les réponses : Les réponses contiennent des explications et des codes sources. Certaines sont complétées de fichier à
télécharger contenant un programme de démonstration. Ces programmes sont volontairement très simples afin qu'il
soit aisé de localiser le code intéressant. Les réponses peuvent également être complétées de liens vers d'autres réponses,
vers la documentation en ligne de Sun ou vers un autre site en rapport.
Nouveautés et mises à jour : Lors de l'ajout ou de la modification d'une question/réponse, un indicateur est placé à coté
du titre de la question. Cet indicateur reste visible pour une durée de 15 jours afin de vous permettre de voir rapidement
les modifications apportées.
J'espère que cette faq pourra répondre à vos questions. N'hésitez pas à nous faire part de tous commentaires/remarques/
critiques.
lien : Comment participer à cette faq?
Comment participer à cette faq ?

Cette faq est ouverte à toute collaboration. Pour éviter la multiplication des versions, il serait préférable que toutes
collaborations soient transmises aux administrateurs de la faq.
Plusieurs compétences sont actuellement recherchées pour améliorer cette faq :
Rédacteur : Bien évidemment, toute nouvelle question/réponse est la bienvenue.
Web designer : Toute personne capable de faire une meilleure mise en page, une feuille de style ou de belles images...
Correcteur : Malgré nos efforts, des fautes d'orthographe ou de grammaire peuvent subsister. Merci de contacter les
administrateurs si vous en débusquez une... Idem pour les liens erronés.
lien : Quels sont les droits de reproduction de cette faq ?
Quels sont les droits de reproduction de cette FAQ ?

Les codes sources présentés sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Pour le
reste, ce document constitue une oeuvre intellectuelle protégée par les droits d'auteurs.
Copyright © 2009 Developpez LLC : Tous droits réservés Developpez LLC. Aucune reproduction ne peut en être faite
sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300
000 E de dommages et intérêts. Cette page est déposée à la SACD.
Où trouver d'autres sources d'information ?

•
Les cours et didacticiels de www.developpez.com
•
Les forums de la section Java de www.developpez.com
-4-
La FAQ Java EE
•
La FAQ Struts
•
La FAQ Général Java
•
La FAQ JDBC
•
La Javadoc : toutes les informations utiles sur les classes, leurs méthodes ... à toujours avoir sous la main.
•
Les didacticiels de Sun
•
La FAQ de JGuru, beaucoup plus complète que celle-ci ...
Remerciements
-5-
La FAQ Java EE
Sommaire > Définitions

Qu'est ce que Java EE?
Auteurs : Stessy ,
La plateforme Java entreprise (Java EE) est un ensemble de spécifications coordonnées et pratiques qui permettent
ensemble des solutions pour le développement, le déploiement, et de la gestion des applications multitiers centralisées
sur un serveur. Construit sur la plateforme de Java 2 édition standard (Java SE), la plateforme Java EE ajoute les
possibilités nécessaires pour fournir une plateforme complète, stable, sécurisée, et rapide de Java au niveau entreprise.
La plateforme entreprise fournit un ensemble de services permettant aux composants de dialoguer entre eux:
• HTTP et HTTPS
• Java Transaction API (JTA)
• Remote Method Invocation/Internet Inter-ORB Protocol (RMI/IIOP)
• Java Interface Definition Language (Java IDL)
• Java DataBase Connectivity (JDBC)
• Java Message Service (JMS)
• Java Naming and Directory Interface (JNDI)
• API JavaMail et JAF (JavaBeans Activation Framework)
• Java API for XML Processing (JAXP)
• Java EE Connector Architecture
• Gestionnaires de ressources
• Entreprise Java Beans (EJB)
• Java Server Pages (JSP)
• Servlet
• Java API for XML Web Services (JAX-WS, anciennement JAX-RPC)
• SOAP with Attachments API for Java (SAAJ)
• Java API for XML Registries (JAXR)
Si vous souhaitez en savoir plus sur Java EE, suivez ces liens:
•
Java EE Home
•
Java EE 5 Tutorial
Que sont les EJB

Auteurs : Stessy ,
Un composant Entreprise JavaBeans (EJB) est une classe ayant des champs et des méthodes pour mettre en application
des modules de la logique métier (Business logic). Vous pouvez penser à un entreprise bean comme à un module pouvant
être employé seul ou avec d'autres entreprise bean pour exécuter la logique métier sur le serveur Java EE.
Il existe actuellement trois types d'entreprise bean :
• les bean session (Session Bean)

• les bean entité (Entity Bean)
• les bean contrôlés par message (Message Driven Bean)
Les entreprise bean interagissent le plus souvent avec des bases de données.
Si vous souhaitez en savoir plus sur les EJB, suivez ces liens :
•
EJB Home
-6-
La FAQ Java EE
•
EJB (J2EE 1.4 tutorial)
•
EJB Spécifications
Que sont les Servlet?

Auteurs : Stessy ,
Techonologie Java utilisée pour effectuer des traitements coté serveur en réponse aux requêtes provenant en général
de poste clients distants.
Bien que les servlets puissent répondre à n'importe quel type de requête, elles sont généralement employées pour
répondre à des requêtes de type HTTP et qui permettent de retourner dynamiquement des pages html.
Si vous souhaitez en savoir plus sur les Servlets, suivez ces liens:
•
Servlets Home
•
Servlets (Java EE 5 Tutorial)
•
Servlets implémentations et spécifications
Que sont les JSP

Auteurs : Stessy ,
Les JavaServerPages (JSP) vous permet d'insérer des petits bouts de code Java (scriptlets) directement dans du code
html. Une page JSP est un document qui contient deux types de texte:
• des données statiques (qui peuvent être exprimées en n'importe quel format texte tel que le HTML, le WML, et
le XML)
• des éléments de JSP, qui déterminent comment la page construit le contenu dynamique.
Pour plus d'informations sur les JSP, vous pouvez suivre ces liens :
•
JSP home
•
JSP (Java EE 5 Tutorial)
•
JSP Spécifications et implémentation
Que sont les connecteurs JCA?

Auteurs : willy78 ,
Les connecteurs JCA sont des modules qui se déploient sur les serveurs d'application.
Ils permettent de connecter un serveur JavaEE à un système propriétaire ("legacy system"), et de normaliser les accès
et interactions avec ce systeme.
L'api JCA défini un contrat entre le serveur d'application et le systeme, via des interfaces comme le fait jdbc.
JCA est une généralisation de JDBC.
JCA 1.0 permet d'envoyer des messages vers le système propriétaire uniquement.
-7-
La FAQ Java EE
JCA 1.5 permet, en plus, de recevoir des messages qui seront traités par un "Message Listener", généralement un
Message Driven Bean
Qu'est ce que JAXP?

Auteurs : vedaer ,
JAXP (Java API for XML Processing) est l'API "standard" (appartenant au JDK) pour la manipulation du format
XML. Cette API met à la disposition du développeur trois ensembles de fonctionnalités : la modélisation, le parsing et
la transformation. Elle est composée de quatre packages principaux.
• javax.xml.parsers : Ce package contient un ensemble d'interfaces devant être implémentées par les différents
parseurs (SAX ou DOM). Ce package fournit aussi un ensemble de factory permettant l'accès aux parseurs.
• org.w3c.dom : Ce package contient l'ensemble des classes et interfaces nécessaires pour travailler avec DOM
(modélisation).
• org.xml.sax : Ce package contient l'ensemble des classes et interfaces nécessaires pour travailler avec SAX
(parsing).
• javax.xml.transform : Ce package contient l'ensemble des classes et interfaces nécessaires pour travailler avec
XSLT (transformation).
Attention, JAXP n'est pas limitée à SAX, DOM, XSLT et ces quatre packages. Elle offre bien plus de fonctionnalités.
Pour savoir ce que sont exactement SAX, DOM, XSLT et en savoir plus sur l'utilisation de JAXP, regardez la partie
XML de la FAQ Java .
Il est aussi important de noter que, même si au départ JAXP fut créée comme une API Java EE, elle est désormais
intégrée au J2SDK standard.
Pour plus d'informations sur XML, vous pouvez visiter la rubrique XML de developpez.com : http://
xml.developpez.com/ .
Qu'est ce que JAX-RPC?

Auteurs : vedaer ,
JAX-RPC (Java API for XML-based Remote Procedure Call) est une API permettant de créer des services et clients
Web basés XML et RPC .
RPC (Remote Procedure Calls), ou appels de procédures à distance, est un système permettant à des clients d'exécuter
des procédures sur des systèmes distants. Ces appels de procédures et les réponses retournées se font grâce au protocole
HTTP et à SOAP (messages XML).
Attention ! Aujourd?hui remplacé par JAX-WS.
Qu'est ce que JAX-WS?

Auteurs : X-plode : Mike François ,
JAX-WS (Java API for XML Web Services) est la nouvelle appellation de JAX-RPC.
JAX-WS est une technologie pour des réaliser des services web et clients en utilisant le language XML.
JAX-WS permet d'écrire en orienté message tout autant que des services web orienté RPC.
JAX-RPC ne convient plus à l'ensemble des concepts couverts.
Cet acronyme donne l'impression qu'il s'agit uniquement de technologies synchrones, relatives à l'appel de procédure
à distance et non aux services web.
De plus l'intégration de JAXB 2.0, pose de nombreux problèmes de compatibilité avec JAX-RPC 1.1.
-8-
La FAQ Java EE
C'est ainsi l'occasion pour Sun de repenser, mettre à jour, améliorer et surtout rationaliser cette brique logicielle en
utilisant les dernières nouveautés du langage lui-même, ainsi que les technologies développées en parallèle dans d'autres
groupes de travail.
Pour plus d'informations sur JAX-WS ( anciennement JAX-RPC ), vous pouvez suivre ces liens :
•
Introduction de JAX-WS
•
JAX-WS (Java EE 5 Tutorial)
•
XML-RPC spécification
Qu'est ce que JDBC?

Auteurs : vedaer ,
JDBC est une API (Application Programming Interface) java disponible depuis la version 1.1 du JDK. Pour note,
JDBC est un nom déposé et non un acronyme, même si en général on lui donne la définition suivante : Java DataBase
Connectivity .
Cette API est constituée d'un ensemble d'interfaces et de classes qui permettent l'accès, à partir de programmes java, à
des données tabulaires (i.e. triées sous forme de table ou de tableur). Par données tabulaires, on entends généralement
des bases de données contenues dans des SGBD relationnels . Mais, JDBC n'est pas restreinte à ce type de source de
données. On peux aussi accéder à des sources de données sous forme de fichiers (fichiers XML par exemple).
Qu'est ce que JAAS?

Auteurs : duj ,
Java Authentication and Authorisation Service.
Il s'agit d'un package fournissant des services d'authentification (login) et d'autorisation (verification de permissions
pour l'execution de méthodes).
JAAS fait partie de la distribution de base du SDK depuis la version 1.4 .
http://java.sun.com/products/jaas/
JAAS est hautement configurable, et permet aux développeurs d'écrire leurs propres modules.
Une libraire fournissant quelques implémentation, dont une permettant une interaction avec Windows NT et Windows
2000 pour l'authentification: http://free.tagish.net/jaas/index.jsp
Qu'est ce que JAXB?

Auteurs : vedaer ,
JAXB (Java Architecture for XML Binding) offre les outils et API nécessaires pour "lier" des objets java à des
documents XML . JAXB utilise des schémas ( W3C XML Schema ) pour faire ce lien. Une fois ce lien créé (grâce
à un compilateur qui va générer les packages correspondant à un schéma donné), vous pouvez facilement sérialiser/
desérialiser les objet java sous un format XML. Pour plus d'informations sur JAXB, vous pouvez suivre ces liens :
•
JAXB home
•
JAXB (Java Web Services Tutorial)
-9-
La FAQ Java EE
Pour le moment, JAXB permet juste de partir d'un Schéma XML pour générer les classes correspondantes (interfaces
à implémenter). JAXB 2.0 devrait palier à cette limitation en permettant de créer des schémas à partir de classes Java
déjà définies. Pour plus d'informations, regardez la JSR 222 : http://www.jcp.org/en/jsr/detail?id=222 .
Qu'est ce que SAAJ ?

Auteurs : vedaer ,
SAAJ (SOAP with Attachments API for Java) est une API Java permettant l'envoi et la réception de messages XML
sur le réseau. Ces messages obéissent à la spécification SOAP (Simple Object Access Protocol) 1.1.
SAAJ est souvent utilisée par des API de plus haut niveau comme JAXR et JAX-RPC. Mais, elle peut tout à fait être
utilisée de manière indépendante. Pour plus d'informations, vous pouvez suivre ces liens :
•
SAAJ home
•
SAAJ (Java EE 5 Tutorial)
•
SAAJ documentation
Vous pouvez trouver la spécification de SOAP à cette adresse : http://www.w3.org/TR/soap/ .
Qu'est ce que JAXR?

Auteurs : vedaer ,
JAXR (Java API for XML Registries) est une API intégrée à Java EE qui permet l'accès à différents types de registres
XML . Ces registres XML sont une infrastucture permettant la construction, le déploiement et la découverte de Web
services .
JAXR permet l'interaction avec plusieurs standards, dont UDDI (Universal Description, Discovery, and Integration)
et ebXML Registry and Repository standard. Pour connaître les versions supportées de ces standards et les différentes
implémentations fournisseur disponibles pour JAXR, suivez les liens ci-dessous.
•
Java API for XML Registries (JAXR)
•
JAXR (Chap. 10 du Java EE Tutorial)
•
XML Downloads & Specifications
•
Java Technology & Web Services
Pour note, JAXR est intégré au JWSDP (Java Web Services Developer Pack), mais vous pouvez aussi le téléchager
séparément (voir liens).
Que sont les Frameworks Web ?

Un framework Web permet de pouvoir abstraire les problèmes rencontrés au quotidien lors du developpement d'une
application Web. Tout autant, il permet de pouvoir avoir un design réutilisable pour un développement donné.
Le résultat est un meilleur code, plus lisible et ainsi plus facilement maintenable.
Les Frameworks Web peuvent se distinguent en deux types :
- 10 -
La FAQ Java EE
• Orienté Requête
• Orienté Composant
- 11 -
La FAQ Java EE
Sommaire > Java EE
- 12 -
La FAQ Java EE
Sommaire > Java EE > Généralités

Comment connaître le navigateur utilisé par un utilisateur
Auteurs : Didier ,
Cette information peut être retrouvée dans le header de la requête:
String browser = request.getHeader("user-agent");
Comment faire pour ne pas afficher l'arborescence de l'application lorque

l'utilisateur entre simplement le contexte de l'application dans l'URL?
Auteurs : Stessy ,
Pour que l'utilisateur ne puisse pas voir l'arborescence de l'application lorqu'il indique uniquement le contexte de
l'application dans l'URL, il suffit simplement d'ajouter un élément dans le fichier web.xml qui s'il existe, sera utilisé
par le conteneur comme page par défaut.
<welcome-file-list>
<welcome-file>welcome.jsp</welcome-file>
</welcome-file-list>
Quelles sont les différentes portées existantes ?

Auteurs : Stessy ,
Les objets créés que ce soit dans les JSP ou les Servlets ont une certaine portée, c'est à dire une certaine durée de vie.
Les différentes portées existantes sont:
• page : les objets ne sont accessibles que dans la page où ils sont définis
• request : les objest sont accessibles pendant toute la durée de la requête
• session : les objets sont accessibles pendant toute la durée de la session
• application : les objest sont accessibles pendant toute la durée de vie de l'application et dans l'application complète
Quelles sont les differences entre un serveur web et un serveur d'application?

Auteurs : adiGuba ,
Un serveur d'application a pour objectif de facilité la création d'application serveur sans se soucier de l'aspect réseau
(toute la couche réseau est laissée au serveur d'application).
Un serveur web peut gérer plusieurs sites indépendemment, il peut utiliser plusieurs langages/technologies différents
(ASP, PHP, JavaEE), gère les transactions sécurisés...
La confusion vient du fait que la plupart du temps les applications JavaEE sont des applications Web, pour la simple
raison que cela permet de ne pas distribuer d'application cliente (un navigateur suffit).
- 13 -
La FAQ Java EE
Sommaire > JSP
- 14 -
La FAQ Java EE
Sommaire > JSP > Généralités

Comment mettre un header et un footer a chaque jsp ?
Auteurs : lunatix ,
(si on est en jsp 2.0 (tomcat 5.0 par exemple))
dans web.xml
<jsp-config>
<jsp-property-group>
<url-pattern>*.jsp</url-pattern>
<include-prelude>/includes/header.jsp</include-prelude>
<include-coda>/includes/footer.jsp</include-coda>
</jsp-property-group>
</jsp-config>
Comment afficher tous les paramêtres d'une requete ?

Auteurs : syj ,
Enumeration en = request.getParameterNames();
while (en.hasMoreElements()) {
String pName = (String) en.nextElement();
log.debug(pName + "=" + request.getParameter(pName)); //
System.out.println(pName + "=" + request.getParameter(pName));
}
Comment afficher tous les attributs du scope request ?

Auteurs : syj ,
java.util.Enumeration en= request.getAttributeNames();

String name = (String) en.nextElement();
if(request.getAttribute(name) == null) {
log.debug(name + "=NULL");
} else {
log.debug(name + "=" + request.getAttribute(name).toString());
}
}
Créer sa propre page d'erreur ?

Auteurs : syj ,
Voici la page d'erreur que l'on utilise. Elle n'est utile qu'en phase de développement.
Mais elle permet de determiner rapidement les problèmes qui peuvent surgir.
<%@ page language="java" isErrorPage="true" %>

<!DOCTYPE HTML PUBLIC "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<title>Page d'erreur</title>
- 15 -
La FAQ Java EE
</head>
<body bgcolor="#FFFFFF">
<div>Une erreur s'est produite !</div>
<h1>Attribut de requete</h1>
<div class="requestAttributs">
<%
java.util.Enumeration en = request.getAttributeNames();
if(request.getAttribute(name) == null) {
%>
<div>
<%=name%>=null
</div>
<%
} else {
%>
<div>
<%=name%>=<%=request.getAttribute(name).toString()%>
</div>
<%
}
}
%>
</div>
<div class="requestParameters">
<%
en=request.getParameterNames();
if(request.getParameter(name) == null) {
%>
<div>
<%=name%>=null
</div>
<%
} else {
%>
<div>
<%=name%>=<%=request.getParameter(name).toString()%>
</div>
<%
}
}
%>
</div>
<h1>Exception</h1>
<div>
<%
Throwable th = pageContext.getException();
if(th != null) {
printRecursiveException(out,th);
}
%>
</div>
<%! public void printRecursiveException(JspWriter out, Throwable th) throws java.io.IOException {

out.println("<div>" + th.getClass().getName() + ":" + th.getMessage() + "</div>");
StackTraceElement ste;
for(int x=0;x < th.getStackTrace().length;x++) {
out.println("<div>" + th.getStackTrace()[x].toString() + "</div>");
}
Throwable parent = th.getCause();

if(parent != null) {
out.println("<div class=\"parentCause\">");
- 16 -
La FAQ Java EE
printRecursiveException(out,parent);
out.println("</div>");
}
}
%>
</body>
</html>
Comment appliquer ma page d'erreur à toutes mes pages JSP ?

Auteurs : syj ,
<error-page>
<exception-type>java.lang.Throwable</exception-type>
<location>/error.jsp</location>
</error-page>
Note: L'insertion doit se faire entre session-config et ressource-ref mais je ne suis pas sur que çà soit le session-config
et ressource-ref qui entoure directement cette balise.
Que sont les objets implicites?

Auteurs : Stessy ,
Des objets sont dit implicites car il ne nous est pas nécessaire de les déclarer ou de les initialiser
Les objest le plus souvent utilisés sont:
• request : lorsqu'un navigateur envoie une requête vers le serveur, il est possible que celui-ci envoie un certain
nombre de paramètres.
Il existe deux sortes de paramètres:
• Les paramètres se trouvant dans l'URL comme par exemple http://www.monsite.com/path/de/ma/page?
param1=valeur1&param2=valeur2
• Les paramètres de formulaire: ces dernier sont transmis dans le corps de la requête
• response : cet objet contient la réponse envoyée au client. La portée de cette instance est la page
• out : peut être employé dans les scriptlets pour écrire des données dans la page qui sera envoyée au client. La
portée de cette instance est la page
• session : cet objet contient, comme son nom l'indique, tous les objets relatif à la session
- 17 -
La FAQ Java EE
Sommaire > JSP > JSTL (Java Standard Tag Library)

Quels sont les objectifs de la JSTL?
Auteurs : adiGuba ,
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 Java EE.
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éveloppez des pages JSP en utilisant des balises XML, donc avec une syntaxe proche des langages
utilisés par les web designers, et leurs permet donc de concevoir des pages dynamiques complexes sans connaissances
du langage Java.
Sun à donc proposer 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 serveur Java EE qui son des implémentations de la spécification Java EE).
- 18 -
La FAQ Java EE
Sommaire > JSP > JSTL (Java Standard Tag Library) > Librairie de base
Comment afficher une expression?
Auteurs : adiGuba ,
Le tag <c:out/> permet d'évaluer une expression et de l'afficher dans la page JSP


<c:out value="${header['user-agent']}" default="Inconnu"/>
Le Corps du tag peut être utilisé à la place de l'attribut default.


<c:out value="${header['user-agent']}">Inconnu</c:out>
Pour de plus amples informations sur les attributs disponibles pour ce tag
- 19 -
La FAQ Java EE
Sommaire > JSP > JSP Taglibs

Que sont les JSP Taglibs ?
Auteurs : adiGuba ,
Une JSP Taglib est une collection d'actions prédéfini destinées à être utilisé dans une page JSP sous forme de tag
(balise XML). Elle se compose d'un descripteur de taglib (Tag Librarie Descriptor) et d'un ensemble de classe Java
implémentant l'interface JspTag. Le descripteur de taglib (*.tld) est un document XML qui décrit les associations en
les balises et la classe Java.
Ces actions sont représentées dans le source JSP comme une balise XML. Lors de la compilation de la JSP, ces balises
sont remplacées par des appels vers la classe Java correspondante.
On peut citer comme exemple les balises standards préfixées avec jsp :
<jsp:useBean id="monBean" scope="session" class="package.MonObject">

<jsp:setProperty name="monBean" property="monAttribut" value="1.0"/>
</jsp:useBean>
<jsp:include page="maPage.jsp"/>
<jsp:redirect page="maPage.jsp"/>
etc...
L'utilisation de taglib permet de limiter l'utilisation de code Java dans une page JSP, voir de totalement le supprimer.
Une Taglib est composé de trois éléments:
• Le Tag Librarie Descriptor qui effectue le mapping entre les tags et les classes Java.
• Les classes Java implémentant les différents Tag (implémentant l'interface Tag , ou une de ses interfaces filles
IterationTag et BodyTag .
• Les classes Java implémentant TagExtraInfo afin d'apporter des informations supplémentaires sur les tags
(optionnel).
- 20 -
La FAQ Java EE
Sommaire > JSP > JSP Taglibs > Taglibs 1.1

Comment utiliser une librairie de tag (taglib) ?
Auteurs : adiGuba ,
Une librairie de tag peut être distribué sous deux formes :
• Le descripteur de fichier est séparé des classes Java...

• Le descripteur de fichier est inclut dans le Jar avec les classes et possède le nom suivant : "META-INF/taglib.tld".
Afin de pouvoir utiliser cette taglib dans un fichier JSP, il faut la déclarer avec la directive taglib .
Respectivement avec le code suivant :
<%@ taglib uri="/WEB-INF/taglib-v1.0.tld" prefix="tag-prefix">
ou
<![CDATA[<%@ taglib uri="/WEB-INF/lib/taglib-v1.0.jar" prefix="tag-prefix" %>]]>
Toutefois, il est préférrable de ne pas utiliser ces notations sous cette forme.
En effet, étant donné que la directive taglib doit être présente sur toutes les pages JSP qui l'utilisent, les modifications
du nom du descripteur de taglib pourrait être longue et pénible.
Afin de faciliter la maintenance, il faut déclarer la taglib dans le fichier web.xml :
<![CDATA[<taglib>
<taglib-uri>taglib-URI</taglib-uri>
<taglib-location>/WEB-INF/lib/taglib-v1.0.jar</taglib-location>
</taglib>]]>
Et utiliser l'URI dans les JSP :
<![CDATA[<%@ taglib uri="taglib-URI" prefix="tag-prefix" %>]]>
Ainsi, les changements de fichier de descripteur s'effectue seulement dans le fichier web.xml ...
Enfin, pour utiliser les tags de la librairie, il suffit de les préfixé par le prefixe indiqué dans la directive taglib :
<![CDATA[<tag-prefix:nom-du-tag param="valeur"/>]]>
Comment l'interface Tag fonctionne-t-elle ?

Auteurs : adiGuba ,
L'évaluation d'un Tag JSP aboutit aux appels suivants :
• Les méthodes setParent(Tag) et setPageContext(PageContext) sont renseignées, ainsi que d'éventuels attributs
présents dans le tag.
• La méthode doStartTag() est appelée. Son code de retour détermine l'affichage du contenu de la balise. Si le retour
vaut Tag.EVAL_BODY_INCLUDE , le corps est évalué et écrit dans le JspWriter de la page, mais il est ignoré
- 21 -
La FAQ Java EE
si il vaut Tag.SKIP_BODY . Si Tag.EVAL_BODY_INCLUDE est retourné alors que la balise n'a pas de corps,
il est ignoré.
• La méthode doEndTag() est appelée. Son code de retour détermine si le reste de la page doit être évalué ou pas. Si le
retour vaut Tag.EVAL_PAGE , le reste de la page est évalué, mais il est ignoré si le retour vaut Tag.SKIP_PAGE .
Enfin, la méthode release() est appelée avant que l'objet ne soit rendu au garbage collector.
Attention toutefois, afin d'éviter trop d'allocation, les tags sont conservés en cache et réutilisés (tout comme les Servlet/
JSP)...
La classe javax.servlet.jsp.tagext.TagSupport propose une implémentation par défaut de l'interface Tag (et de son
interface fille IterationTag ).
Comment l'interface IterationTag fonctionne-t-elle ?

Auteurs : adiGuba ,
L'interface IterationTag étend l'interface Tag . Elle hérite donc de toutes ses propriétés et permet d'effectuer des
itérations sur le contenu de la balise :
La méthode doAfterBody() est appelée après chaque affichage du corps du tag. Son code de retour determine si
le corps doit être réévalué ou pas. Si le retour vaut IterationTag.EVAL_BODY_AGAIN , le corps sera réévalué,
mais si le retour vaut Tag.SKIP_BODY , on passe à la fin du tag ( doEndTag() ) sans réévaluer le corps. La classe
javax.servlet.jsp.tagext.TagSupport propose une implémentation par défaut de l'interface IterationTag .
Comment l'interface BodyTag fonctionne-t-elle ?

Auteurs : adiGuba ,
L'interface BodyTag étend l'interface IterationTag. Elle hérite donc de toutes ses propriétés, mais permet plus de
traitement sur le corps de la balise :
La méthode doStartTag() peut désormais retourner BodyTag.EVAL_BODY_BUFFERED .
Dans ce cas (et dans ce cas seulement), les méthodes setbodyContent() puis doInitBody() sont appelées avant la première
évaluation du corps de la balise.
La méthode setBodyContent() permet au serveur d'application d'indiqué un buffer qui sera utilisé pour écrire le contenu
du corps.
La méthode doInitBody() est appelée avant la première évaluation du corps du message.
La classe javax.servlet.jsp.tagext.BodyTagSupport propose une implémentation par défaut de l'interface BodyTag .
Comment écrire le descripteur de taglib (TLD) ?

Auteurs : adiGuba ,
Le Tag Library Descriptor décrit les différents tag de la librairie.
Il s'agit d'un fichier XML qui prend 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>
<tlibversion>1.0</tlibversion>
<jspversion>1.1</jspversion>
<shortname>name</shortname>
<uri></uri>
<info>Description de la taglib</info>
- 22 -
La FAQ Java EE
<tag>...</tag>
</taglib>
Après l'entête XML et la déclaration du doctype, on a les éléments suivants :
• tlibversion : Numero de version de la librairie.

• jspversion : Version minimum des JSP requise pour pouvoir utilisé la librarie (optionnel, défaut: 1.1).
• shortname : Indique le prefix par défaut de la librairie pour les EDI compatible (ceci n'est qu'a titre indicatif, le
prefix de la directive <%@ taglib %> est utilisé).
• uri : Une URI unique qui identifie cette version de la taglib (optionnel).
• info : Un texte de description de la taglib (optionnel).
• tag : Une ou plusieurs mapping de balise avec les classes Java.
Dans un Jar, ce fichier doit se situer dans le répertoire META-INF avec le nom taglib.tld afin de pouvoir référencer
directement le fichier Jar.
Comment faire le mapping entre un nom de balise et une classe Tag ?

Auteurs : adiGuba ,
Dans le fichier TLD, il faut ajouter, pour chaque tag, les balises suivantes :
<tag>
<name>name</name>
<tagclass>package.NameTag</tagclass>
<teiclass>package.NameTEI</teiclass>
<bodycontent>JSP</bodycontent>
<info>description</info>
<attribute>
<name>arg1</name>
<required>false</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
Avec les éléments suivants :
• name : Nom de la balise (Utilisation: <taglib-prefix:nom/>).

• tagclass : Nom de la classe Java qui représente cette balise (hérite de Tag).
• teiclass : Nom de la classe Java qui fournit des informations complémentaire sur la balise (optionnel).
• bodycontent : Type de contenu que peut accepter la balise, peut prendre les valeurs empty (pas de corps), JSP (le
contenu est interprété comme du JSP), ou tagdependent (le contenu n'est pas interprété) (optionnel, défaut: JSP).
• info : Un texte de description du tag (optionnel).
• attribute : Zéro, une, ou plusieurs déclarations d'attribut du tag, décomposé de la manière suivante :
• name : Nom de l'attribut. La classe tagclass doit posséder un mutateur pour cet attribut.
• required : true/false , indique si l'attribut est obligatoire ou pas (optionnel, défaut: false )
- 23 -
La FAQ Java EE
• rtexprvalue : true/false , indique si l'attribut peut être le résultat d'une expression ( ${bean} ou <%=bean
%> ) ou si il doit être une chaine statique (optionnel, défaut: false/valeur statique)
Comment écrire un Tag ?

Auteurs : adiGuba ,
Exemple simple, un tag vide (sans contenu ni attribut) qui affiche simplement la chaine "Hello World".
Le code pourrait se limiter a cela :
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 Tag.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 chaine "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.
Il est inutile de surcharger doEndTag() car son implémentation par défaut retourne Tag.EVAL_PAGE .
Notre descripteur de fichier complet ressemble à ceci :
<?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>
<tlibversion>1.0</tlibversion>
<jspversion>1.1</jspversion>
<shortname>tex</shortname>
<uri></uri>
<info>Taglib d'exemple</info>
<tag>
<name>hello</name>
<tagclass>HelloTag</tagclass>
<bodycontent>empty</bodycontent>
</tag>
</taglib>
Le fait de spécifier un bodycontent empty permet de lancer une exception à la compilation si le tag possède un contenu
quelconque...
Notre page JSP pourrait ressembler à ceci :
<%@ taglib uri="taglib-URI" prefix="p" %>

<html>
<body>
- 24 -
La FAQ Java EE
<b><p:hello/></b>
</body>
</html>
donnera l'affichage suivant :
Hello World !
Comment utiliser des attributs de balise ?

Auteurs : adiGuba ,
Cet exemple se base sur l'exemple précédent.
Nous allons améliorer notre tag précédent en lui ajoutant un attribut name.
Si name est présent, on devra afficher "Hello " suivi de la valeur de l'attribut name, sinon on affiche "Hello World".
Le code précédent devient :
public class HelloTag extends TagSupport {
private String name = null;
public void setName(String string) {

name = string;
}

if (name==null) name = "World";
try {
pageContext.getOut().println ("Hello " + name + " !");
throw new JspException ("I/O Error", e);
}
return SKIP_BODY;
}
}
Explication:
• On ajoute une variable name ainsi que son mutateur setName() .

Le mutateur setName() est obligatoire car il sera utilisé afin d'initialiser l'attribut de classe name avec la valeur
de l'attribut du tag , avant d'appeller doStartTag() .
• Dans doStartTag() , on affiche "Hello " + name + " !" ...
enfin, on modifie le TLD de la manière suivante :
<tag>
<name>hello</name>
<tagclass>HelloTag</tagclass>
<bodycontent>empty</bodycontent>
<attribute>
<name>name</name>
</attribute>
</tag>
Ainsi la page JSP :
- 25 -
La FAQ Java EE
<%@ taglib uri="taglib-URI" prefix="p">

<html>
<body>
<b><p:hello/></b>
<br/>
<b><p:hello name="Fred"/></b>
<br/>
</body>
</html>
donnera l'affichage suivant :
Hello World ! Hello Fred !
Comment créer un tag conditionnel ?

Auteurs : adiGuba ,
On peut avoir besoin d'exécuter une portion de code seulement si une condition est vérifié.
Par exemple, on va exécuter le corps d'un tag seulement si l'attribut indiqué en paramètre est présent dans la session :
public class IsPresentTag extends TagSupport {
private String name = "World";
public void setName(String string) {

name = string;
}

if (name==null) throw new JspException ("name est null !");
if (pageContext.getAttribute(name,PageContext.SESSION_SCOPE) != null )
return EVAL_BODY_INCLUDE;
return SKIP_BODY;
}
}
ainsi le code suivant :
<p:isPresent name="infoConnection">
[ Vous êtes en ligne ]
</p:isPresent>
remplace le scriplet suivant :
<% if ( session.getAttribute("infoConnection") ) { %>

[ Vous êtes en ligne ]
- 26 -
La FAQ Java EE
<% } %>
Comment créer un tag itératif ?

Auteurs : adiGuba ,
Afin de créer un tag itératif, il faut implémenter l'interface IterationTag .
Toutefois, TagSupport implémente déjà cette interface, on pourra donc étendre cette classe afin de bénéficier des
méthodes par défaut...
Notre tag itératif effectuera un certain nombre de boucle selon un paramètre count.
Son mapping serait :
<tag>
<name>iterate</name>
<tagclass>IterateTag</tagclass>
<attribute>
<name>count</name>
<required>true</required>
</attribute>
</tag>
Et son code source :
public class IterateTag extends TagSupport {
private int count = 0;

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

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

current++;
if (current < count) return IterationTag.EVAL_BODY_AGAIN;
}
}
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 le mutateur prend un int en
paramètre.
En cas de valeur incorrecte, une exception est lancée...
• Dans doStartTag() , on initialise current qui contiendra le nombre de ligne déjà affiché. Il est important de
l'initialisé dans doStartTag() car la même instance de Tag peut être utilisé plusieurs fois...
Utilisation :</paragapah>
- 27 -
La FAQ Java EE
<p:iterate count="3">
Cette ligne sera affichée trois fois
<br/></p:iterate>
Résultat:

Comment interagir avec le contenu du tag ?

Auteurs : adiGuba ,
Il peut être intéressant d'interagir avec le corps de la balise.
Par exemple, dans le cas d'un tag itératif, on peut avoir besoin du numéro de ligne courant dans le body.
Pour cela, il suffit de stocker des éléments dans un des scopes (page, request, session, application)...
On reprend donc le tag précédent et on met le numéro de la ligne dans le scope "page".
Notre code devient alors :
public class IterateTag extends TagSupport {
private int count = 0;

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

current = 0;
if (current < count) {
pageContext.setAttribute("line", new Integer(current) );
return Tag.EVAL_BODY_INCLUDE;
}
}

current++;
if (current < count) {
pageContext.setAttribute("line", new Integer(current) );
return IterationTag.EVAL_BODY_AGAIN;
}
}
public int doEndTag() throws JspException {

pageContext.removeAttribute("line");
return Tag.EVAL_PAGE;
}
}
Explication:
• Avant chaque évaluation du corps, on place dans le scope "page" un attribut "line" contenant un Integer
contenant le numéro de ligne courante.
• Dans doEndTag(), on supprime cet attribut afin de ne pas 'polluer' inutilement le reste de la page.
- 28 -
La FAQ Java EE
Note : On peut également proposer un attribut supplémentaire afin de changer le nom de l'attribut stocké dans le scope
"page", ainsi que le scope à utiliser...
Utilisation :
Ligne numéro <%=pageContext.getAttribute("line")%>
</p:iterate>
Résultat :
Ligne numéro 0 Ligne numéro 1 Ligne numéro 2
- 29 -
La FAQ Java EE
Sommaire > JSP > JSP Taglibs > Taglibs 1.2

Comment définir/modifier des variables de script dans un Tag ?
Auteurs : adiGuba ,
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 :
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 :
<tag>
<name>iterate</name>
<tagclass>IterateTag</tagclass>
<teiclass>IterateTEI</teiclass>
<attribute>
<name>count</name>
<required>true</required>
</attribute>
</tag>
Pour pouvoir utilisé le code suivant :
Ligne numéro <%=line%> <br/>
- 30 -
La FAQ Java EE
</p:iterate>
Résultat :
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.
Comment modifier le corps du tag ?

Auteurs : 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 :
public class HtmlCodeTag extends BodyTagSupport {

return BodyTag.EVAL_BODY_TAG;
}

try {
String bodyString = getBodyContent().getString();
bodyString = bodyString.replaceAll("<", "<");
bodyString = bodyString.replaceAll(">", ">");
bodyString = bodyString.replaceAll("\t", " ");
bodyString = bodyString.replaceAll("\n", "<br/>\n");
getPreviousOut().println(bodyString);
throw new JspException (e);
}
return SKIP_BODY;
}
}
Dans le TLD :
<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 :
- 31 -
La FAQ Java EE
<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 :
<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...
Comment valider les attributs du tag avec TagExtraInfo ?

Auteurs : 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.
Comment empêcher le compilateur d'interpréter le corps du Tag ?

Auteurs : 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 :
<p:htmlCode>
<p>
Code Java <%=new java.util.Date()%>
TagLib : <p:hello/>
</p>
</p:htmlCode>
donnera:
<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é.
- 32 -
La FAQ Java EE
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é) :
<tag>
<name>htmlJspCode</name>
<tagclass>HtmlCodeTag</tagclass>
<bodycontent>tagdependent</bodycontent>
</tag>
Ainsi le code suivant :
<p:htmlJspCode>
<p>
Code Java <%=new java.util.Date()>
TagLib : <p:hello/>
</p>
</p:htmlJspCode>
donnera:
<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...
Comment gérer les exceptions d'un tag ?

Auteurs : 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 :
try {
...
tag.doStartTag();
...
tag.doInitBody();
...
tag.doAfterBody();
...
tag.doEndTag();
...
} catch (Throwable t) {
- 33 -
La FAQ Java EE
tag.doCatch(t);
} finally {
tag.doFinally();
}
Comment écrire des tags collaboratifs ?

Auteurs : 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:
<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..
- 34 -
La FAQ Java EE
Sommaire > Servlets
- 35 -
La FAQ Java EE
Sommaire > Servlets > Généralités

Pourquoi n'y a-t-il pas de constructeur dans une servlet?
Auteurs : Stessy ,
Une servlet est un peu comme un applet par le fait qu'elle possède une méthode init() qui agit en tant que constructeur.
Puisque l'environnement de servlet prend soin d'instancier la servlet, un constructeur explicite n'est pas nécessaire.
N'importe quel code d'initialisation que vous devez utiliser devrait être placé dans la méthode init() puisque cette
méthode est appelée lorsque le servlet est chargée par le conteneur de servlet.
Quelle est la différence entre les méthodes doGet() et doPost()?

Auteurs : Stessy ,
doGet() est appelée à la suite d'une requête de type HTTP GET . Cela se passe généralement lorsqu'un utilisateur clique
sur un lien ou lorsque celui-ci entre une URL dans la barre d'adresse du navigateur.
La méthode doPost() est appelée en réponse d'une requête HTTP POST .
Les 2 méthodes sont appelées à partir de l'implémentation par défaut de la méthode service() se trouvant dans la classe
de base HttpServlet
Fondamentalement le navigateur demande toujours des pages par l'intermédiaire de GET et peut envoyer des données
sous les 2 formes GET et POST . Les 2 seules différences résident dans le fait que :
• GET est restreint au niveau de la taille des paramètres envoyés au serveur. Cela veut dire qu'il est, la plupart du
temps, préférable d'envoyer des données avec la méthode POST .
• En envoyant des données par l'intermédiaire de GET évoque également une question concernant la sécurité
puisqu'elles sont ajoutées à la suite de l'URL. Pour cette raison il est plus prudent d'utiliser la méthode POST
pour envoyer des données au serveur.
Comment connaitre la version de l'API servlet utilisée par un moteur de servlet?

Auteurs : Stessy ,
L'interface ServletContext inclut les méthodes getMajorVersion() et getMinorVersion() pour vous indiquer quelle version
de l'API Servlet est utilisée.
Un petit exemple :
//Si le moteur de servlet implémente la spec 2.4 de l'API servlet

//majorVersion est égal à 2
int majorVersion = getServletContext().getMajorVersion();
//minorVersion est égal à 4
int minorVersion = getServletContext().getMinorVersion();
Comment accéder à un JavaBean depuis une servlet?

Auteurs : Stessy ,
Pour pouvoir partager des variables entre vos pages JSP et vos servlets, vous devez savoir comment créer et accéder
à ces variables depuis vos servlets.
Les différents exemples qui vont suivre dépendent de la portée, ou si vous préferez, la durée de vie de vos objets.
Pour en savoir plus sur les différentes portées existantes, reportez vous à la section suivante : Quelles sont les
différentes portées existantes?
- 36 -
La FAQ Java EE
• page :
Dans cet exemple, le Bean est instancié comme une variable locale est n'est donc pas partageable entre différentes
servlets.
com.developpez.beans.MyBean myBean = new

com.developpez.beans.MyBean();
• request :
Dans cet exemple, le Bean instancié sera accessible pendant toute la durée de la requête
com.developpez.beans.MyBean myBean =
(com.developpez.beans.MyBean) request.getAttribute("myBean");
if (myBean == null) {
myBean = new com.developpez.beans.MyBean();
request.setAttribute("myBean", myBean);
}
• session :
Dans cet exemple, lorsque le Bean est instancié il est placé dans la session actuelle.
HttpSession session = request.getSession(true);

(com.developpez.beans.MyBean) session.getAttribute("myBean");
session.setAttribute("myBean", myBean);
}
• application :
Dans ce dernier exemple, lorsque le Bean est instancié il est placé dans le contexte de la servlet.
(com.developpez.beans.MyBean) getServletContext().getAttribute("myBean");
getServletContext().setAttribute("counter", counter);
}
Quel est l'objet ServletConfig et quelle est son utilité

Auteurs : Stessy ,
L'objet ServletConfig est une interface. Cette interface contient les 4 méthodes suivantes
• getInitParameter(java.lang.String name)
• Cette méthode retourne un String contenant le paramètre d'initialisation de la servlet correspondant au
paramètre name
• getInitParameterNames()
- 37 -
La FAQ Java EE
• Cette méthode retourne un objet Enumération contenant les paramètres d'initialisation de la servlet
• getServletContext()
• Cette méthode retourne une référence de l'interface ServletContext
C'est la méthode la plus valable car elle permet de partager l'information à travers l'application
• getServletName()
• Cette méthode retourne un String contenant le nom de l'instance de la servlet
Comment modifier le Time Out par défaut de session?

Auteurs : bahamouth ,
Dans le fichier web.xml situé dans le répertoire WEB-INF de l'application, il suffit d'ajouter les lignes suivantes:
<session-config>
<session-timeout>60</session-timeout>
</session-config>
Comment modifier le Time Out par de session par programmation?

Auteurs : Jaxofun ,
Comme ceci
request.getSession().setMaxInactiveInterval(int);
Comment charger des servlets de l'application au démarrage de Tomcat?

Auteurs : bahamouth ,
Dans le fichier web.xml du répertoire WEB-INF lors de la déclaration du servlet, rajouter la ligne:
<load-on-startup>1</load-on-startup>
Exemple:
<servlet>
<servlet-name>Controller</servlet-name>
<display-name>Controller</display-name>
<servlet-class>com.company.Controller</servlet-class>
<init-param>
<param-name>index</param-name>
<param-value>/index.jsp</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
- 38 -
La FAQ Java EE
</servlet>
Comment lire un message d'erreur de Tomcat ?

Auteurs : christopheJ ,
Ces messages sont composés de deux parties. Pour débugger il faut regarder la deuxieme partie qui commence après:
root cause
Ou enore le message
cause mere
L'erreur est alors indiquée sous la forme d'une exception.
Comment placer et récupérer un paramétre d'initialisation d'une servlet?

Auteurs : Righetto Dominique ,
Placer la définition <init-param> dans la description de votre servlet dans le fichier web.xml comme ceci
<servlet>
<servlet-name>maServlet</servlet-name>
<display-name>Ma Servlet</display-name>
<description>Ce que fait ma servlet</description>
<servlet-class>com.servlet.MaServlet</servlet-class>
<init-param>
<param-name>MON_PARAM</param-name>
<param-value>Bonjour</param-value>
</init-param>
</servlet>
Puis dans le code de votre servlet, utilisez ceci pour récupérer la valeur de MON_PARAM
getInitParameter("MON_PARAM");
Si vous désirez mettre plus de paramétres, il suffit d'ajouter des déclarations <init-param> comme ceci
<servlet>
<servlet-name>maServlet</servlet-name>
<display-name>Ma Servlet</display-name>
<description>Ma Servlet</description>
<servlet-class>com.servlet.MaServlet</servlet-class>
<init-param>
<param-name>MON_PARAM</param-name>
</init-param>
<init-param>
<param-name>MON_PARAM_2</param-name>
</init-param>
- 39 -
La FAQ Java EE
</servlet>
Comment uploader un fichier depuis une applet vers une servlet?

Auteurs : SnorkyBZH ,
Coté applet :
URL urlservlet = new URL("http://localhost:8080/imed/ImageMapServlet");

HttpURLConnection connExtension = (HttpURLConnection)urlservlet.openConnection();
FileInputStream in = new FileInputStream(image);

in.read(tableauImage);
in.close();
HttpURLConnection connImage = (HttpURLConnection)urlservlet.openConnection();

connImage.setDoInput(true);
connImage.setDoOutput(true);
connImage.setUseCaches(false);
connImage.setRequestProperty("Content-Type","application/octet-stream");
DataOutputStream out = new DataOutputStream(connImage.getOutputStream());
out.write(tableauImage, 0, tableauImage.length);
out.flush();
out.close();
Coté servlet
// Récupération du flux entrant

java.io.DataInputStream dis = new java.io.DataInputStream(request.getInputStream());
dis.readFully(temp);
dis.close();
// Ecriture du fichier image sur le serveur

File cibleServeur = new File("/repertoire/nomfichier");
FileOutputStream fos = new FileOutputStream(cibleServeur);
fos.write(temp);
fos.close();
Comment télécharger un fichier depuis une servlet?

Auteurs : Stessy ,
Voici un exemple de code permettant de télécharger un fichier depuis le serveur vers le poste client
response.setContentType("application/download");
response.setHeader("Content-Disposition", "attachment;filename=\"" + filename + "\"");
ServletOutputStream out = response.getOutputStream();

File file = null;
BufferedInputStream from = null;
try {
//dans mon cas le filepath et le path complet après création
// d'un temp file
file = new File(filepath);
response.setContentLength((int) file.length());
int bufferSize = 64 * 1024;
long time = System.currentTimeMillis();
- 40 -
La FAQ Java EE
try {
from = new BufferedInputStream(new FileInputStream(file), bufferSize * 2);
byte[] bufferFile = new byte[bufferSize];
for (int i = 0; ; i++) {
int len = from.read(bufferFile);
if (len < 0) break;
out.write(bufferFile, 0, len);
}
out.flush();
} finally {
try {
from.close();
} catch (Exception e) { }
try {
out.close();
} catch (Exception e) {}
}
time = (System.currentTimeMillis() - time) / 1000;
// seconds download
double kb = (file.length() * 1.0 / 1024);
if (file != null) file.delete();

} catch (Exception e) {
return;
} finally {
try {
file.delete();
} catch (Exception ex) {}
}
Comment faire pour gérer des actions à effectuer lors de la création ou suppression de session ?
Auteurs : SEMPERE Benjamin ,
En implémentant l'interface HttpSessionListener comme ceci
package com.dvp.faq.javaee;
import javax.servlet.http.HttpSessionListener;
import javax.servlet.http.HttpSessionEvent;
public class MyHttpSessionListener implements HttpSessionListener {
/** Cette méthode est appelée lors de la création de

session */
public void sessionCreated(HttpSessionEvent hse){
System.out.println("Une session vient d'être créée");
}
/** Cette méthode est appelée lors de la destruction

de session*/
public void sessionDestroyed(HttpSessionEvent hse) {
System.out.println("Une session vient d'être détruite");
}
}
Ensuite, il suffit de référencer le listener dans le fichier web.xml (sous la balise racine)
<web-app>
<listener>
- 41 -
La FAQ Java EE
<listener-class>
com.dvp.faq.javaee.MyHttpSessionListener
</listener-class
</listener>
</web-app>
Comment faire pour gérer des actions à effectuer lors du démarrage ou de l'arrêt de l'application ?
En implémentant l'interface ServletContextListener comme ceci
package com.dvp.faq.javaee;
import javax.servlet.ServletContextListener;
import javax.servlet.ServletContextEvent;
public class MyHttpServletContextListener implements ServletContextListener {
/** Cette méthode appelée lors du démarrage de

l'application*/
public void contextInitialized(ServletContextEvent sce) {
System.out.println("L'application vient de démarrer");
}
/** Cette méthode appelée lors de l'arret de

l'application*/
public void contextDestroyed(ServletContextEvent sce) {
System.out.println("L'application vient de s'arreter");
}
}
Ensuite, il suffit de référencer le listener dans le fichier web.xml (sous la balise racine)
<web-app>
<listener>
<listener-class>
com.dvp.faq.javaee.MyHttpServletContextListener
</listener-class>
</listener>
</web-app>
Comment récupérer le nom associé au contexte d'une application Web?

A l'aide de l'interface HttpServletRequest
String contextPath = request.getContextPath();
- 42 -
La FAQ Java EE
Sommaire > Servlets > Session

Quelle est l'utilité des sessions
Auteurs : Stessy ,
La plupart des applications web utilisent le protocole HTTP. Malheureusement ce protocole est ce que l'on appelle un
protocole sans état, c'est à dire que le serveur web ne maintient pas les informations à propos du client entre deux
requêtes. De ce fait le serveur ne sait pas déterminer si une requête ou une réponse provient du même client. C'est pour
cela que les applications web utilisent le concept de session. Une session représente l'ensemble des intéractions pouvant
intervenir entre un client et le serveur
Comment créer un objet session

Auteurs : Stessy ,
Il existe deux méthodes permettant de créer des sessions :
HttpSession getSession()
et
HttpSession getSession(boolean)
Voici un petit exemple permettant de comprendre la différence entre ces 2 méthodes
// Si la session existe, ces 2 méthodes renvoient la

// session existante, sinon ces 2 méthodes créent une
// nouvelle session HttpSession session = request.getSession();
HttpSession session = request.getSession(true)
// Si la session existe, cette méthode renvoie la

session existante, sinon la méthode retourne la
valeur null HttpSession session =
request.getSession(false);
Comment les session sont-elles gérées ?

Auteurs : Stessy ,
Il existe 3 moyens de gérer les sessions :
• à l'aide de cookies
• à l'aide re la réécriture d'URL
• à l'aide des sessions SSL en HTTPS
Cookies
A chaque session créée, le serveur envoie un identificateur (sous la forme d'un cookie) correspondant au client. Ensuite
le client renverra ce cookie au serveur lors de sa prochaine requête permettant ainsi au serveur d'identifier le client.
Voici un petit exemple permettant d'ajouter un cookie dans l'entête de la réponse.
- 43 -
La FAQ Java EE
javax.servlet.http.Cookie cookie = new

javax.servlet.http.Cookie("user","abc123456");
response.addCookie(cookie);
Mais il arrive assez souvent que le client refuse de recevoir des cookies.
Dans ce cas il vous reste une 2è solution qui consiste en la réécriture d'URL
Réécriture d'URL
Par cette technique le serveur ajoute l'dentificateur de session à la fin de chaque URL des pages envoyées par celui-ci.
Mais malheureusement cette technique a un coût car le serveur doit effectuer une opération supplémentaire. Celui-ci
doit personnifier l'url en y incluant l'identifiant de session.
2 méthodes existent pour individualiser les URL:
encodeURL(String)
et
encodeRedirectURL(String)
Ces méthodes réécrivent l'URL uniquement si le client n'accepte pas les cookies. Dans l'autre cas les URL resteront
inchangées.
La 2è méthode est utilisée lorsque la servlet utilise la méthode
sendRedirect(String)
Exemple :
response.sendRedirect(response.encodeRedirectURL("maServlet");
Les Sessions SSL en HTTPS

Il nous suffit de récupérer la session courante. A cela près, qu'une session SSL est déterminé par les variables d'état
suivantes:
• Session ID (l'dentifiant de session) :
une séquence arbitraire de 32 octets choisie par le serveur pour identifier une session
• Peer certificate (le certificat du pair) :
c'est un certificat X 509 du correspondant (soit pour un serveur ou un client).
• Compression method :
l'algorithme de compression utilisé, NULL pour l'instant (ce champ reste vide)
• Cipher spec (la suite de chiffrement) :
définit les algorithmes de chiffrement et de hachage
• MasterSecret :
c'est un clé de 48 octets partagée entre le client et le serveur.
• Is resumable (le drapeau) :
c'est un flag qui indique si il est possible d'ouvrir de nouvelles connexions sur la session en question.
- 44 -
La FAQ Java EE
Sommaire > Frameworks Web

Quels sont les types de frameworks Web orienté requête existant ?
• Struts
• WebWork
• Spring MVC
Quels sont les types de frameworks Web orienté composant existant ?

• JSF
• Wicket
- 45 -
La FAQ Java EE
Sommaire > Conteneurs Web et Serveurs d'Application
- 46 -
La FAQ Java EE
Sommaire > Conteneurs Web et Serveurs d'Application > Serveurs d'application
- 47 -
La FAQ Java EE
Sommaire > Conteneurs Web et Serveurs d'Application > Serveurs d'application > Glassfish
- 48 -
La FAQ Java EE
Sommaire > Conteneurs Web et Serveurs d'Application > Serveurs d'application > JBoss
- 49 -
La FAQ Java EE
Sommaire > Conteneurs Web et Serveurs d'Application > Serveurs d'application > Weblogic
- 50 -
La FAQ Java EE
Sommaire > Conteneurs Web et Serveurs d'Application > Serveurs d'application > JOnAS
- 51 -
La FAQ Java EE
Sommaire > Conteneurs Web et Serveurs d'Application > Serveurs d'application > Websphere
- 52 -
La FAQ Java EE
Sommaire > Conteneurs Web et Serveurs d'Application > Conteneurs Web
- 53 -
La FAQ Java EE
Sommaire > Conteneurs Web et Serveurs d'Application > Conteneurs Web > Tomcat
Comment gérer une connexion JDBC?
Auteurs : christopheJ ,
Il faut que le jar du JDBC soit dans les lib de Tomcat
Puis il y a trois étapes :
dans le server.xml
<Context path="/Le_Contexte" reloadable="true" debug="0"

docBase="Le_DocBase" workDir="Le_workDir">
<Ressource name="jdbc/Le_Contexte" auth="Container" type="javax.sql.DataSource"/>
<ResourceParams name="jdbc/Le_Contexte">
<parameter>
<name>user</name>
<value>Le_Login_SGBD</value>
</parameter>
<parameter>
<name>password</name>
<value>Le_Password_SGBD</value>
</parameter>
<parameter>
<name>driverClassName</name>
<value>Le_Driver_SGBD</value>
</parameter>
<parameter>
<name>url</name>
<value>L_URL_Connection</value>
</parameter>
</ResourceParams>
</Context>
Puis dans le web.xml il faut déclarer la ressource après la section <servlet-mapping> :
<resource-ref>
<description>reference a la ressource BDD pour le pool</description>
<res-ref-name>jdbc/Le_Contexte</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
Enfin dans la méthode init de la servlet, il faut recupèrer la source de données
try {
Context initCtx = new InitialContext();
Context envCtx = (Context) initCtx.lookup("java:comp/env");
ds = (DataSource) envCtx.lookup("jdbc/Le_Contexte");
} catch (Exception e) {
//Gestion de l'erreur
}
sachant que ds est une variable d'instance de type DataSource.

Quand on a besoin de l'accès a la base de données, on fait:
Connection conn=ds.getConnection();
ne pas oublier de libérer avec un close après.
- 54 -
La FAQ Java EE
On peut aussi préciser dans le serveur xml, le nombre de connection que l'on veut dans le pool (nb max, nb min, nombre
en attente)
Attention! Bien que cette FAQ mentionne cette possibilité, mettre la balise dans server.xml est fortement déconseillé
depuis tomcat 5.0! Préférez l'utilisation d'un fichier context autonome.
Pour en savoir plus sur la gestion d'un pool de connexion sous Tomcat
Comment partager le context entre 2 webapps?

Auteurs : draken ,
Voici un exemple des lignes à rajouter dans le fichier conf/server.xml :
<Context path="/webapp1" docBase="webapps/webapp1" crossContext="true"

debug="0" reloadable="true">
</Context>
<Context path="/webapp2" docBase="webapps/webapp2" crossContext="true"
debug="0" reloadable="true">
</Context>
Ne pas oublir d'inclure dans le <Context> l'attribut:
crossContext="true"
Ensuite au niveau de la servlet on accède à la seconde webapp de la manière suivante:
ServletContext myContext = this.getServletContext();

ServletContext otherContext = myContext.getContext("/webapp1");
- 55 -

La Faq Java Ee

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

La Faq Java Ee

Transféré par

Droits d'auteur :

Formats disponibles

La FAQ Java EE

Date de publication : 17/05/2003

Dernière mise à jour : 17/05/2009

L'équipe Java - Stessy - adiGuba - bahamouth - christopheJ

1. Informations générales (5) .........................................................................................................................................................4

Sommaire > Informations générales

lien : Comment participer à cette faq?

Comment participer à cette faq ?

lien : Quels sont les droits de reproduction de cette faq ?

Quels sont les droits de reproduction de cette FAQ ?

Où trouver d'autres sources d'information ?

Sommaire > Définitions

Que sont les EJB

• les bean session (Session Bean)

Que sont les Servlet?

Que sont les JSP

Que sont les connecteurs JCA?

Qu'est ce que JAXP?

Qu'est ce que JAX-RPC?

Qu'est ce que JAX-WS?

Qu'est ce que JDBC?

Qu'est ce que JAAS?

Qu'est ce que JAXB?

Qu'est ce que SAAJ ?

Vous pouvez trouver la spécification de SOAP à cette adresse : http://www.w3.org/TR/soap/ .

Qu'est ce que JAXR?

Que sont les Frameworks Web ?

Les Frameworks Web peuvent se distinguent en deux types :

Sommaire > Java EE

Sommaire > Java EE > Généralités

String browser = request.getHeader("user-agent");

Comment faire pour ne pas afficher l'arborescence de l'application lorque

Quelles sont les différentes portées existantes ?

Quelles sont les differences entre un serveur web et un serveur d'application?

Sommaire > JSP

Sommaire > JSP > Généralités

Comment afficher tous les paramêtres d'une requete ?

Comment afficher tous les attributs du scope request ?

java.util.Enumeration en= request.getAttributeNames();

Créer sa propre page d'erreur ?

<%@ page language="java" isErrorPage="true" %>

<%! public void printRecursiveException(JspWriter out, Throwable th) throws java.io.IOException {

Throwable parent = th.getCause();

Comment appliquer ma page d'erreur à toutes mes pages JSP ?

Que sont les objets implicites?

Sommaire > JSP > JSTL (Java Standard Tag Library)

Le Corps du tag peut être utilisé à la place de l'attribut default.

Sommaire > JSP > JSP Taglibs

<jsp:useBean id="monBean" scope="session" class="package.MonObject">

Sommaire > JSP > JSP Taglibs > Taglibs 1.1

• Le descripteur de fichier est séparé des classes Java...

<%@ taglib uri="/WEB-INF/taglib-v1.0.tld" prefix="tag-prefix">

<![CDATA[<%@ taglib uri="/WEB-INF/lib/taglib-v1.0.jar" prefix="tag-prefix" %>]]>

Et utiliser l'URI dans les JSP :

<![CDATA[<%@ taglib uri="taglib-URI" prefix="tag-prefix" %>]]>

Comment l'interface Tag fonctionne-t-elle ?

Comment l'interface IterationTag fonctionne-t-elle ?

Comment l'interface BodyTag fonctionne-t-elle ?

Comment écrire le descripteur de taglib (TLD) ?

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

Après l'entête XML et la déclaration du doctype, on a les éléments suivants :

• tlibversion : Numero de version de la librairie.