JSP: Généralités
1. Présentation
La technologie JSP/Servlets est la réponse que Sun propose pour qu'on puisse générer des pages Web ayant des contenus dynamiques.
Avec cette technologie on crée des pages au sein desquelles coexistent à la fois du code HTML ou XML et du code java.
les pages JSP (des fichiers d'extension ".jsp") ainsi formées, bénéficient de la puissance du langage Java et permettent aux développeurs de séparer la présentation d'une application de sa logique applicative.
Le serveur, au moment de traiter une JSP, distingue le code HTML du code java, en s'appuyant des balises spéciales. La définition de ces balises dans la spécification JSP 1.0 n'était pas compatible avec XML et à la spécification JSP 1.2, on a introduit une nouvelle syntaxe qui a corrigé cet inconvénient.
Les deux syntaxes sont toujours utilisées. Tout au long de cet article, on précisera, si le besoin se fait sentir, les deux syntaxes pour mieux éclairer l'évolution de JSP.
Les balises introduites par les différentes spécifications pour permettre de distinguer le code Java du code HTM ou XML, indiquent que les fragments de code java dans une page JSP sont soient sous forme d'expression, de scriptlet, de directive et/ou d'action.
2. Qu'est ce qu'une expression ?
Une expression se présente dans une JSP, selon la spécification JSP 1.0, sous la forme suivante:
<%= expression %>
L' expression c'est ce qui est entre les tags "<%=" et "%>"; elle est évaluée et la réponse est transmise à la sortie.
Exemple d'utilisation d'une expression:
Current time: <%= new java.util.Date() %>
L'instruction ci-dessus (new java.util.Date()) avec la syntaxe compatible XML, prend la forme suivante:
Current time : <jsp:expression> new java.util.Date()</jsp:expression>
On a ci-dessus l'exemple d'une expression java encadrée par les balises "<jsp:expression>" et "</jsp:expression>".
3. Scriptlet
Une scriptlet se présente sous la forme:
<% code java %>.
Entre les tags "<%" et "%>" on écrit du code java qui constitue le corps de la scriptlet; sous le format compatible XML on a
<jsp:scriptlet> code java </jsp:scriptlet >
4. Déclaration
Une déclaration a la syntaxe
"<%! déclaration %>"
Elle est encadrée par les "<%!" et "%>" et ce sont des déclarations comme on en fait couramment en java;
Exemples:
<%! private int compteurAccess = 0; %>
On a fait ainsi la déclaration de la variable entière compteurAccess et on l'a initialisé à zéro. ET sous format compatible avec XML on a:
<jsp:declation> private int compteurAccess = 0; </jsp:declation>
5. Directive
Une directive est une instruction qui affecte l'ensemble de la Page JSP où elle est définie; elle se présente sous la forme suivante selon la première spécification des JSP:
<%@ directive attribut="valeur"%>
Il y a eu deux directives à la sortie de la spécification JSP 1.0 et une troisième, taglib est rajoutée depuis.
4.1) La directive page
La directive Page possède plusieurs attributs; les plus utilisés sont:
import, contentType, isThreadSafe, session, buffer, autoflush, extends, info, errorPage, language.
Regardons leur signification et comment on les utilise dans une JSP:
- L'attribut import="package.class" ou import="package.class1,..., package.classN".
L'attribut import ; précise quels packages on peut importer:
<%@ page import="java.util.*" %>
Ici on importe le package java.util.*
L'attribut import est le seul qu'on peut utiliser comme suit:
<%@ page import="package.class1,...,package.classN"%> - L'attribut contentType="MIME-Type" ou contentType="MIME-Type; charset=Character-Set":
Ici on précise le MIME utilisé pour la sortie; par défaut c'est text/html.
<%@ page contentType="text/plain" %>;
Cette directive est équivalente à la scriptlet suivante:
<% response.setContentType("text/plain"); %> - L'attribut isThreadSafe="true|false".
Par défaut, l'attribut isThreadSafe a comme valeur true; elle indique une évolution normale de la servlet quand plusieurs thread sont lancées simultanément avec une seule instance de la servlet ; on suppose qu'on veut synchroniser l'accès à la servlet.
Une valeur fausse de isThreadSafe indique que la servlet implémente "SingleThreadModel". - L'attribut session="true|false".
Par défaut cet attribut vaut true; cela indique que la variable prédéfinie HttpSession doit être rattachée à la session en cours si elle existe; sinon on doit créer une nouvelle session et l'associer avec HttpSession. - L'attribut buffer="sizekb|none".
Cet attribut définit la taille du Buffer en pour JspWriter; par défaut on a la taille spécifiée par le serveur qui est par défaut égale à 8 kb. - L'attribut autoflush="true|false".
Si il a comme valeur "true" cela indique que le buffer doit être vidé s'il est plein ; la valeur "false" est rarement utilisée. - L'attribut extends="package.class".
Ici on indique que la superclass de la servlet sera produite ; ceci est à utiliser avec précaution si le serveur fait appel à une autre superclass déjà définie. - L'attribut info="message".
Ici on définit une chaîne de caractères qui peut-être récupérée par la méthode getServletInfo. - L'attribut errorPage="url".
On spécifie une JSP qui lancera des exceptions qui ne sont pas captées dans la page courante. - L'attribut isErrorPage="true|false ".
Cet attribut indique (avec la valeur "true") ou pas (avec la valeur "false") que la page courante est utilisée comme une page d'erreur pour une autre JSP. - L'attribut language="java".
C'est pour dire que le langage utilisé est java; pour l'instant c'est le seul langage qui supporte les JSPs.
Remarque
Il y a un syntaxe XML pour définir une directive:
<jsp:directive.directiveType attribute=value />
Par exemple la directive page (avec l'attribut import) suivante:
<%@ page import="java.util.*" %> est, dans la syntaxe compatible XML, équivalente à :
<jsp:directive.page import="java.util.*" />
5.1. La directive include
Cette directive permet d'inclure des fichiers au moment où la JSP est traduite en servlet. Elle se présente sous la forme suivante:
<%@ include file="une url relative ici" %>
Le contenu introduit par la directive est "parsé" comme une page JSP normale. C'est un moyen pratique de mettre en facteur commun des contenus statiques. En effet, il s'agit ici d'une inclusion statique, c'est-à-dire que si la ressource incluse est modifiée après l'inclusion, cette modification ne sera pas visible dans la page contenant la directive, jusqu'à ce que celle-ci soit modifiée à son tour et de nouveau traduite en code Java. Il faut vraiment considérer ce type d'inclusion comme une partie de page (un fragment de code). C'est comme si nous avions une seule page découpée en plusieurs morceaux. Ainsi, si on déclare des variables dans le fragment de page, ces variables seront bien entendu accessibles dans la page qui propose l'inclusion, puisque finalement, il s'agit de la même page.
5.2. La directive taglib
Cette directive permet de déclarer l'utilisation d'une bibliothèque de tags personnalisés. L'utilisation de cette directive est détaillée dans la section consacrée aux bibliothèques de tags personnalisés. (voir cours sur taglib)
6. Variables prédéfinies
Pour l'écriture des scriptlets et des expressions, on peut se servir des variables prédéfinies. Les plus utilisées sont au nombre de sept:
6.1. request
Les pages JSP sont des composants Web dont le rôle est de répondre à des requêtes HTTP. L'objet implicite request représente la requête que doit traiter la page. Grâce à cet objet, il est possible de lire les en-têtes de la requête, ses paramètres, ainsi que de nombreuses autres informations. Le plus souvent, l'objet request est utilisé pour connaître les paramètres de la requête.
La méthode getParameter(String), par exemple, retourne la valeur du paramètre dont le nom correspond à la chaîne utilisée comme argument. Le nom utilisé comme argument de la méthode getParameter(String) doit être le même que celui employé dans le formulaire traitant la requête. Ainsi, on peut s'en servir pour récupérer la valeur du prénom saisie par l'opérateur dans un formulaire et l'afficher en procédant de la façon suivante:
<%= request.getParameter("prénom") %>
6.2. response
.....
6.3. out
L'objet implicite out est une référence au stream de sortie utilisée par l'objet response. Il peut être employé dans une scriptlet pour écrire des données dans la réponse envoyée au client.
6.4. session
HTTP est un protocole sans état ce qui veut dire que du point de vue d'un serveur Web, chaque requête envoyée par un client est une nouvelle requête, sans aucune relation avec les précédentes. Comme pour les applications Web, l'interaction d'un client avec l'application s'étend souvent sur plusieurs requêtes/réponses, on se sert du concept de session pour rassembler les différentes interactions en une conversation cohérente entre le client et l'application.
Les composants JSP d'une application Web participent automatiquement à une session, sans nécessité aucune intervention. En revanche, si une page JSP utilise la directive page pour donner à l'attribut session la valeur false, cette page n'aura plus accès à l'objet session et ne pourra donc pas participer à la session. Grâce à l'objet session, la page peut stocker des informations à propos du client ou de l'état de la conversation avec celui-ci.
Par contre, nous ne pouvons placer dans une session que des objets, et non des primitives Java. Pour conserver des primitives, il faut les envelopper dans une classe prévue à cet effet, comme Integer, Double ou Boolean. Les méthodes permettant de placer des objets dans la session et de les y retrouver sont les suivantes:
Object setAttribute(String nom, Object valeur); Object getAttribute(String nom); Enumeration getAttributeNames ( ); void removeAttribute(String nom);
Lorsque d'autres composants de l'application Web reçoivent une requête, ils peuvent accéder aux données qui ont été placées dans la session par les premiers composants. Ils peuvent modifier ces données ou en ajouter.
Vous pouvez placer des JavaBean dans la session. Par contre là, il est nécessaire de le préciser au moyen de l'attribut scope, puisque par défaut, la portée d'un JavaBean est la page JSP en cours. Ainsi, vous pouvez, par exemple, conserver le nom de l'utilisateur durant toute la session de l'application Web messagerie. Du coup, dans la page d'accueil du site, nous pouvons faire apparaître son identité et donner la liste des messages le concernant. Si nous désirons par exemple qu'un objet utilisateur d'un JavaBean Personne soit stocké dans une session, nous devons procéder de la façon suivante:
<jsp:useBean id = "utilisateur" class = "bd.Personne" scope = "session" />
6.5. application
Cet objet représente l'environnement de l'application Web. Il peut être utilisé pour lire les paramètres de configuration de l'application. Ces paramètres sont définis dans le descripteur de déploiement, dans l'élément <webapp>
C'est le ServletContext comme celui obtenu via getServletConfig().getContext()
6.6. config
Une fois qu'une page JSP est compilée, elle est transformée en servlet par le conteneur (serveur) ; Le descripteur de déploiement contient un certain nombre de paramètres notamment les paramètres d'initialisation ; ces éléments figurent entre les tags <servlet> et </servlet> et l'objet config est utilisé pour accéder aux paramètres d'initialisation. Cet objet est une instance de la Classe ServletConfig.
6.7. pagecontext
La spécification JSP a introduit une nouvelle classe appelée PageContext; elle encapsule des spécificités du serveur; .......
6.8. page.
Rarement utilisé, cette variable permet de faire appel à des applications écrites dans d'autre langage que java.
7. Action
Les actions JSP utilisent la construction de balise au format XML pour faciliter l'encapsulation des classes java. On a ainsi la possibilité par exemple d'inclure des fichiers dans une page JSP, d'utiliser et de réutiliser des JavaBean ou de rediriger l'exécution d'une JSP vers une autre page.<br /> Les actions JSP les plus représentatives sont:
* jsp:include - permet d'inclure un fichier au moment où la page est demandée. * jsp:useBean - trouve ou instancie un javabean. * jsp:setProperty - * jsp:getProperty - insère la propriété d'un javabean en sortie * jsp:forward - redirige la requête vers une autre page * jsp:plugin - Génère un code de specification du browser qui construit un tag relative OBJECT.
7.1. L'action jsp:include
Contrairement à la directive include qui inclut un fichier au moment ou le serveur traduit la JSP en servlet, l'action jsp:include permet d'inclure le fichier au moment où il est demandé par un client. Avec l'action standard include, la page stoppe le traitement de la requête et la transmet à la ressource incluse. Celle-ci renvoie sa réponse, qui est incluse dans la page appelante. Cette page reprend alors le contrôle de la requête. Il doit s'agir d'une page valide ou d'une servlet. Nous avons donc ici un comportement dynamique. La page incluse est considérée comme une page en elle-même. Si vous déclarez des variables à l'intérieur de cette dernière, elles ne seront pas accessibles dans la page qui propose l'inclusion. Du coup, nous ne pouvons pas considérer la page incluse comme un fragment de page, même si elle s'occupe de la gestion d'une partie de page. D'ailleurs, son extension est comme une page classique c'est à dire .jsp et non plus comme un fragment de page.
<jsp:include page="URL relative" flush="true" />
(en construction)
7.2. L'action jsp:useBean
....
<jsp:useBean id="name" class="package.class"/>
(en construction)
7.3. L'action jsp:setProperty
....
<jsp:setProperty name="orderBean" property="numberOfItems" param="numItems"/>
(en construction)
7.4. L'action jsp:getProperty
....
<jsp:getProperty name="primeTable" property="numDigits" />
(en construction)
7.5. L'action jsp:forward
Il arrive qu'une page JSP souhaite rediriger la requête vers une autre page. Avec l'action standard forward, la page arrête le traitement de la requête et transmet celle-ci à la ressource désignée. La page appelante ne reprend pas le contrôle. A la différence de l'action include qui peut être employée n'importe où dans une page, l'action forward doit être placée avant tout envoi de données dans l'objet OutputStream de la réponse, c'est-à-dire avant tout code HTML dans la page, et avant toute scriptlet ou expression écrivant l'OutputStream. Si des données ont déjà été écrites, l'action forward provoque une exception.
<jsp:forward page="/utils/errorReporter.jsp"/>
(en construction)
7.6. L'action jsp:plugin
.......
(en construction)
Exemples
Exemples: illustration des éléments des JSP
C'est un exemple qui montre l'utilisation des expressions, des scriptlets, des déclarations et des directives.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>utilisation de JavaServer Pages</TITLE>
<META NAME="author" CONTENT="Omara - Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.">
<META NAME="keywords"
CONTENT="JSP,JavaServer Pages,servlets">
<META NAME="description"
CONTENT="un petit exemple pour les quatre principales tags JSP .">
<LINK REL=STYLESHEET
HREF="My-Style-Sheet.css"
TYPE="text/css">
</HEAD>
<BODY BGCOLOR="#FDF5E6" TEXT="#000000" LINK="#0000EE"
VLINK="#551A8B" ALINK="#FF0000">
<CENTER>
<TABLE BORDER=5 BGCOLOR="#EF8429">
<TR><TH CLASS="TITLE">
utilisation de JSP</TABLE>
</CENTER>
<P>
quelques contenus dynamiques illustrant différents mécanismes de JSP:</p>
<UL>
<LI><B>Expression.</B>
Your hostname: <%= request.getRemoteHost() %>.
<LI><B>Scriptlet.</B>
<% out.println("Attached GET data: " +
request.getQueryString()); %>
<LI><B>Declaration (plus expression).</B>
<%! private int accessCount = 0; %>
acces a la page lorsque le server reboot: <%= ++accessCount %>
<LI><B>Directive (plus expression).</B>
<%@ page import = "java.util.*" %>
Current date:<%= new Date() %>
</UL>
</BODY>
</HTML>
Exemples: utilisation de jsp:useBean et jsp:setProperty/js:getProperty
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>Réutilisation des JavaBeans dans une JSP</TITLE>
<LINK REL=STYLESHEET
HREF="My-Style-Sheet.css"
TYPE="text/css">
</HEAD>
<BODY>
<CENTER>
<TABLE BORDER=5>
<TR><TH CLASS="TITLE">
Réutilisation de JavaBeans dans une JSP</TABLE>
</CENTER>
<P>
<jsp:useBean id="test" class="hall.SimpleBean" />
<jsp:setProperty name="test"
property="message"
value="Hello WWW" />
</p>
<H1>Message: <I>
<jsp:getProperty name="test" property="message" />
</I></H1>
</BODY>
</HTML>
Exemples: utilisation de jsp:include
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>les nouvelles</TITLE>
<LINK REL=STYLESHEET
HREF="My-Style-Sheet.css"
TYPE="text/css">
</HEAD>
<BODY BGCOLOR="#FDF5E6" TEXT="#000000" LINK="#0000EE"
VLINK="#551A8B" ALINK="#FF0000">
<CENTER>
<TABLE BORDER=5 BGCOLOR="#EF8429">
<TR><TH CLASS="TITLE">
Qelles nouvelles à toto.com</TABLE>
</CENTER>
<P>
Ici un résumé des quatre récents nouvelles:
</P>
<OL>
<LI><jsp:include page="news/Item1.html" flush="true"/>
<LI><jsp:include page="news/Item2.html" flush="true"/>
<LI><jsp:include page="news/Item3.html" flush="true"/>
<LI><jsp:include page="news/Item4.html" flush="true"/>
</OL>
</BODY>
</HTML>
