ENI Initiation à JSP Dr RV p.

LA TECHNOLOGIE JSP(JAVASERVER PAGES ) Demande de fichier JSP

Les JSP (Java Server Pages) sont une technologie

basée sur Java qui permettent la génération de pages
web dynamiques.

La technologie JSP permet de séparer la présentation

sous forme de code HTML et les traitements (logique
applicative des pages Web) sous formes de classes
java définissant un bean ou une servlet. Ceci est Lorsque le serveur Web reçoit une requête pour un
d'autant plus facile que les JSP définissent une syntaxe fichier JSP, le serveur envoie cette requête au serveur
particulière permettant d'appeler un bean et d'insérer le d'[Link]-ci analyse le fichier JSP et génère
résultat de son traitement dans la page HTML une source Java qui est compilée et exécutée en tant
dynamiquement. que servlet. La génération et la compilation de la source
Java s'effectue uniquement au premier appel du servlet
1. Présentation des JSP à moins que le fichier JSP d'origine ait été mis à jour.
Dans ce cas, le serveur détecte ce changement et
Les JSP permettent d'introduire du code java dans des régénère et compile le servlet avant de l'exécuter
tags prédéfinis à l'intérieur d'une page HTML. La
technologie JSP mélange la puissance de java côté Il y a plusieurs manières de combiner les technologies
serveur et la facilité de mise en page d'HTML côté client. JSP, les beans/EJB et les servlets en fonction des
besoins pour développer des applications web.
Concrètement, les JSP sont basées sur les servlets. Au
premier appel de la page JSP, le moteur de JSP crée et Cette approche possède plusieurs avantages :
compile automatiquement une servlet qui permet la
génération de la page web. Le code HTML est repris • l'utilisation de Java par les JSP permet une
intégralement dans la servlet. Le code java est inséré indépendance de la plate-forme d'exécution
dans la servlet. mais aussi du serveur web utilisé.

La servlet est sauvegardée puis elle est exécutée. Les • la séparation des traitements et de la
appels suivants de la JSP sont beaucoup plus rapides présentation : la page web peut être écrite par
car la servlet, conservée par le serveur, est directement un designer et les tags Java peuvent être
exécutée. ajoutés ensuite par le développeur. Les
traitements peuvent être réalisés par des
JSP a donc un fonctionnement lourd qui se déroule composants réutilisables (des Java beans).
en 4 temps : alors que dans une servlet, les traitements et la
présentation sont regroupés
• La requete est recu par le serveur
• les JSP sont basées sur les servlets : tout ce qui
• La page demandé est traduite en servlets est fait par une servlet pour la génération de
pages dynamiques peut être fait avec une JSP.
• Puis elle est compilée
Les JSP et les technologies concurrentes
Enfin elle est exécutée et la page html est transmise
au client Il existe plusieurs technologies dont le but est similaire
aux JSP notamment ASP, PHP et [Link]. Chacune de
Modèles d'accès à JSP ces technologies possèdent des avantages et des
inconvénients dont voici une liste non exhaustive.
Il est possible d'accèder aux fichiers JSP de de la
manière suivante :

• Le navigateur envoie une demande de fichier

JSP.

Le fichier JSP accède à des beans ou à d'autres

composants qui génèrent du contenu
dynamique envoyé au navigateur. Le schéma
suivant illustre ce modèle d'accès pour JSP.
ENI Initiation à JSP Dr RV p.2

JSP PHP ASP [Link]

Tous les langages

langage Java PHP VBScript ou JScript supportés par .Net (C#,
[Link], Delphi, ...)

Compilé en pseudo Compilé en pseudo

mode d'exécution Interprété Interprété
code (byte code) code (MSIL)

Repose sur la plate- Open source Facile à mettre en Repose sur la plate-
forme Java dont elle Nombreuses oeuvre forme .Net dont elle
hérite des avantages bibliothèques et hérite des avantages
sources d'applications Wysiwyg et
principaux avantages
libres disponibles événementiel
Facile à mettre en Code behind pour
oeuvre séparation affichage /
traitements

Débogage assez Débogage assez Débogage assez Fonctionne

fastidieux fastidieux fastidieux essentiellement sur
Beaucoup de code à Beaucoup de code à Beaucoup de code à plate-formes Windows.
écrire écrire écrire (Voir le projet Mono
support partiel de la Fonctionne pour le support d'autres
principaux
POO en attendant la essentiellement sur plateformes)
inconvénients
version 5 plateformes Windows
Pas de POO, objet
métier encapsulé dans
des objets COM lourd
à mettre en oeuvre

2. Les outils nécessaires Configuration à l’aide des variables

d’environnement
Dans un premier temps, Sun a fourni un kit de
développement pour les JSP : le Java Server Web JAVA_HOME = c:\jdsk // repertoire d’installation du
Development Kit (JSWDK). Actuellement, Sun a chargé jdk
le projet Apache de développer l'implémentation TOMCAT_HOME = c:\tomcat // repertoire d’installation
officielle d'un moteur de JSP. Ce projet se nomme de Tomcat
Tomcat. CATALINA_HOME = c:\tomcat // repertoire d’installation
de Tomcat
En fonction des versions des API utilisées, il faut choisir
un produit différent. Le tableau ci dessous résume le
produit a utiliser en fonction de la version des API
3. Les Tags JSP
utilisée.
Version Il existe trois types de tags :
Version de l'API de l'API
Produit Version servlet JSP • tags de directives : ils permettent de contrôler la
implémentée implément structure de la servlet générée
ée
• tags de scripting: il permettent d'insérer du code
JSWDK 1.0.1 2.1 1.0 java dans la servlet
Tomcat 3.2 2.2 1.1
Tomcat 4.0 2.3 1.2 • tags d'actions: ils facilitent l'utilisation de
composants

Ces produits sont librement téléchargeables sur le site Attention : Les tags sont sensibles à la casse.
de Sun à l'adresse suivante :
[Link]
ENI Initiation à JSP Dr RV p.3

3.1. Les tags de directives <%@ … %> Les options définies par cette directive sont de la forme
option=valeur.
Les spécifications des JSP définissent trois directives :
Valeur par Autre valeur
Option Valeur
• page : permet de définir des options de défaut possible
configuration autoFlush Une chaine «true» «false»
«none» ou
• include : permet d'inclure des fichiers statiques «nnnkb» (nnn
dans la JSP avant la génération de la servlet buffer Une chaine «8kb»
indiquant la
valeur)
• taglib : permet de définir des tags personnalisés
Une chaîne
Leur syntaxe est la suivante : contentType contenant le
type mime
<%@ directive attribut="valeur" ... %> Une chaîne
errorPage contenant
une URL
3.2. La directive page extends Une classe
Une classe
Cette directive doit être utilisée dans toutes les pages import ou un
JSP : elle permet de définir des options qui s'applique à package.*
toute la JSP. info Une chaîne
Elle peut être placée n'importe ou dans le source mais il isErrorPage Une chaîne «false» «true»
est préférable de la mettre en début de fichier, avant isThreadSafe Une chaîne «true» «false»
même le tag <HTML>. Elle peut être utilisée plusieurs langage Une chaîne «java»
fois dans une même page mais elle ne doit définir la session Une chaîne «true» «false»
valeur d'une option qu'une seule fois, sauf pour l'option
import.
Exemple : • errorPage="relativeURL"

Cette option permet de préciser la JSP appelée

<%@ page import="[Link].*" %> au cas où une exception est levée
<%@ page import="[Link]" %>
<%@page info="Ma premiere JSP"%> Si l'URL commence pas un ‘/', alors l'URL est
relative au répertoire principale du serveur web
sinon elle est relative au répertoire qui contient
Les options sont : la JSP
• autoFlush="true|false"
• extends="[Link]"
Cette option indique si le flux en sortie de la
servlet doit être vidé quand le tampon est plein. Cette option permet de préciser la classe qui
Si la valeur est false, une exception est levée sera la super classe de l'objet java créé à partir
dès que le tampon est plein. On ne peut pas de la JSP.
mettre false si la valeur de buffer est none.
• import= "{ [Link] | package.* }, ..."
• buffer="none|8kb|sizekb"
Cette option permet d'importer des classes
Cette option permet de préciser la taille du contenues dans des packages utilisées dans le
buffer des données générées contenues par code de la JSP. Cette option s'utilise comme
l'objet out de type JspWriter. l'instruction import dans un source java.

Chaque classe ou package est séparée par une

• contentType="mimeType [ ; virgule.
charset=characterSet ]" |
"text/html;charset=ISO-8859-1" Cette option peut être présente dans plusieurs
directives page.
Cette option permet de préciser le type MIME
des données générées.
• info="text"
Cette option est équivalente à <%
[Link]("mimeType"); %> Cette option permet de préciser un petit
ENI Initiation à JSP Dr RV p.4

descriptif de la JSP. Le texte fourni sera renvoyé <title>Page de test de la directive page</title>
par la méthode getServletInfo() de la servlet </head>
générée. <body>
<h1> Page de test de la directive page</h1>
Bla bla bla...
• isErrorPage="true|false"
</body>
</html>
Cette option permet de préciser si la JSP génère
un page d'erreur. La valeur true permet d'utiliser
l'objet Exception dans la JSP 3.3. La directive include

Cette directive permet d'inclure un fichier dans le source

• isThreadSafe="true|false" JSP. Le fichier inclus peut être un fragment de code
JSP, HTML ou java. Le fichier est inclus dans la JSP
Cette option indique si la servlet générée sera avant que celle ci ne soit interprétée par le moteur de
multithread : dans ce cas, une même instance JSP.
de la servlet peut gérer plusieurs requêtes
simultanément. En contre partie, elle doit gérer Ce tag est particulièrement utile pour insérer un élément
correctement les accès concurrents aux commun à plusieurs pages tel qu'un en-tête ou un bas
ressources. La valeur false impose à la servlet de page. Si le fichier inclus est un fichier HTML, celui ci
générée d'implémenter l'interface ne doit pas contenir de tag <HTML>, </HTML>,
SingleThreadModel. <BODY> ou </BODY> qui ferait double emploi avec
ceux présents dans le fichier JSP. Ceci impose d'écrire
des fichiers HTML particuliers uniquement pour être
• language="java"
inclus dans les JSP : ils ne pourront pas être utilisés
seuls.
Cette option définie le langage utilisé pour écrire
le code dans la JSP. La seule valeur autorisée La syntaxe est la suivante :
actuellement est «java».
<%@ include file="chemin relatif du fichier" %>
• session="true|false"
Si le chemin commence par un ‘/', alors le chemin est
Cette option permet de préciser si la JSP est relatif au contexte de l'application, sinon il est relatif au
incluse dans une session ou non. La valeur par fichier JSP.
défaut (true) permet l'utilisation d'un objet Exemple :
session de type HttpSession qui permet de
[Link] :
gérer une session.
<p><table border="1" cellpadding="4" cellspacing="0"
• Valeurs possibles des options de la directive
width="30%" align=center >
page : <tr bgcolor="#A6A5C2">
<td align="center">BONJOUR</Td>
– <%@ page language="java" </Tr>
– <%@ page import="[Link].*, </table></p>
[Link].*" %>
– <%@ page contentType="text/plain" %> [Link] :
– <%@ page session="true|false " %> <HTML>
– <%@ page <HEAD>
errorPage="pathToErrorPage" %> <TITLE>Essai de page JSP</TITLE>
– <%@ page isErrorPage="true|false" %> </HEAD>
– <%@ page … <BODY>
<p align="center">Test d'inclusion d'un fichier dans la
Exemple de directive page JSP</p>
<%@ include file="[Link]"%>
<%@ page language="Java" <p align="center">fin</p>
import="[Link].*,[Link].*" </BODY>
session="true" buffer="12kb" autoFlush="true« </HTML>
info="Ma directive page" errorPage="[Link]«
isErrorPage="false" isThreadSafe="false" %>
Pour visualiser la JSP, il faut saisir l'url
[Link]
dans un navigateur.
<html>
<head>
ENI Initiation à JSP Dr RV p.5

Attention : un changement dans le fichier int minimum(int val1, int val2) {

inclus ne provoque pas une if (val1 < val2) return val1;
regénération et une compilation de la servlet else return val2;
correspondant à la JSP. }
Pour insérer un fichier dynamiquement à %>
l'exécution de la servlet <% int petit = minimum(5,3);%>
il faut utiliser le tag <jsp:include>. <p>Le plus petit de 5 et 3 est <%= petit %></p>
</BODY>
</HTML>

3.4. Les tags de scripting

3.4.2. Le tag d'expressions <%= … %>
Ces tags permettent d'insérer du code java qui sera
Le moteur de JSP remplace ce tag par le résultat de
inclus dans la servlet générée à partir de la JSP. Il existe
l'évaluation de l'expression présente dans le tag.
trois tags pour insérer du code java :
Ce résultat est toujours converti en une chaîne. Ce tag
• le tag de déclaration : le code java est inclus est un raccourci pour éviter de faire appel à la méthode
dans le corps de la servlet générée. Ce code println() lors de l'insertion de données dynamiques dans
peut être la déclaration de variables d'instances le fichier HTML.
ou de classes ou la déclaration de méthodes.
La syntaxe est la suivante : <%= expression %>
• le tag d'expression : évalue une expression et
insère le résultat sous forme de chaîne de Le signe ‘=' doit être collé au signe ‘%'.
caractères dans la page web générée.
Attention : il ne faut pas mettre de ‘ ;' à la fin de l'expre
• le tag de scriptlets : par défaut, le code java est
inclus dans la méthode service() de la servlet.

Il est possible d'utiliser dans ces tags plusieurs objets Exemple : Insertion de la date dans la page
définis par les JSP. HTML
3.4.1. Le tag de déclarations <%! … %>
<%@ page import="[Link].*" %>
Ce tag permet de déclarer des variables ou des <HTML>
méthodes qui pourront être utilisées dans la JSP. Il ne <HEAD>
génère aucun caractère dans le fichier HTML de sortie. <TITLE>Essai de page JSP</TITLE>
</HEAD>
La syntaxe est la suivante : <BODY>
<p align="center">Date du jour :
<%! declarations %> <%= new Date() %>
</p>
Exemple : </BODY>
</HTML>
<%! int i = 0; %>
<%! dateDuJour = new [Link](); %>
Résultat :

Les variables ainsi déclarées peuvent être utilisées dans Date du jour : Thu Feb 15 11:15:24 CET 2001
les tags d'expressions et de scriptlets.

Il est possible de déclarer plusieurs variables dans le L'expression est évaluée et convertie en chaîne avec un
même tag en les séparant avec des ‘ ;'. appel à la méthode toString(). Cette chaîne est insérée
dans la page HTML en remplacement du tag. Il est ainsi
Ce tag permet aussi d'insérer des méthodes dans le possible que le résultat soit une partie ou la totalité d'un
corps de la servlet. tag HTML ou même JSP.
Exemple :

<HTML>
<HEAD><TITLE>Test</TITLE>
</HEAD>
<BODY> Exemple :
<%!
ENI Initiation à JSP Dr RV p.6

<HTML> Ce tag ne peut pas contenir autre chose que du code

<HEAD> java : il ne pas par exemple contenir de tags HTML ou
<TITLE>Essai de page JSP</TITLE> JSP. Pour faire cela, il faut fermer le tag du scriptlet,
</HEAD> mettre le tag HTML ou JSP puis de nouveau
<BODY> commencer un tag de scriptlet pour continuer le code.
<%="<H1>" %> Exemple :
Bonjour
<%="</H1>" %>
</BODY> <HTML>
</HTML> <HEAD>
<TITLE>Essai de page JSP</TITLE>
Résultat : code HTML généré </HEAD>
<BODY>
<HTML> <% for (int i=0; i<10; i++) { %>
<HEAD> <%= i %> <br>
<TITLE>Essai de page JSP</TITLE> <% }%>
</HEAD> </BODY>
<BODY> </HTML>
<H1>
Bonjour
</H1> Résultat : la page HTML générée
</BODY> <HTML>
</HTML> <HEAD>
<TITLE>Essai de page JSP</TITLE>
</HEAD>
3.4.3. Les variables implicites <BODY>
0 <br>
Les spécifications des JSP définissent plusieurs objets 1 <br>
utilisables dans le code dont les plus utiles sont : 2 <br>
Object Classe Role 3 <br>
4 <br>
[Link] Flux en sortie de la
out 5 <br>
Writer page HTML générée
6 <br>
[Link] 7 <br>
request Contient la requête
ServletRequest 8 <br>
[Link] 9 <br>
response Contient la réponse
ServletRequest </BODY>
[Link] </HTML>
session Gère la session
Session

3.5. Les tags de commentaires

3.4.4. Le tag des scriptlets <% … %>
Il existe deux types de commentaires avec les JSP :
Ce tag contient du code java : un scriptlet.
• les commentaires visibles dans le code HTML
La syntaxe est la suivante :
• les commentaires invisibles dans le code HTML
<% code java %>
3.5.1. Les commentaires HTML <!-- … -->
Exemple :
Ces commentaires sont ceux définis par format HTML.
<%@ page import="[Link]"%> Ils sont intégralement reconduit dans le fichier HTML
<html> généré. Il est possible d'insérer, dans ce tag, un tag JSP
<body> de type expression
<%! Date dateDuJour; %>
<% dateDuJour = new Date();%> La syntaxe est la suivante :
Date du jour : <%= dateDuJour %><BR>
<!-- commentaires [ <%= expression %> ] -->
</body>
</html>

Exemple :
Par défaut, le code inclus dans le tag est inséré dans la
méthode service de la servlet générée à partir de la
JSP. <%@ page import="[Link].*" %>
 ENI Initiation à JSP Dr RV p.7

<HTML>
<HEAD> EXEMPLE FINAL
<TITLE>Essai de page JSP</TITLE> <%@ page import = “[Link], [Link].* “%>
</HEAD> <HTML>
<BODY> <BODY>
<!-- Cette page a ete generee le <%= new Date() %> --> <%
<p>Bonjour</p> // Déclaration
</BODY> ! int a, b,s ;
</HTML> Date d ;
int produit (int a, int b)
{ return a*b ;}
Résultat : %>
<%
<HTML> / /Scripplet
<HEAD> a=2;
<TITLE>Essai de page JSP</TITLE> b=5;
</HEAD> s=a+b;
<BODY> d=new Date();
<!-- Cette page a ete generee le Thu Feb 15 int p = produit (a,b);
11:44:25 CET 2001 --> [Link](“<B> Produit = ”+ p+ “</B>”);
<p>Bonjour</p> %>
</BODY> < !-- Tage d’expression -->
</HTML> Somme = <% = s %> <BR>
Nous sommes le <%=d%>
</BODY>
Le contenu d'une expression incluse dans des
</HTML>
commentaires est dynamique : sa valeur peut changer à
chaque génération de la page en fonction de son
contenu.

3.5.2 . Les commentaires cachés <%-- … --%>

Envoi des données à partir d’un formulaire
Les commentaires cachés sont utilisés pour documenter
la page JSP. Leur contenu est ignoré par le moteur de [Link]
JSP et ne sont donc pas reconduit dans les données
HTML générées. <FORM METHOD=“POST/GET” ACTION = ”[Link]” >
Nom : <input type=text name=”nom”>
La syntaxe est la suivante : Prenom : <input type=text name=”prenom”>
<input type=submit value=”Valider”>
<%-- commentaires --%> </FORM>

Exemple : ou bien
<HTML>
<HEAD> <a href = “[Link]” ? nom=”rabe”& prenom =”koto” >
<TITLE>Essai de page JSP</TITLE> Envoyer </a>
</HEAD>
<BODY> [Link]
<%-- Commentaires de la page JSP --%>
<p>Bonjour</p> <HTML>
</BODY> <BODY>
</HTML> <% String nom = [Link](“nom”);
String prenom = [Link](“prenom”);
[Link](“<B> Anarana= ”+ nom+ “</B><BR>”);
Résultat : [Link](“<B> Fanampin’anarana= ”+ prenom+
<HTML> “</B>”);%>
<HEAD><TITLE>Essai de page JSP</TITLE> <H2>Bonjour <%= nom %></H2>
</HEAD> </BODY>
<BODY> </HTML
<p>Bonjour</p>
</BODY>
</HTML>
Exemple 2 : Formulaire HTML
<form action="[Link]"
Ce tag peut être utile pour éviter l'exécution de code lors method=post>
de la phase de débuggage.
ENI Initiation à JSP Dr RV p.8

Nom : <input type=text name=”nom”> <br> <jsp:useBean

Quelles sont vos connaissances de HTML ? id="beanInstanceName"
<input type="radio" name="choice" value="1" scope="page|request|session|application"
checked>faibles { class="[Link]" |
<input type="radio" name="choice" value="2">moyennes type="[Link]" |
<input type="radio" name="choice" value="3">bonnes class="[Link]" type="[Link]" |
<br> beanName="{[Link] | <%= expression %>}"
Indiquez votre expertise en programmation: type="[Link]"
<input type="radio" name="choice2" value="1" }
checked>absente { /> |
<input type="radio" name="choice2" value="2">moyenne > ...
<input type="radio" name="choice2" value="3">bonne </jsp:useBean>
<P> }
<input type="submit"
value="Voir le résultat!"> L'attribut id permet de donner un nom à la variable qui
</form> va contenir la référence sur le bean.

JAVA: [Link] L'attribut scope permet de définir la portée durant

<% laquelle le bean est défini et utilisable. La valeurs de
// Parameters come as strings cette attribut détermine la manière dont le tag localise ou
String choice = [Link]("choice"); instancie le bean. Les valeurs possibles sont :
String choice2 = [Link]("choice2"); Valeur Rôle
String nom = [Link]("nom");
[Link](nom + ", votre input était: question a=" + c'est la valeur par défaut. Le bean est utilisable
choice + " ,question b=" + choice2); page dans toute la page JSP ainsi que dans les
fichiers statiques inclus.
// [Link]() translates a string to an Integer Le bean est accessible durant la durée de vie
int score = [Link](choice) + de la requête. La méthode getAttribute de
Request
[Link](choice2); l'objet request permet d'obtenir une référence
sur le bean.
[Link]("<h3>Votre score est de " + score + "</h3>"); le bean est utilisable par toutes les JSP qui
appartiennent à la même session que la JSP
if (score < 3) { qui a instancié le bean. Le bean est utilisable
[Link] ("<p>Vous êtes un débutant</p>"); session tout au long de la session par toutes les pages
} else if (score < 5) { qui y participent. La JSP qui créé le bean doit
[Link] ("<p>Vous avez un niveau moyen</p>"); avoir l'attribut session = « true » dans sa
} else { directive page.
[Link] ("<p>Vous êtes un expert !</p>"); le bean est utilisable par toutes les JSP qui
} appartiennent à la même application que la
%> application JSP qui a instancié le bean. Le bean n'est
instancié que lors du rechargement de
l'application.

3.6. Les tags d'actions L'attribut class permet d'indiquer la classe du bean

3.6.1. Le tag <jsp:useBean> L'attribut type permet de préciser le type de la variable

qui va contenir la référence du bean. La valeur indiquée
Le tag <jsp:useBean> permet de localiser une instance doit obligatoirement être une super classe du bean ou
ou d'instancier un bean pour l'utiliser dans la JSP. une interface implémentée par le bean (directement ou
L'utilisation d'un bean dans une JSP est très pratique par héritage)
car il peut encapsuler des traitements complexes et être
L'attribut beanName permet d'instancier le bean grâce à
réutilisable par d'autre JSP ou composants. Le bean
la méthode instanciate() de la classe Beans.
peut notamment assurer l'accès à une base de données.
L'utilisation des beans permet de simplifier les Exemple :
traitements inclus dans la JSP.
Lors de l'instanciation d'un bean, on précise la porté du <jsp:useBean id="monBean" scope="session"
bean. Si le bean demandé est déjà instancié pour la class="[Link]" />
porté précisée alors il n'y pas de nouvelle instance du
bean qui est créée mais sa référence est simplement Dans cet exemple, une instance de MonBean est
renvoyée : le tag <jsp:useBean> n'instancie pas instancié un seul est unique fois lors de la session. Dans
obligatoirement un objet. la même session, l'appel du tag <jsp:useBean> avec le
La syntaxe est la suivante : même bean et la même portée ne feront que renvoyer
 ENI Initiation à JSP Dr RV p.9

l'instance créée. Le bean est accessible durant toute la Comme les paramètres de la requête sont toujours
session. fournis sous forme de String, une conversion est
réalisée en utilisant la méthode valueOf() du wrapper du
Le tag <jsp:useBean> recherche si une instance du type de la propriété.
bean existe avec le nom et la portée précisée. Si elle
n'existe pas, alors une instance est créée. Si il y a Exemple :
instanciation du bean, alors les tags <jsp:setProperty>
inclus dans le tag sont utilisés pour initialiser les <jsp:setProperty name="monBean"
propriétés du bean sinon ils sont ignorés. Les tags inclus property="*" />
entre les tags <jsp:useBean> et </jsp:useBean> ne sont
exécutés que si le bean est instancié.
L'attribut property="propertyName"
Exemple : [ param="parameterName"] permet de mettre à jour un
attribut du bean. Par défaut, l'alimentation est faite
<jsp:useBean id="monBean" scope="session" automatiquement avec le paramètre correspondant dans
class="[Link]" > la requête. Si le nom de la propriété et du paramètre
<jsp:setProperty name="monBean" property="*" /> sont différents, il faut préciser l'attribut property et
</jsp:useBean> l'attribut param qui doit contenir le nom du paramètre qui
va alimenter la propriété du bean.
Cet exemple a le même effet que le précédent avec une
initialisation des propriétés du bean lors de son Exemple :
instanciation avec les valeur des paramètres
correspondants. <jsp:setProperty name="monBean"
property="nom"/>
3.6.2 . Le tag <jsp:setProperty >

Le tag <jsp:setProperty> permet de mettre à jour la L'attribut property="propertyName" value="{string | <%=

valeur d'un ou plusieurs attributs d'un Bean. Le tag expression %>}" permet d'alimenter la propriété du bean
utilise le setter (méthode getXXX() ou XXX est le nom avec une valeur particulière.
de la propriété) pour mettre à jour la valeur. Le bean doit
exister grâce à un appel au tag <jsp:useBean>. Exemple :

Il existe trois façon de mettre à jour les propriétés soit à <jsp:setProperty name="monBean"
partir des paramètres de la requête soit avec une property="nom" value="toto" />
valeur :

• alimenter automatiquement toutes les propriétés Il n'est pas possible d'utiliser param et value dans le
avec les paramètres correspondants de la même tag.
requête
Ce tag peut être utilisé entre les tags <jsp:useBean> et
• alimenter automatiquement une propriété avec </jsp:useBean> pour initialiser les propriétés du bean
le paramètre de la requête correspondant lors de son instanciation.
• alimenter une propriété avec la valeur précisée

La syntaxe est la suivante : EXEMPLE FINAL DE USEBEAN

<jsp:setProperty name="beanInstanceName" [Link] ( à placer dans un repertoire Essai du
{ property="*" | repertoire classes de webInf )
property="propertyName" [ param=" parameterName" ] |
property="propertyName" value="{string | <%= package essai;
expression%>}" public class Bean{
} // PROPRIETES
/> String login;
String password;
L'attribut name doit contenir le nom de la variable qui Bean(){}
contient la référence du bean. Cette valeur doit être
identique à celle de l'attribut id du tag <jsp:useBean> // METHODES OBLIGATOIRES
utilisé pour instancier le bean. public void setLogin (String login ) {[Link]=login;}
public void setPassword (String p ) {password=p;}
L'attribut property= «*» permet d'alimenter
automatiquement les propriétés du bean avec les public String getLogin ( ) { return login;}
paramètres correspondants contenus dans la requête. public String getPassword (String p ) { return
Le nom des propriétés et le nom des paramètres doivent password;}
être identiques.
ENI Initiation à JSP Dr RV p.10

// AUTRES METHODES L'attribut name indique le nom du bean tel qu'il a été
public void connectBase() {……….} déclaré dans le tag <jsp:useBean>.
} L'attribut property indique le nom de la propriété dont on
veut la valeur.
[Link]
Remarque : avec Tomcat 3.1, l'utilisation du tag
<a href = “[Link]” ? login=”rabe”& password =”rabe” <jsp:getProperty> sur un attribut dont la valeur est null
> Cliquer ici </a> n'affiche rien alors que l'utilisation d'un tag d'expression
retourne « null ».
ou bien
Exemple :
<FORM METHOD = « POST» ACTION [Link]
= « [Link] » >
Nom : <input type=text name=”login”> <br> <html>
Mot de passe : <input type=password <HEAD>
name=”password”> <br> <TITLE>Essai d'instanciation d'un bean dans une
<input type=submit value=”Valider”> JSP</TITLE>
</FORM> </HEAD>
<body><p>Test d'utilisation d'un Bean dans une JSP
[Link] </p>
<jsp:useBean id="personne" scope="request"
<jsp :useBean id = « Bean » class = »[Link] » /> class="[Link]" />
<!-- Les noms des parameters de la requête sont <p>nom initial = <%=[Link]() %></p>
identiques à ceux des propriétés du bean -- > <p>nom initial = <jsp:getProperty name="personne"
<jsp:seProperty name=”Bean” property =”*” /> property="nom" /></p>
<jsp:setProperty name="personne" property="nom"
<jsp:seProperty name=”Bean” property =”login” /> value="mon nom est DUPONT" />
<jsp:seProperty name=”Bean” property =”password” /> <p>nom mise à jour = <jsp:getProperty
name="personne" property="nom" /></p>
<% [Link](); %> <%[Link]("mon nom est RABE");%>
<p>nom mise à jour = <%= [Link]() %></p>
<!-- Initialisation des propriétés du bean --> <% [Link](null);%>
<p>nom mis à jour = <jsp:getProperty name="personne"
<jsp:seProperty name=”Bean” property =”login” property="nom" /></p>
value=”koto” /> <p>nom mis à jour = <%= [Link]() %></p>
<jsp:seProperty name=”Bean” property =”password” </
value=”koto” /> </body>
</html>
<!-- Les noms des parameters de la requête sont
différents de ceux des propriétés du bean --> [Link]
< !-- <a href = “[Link]” ? nom=”rabe”& motdepass
=”rabe” > Cliquer ici </a> --> package test;
public class Personne {
<jsp:seProperty name=”Bean” property =”login” private String nom;
param=”nom” /> private String prenom;
public Personne() {
<jsp:seProperty name=”Bean” property =”password” [Link] = "nom par defaut";
param=”motdepass” /> [Link] = "prenom par defaut";
}
public void setNom (String nom) {
[Link] = nom;
3.6.3. Le tag <jsp:getProperty>
}
Le tag <jsp:getProperty> permet d'obtenir la valeur d'un public String getNom() { return ([Link]);
attribut d'un Bean. Le tag utilise le getter (méthode }
getXXX() ou XXX est le nom de la propriété) pour public void setPrenom (String prenom) {
obtenir la valeur et l'insérer dans la page HTML généré. [Link] = prenom;
Le bean doit exister grâce à un appel au tag }
<jsp:useBean>.
public String getPrenom () {
La syntaxe est la suivante : return ([Link]);
}
<jsp:getProperty name="beanInstanceName" }
property=" propertyName" />
ENI Initiation à JSP Dr RV p.11

Remarques c'est le serveur web qui détermine la localisation de la

ressource.
Code java
<%@ page import="[Link]" %> Il est possible de passer un ou plusieurs paramètres
<html> vers la ressource appelée grâce au tag <jsp :param>.
<body>
Exemple :
<%
Personne personne = new Personne (); [Link]
[Link]([Link]("nom"); <html>
[Link]([Link]("prennom"); <body>
%> <p>Page initiale appelée</p>
<p>Votre nom = <%= [Link]() %></p> <jsp:forward page="[Link]"/>
<p>Votre prenom = <%= [Link]() </body>
%></p> </html>
</body> [Link]
</html> <HTML>
<HEAD>
Tags JSP (équivalent) <TITLE>Page HTML</TITLE>
</HEAD>
<jsp:useBean id="personne" scope="request" <BODY>
class="[Link]" /> <p><table border="1" cellpadding="4"
<jsp:setProperty name="personne" property="nom" cellspacing="0" width="30%" align=center >
value="*" /> <tr bgcolor="#A6A5C2">
<p>Votre nom = <jsp:getProperty name="personne" <td align="center">Page HTML forwardée</Td>
property="nom" /></p> </Tr>
<p>Votre nom = <jsp:getProperty name="personne" </table></p>
property="prenom" /></p> </BODY>
</HTML>

Le fichier [Link] doit être dans le même répertoire

Pour tester cette JSP avec Tomcat, il faut compiler le que la JSP. Lors de l'appel à la JSP, c'est le page HTML
bean Personne dans le répertoire qui est affichée. Le contenu généré par la page JSP
\webapps\examples\web-inf\classes\test et placer le n'est pas affiché.
fichier [Link] dans le répertoire
t\webapps\examples\jsp\test.

3.6. Le tag de redirection <jsp:forward>

Le tag <jsp:forward> permet de rediriger la requête vers

une autre URL pointant vers un fichier HTML, JSP ou un Exemple : Utilisation des paramètres
servlet. [Link]
<html>
Dès que le moteur de JSP rencontre ce tag, il redirige le <body>
requête vers l'URL précisée et ignore le reste de la JSP <p>Page initiale appelée</p>
courante. Tout ce qui a été généré par la JSP est perdu. <jsp:forward page="[Link]">
<jsp:param name= "nom" value= “rabe” />
La syntaxe est la suivante : </jsp :forward>
</body>
<jsp:forward page="{relativeURL | <%= expression </html>
%>}" />
ou [Link]
<HTML>
<jsp:forward page="{relativeURL | <%= expression
<BODY>
%>}" >
<%
<jsp:param name="parameterName" value="{
String npm = [Link](“nom”);
parameterValue | <%= expression %>}" /> +
[Link]( nom);
</jsp:forward>
%>
L'option page doit contenir la valeur de l'URL de la </BODY>
ressource vers laquelle la requête va être redirigée. </HTML>

Cette URL est absolue si elle commence par un ‘/' ou

relative à la JSP sinon. Dans le cas d'une URL absolue, 3.7. Le tag <jsp:include>
ENI Initiation à JSP Dr RV p.12

Ce tag permet d'inclure le contenu généré par une JSP

(bibliothèques jar, classes, ...) qui seront
ou une servlet dynamiquement au moment où la JSP est
automatiquement chargées. Le chemin de ces
exécutée. C'est la différence avec la directive include
ressources tient compte de l'attribut codebase
avec laquelle le fichier est inséré dans la JSP avant la
génération de la servlet. précise la hauteur de l'applet en pixel ou en
Height
pourcentage
La syntaxe est la suivante :
précise le nombre de pixels insérés à gauche
<jsp:include page="relativeURL" flush="true" /> hspace
et à droite de l'applet
L'attribut page permet de préciser l'URL relative de précise la version minimale du jre à utiliser
l'élément à insérer. jrversion
pour faire fonctionner l'applet

L'attribut flush permet d'indiquer si le tampon doit être Name précise le nom de l'applet
envoyé au client et vidé. Si la valeur de ce paramètre est
true, il n'est pas possible d'utiliser certaines précise le nombre de pixels insérés en haut et
vspace
fonctionnalités dans la servlet ou la JSP appelée : il n'est en bas de l'applet
pas possible de modifier l'entête de la réponse (header,
précise la longueur de l'applet en pixel ou en
cookies) ou renvoyer ou faire suivre vers une autre Width
pourcentage
page.

Exemple : Pour fournir un ou plusieurs paramètres, il faut utiliser

dans le corps du tag <jsp:plugin> le tag <jsp:params>.
<html> Chaque paramètre sera alors défini dans un tag
<body> <jsp:param>.
<jsp:include page="[Link]"/>
<H1>Bonjour</H1>
Exemple :
<jsp:include page="[Link]"/>
</body> <jsp:plugin type="applet" code="[Link]"
</html> codebase="applets"
Il est possible de fournir des paramètres à la servlet ou à jreversion="1.1" width="200"
la JSP appelée en utilisant le tag <jsp:param>. height="200" >
<jsp:params>
<jsp:param name="couleur" value="eeeeee" />
</jsp:params>
3.8. Le tag <jsp:plugin> </jsp:plugin>
Ce tag permet la génération du code HTML nécessaire Le tag <jsp:fallback> dans le corps du tag <jsp:plugin>
à l'exécution d'une applet en fonction du navigateur : un permet de préciser un message qui sera affiché dans les
tag HTML <Object> ou <Embed> est généré en fonction navigateurs ne supportant pas le tag HTML <Object> ou
de l'attribut User-Agent de la requête. <Embed>.

Le tag <jsp:plugin> possède trois attributs obligatoires : 4. La gestion des erreurs

Attribut Rôle Lors de l'exécution d'une page JSP, des erreurs peuvent
survenir. Chaque erreur se traduit par la levée d'une
code permet de préciser le nom de classe exception. Si cette exception est capturée dans un bloc
try/catch de la JSP, celle ci est traitée. Si l'exception
contient une URL précisant le chemin absolu
n'est pas capturée dans la page, il y a deux possibilités
codebase ou relatif du répertoire contenant la classe ou
selon qu'une page d'erreur soit associée à la page JSP :
l'archive

type les valeurs possibles sont applet ou bean • sans page d'erreur associée, la pile d'exécution
de l'exception est affichée

Il possède aussi plusieurs autres attributs optionnels • avec une page d'erreur associée, une
dont les plus utilisés sont : redirection est effectuée vers cette JSP

Attribut Rôle La définition d'une page d'erreur permet de la préciser

dans l'attribut errorPage de la directive page des autres
permet de préciser l'alignement de l'applet : les JSP de l'application. Si une exception est levée dans les
align traitements d'une de ces pages, la JSP va
valeurs possibles sont bottom, middle ou top
automatiquement rediriger l'utilisateur va la page
archive permet de préciser un ensemble de ressources d'erreur précisée.
ENI Initiation à JSP Dr RV p.13

La valeur de l'attribut errorPage de la directive page doit  Le navigateur retourne cette information
contenir l'URL de la page d'erreur. Le plus simple est de (inchangée) lorsqu'il visite de nouveau le même
définir cette page à la racine de l'application web et de site (URL).
faire précéder le nom de la page par un caractère '/'  Ayant lu cette information, le serveur peut
dans l'url. identifier le client et lui fournir un certain nombre
Exemple : de facilités :
 achat en ligne
<%@ page errorPage="/[Link]" %>  authentification
 personnalisation de portail
5. La définition d'une page d'erreur  diriger les recherches d'un moteur
Une page d'erreur est une JSP dont l'attribut  Identification des utilisateurs (e-
isErrorPage est égal à true dans la directive page. Il commerce
est possible dans une telle page d'afficher un message
d'erreur personnalisé mais aussi d'inclure des  Durée de vie réglable
traitements liés à la gestion de l'exception : ajouter
l'exception dans un journal, envoie d'un mail pour son  Pas de menace sécuritaire ( Jamais interprété
traitement, ... ou exécuté : pas de virus)
 Un cookie est limité à 4KB et les navigateurs se
limitent à 300 cookies (20 par site) : pas de
Exemple :
surcharge de disque
<%@ page language="java"
 Bien pour rendre privées des données non
contentType="text/html" %>
sensibles
%@ page isErrorPage="true" %>
- nom, adresse,
<html>
<body>
<h1>Une erreur est survenue lors des ■ Eviter la saisie d’informations à répétition
traitements</h1> – login, password, adresse, téléphone…
<p><%= [Link]() %></p>
</body> Utilisation de cookies en JSP
</html>
En JSP, un cookie est un objet de la classe
[Link] utilisée pour créer un cookie
ayant pour Constructeur :
Exemple final : public Cookie(String name,String value)

Exemple : ● Création d'un cookie

Cookie unCookie = new Cookie("nom","martin");
[Link] [Link](unCookie);

<%@ page errorPage="[Link]" %> ● Récupération d'un cookie

<html> Cookie[] cookies = [Link]();
<body> if (cookies != null)
Calcul division par zero <% =10/0 %> for ( int i=0;i<[Link];i++ ){
</body> if (cookies[i].getName().equals("nom")){
String valeur = cookies[i].getValue();
[Link] break;
}
@ page isErrorPage="true" %> }
<html> }
<body>
<h1>Tentative de division par zéro</h1> ● Afficher la liste des cookies
</body>
</html> Cookie cookie = null;
Cookie[] cookieArray = [Link]();

5. Les cookies en JSP if(cookieArray != null)

 Un cookie est une information envoyée par un {
serveur web à un navigateur et sauvegardée par
%>
celui-ci sur le disque de sa machine
<p><b>Cookies Information</b></p>
<%
ENI Initiation à JSP Dr RV p.14

for(int i=0; i<[Link]; i++) - si uri="/", le cookie est valide pour

toutes les pages du serveur
{ cookie = cookieArray[i];
[Link]("CookieName :" + [Link]());
[Link]("CookieValue :" + [Link]()); Définit la valeur du cookie. Valeurs
avec différents caractères spéciaux
} (espace blanc, supports et
parenthèses, le signe égal, virgule,
}
guillemet, barres obliques, des points
setValue (String)
else d'interrogation, le signe «à», et point-
virgule) doit être évitée. Les valeurs
{ [Link]("Cookies is not added in the response");} vides ne peuvent pas se comporter
%> de la même manière sur tous les
navigateurs.

Attributs des cookies

Exemple d'utilisation de cookies
Un cookie est défini par son nom auquel est associée
une valeur. Nous allons écrire du code dans le fichier JSP pour
Il est possible d'y ajouter certains attributs et de les lire définir et afficher le cookie.
avec les méthodes [Link](…) Créer un formulaire
[Link](… suivantes : Voici le code du formulaire ([Link]) qui
invite l'utilisateur à entrer son nom.

Méthode Description <% @ Page language = "java"%>

<html>
Retourne le commentaire décrivant <head>
getComment () le but de ce cookie, ou null si aucun Formulaire d'entrée <title> Cookie </ title>
commentaire n'a été définie. </ Head>
<body>
<form method="post" action="[Link]">
Renvoie l'âge maximal spécifié du <p> <b> Entrez Votre Nom: </ b> <input type="text"
getMaxAge ()
cookie. name="username"> Photos
<input type="submit" value="Submit">
getName () Retourne le nom du cookie.
</ Form>
Renvoie le préfixe de toutes les URL
getPath ()
pour lesquelles ce cookie est ciblé. </ Body>

getValue () Retourne la valeur du cookie. Voici le code du fichier de [Link] qui permet
de créer le cookie:
Si un navigateur Web présente ce
<% @ Page language = "java" import = "[Link].
cookie à un utilisateur, le but de
setComment (String) *"%>
l'cookie sera décrit en utilisant ce
<%
commentaire.
String username = [Link]
("username");
Définit l'âge maximum du cookie if (username == null) username = "";
(durée de vie dans le disque) . Le
cookie expirera après que plusieurs Date now = new Date ();
secondes se sont écoulées. Les String timestamp = [Link] ();
valeurs négatives indiquent le Cookie cookie = new Cookie ("username",
setMaxAge (int)
comportement par défaut: le cookie username);
n'est pas stocké persistante, et sera [Link] (365 * 24 * 60 * 60);
supprimé lorsque le navigateur Web [Link] (cookie);
de l'utilisateur sort. Une valeur de %>
zéro provoque le cookie à supprimer
<html>
- définit le chemin dans le domaine
setPath (String uri) <head>
pour lequel le cookie est valide
<title> Cookie enregistré </ title>
- par défaut, le cookie est valide pour
</ Head>
la page qui le définit et toutes les
<body>
pages du répertoire du dessous
ENI Initiation à JSP Dr RV p.15

<p> <a href="[Link]"> Page ENREGISTREMENT DE VARIABLE DANS LA SESSION

suivante pour afficher la valeur du cookie </ a> <p>
</ Body> FICHIER [Link]

<%@ page session="true" %>

Voici le code de la page qui affiche la cookie <%
([Link]) String nomForm =
[Link]( "nomUsager" );
<% @ Page language = "java"%> [Link]( "nom", nomForm );
<% %>
String cookieName = "username"; <html>
Cookie cookies [] = [Link] (); <head>
Cookie myCookie = null; <title> Exemple de session - page d'enregistrement de
if (cookies != null) variable </title>
{ </head>
for (int i = 0; i < [Link]; i++) <body>
{ <a href="[Link]">Continue</a>
if (cookies [i].getName().equals (cookieName)) </body>
{ </html>
myCookie = cookies[i];
break; RECUPERATION DE VARIABLE DANS LA SESSION
} FICHIER [Link]
}
} <%@ page session="true" %>
%> <% String nomUsager = (String)
<html> [Link]("nom"); %>
<head> <html>
<title> Afficher les fichiers Cookie </ title> <head>
</ Head> <title> Exemple de session - page de recuperation de
<body> variable </title>
<% </head>
if (myCookie == null) { <body>
%> Salut, <%= nomUsager %>
Pas de Cookie trouvé avec le nom <% = cookieName%> </body>
<% </html>
} else {
%>
<p> Bienvenue: <% = [Link] ()%>. Exemple 2 : VARIABLE DE TYPE PRIMITIF
<% STOCKEE DANS UNE SESSION
}
%> <%@ page session="true" %>
</ Body> </html> <%
int compteur;
Integer compteurInteger = (Integer)
[Link]("compteur");
6. Les sessions en JSP compteur = (compteurInteger != null) ?
Exemple 1 : [Link](): 0;
FICHIER [Link] compteur++;
[Link]("compteur",new
<%@ page session="true" %> Integer(compteur));
<html> %>
<head> <html>
<title> Page du debut de la session </title> <head>
</head> <title> Exemple de session </title>
<body> </head>
<form method="post" action="[Link]"> <body>
Quell est votre nom? <input type="text" <table>
name="nomUsager" size="20" /> <th align="left" >Nombre de fois que cette page a
<input type="submit" value="Soumettre"/> &eacute;t&eacute; visit&eacute;e </th>
</form> <td> <%= compteur %> </td>
</body> </tr>
</html> </table>
</body>
 ENI Initiation à JSP Dr RV p.16

</html> </font>
</body>
Exemple3 : </html>

[Link] :

package essai;
T ACTION="page2jsp"> import [Link];
import [Link].*;
AME="nom">
public class Bean1 {
AME="solde"> Calendar calendar = null;
VALUE="SUBMIT">
public Bean1() {
calendar = [Link]();
g) Date daty = new Date();
omme"); [Link](daty);
tSolde=”0” ; }

public int getNom() {

de"> return "RABE JEAN";
}

public int getYear() {

return [Link]([Link]);
}

public String getMonth() {

int m = getMonthInt();
String[] months = new String [] { "January", "February",
getParameter("solde")); "March", "April", "May", "June",
"July", "August", "September",
om,solde) dans une table "October", "November", "December" };
soldes if (m > 12)
return "Unknown to Man";
somme",TotSolde) ; return months[m - 1];
}
[Link]">
public int getMonthInt() {
return 1 + [Link]([Link]);
}

1) Exemple [Link] public String getDate() {

return getMonthInt() + "/" + getDayOfMonth() + "/" +
<html> getYear();
<body bgcolor="white"> }
<jsp:useBean id='clock' scope='page'
class='essai.Bean1' type="essai.Bean1" /> public String getTime() {
<font size=4> return getHour() + ":" + getMinute() + ":" + getSecond();
<ul> }
<li> NOM: is <jsp:getProperty name="clock" public int getDayOfMonth() {
property="nom"/> return
<li> Year: is <jsp:getProperty name="clock" [Link](Calendar.DAY_OF_MONTH);
property="year"/> }
<li> Month: is <jsp:getProperty name="clock" public int getDayOfYear() {
property="month"/> return [Link](Calendar.DAY_OF_YEAR);
<li> Time: is <jsp:getProperty name="clock" }
property="time"/> public int getHour() {
<li> Date: is <jsp:getProperty name="clock" return [Link](Calendar.HOUR_OF_DAY);
property="date"/> }
</ul> public int getMinute() {
ENI Initiation à JSP Dr RV p.17

return [Link]([Link]);
} public void setNom(String nom) { [Link]=nom; }
public int getSecond() {
return [Link]([Link]); public boolean getSuccess() {
} if (note<10) return false;
} else return true;
}

2) Exemple [Link] public String getResultat() {

return “ ECHEC”;
<%@ page import = "essai.Bean2" %> }
}
<jsp:useBean id="bean" class="essai.Bean2"
scope="session"/>
<jsp:setProperty name="bean" property="*"/> Exemple 3 d’utilisation de JavaBeans contenant les
méthodes de manipulation d’une base de données
<html> ( modèle MVC
<head><title>Exemple Bean</title></head>
<body bgcolor="white"> VUE : FORMULAIRE
<font size=4>
Le nom ...=<jsp:getProperty name="bean" <html>
property="nom"/> <head>
Le nom ...=<%= [Link]() %> <title> Validation au serveur </title>
La note...=<jsp:getProperty name="bean" </head>
property="note"/> <body>

<% if (! [Link]()) { %>

<form name="form" action="[Link]" method="post">
Vous êtes <%= [Link]() %> <p>
<% } <b>Codecli:</b> <input type="text" name="codecli"
else if ([Link]()) { %> Value=""> <br>

Vous avez une note comprise entre 10 et 20<p> <b>Nom :</b><input type="text" name="nom"
Vous êtes admis en classe supérieure<p> value="" /> <br>
<% } %>
<b>Adresse:</b><input type="text" name="adresse"
<form method=get> value="" /> <br>
Votre nom <input type=text name=nom> <br>
Votre note<input type=text name=note> <b>Solde :</b><input type="text" name="solde"
<input type=submit value="Submit"> value="" >
</form> <br>
</font> <p> </p>
</body>
</html> <input type="submit" name="BT" value="Ajouter" >
[Link] <input type="submit" name="BT" value="Supprimer" >
<input type="submit" name="BT" value="Modifier" >
package Bean2; <input type="submit" name="BT" value="Consulter" >
<input type="submit" name="BT" value="Lister" >
import [Link].*;
<br>
public class Bean2 { </form>
int note; </body>
String nom; </html>

public Bean2() {
note=0;
} MODELE : Fichier JavaBeans : [Link]

public void setNote(int a) { [Link] = a; }

package TClient;
public int getNote() { return [Link] ;} import [Link].*;
import [Link].*;
public String getNom() { return nom; } import [Link].*;
ENI Initiation à JSP Dr RV p.18

import [Link].*; connection();

try{
public class BeanClient{ rescom=[Link]("Insert into client
values(' "+[Link]+" ' , ' "+[Link]+ " ' , ' "+
//variable client [Link]+"' ,' "
public String Codecli; + [Link]+" ' ) ");
public String Nom; return"enregistrement client réussi";
public String Adresse; }
public int Solde; catch(Exception e2){return"client déja
Connection con = null; existant"+[Link](); }
Statement statement = null; }//fin ajouTclient
Statement st = null;
ResultSet res = null;
ResultSet rescom = null; public String ModifClient()
public BeanClient(){//debut constructeur {
[Link] = ""; connection();
[Link] = ""; try{
[Link] = "";
[Link] =0; res=[Link](" update client set
}//fin constructeur Nom=' " +[Link]+
" ' ,Adresse= ' "+[Link]+" ',Solde='
public void connection(){ "+[Link]+" ' where Codecli=' "+[Link]+" '
String url ="jdbc:odbc:Base_dsn"; ");
try{
[Link]("[Link]"); return "modification client
con = [Link](url,"",""); reuissi";
statement = [Link](); }//fin try
st = [Link](); catch(Exception e){
return"erreur de
}//fin try modification"+[Link]();
catch(Exception e1) }
{ [Link]([Link]());} }//fin modification client
}//fin connection
//fin resaka client

public void setCodecli(String _Codecli){ }//fin class BeanClient

[Link] = _Codecli;
}
CONTROLEUR : [Link] (PAGE DE
public String getCodecli(){ RECUPERATION
return([Link]); }
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML
public void setNom(String _Nom){ 4.01 Transitional//EN">
[Link] = _Nom; }
<html>
public String getNom(){ return([Link]); <head> <title>modifClient</title>
} </head>

public void setAdresse(String _Adresse){ <body>

[Link] = _Adresse; <%
} String Vcodecli = [Link]("Codecli");
public String getAdresse(){ String Nom1 = [Link]("Nom");
return([Link]); String Adresse1 = [Link]("Adresse");
} String VSolde = [Link]("Solde");
String BT= [Link]("BT");
public void setSolde(int Solde){ [Link] = Solde; %>
} <jsp:useBean id="obj_client" scope="request"
public int getSolde(){ return([Link]); class="[Link]"/>
}
<%
// ajout client try{
public String AjoutClient() if([Link]("Modifier")){
{ int t= [Link](VSolde);
ENI Initiation à JSP Dr RV p.19

obj_client.setCodecli(Vcodecli); value="<jsp:getProperty name="form"

obj_client.setNom(Nom1); property="email"/>" />
obj_client.setAdresse(Adresse1); <b>Courriel</b> (user@host)</br>
obj_client.setSolde(t);
[Link](""); <input type="text" name="ssn"
%> value="<jsp:getProperty name="form"
property="ssn"/>"/>
<font color="blue"><%=obj_client.ModifClient() <b>NAS</b> (123456789)</br>
%></font> <p>
<% <input type="submit" value="Soumettre" />
}//fin if </form>
else </body>
If if([Link]("Ajouter")){ //code ………} </html>
else
If if([Link]("Ajouter")){ // code ………}
REMARQUE :
A la place de value="<jsp:getProperty name="form"
}//fin try property="name"/>" , on peut écrire
value="<%= [Link]() %> "
catch(Exception e){
[Link]("");
[Link]("erreur eto ve"+[Link]());
} FICHIER JAVA BEAN : [Link]
%>
<jsp:forward page="[Link] "/> package form;
</body>
</html> public class FormBean {
private String name;
private String email;
private String ssn;
TP1 : VALIDATION COTE SERVEUR
public FormBean() {
FICHIER [Link] name = "";
email = "";
<jsp:useBean id="form" class="[Link]"> ssn = "";
<jsp:setProperty name="form" property="*"/> }
</jsp:useBean> public void setName(String name) {
<html> [Link] = name;
<head> }
<title> Validation au serveur </title>
</head> public String getName() {
<body> return name; }

<% public void setEmail(String email) {

String[] errors = (String[])[Link]("errors"); [Link] = email;
if (errors != null && [Link] > 0) { }
%>
<b> S'il vous pla&icirc;t, corrigez les erreurs public String getEmail() {
suivantes</b> return email;}
<ul>
<% for (int i=0; i < [Link]; i++) { %> public void setSsn(String ssn) {
<li> <%= errors[i] %> </li> [Link] = ssn;}
<% } %>
</ul> public String getSsn() {
<% } %> return ssn;
<form action="[Link]" method="post"> }
<input type="text" name="name" }
value="<jsp:getProperty name="form"
property="name"/>" /> FICHIER [Link]
<b>Nom</b> (Nom de Famille, Pr&eacute;nom)</br>
<%@ page import="[Link],[Link]"
<input type="text" name="email" %>
<%!
ENI Initiation à JSP Dr RV p.20

private boolean isValidSSN(String ssn) { <b>NAS: </b><jsp:getProperty name="form"

// check for 9 characters, no dashes property="ssn"/><br>
return ([Link]() == 9 && [Link]("-") == -1); </ul>
} </body>
</html>
private boolean isValidEmail(String email) {
// check an "@" somewhere after the 1st character TP2 :MANIPULATION D’UNE BASE DE DONNEEES
return ([Link]("@") > 0);
}
FICHIER [Link]
private boolean isValidName(String name) {
// should be Last, First - check for the comma <html>
return ([Link](",") != -1); <head>
} <title> Validation au serveur </title>
%> </head>
<% <body>
Vector errors = new Vector();

String name = [Link]("name"); <form name="form"

String ssn = [Link]("ssn"); action="/examples/[Link]"
String email = [Link]("email"); method="post">

if (! isValidName(name)) <b>Codecli:</b> <input type="text" name="codecli"

[Link]("Le nom doit &ecirc;tre sp&eacute;cifier Value=""> <br>
comme suit: Nom de Famille, Pr&eacute;nom");
if (! isValidEmail(email)) <b>Nom :</b><input type="text" name="nom"
[Link]("Le courriel doit avoir le symbole @ "); value="" /> <br>
if (! isValidSSN(ssn))
[Link]("Le NAS ne doit pas avoir de tir&eacute; <b>Adresse:</b><input type="text" name="adresse"
et doit avoir 9 chiffres"); value="" /> <br>

String next; <b>Solde :</b><input type="text" name="solde"

if ([Link]() == 0) { value="" >
// data is OK <br>
// dispatch to thanks <p> </p>
next = "[Link]";
} <input type="submit" name="BT" value="Ajouter" >
else { <input type="submit" name="BT" value="Supprimer" >
// data has errors, try again <input type="submit" name="BT" value="Modifier" >
String[] errorArray = (String[])[Link](new <input type="submit" name="BT" value="Consulter" >
String[0]); <input type="submit" name="BT" value="Lister" >
[Link]("errors", errorArray);
next = "[Link]"; <br>
} </form>
%> </body>
<jsp:forward page="<%= next %>" /> </html>

PAGE [Link] PAGE DE VALIDATION ([Link] )

<jsp:useBean id="form" class="[Link]"> <%@ page import="[Link].*" %>

<jsp:setProperty name="form" property="*"/> <%@ page import="[Link].*" %>
</jsp:useBean> <%@ page import="[Link].*" %>
<html> <%@ page session="true" %>
<body bgcolor="white">
<b>Merci beaucoup! Votre formulaire a <html>
&eacute;t&eacute; bien re&ccedil; </b> <head>
<ul> <title> Validation au serveur </title>
</head>
<b>Nom: </b><jsp:getProperty name="form" <body>
property="name"/><br>
<b>Courriel: </b><jsp:getProperty name="form" <%
property="email"/><br> int nb ;
ENI Initiation à JSP Dr RV p.21

double s ; [Link]();
Connection con=null; [Link]();
Statement statement = null; }
ResultSet res =null; catch(Exception e) {
ResultSet rescom =null; [Link]("ERROR DELETE");
String requete ; }
}
String mcodecli = (String) else
[Link]("codecli"); if ([Link]("Modifier"))
String mnom = (String) [Link]("nom"); {
String madresse = (String) // MODIFIER
[Link]("adresse"); try {
String msolde = (String) nb =[Link]("UPDATE client set nom
[Link]("solde"); =' " +mnom+"' , " +" adresse= ' " +madresse+" ',"+
if ([Link]("") || msolde==null) "solde= "+ s + " WHERE codecli= ' " +mcodecli+ " ' ");
s=0; [Link]("<h3> ENREGISTREMENT MODIFIE </h3>
else ");
s= [Link](msolde); [Link]();
if ([Link]("") || mcodecli==null) [Link]();
[Link]("LE CODE DU CLIENT EST NUL "); }
else catch(Exception e) {
{ [Link]("ERROR UPDATE");
}
String url ="jdbc:odbc:veno"; }
try { else
[Link]("[Link]");
con =[Link](url,"",""); if ([Link]("Consulter"))
statement=[Link](); {
} // CONSULTER
catch(Exception e) { if ([Link]("") || mcodecli==null)
[Link]("ERROR CONNEXION"); return: } [Link]("Selectionnez un client svp ");
else{
String bt = [Link]("BT"); try {
if ([Link]("Ajouter")) res =[Link]("select * from client where
{ codecli=' "+mcodecli+" ' ");
// AJOUTER if (res==null)
try { [Link]("<h3> CODE INCORRECT </h3> ") ;
requete ="INSERT INTO else
client(codecli,nom,adresse,solde) VALUES( "+" ' {
"+mcodecli +" ',' " +mnom +" ' ,' "+madresse+ [Link]();
" ',"+s+")"; mnom= [Link]("nom");
nb =[Link](requete); madresse =[Link]("adresse");
[Link]("<h3> ENREGISTREMENT AJOUTE </h3> msolde= (new
"); Double([Link]("solde"))).toString();
[Link](); [Link]("<h3> CODECLI : " + mcodecli+"</h3>
[Link](); <BR>");
} [Link]("<h3> NOM : " + mnom+"</h3> <BR>");
catch(Exception e) { [Link]("<h3> ADRESSE : " +
[Link]("<h3> ENREGISTREMENT DEJA madresse+"</h3><BR>");
EXISTANT </h3> "); [Link]("<H3>SOLDE : " + msolde+"</h3> <BR>");
} }
} [Link]();
else [Link]();
if ([Link]("Supprimer")) [Link]();
{ }
// SUPPRIMER
try { catch(Exception e) {
nb =[Link]("DELETE FROM [Link]("<h3> CODE CLIENT INCORRECT </h3> ");
commande where codecli = ' " + mcodecli + " ' " ); }
nb =[Link]("DELETE FROM cLIENT }
where codecli = ' " + mcodecli + " ' "); }
[Link]("<h3> ENREGISTREMENT SUPPRIME else
</h3> "); // LISTER
ENI Initiation à JSP Dr RV p.22

if ([Link]("Lister")) ResultSet res =null;

{ ResultSet rescom =null;
%> ResultSetMetaData metaData;
<TABLE Border="1"> double SumSolde=0;
<tr> double QteTot=0 ;
<th><b><i>NOM</i></b></th> double MontantTot=0 ;
<th><b><i>LIBELLE</i></b></th> String message ;
<th><b><i>PU</i></b></th> // Connection à la base
<th><b><i>QTE</i></b></th>
<th><b><i>MONTANT</i></b></th> String codecli = (String)[Link]("codecli");
</tr> String nom = (String)[Link]("nom");
String adresse =
<% (String)[Link]("adresse");
try String solde= (String)[Link]("solde");
{ message= (String)[Link]("message");
rescom =[Link]("select if (message==null) message="NO ERROR" ;
[Link],Nom,Adresse,Libelle,Pu,Qte,qte*Pu as try {
Montant from client,commande,produit where [Link]("[Link]");
[Link]=[Link] and con =[Link](url,"","");
[Link]=[Link] Order by nom"); statement = [Link]();
while ([Link]()) { }
%>
<tr> catch (ClassNotFoundException ex) {
<td><b><i><%=[Link]("nom") message="Cannot find the database driver
%></i></b></td> <td><b><i>< classes.";
%=[Link]("Libelle")%></i></b></td>
<td><b><i><%=[Link]("Pu")%></i></b></td> }
<td><b><i><%=[Link]("qte")%></i></b></td> catch (SQLException ex) {
<td><b><i><%=[Link]("Montant")%></i> message="Cannot connect to this database.";
</b></td> }
</tr>
<% if (con == null || statement == null) {
} message="There is no database to execute the
%> query.";
</TABLE> return;
<% [Link]();[Link]();[Link](); }
} %>
catch(Exception e) <%
{ [Link]("<h3> Error de lecture Commande </h3> if (codecli==null) {
") ; } try {
} res =[Link]("select sum(solde) as
// Fin Lister SumSolde from Client ");
} [Link]();
%> SumSolde =[Link]("SumSolde");
</BODY> [Link]();
</HTML> res =[Link]("select * from Client ");
[Link]();
TP 3 : UTILISATION D'UNE SESSION codecli =[Link]("codecli");
nom =[Link]("nom");
<%@ page import ="[Link].*" %> adresse =[Link]("adresse");
<%@ page import ="[Link].*" %> solde =[Link]("solde");
<%@ page session="true" %> [Link]();
}
<html> catch(Exception e) { message="Error IO Client" ; }
<head> }
<title> Validation au serveur </title> %>
</head>
<body> <form name="form" action="/examples/[Link]"
method="post">
<%
String url ="jdbc:odbc:veno"; <b>Selectionnez un client:</b>
Connection con=null; <select name="liste" size="1">
Statement statement = null; <%
ENI Initiation à JSP Dr RV p.23

try {
res =[Link]("select codecli,nom from rescom =[Link]("select
Client order by nom "); [Link],Nom,Adresse,Libelle,Pu,Qte,qte*Pu as
while ([Link]()){ %> Montant from client,commande,produit where
<option value="<%=[Link]("codecli")%>"> [Link]=[Link] and
<%= [Link]("nom")%> [Link]=[Link] Order by nom");
</option> QteTot=0;
<% while ([Link]()){
} if ([Link]([Link]("codecli")))
%> {QteTot+=[Link]("Qte");
</select> }
<% [Link](); %> }
<% } [Link]();
catch(Exception e) %>
{ message="Error LISTE" ; }
%> <tr>
<th><b><i>NOM</i></b></th>
<br><br> <th><b><i>LIBELLE</i></b></th>
<th><b><i>PU</i></b></th>
<b>Codecli:</b> <input type="text" name="codecli" <th><b><i>QTE</i></b></th>
onKeypress="if ([Link]==13 && <th><b><i>MONTANT</i></b></th>
[Link]==13) [Link]();" </tr>
value="<%= codecli%>" /> <br>
<%
<b>Nom :</b><input type="text" name="nom" rescom =[Link]("select
value="<%= nom %>" /> <br> [Link],Nom,Adresse,Libelle,Pu,Qte,qte*Pu as
Montant from client,commande,produit where
<b>Adresse:</b><input type="text" name="adresse" [Link]=[Link] and
value="<%= adresse %>" /> <br> [Link]=[Link] Order by nom");
<b>Solde :</b><input type="text" name="solde" while ([Link]()){
value="<%=solde%>" /> if ([Link]([Link]("codecli")))
<br> {
<p> </p> %>
<input type="reset" name="nouveau" <tr>
value="Nouveau" /> <td><b><i><%=[Link]("nom")%></i></b>
<input type="submit" name="BT" value="Ajouter" /> </td><td><b><i><%=[Link]("Libelle")
<input type="submit" name="BT" value="Supprimer" /> %></i></b></td>
<input type="submit" name="BT" value="Modifier" /> <td><b><i><%=[Link]("Pu")%></i></b></td>
<input type="submit" name="BT" value="Consulter" /> <td><b><i><%=[Link]("qte")%></i></b></td>
<br> <td><b><i><%=[Link]("Montant")%></i>
<b>Message :</b><input type="text" size="40" </b></td>
name="message" value="<%=message%>" /> <br> </tr>
</form> <%
<table border="2">
<% }
%>
// Parcours de la requete Commande <%
try { }
%>
rescom =[Link]("select
[Link],Nom,Adresse,Libelle,Pu,Qte,qte*Pu as <%
Montant from client,commande,produit where [Link]();
[Link]=[Link] and [Link]();
[Link]=[Link] Order by libelle"); [Link]();
MontantTot=0; }
QteTot=0;
while ([Link]()){ catch(Exception e)
if ([Link]([Link]("codecli"))) { message="Error de lecture Commande" ; }
{MontantTot+=[Link]("Pu")*[Link]("Qte"); %>
// QteTot+=[Link]("Qte");
} <br>
} <tr>
[Link](); <td>&nbsp;</td>
ENI Initiation à JSP Dr RV p.24

<td>&nbsp;</td> try {
<td>MONTANT TOTAL </td> requete ="INSERT INTO
<td>&nbsp;</td> client(codecli,nom,adresse,solde) VALUES("+
<td><%= MontantTot+" Fmg" %></td> "'"+mcodecli +"','" +mnom +"','"+madresse+" ',"+s+")";
</tr> nb =[Link](requete);
messages="ENREGISTREMENT AJOUTE";
<tr> [Link]();
<td>&nbsp;</td> [Link]();
<td>&nbsp;</td> }
<td>QTE TOTAL </td> catch(Exception e) {
<td><%= QteTot%></td> messages="ENREGISTREMENT DEJA EXISTANT";
<td>&nbsp;</td> }
}
</tr> else
</TABLE> if ([Link]("Supprimer"))
</body> {
</html> try {
nb =[Link]("DELETE FROM
commande where codecli = '" + mcodecli + "'");
FICHIER [Link]
nb =[Link]("DELETE FROM cLIENT
<%@ page import="[Link].*" %> where codecli = '" + mcodecli + "'");
<%@ page import="[Link].*" %> messages="ENREGISTREMENT SUPPRIME";
<%@ page import="[Link].*" %> [Link]();
<%@ page session="true" %> [Link]();
}
<html> catch(Exception e) { messages="ERROR DELETE";}
<head> }
<title> Validation au serveur </title> else
</head> if ([Link]("Modifier")){
<body> try {
<% nb =[Link]("UPDATE client set nom
int nb ; double s ; =' " +mnom+" '," +" adresse=' " +madresse+" ',"+ "solde=
Connection con=null; Statement statement = null; "+ s + " WHERE codecli=' " +mcodecli+ " ' " );
ResultSet res =null; messages="ENREGISTREMENT MODIFIE";
String requete ; [Link]();
[Link]();
String mliste = (String) [Link]("liste"); }
String mcodecli =(String) catch(Exception e) {
[Link]("codecli"); messages="ERROR UPDATE";
String mnom = (String) [Link]("nom"); }
String madresse = (String) }
[Link]("adresse"); else
String msolde = (String) [Link]("solde"); if ([Link]("Consulter"))
String messages ="OPERATION REUSSIE" ; {
if ([Link]("") || msolde==null) if ([Link]("") || mliste==null)
s=0; { messages="Selectionnez un client svp ";
else }
s= [Link](msolde); else
if ([Link]("") || mcodecli==null) {
messages="LE CODE DU CLIENT EST NUL "; try {
else res =[Link]("select * from client where
{ codecli='"+mliste+"'");
String url ="jdbc:odbc:DsnEssai"; [Link]();
try { mcodecli= [Link]("codecli");
[Link]("[Link]"); mnom= [Link]("nom");
con =[Link](url,"",""); madresse =[Link]("adresse");
statement=[Link](); msolde= (new
} Double([Link]("solde"))).toString();
catch(Exception e) { [Link]();
messages="ERROR CONNEXION"; [Link]();
} [Link]();
String bt = [Link]("BT"); }
if ([Link]("Ajouter")){ catch(Exception e) {
ENI Initiation à JSP Dr RV p.25

messages="ERROR CONSULTER";
}
}
}
}
// data is OK
// dispatch to thanks
[Link]("codecli", mcodecli);
[Link]("nom", mnom);
[Link]("adresse", madresse);
[Link]("solde",msolde );
[Link]("message",messages );
%>
<jsp:forward page="[Link]" />
</BODY>
</HTML>

7. Packager une application web

Le format war (Web Application Archive) indépendant de

toute plate-forme et exploitable par tous les conteneurs
web ,permet de regrouper en un seul fichier tous les
éléments d'une application web que ce soit pour le côté
serveur (servlets, JSP, classes java, ...) ou pour le côté
client (ressources HTML, images, son ... ).

Le but principal est de simplifier le déploiement d'une

application web et d'uniformiser cette action quel que
soit le conteneur web utilisé.
Le nom du fichier .war est important car ce nom sera
7.1. La structure d'un fichier .war automatiquement associé dans l'url pour l'accès à
l'application en concaténant le nom du domaine, un
Comme les fichiers jar, les fichiers war possèdent une slash et le nom du fichier war. Par exemple, pour un
structure particulière qui est incluse dans un fichier serveur web sur le poste local avec un fichier [Link]
compressé de type "zip" possédant comme extension déployé sur le serveur d'application, l'url pour accéder à
".war". l'application web sera [Link]

Le répertoire WEB-INF et le fichier [Link] qu'il contient

doivent obligatoirement être présents dans l'archive. Le
fichier [Link] est le descripteur de déploiement de
l'application web.

Le répertoire WEB-INF/classes est automatiquement

ajouté par le conteneur au CLASSPATH lors du
déploiement de l'application web.

L'archive web peut être créée avec l'outil jar fourni avec
le JDK ou avec un outil commercial. Avec l'outil jar, il
suffit de créer l'arborescence de l'application, de se
placer dans le répertoire racine de cette arborescence et
d'exécuter la commande :

jar cvf nom_web_app.war .

Toute l'arborescence avec les fichiers qu'elle contient

sera incluse dans le fichier nom_web_app.war.

7.2. Le déploiement d'une application web

Le déploiement d'une archive web dans un serveur

d'application est très facile car il suffit simplement de
copier le fichier .war dans le répertoire par défaut dédié
aux applications web. Par exemple dans Tomcat, c'est
le répertoire webapps. Attention cependant, si chaque
ENI Initiation à JSP Dr RV p.26

conteneur qui respecte les spécifications 1.1 des JSP développement de l'application car il n'est alors pas
sait utiliser un fichier .war, leur exploitation par chaque obligatoire de générer l'archive web à chaque
conteneur est légèrement différente. modification pour réaliser des tests. Attention, si
l'application est redéployée sous la forme d'une
Par exemple avec Tomcat, il est possible de travailler archive .war, il faut obligatoirement supprimer le
directement dans le répertoire webapps avec le contenu répertoire qui contient l'ancienne version de l'application.
de l'archive web décompressé. Cette fonctionnalité est
particulièrement intéressante lors de la phase de

8. Intégration du serveur Tomcat dans Eclipse

Ce tutorial a pour objet de présenter la configuration d'Eclipse pour développer des applications web sous Tomcat. Il
commence par l'installation du plugin Tomcat dans Eclipse, puis la prise en charge pas Eclipse d'un serveur Tocmat.
Enfin, on montre comment créer un premier projet Web sous Eclipse, et sa mise au point sous Tomcat.

1. Création d'un serveur Tomcat sous Eclipse

Avant de créer ce serveur, on doit s'assurer que le plugin Tomcat est bien installé dans Eclipse. Cela se passe dans la
fenêtre des Preferences d'Eclipse, à laquelle on peut accéder dans le menu Windows.

Figure 1. Ouvir les préférences d'Eclipse

Cette fenêtre comporte énormément d'options, que l'on peut filtrer. La capture d'écran suivante montre celle qui nous
intéresse : les Server Runtime Environments.
ENI Initiation à JSP Dr RV p.27

Figure 2. Ouvrir le panneau des serveurs disponibles

Pour le moment aucun serveur n'est disponible, ce qui est normal, puisque l'on en n'a déclaré aucun.

Cliquer sur le bouton Add... ouvre la liste des plugins qu'Eclipse possède déjà. Si Tomcat n'apparaît pas dans cette liste,
on peut la compléter par téléchargement en clique sur le lien Download additional server adapters, en haut droite de ce
panneau.

Dans notre cas, les plugins pour les différentes versions de Tomcat sont déjà présents, on sélectionne celui qui
correspond à la version 6 de Tomcat.
ENI Initiation à JSP Dr RV p.28

Figure 3. Sélection de Tomcat version 6

L'étape suivante consiste à indiquer à Eclipse où se trouve le répertoire d'installation de Tomcat. On peut le préciser en
cliquant sur le bouton Browse... et en allant sélectionner le bon répertoire.

Une fois le répertoire validé, l'installation de Tomcat que l'on a spécifiée apparaît dans la liste des Server Runtime
Environments.
ENI Initiation à JSP Dr RV p.29

Figure 4. L'installation de Tomcat dans Eclipse est validée

Notre installation est validée, nous allons pouvoir passer à l'étape suivante.

2. Création d'un premier projet Web

Un projet Web est un type de projet spécial sous Eclipse. Spécial, en ce sens qu'il est attaché à un serveur d'applications
(ici Tomcat, ce pourrait être un autre serveur), et qu'il expose des fonctionnalités particulières pour créer des servlets, des
pages, ou des services web (que nous ne présenterons pas ici).

La création d'un projet Web débute comme un projet Eclipse normal. Comme il ne s'agit pas d'un projet Java classique,
on sélectionne la rubrique Project... du sous-menu New.
ENI Initiation à JSP Dr RV p.30

Figure 5. Création d'un projet web - 1

Dans le panneau qui s'ouvre, on sélectionne alors Dynamic Web Project, sous le nœud Web.
ENI Initiation à JSP Dr RV p.31

Figure 6. Création d'un projet web - 2

Le panneau qui s'ouvre alors est un peu plus compliqué que celui d'un projet Java classique. En particulier, il nous
demande de choisir le serveur que ce projet va utiliser pour fonctionner. Dans notre exemple, on sélectionne le serveur
Tomcat que l'on vient de créer. La version de l'API Servlet est sélectionnée automatiquement : 2.5, version la plus
récente supportée par Tomcat v6.
ENI Initiation à JSP Dr RV p.32

Figure 7. Création d'un projet web - 3

Le panneau suivant nous demande dans quel répertoire on souhaite ranger nos fichier source. On conserve le choix par
défaut : le répertoire src.
ENI Initiation à JSP Dr RV p.33

Figure 8. Création d'un projet web - 4

Le dernier panneau nous demande dans quel répertoire on souhaite ranger les ressources de ce projet web : le répertoire
WebContent. C'est dans ce répertoire que l'on pourra ranger les différentes ressources de notre projet : pages HTML,
tout fichier multimedia, fichier Javascript, etc...

On peut également générer automatiquement le fichier [Link] de notre application web, ce qui une commodité offerte
par Eclipse. Ce fichier sera rangé automatiquement dans WebContent/WEB-INF.
ENI Initiation à JSP Dr RV p.34

Figure 9. Création d'un projet web - 5

Une fois notre projet créé, Eclipse nous demande si l'on souhaite utiliser la perspective Java EE. Cette perspective est
bien adaptée au développement des projets Java EE (elle est même faite pour ça !), on accepte donc cette proposition.

Figure 10. Utilisation de la perspective Java EE

ENI Initiation à JSP Dr RV p.35

Sur la partie gauche de cette perspective, se trouve la vue Project Explorer (qui ressemble beaucoup à Package
Explorer), dans laquelle notre nouveau projet apparaît.

Figure 11. Structure de notre projet dans la vue Project Explorer

Notre projet est maintenant créé, et l'on va pouvoir passer à l'étape suivante : créer une première servlet.

3. Création d'une première servlet

La perspective Java EE nous montre une frise d'icône qui nous permet de créer directement des classes Java de servlet.
C'est que nous allons utiliser pour notre première servlet.

La première rubrique du menu qui s'ouvre est celle qui nous permet de créer une servlet.

Figure 12. Création d'une première servlet

Un panneau s'ouvre alors, qui nous permet de spécifier la classe de cette servlet : son nom, et le nom du package dans
lequel cette classe sera placée. Une servlet étend nécessairement HttpServlet, on ne doit donc prendre garde à ce point
si l'on modifie la classe qu'étend notre servlet.
ENI Initiation à JSP Dr RV p.36

Figure 13. Création d'une première servlet : fixer la classe

Le panneau suivant nous permet de fixer les informations sur cette servlet, qui seront écrites dans le fichier [Link] de
notre application.

• Le nom de notre servlet, utilisé pour s'y référer dans le fichier [Link].

• Ses paramètres d'initialisation.

• Le (ou les) paramètres URL mappings, qui fixeront l'URL à laquelle notre servlet sera disponible.
ENI Initiation à JSP Dr RV p.37

Figure 14. Création d'une première servlet : fixer ses paramètres

Le dernier panneau de création précise le contenu de la classe qu'Eclipse va nous générer. Par commodité, Eclipse peut
créer pour nous différentes méthodes standard de notre servlet, telles que init(), doGet() ou doPost().
ENI Initiation à JSP Dr RV p.38

Figure 15. Création d'une première servlet : méthodes à générer

Une fois ces étapes déroulées, notre classe de servlet est créée, et apparaît dans la structure de notre projet.

Figure 16. Servlet créée dans la structure du projet

Le fichier [Link] a bien été modifié, et prend bien en compte la servlet qui vient d'être créée.
ENI Initiation à JSP Dr RV p.39

Figure 17. Servlet déclarée dans le fichier [Link]

Notre servlet est très simple, son code est le suivant.

Exemple 1. Code d'une première servlet

public class HelloWorld extends HttpServlet {

protected void doGet(

HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {

PrintWriter pw = [Link]() ;
[Link]("Hello world !") ;
}

protected void doPost(

HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {

doGet(request, response) ;
}
}

Une fois cette classe créée, il nous reste à la faire fonctionner dans Tomcat, ce qui est l'objet de la prochaine étape.

4. Première installation de Tomcat

Une servlet doit être exécutée dans un serveur d'applications, dans notre exemple il s'agit de Tomcat. La première étape
consiste à créer une instance de serveur Tomcat, associée à notre espace de travail.

La création d'une instance de Tomcat (comme de tout autre serveur d'application) peut se faire directement dans la vue
Servers, présente dans le bas de la perspective Java EE. Le menu contextuel de cette vue permet de créer cette
nouvelle instance.
ENI Initiation à JSP Dr RV p.40

Figure 18. Création d'un serveur Tomcat dans la vue Servers

Le panneau qui s'ouvre alors permet de sélectionner le serveur qui va être créé. Pour cela, il faut renseigner les différents
éléments du panneau.

• Le type de serveur : ici Tomcat v6.

• Le Server host name : ici localhost.

• Le Server name : ici Tomcat v6.0 Server at localhost. Ce nom est un nom logique utilisé par Eclipse. Il peut être
utile de modifier sa valeur par défaut lorsque l'on fait fonctionner plusieurs serveurs de même type sur une même
machine.

• Le Server runtime environment : c'est ici que l'on sélectionne le Tomcat que l'on a installé précédemment. On
peut aussi installé de nouveaux serveur en cliquant sur le lien Add... qui se trouve à côté de ce sélecteur.
ENI Initiation à JSP Dr RV p.41

Figure 19. Sélection du serveur

Une fois l'instance de serveur créé, il faut lui ajouter des projets. Ici nous avons créé un serveur Tomcat, capable
d'exécuter des servlets, on peut donc lui ajouter des projets qui contiennent des servlets. Eclipse ne nous propose ici que
les projets web. Si nous avions d'autres projets Java dans notre espace de travail, ils n'apparaitraient pas dans cette liste.
ENI Initiation à JSP Dr RV p.42

Figure 20. Ajout d'un projet web au serveur

Cette étape était la dernière : notre serveur est maintenant créé, et notre projet web lui a été ajouté. Notons que l'on peut
aussi ajouter des projets à un serveur en les glissant / déposant à partir de la vue Project explorer.

Notre vue Servers a maintenant l'allure suivante.

Figure 21. Vue Server une fois Tomcat installé

5. Exécution d'une première servlet

ENI Initiation à JSP Dr RV p.43

Lorsque toute la configuration précédente a été effectuée, l'exécution d'une servlet devient assez simple. Il suffit de
sélectionner la traditionnelle option Run as... du menu contextuel de la classe que l'on veut exécuter. Comme cette
classe ne comporte pas de méthode main(), la rubrique Java Application n'est pas présente. En revanche, nous avons la
rubrique Run on Server, que nous allons sélectionner.

Figure 22. Lancement d'une servlet

Eclipse nous demande alors quel serveur va exécuter cette servlet. Ici nous n'en avons qu'un, dans une configuration
complexe, il pourrait y en avoir plusieurs.
ENI Initiation à JSP Dr RV p.44

Figure 23. Choix d'un serveur d'exécution

Ici encore, il est possible d'ajouter des ressources de notre espace de travail au serveur. On peut sauter cette étape en
cliquant directement sur le bouton Finish du panneau précédent.
ENI Initiation à JSP Dr RV p.45

Figure 24. Sélection de ressources à ajouter au serveur

Eclipse nous ouvre enfin une vue Navigateur, sur l'URL associée à notre servlet. Cette URL est composée de deux
éléments principaux : l'hôte sur lequel on a installé notre serveur, et l'élément d'URL auquel est associée notre servlet. Le
port choisi par Eclipse est le port 8080, par défaut. Nous verrons dans la suite comment le changer.
ENI Initiation à JSP Dr RV p.46

Figure 25. Une première servlet lancée

On peut également copier cette URL et la coller dans un navigateur lancé localement.

6. Création d'une première JSP

Créer et exécuter une page JSP suit le même processus qu'une servlet. Le menu contextuel du projet nous permet
d'ouvrir le panneau de création d'une JSP.

Figure 26. Création d'une JSP

ENI Initiation à JSP Dr RV p.47

Le premier panneau qui s'ouvre alors permet de fixer dans quel répertoire notre JSP va être créée. Ce répertoire doit se
trouver sous celui que nous avons déclaré comme étant celui qui contient nos ressources web, au niveau de notre projet.
Par défaut, il s'agit du répertoire WebContent.

Figure 27. Choix du répertoire de création de notre JSP

Le second panneau est plus technique. Il nous demande le type de la JSP que nous voulons créer. Il y a sept possibilités,
et l'objet de ce tutorial n'est pas de présenter les différences qui existent entre chacune. On sélectionne donc la
quatrième : JSP with html markup.
ENI Initiation à JSP Dr RV p.48

Figure 28. Choix du type de JSP

Il ne nous reste plus qu'à valider la création de notre JSP. Elle apparaît sous le nœud WebContent de notre projet dans la
vue Project Explorer sous la forme suivante.
ENI Initiation à JSP Dr RV p.49

Figure 29. Structure de notre projet avec une JSP

7. Exécution d'une première JSP

Mettons un peu de code dans notre JSP avant de l'exécuter.

Exemple 2. Code d'une première JSP

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"[Link]
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
Bonjour le monde, il est <%=new [Link]() %>
</body>
</html>

Bien que n'étant pas (encore !) une classe Java, une JSP s'exécute de la même manière qu'une servlet, en allant
chercher la rubrique Run on Server qui se trouve dans le sous-menu Run as... du menu contextuel de cette JSP.
ENI Initiation à JSP Dr RV p.50

Figure 30. Exécution de notre première JSP

Eclipse nous demande alors quel serveur il doit utiliser pour cette exécution. Dans notre exemple nous n'en avons créé
qu'un seul, le choix est donc facile.
ENI Initiation à JSP Dr RV p.51

Figure 31. Choix du serveur d'exécution

De même que pour l'exécution d'une servlet, on peut alors changer les ressources connues de ce serveur.
ENI Initiation à JSP Dr RV p.52

Figure 32. Choix des ressources pour l'exécution

Tout comme pour une servlet, notre exécution se fait dans le navigateur intégré à Eclipse. Eclipse nous l'affiche dans sa
vue, comme sur la capture suivante.

Figure 33. Exécution d'une JSP dans un navigateur

ENI Initiation à JSP Dr RV p.53

On peut bien sûr copier l'URL affichée par ce navigateur, et la coller dans un autre navigateur.

Lorsque l'on dit "exécuter une JSP" (ou une servlet) dans un navigateur, il ne faut pas se méprendre sur le sens des
choses. La servlet, ou la JSP est exécutée dans une JVM, dans Tomcat, et ce que l'on observe dans la navigateur, ce
n'est que l'affichage de la page contenant le code HTML généré par cette servet ou cette JSP.

8. Arrêt et redémarrage de Tomcat

Notons que la vue Servers présente des boutons qui nous permetttent d'arrêter, et de relancer tomcat. Le lancement de
Tomcat peut se faire en mode normal ou en mode debug, ce qui permet d'exécuter pas à pas nos servlets, nos JSPs, et
nos services web si l'on en avait.

Figure 34. Lancement de Tomcat en mode normal

On peut aussi "rafraîchir" Tomcat. Cela signifie que l'on force le rechargement de toute ressource (servlet ou JSP
notamment) qui aurait été modifiée dans Eclipse, alors que Tomcat était en cours d'exécution.

Figure 35. Rafraîchissement de Tomcat

Enfin on peut accéder à un panneau de configuration de Tomcat, simplement en double-cliquant dessus dans la vue
Servers. Ce panneau s'affiche dans une vue spéciale, qui porte le nom que l'on a donné à l'instance. Elle permet de
configurer de nombreux paramètres, dont le port d'écoute HTTP de Tomcat, ce qui est utile en cas d'instances multiples
par exemple.

Figure 36. Panneau de configuration de Tomcat

ENI Initiation à JSP Dr RV p.54