Appalications JEE avec Servlet/JSP

P R O F Y . B O U K O U C H I
4 E A N N É E G É N I E I N F O R M A T I Q U E
E N S A D ’ A G A D I R
Développement des applications JEE web backend

• JEE (Java Platform, Enterprise Edition), anciennement J2EE ( Java 2 Platform
Entreprise Edition ) est la version entreprise de la plate-forme "Java" qui se
compose de l'environnement "JSE" ainsi que de nombreuses API et composants
destinés à une utilisation "côté serveur" au sein du système d'information de
l'entreprise.
• L'objectif majeur de Java EE est de faciliter le développement d'applications web
robustes et distribuées, déployées et exécutées sur un serveur d'applications
C’EST QUOI JEE?

LES SPÉCIFICATIONS JEE
• JEE propose des spécifications (Java Specification Requests -JSR-)pour une
infrastructure dans laquelle s'exécutent les composants. Elle décrivent les rôles de
chaque élément et précisent un ensemble d'interfaces pour permettre à chacun de
ces éléments de communiquer.
• Les spécifications précisent à l'aide des API un certain nombre de fonctionnalités
que doit implémenter l'environnement d'exécution:
• JSR 221: JDBCTM 4.0 API Specification
• JSR 52: A Standard Tag Library for JavaServer Pages
• JSR 369: JavaTM Servlet 4.0 Specification
• JSR 370: JavaTM API for RESTful Web Services (JAX-RS 2.1) Specification
• JSR 371: Model-View-Controller (MVC 1.0) Specification
• Etc.
• Ces fonctionnalités permettent de séparer les applications et l'environnement dans
lequel elles s'exécutent et permettent aux développeurs de se concentrer sur la
logique métier.

API JEE version de l'API dans J2EE/Java EE
1.2 1.3 1.4 5 6 7
1 Entreprise Java Bean (EJB) 1.1 2.0 2.1 3.0 3.1 3.2
2 Remote Method Invocation (RMI) et RMI-IIOP 1.0
3 Java Naming and Directory Interface (JNDI) 1.2 1.2 1.2.1
4 Java Database Connectivity (JDBC) 2.0 2.0 3.0
5
Java Transaction API (JTA)
Java Transaction Service (JTS)
1.0 1.0 1.0 1.1 1.1 1.2
6 Java Messaging service (JMS) 1.0 1.0 1.1 1.1 1.1 2.0
7 Servlets 2.2 2.3 2.4 2.5 3.0 3.1
8 Java Server Pages (JSP) 1.1 1.2 2.0 2.1 2.2 2.2
9 Java Server Faces (JSF) 1.2 2.0 2.2
10 Expression Language (EL) 2.2 3.0
11 Java Server Pages Standard Tag Libray (JSTL) 1.2 1.2 1.2
12 JavaMail 1.1 1.2 1.3 1.4 1.4 1.4
13 J2EE Connector Architecture (JCA) 1.0 1.5 1.5 1.6 1.6
14 Java API for XML Parsing (JAXP) 1.1 1.2
15 Java Authentication and Authorization Service (JAAS) 1.0
16 JavaBeans Activation Framework 1.0.2 1.0.2
17 Java API for XML-based RPC (JAXP-RPC) 1.1 1.1 1.1 1.1
18 SOAP with Attachments API for Java (SAAJ) 1.2 1.3
19 Java API for XML Registries (JAXR) 1.0 1.0 1.0 1.0

API JEE version de l'API dans J2EE/Java EE
1.2 1.3 1.4 5 6 7
20 Java Management Extensions (JMX) 1.2
21 Java Authorization Service Provider Contract for Containers (JACC) 1.0 1.1 1.4 1.4
22 Java API for XML-Based Web Services (JAX-WS) 2.0 2.2 2.2
23 Java Architecture for XML Binding (JAXB) 2.0 2.2
24 Streaming API for XML (StAX) 1.0
25 Java Persistence API (JPA) 1.0 2.0 2.1
26 Java API for RESTful Web Services (JAX-RS) 1.1 2.0
27 Web Services 1.2 1.3 1.3
28 Web Services Metadata for the Java Platform 2.1 2.1
29 Java APIs for XML Messaging (JAXM) 1.3
30 Context and Dependency Injection (CDI) 1.0 1.1
31 Dependancy Injection (DI) 1.0
32 Bean Validation 1.0 1.1
33 Managed beans 1.0 1.0
34 Interceptors 1.1 1.1
35 Common Annotations 1.1 1.1
36 Java API for WebSocket 1.0
37 Java API for JSON 1.0
38 Concurrency Utilities for Java EE 1.0
39 Batch Applications for the Java Platform 1.0

• Pour exécuter ces composants de natures
différentes, JEE définit des conteneurs
pour chacun d'eux.
• Les conteneurs permettent aux
applications d'accéder aux ressources et
aux services en utilisant les API.
• Les appels aux composants se font par
des clients en passant par les conteneurs.
• Les clients n'accèdent pas directement
aux composants mais sollicitent le
conteneur pour les utiliser.
L'ENVIRONNEMENT D'EXÉCUTION DES APPLICATIONS J2EE

Les conteneurs assurent la gestion du cycle
de vie des composants qui s'exécutent en
eux.
Il existe plusieurs conteneurs définis par JEE:
• conteneur web : pour exécuter les
servlets et les JSP
• conteneur d'EJB : pour exécuter les
EJB
• conteneur client : pour exécuter
des applications standalone sur les
postes qui utilisent des composants
JEE
Les serveurs d'applications peuvent fournir:
• un conteneur web uniquement
• ou un conteneur d'EJB uniquement
• ou les deux
LES CONTENEURS

Pour déployer une application dans un
conteneur, il faut lui fournir deux éléments:
• l'application avec tous les composants
(classes compilées, ressources ...) regroupés
dans une archive ou module. Chaque
conteneur possède son propre format
d'archive.
• un fichier descripteur de déploiement
contenu dans le module qui précise au
conteneur des options pour exécuter
l'application
DÉPLOIEMENT D’UNE APPLICATION

Il existe trois types d'archives (JAR, WAR ou EAR) :
1. Bibliothèque => JAR: Regroupe des classes
2. Application client => JAR: Regroupe les ressources
nécessaires à leur exécution (classes, bibliothèques, images,
...)
3. EJB => JAR: Regroupe les EJB et leurs composants (classes)
4. Web => WAR: Regroupe les servlets et les JSP ainsi que les
ressources nécessaires à leur exécution (classes,
bibliothèques de balises, images, ...)
5. Application => EAR : Une application est un regroupement
d'un ou plusieurs modules dans un fichier EAR (Entreprise
ARchive). L'application est décrite dans un fichier
application.xml lui-même contenu dans le fichier EAR
6. JCA =>RAR : JEE Connector Architecture (JCA) est la solution
de JEE pour résoudre le problème d’intégration entre le
monde JEE et le système d’information d’entreprise (EIS)
comme les ERP, mainframes, SGBD, applications anciennes
écrites en C, C++, COBOL…
DÉPLOIEMENT D’UNE APPLICATION

Un site web est un ensemble constitué de pages web (elles-mêmes faites
de fichiers HTML, CSS, Javascript, etc.).
On distingue deux types de sites
• les sites internet statiques : ce sont des sites dont le contenu est
«fixe», il n'est modifiable que par le propriétaire du site. Ils sont
réalisés à l'aide des technologies HTML, CSS et Javascript uniquement.
• les sites internet dynamiques : ce sont des sites dont le contenu est
«dynamique», en plus des langages précédemment cités, ils font
intervenir d'autres technologies (Java EE, PHP, dotnet, etc. )
SERVEUR JEE

La communication client/serveur qui s'effectue entre le client et le serveur est régie par des
règles de protocole HTTP:
1. l'utilisateur saisit une URL dans la barre d'adresses de son navigateur ;
2. le navigateur envoie alors une requête HTTP au serveur pour lui demander la page
correspondante ;
3. le serveur reçoit cette requête, l'interprète et génère alors une page web qu'il va
renvoyer au client par le biais d'une réponse HTTP ;
4. le navigateur reçoit, via cette réponse, la page web finale, qu'il affiche alors à
l'utilisateur.
SERVEUR JEE

• le client ne comprend que les langages de présentation comme : HTML, CSS et
Javascript (ils sont tous interprétés par le navigateur directement sur la machine
client).
• le serveur génère des pages à envoyer au client de manière dynamique, il dispose de
technologies (JEE, PHP, .NET, Django et Ruby on Rails, etc.) capable de :
• analyse des données reçues via HTTP.
• transformation des données.
• enregistrement des données dans une BD.
• intégration des données dans le design.
• Etc.
SERVEUR JEE

• Serveur http : c’est un serveur qui gère exclusivement des requêtes HTTP.
• Un serveur web JEE est constitué d'un serveur HTTP (Web) et d'un conteneur web
• Un serveur d'applications JEE est constitué d'un serveur HTTP, d'un conteneur web et d’un
conteneur EJB
SERVEUR JEE

• les solutions propriétaires et payantes : WebLogic (Oracle) et WebSphere (IBM),
sont les références dans le domaine, utilisées dans les banques et la finance, elles
sont à la fois robustes, finement paramétrables et très coûteuses.
• les solutions libres et gratuites : Apache Tomcat, JBoss, GlassFish et JOnAS sont les
principaux représentants.
SERVEUR JEE

FRAMEWORK
Il est parfois lourd d’utiliser un composant
standard de J2EE : trop ouvert, trop complexe,
design patterns à connaître et à implémenter.
Solution : les frameworks
• couches d'abstraction s'appuyant sur
d'autres briques plus génériques visant à
simplifier l’utilisation de certaines
technologies
• briques spécialisées intégrant un ensemble
de bonnes pratiques et un cadre de codage
Rank Framework Popularity
1 Spring mvc 28.82
2 JSF 15.2
3 Spring Boot 13.35
4 GWT 7.74
5 Grails 6.35
6 Struts 5.4
7 Dropwizard 4.9
8 Play framework 3.26
9 JHipster 2.49
10 jax-rs 2.44
11 Vaadin 2.15
12 Seam 1.94
13 Wicket 1.91
14 Tapestry 1.9
15 Sparkjava 0.77
16 Vert.x 0.76
17 Rapidoid 0.25
18 Lagom 0.24
19 Ratpack 0.13Web Frameworks Index at a Glance 2017/11/15 

Frameworks : Hibernate
• Permet l'accès à une SGBD
• Mapping objet/relationnel (ORM)
Frameworks : Struts
• Ne nécessite qu'un simple moteur de servlet
contrairement aux EJB
• Implémentation du modèle MVC2
• Basé sur les technologies Servlet/JSP
Frameworks : Spring
• Ne nécessite qu'un simple moteur de servlet
contrairement aux EJB
• Conteneur léger
• POA : programmation orienté aspect
FRAMEWORK

Les technologies des applications Web Java, coté serveur
DÉVELOPPEMENT APPLICATION WEB JEE

Environnement de Developpement Intégré (IDE)
• Eclipse IDE for Java EE Developers
• autres : Netbeans, Jdeveloper, etc.
Serveur Web
• Apache Tomcat
• Autres :Wildfly, GlassFish, etc.
Serveur BD
• Serveur MySql avec Workbench
• Autres: Postgres, SQLServer, Oracle, etc.
DÉVELOPPEMENT APPLICATION WEB JEE

• Les Servlets et les JSPs sont la base de JEE
• Les frameworks MVC les plus populaires aujourd’hui sont à la
base des Servlets et JSPs:
• Spring
• JSF
• Struts
 Application Web JEE Prof Y.BOUKOUCHI - ENSA d'Agadir 23

• Une application web est composée de servlets,
JSP, html, et d'autres ressources
• La portabilité de telles applications impose :
– une structure commune
– une description standard de leur déploiement
• Toutes les ressources d'une application web sont
réunies dans un même répertoire dont la
structure est strictement définie.
• La description du déploiement est contenue dans
un fichier XML de nom web.xml
Application
WebContent
.html, .css,
.jsp, .jpg, …
WEB-INF
web.xml
html,
jsp,…
Lib
• jar
Classes
• *.class

• L'ensemble des fichiers peut être réuni dans un fichier
d'archive (.war ) sous forme compressée
• L'ensemble de ces informations est indépendante du
serveur et simplifie le portage et le déploiement d'une
application web
• Structure générale de déploiement d'une application
web:
• Ressources public : html, css, jsp, image, etc.
• Ressources privées: WEB-INF
• Classes: fichiers compilés (servlets, …)
• web.xml (fichier de déploiement ).
• html, jsp, etc.
• lib : jar
Application
WebContent
.html, .css,
.jsp, .jpg, …
WEB-INF
web.xml
html,
jsp,…
Lib
• jar
Classes
• *.class

• Le fichier web.xml est nommé
un fichier de déploiement ».
• Il contient en particulier des
informations établissant une
ou plusieurs correspondance
entre un répertoire cité par le
client et le véritable répertoire
concerné sur le serveur.
<?xml version= 1.0 encoding= UTF-8 ?>
<web-app version= 3.0 xmlns=
http://java.sun.com/xml/ns/javaee
xmlns:xsi= http://www.w3.org/2001/XMLSchema-instance
xsi:schemaLocation= http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd >
<servlet>
<servlet-name>nomServlet</servlet-name>
<servlet-class>cheminServlet</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/urlServlet</url-pattern>
</servlet-mapping>
</web-app>
web.xml

• Un ou une servlet est une classe Java qui permet de créer dynamiquement des données
au sein d'un serveur Web.
• Ces données sont le plus généralement présentées au format HTML, mais elles peuvent
également l'être au format XML ou tout autre format destiné aux navigateurs web.
UNE SERVLET
Version Date de sortie Plateforme
Servlet 4.0 Septembre 2017 JavaEE 8
Servlet 3.1 Mai 2013 JavaEE 7
Servlet 3.0 Décembre 2009 JavaEE 6, JavaSE 6
Servlet 2.5 Septembre 2005 JavaEE 5, JavaSE 5
Servlet 2.4 Novembre 2003 J2EE 1.4, J2SE 1.3
Servlet 2.3 Aout 2001 J2EE 1.3, J2SE 1.2
Servlet 2.2 Aout 1999 J2EE 1.2, J2SE 1.2
Servlet 2.1 Novembre 1998 --
Servlet 2.0 -- --
Servlet 1.0 Juin 1997 --
 Les concepts de base Prof Y.BOUKOUCHI - ENSA d'Agadir 29
Les servlets utilisent l'API Java Servlet (package
javax.servlet).
À l'aide de Servlets, vous pouvez :
1. collecter les entrées des utilisateurs via des
formulaires de pages Web,
2. présenter des enregistrements à partir d'une base de
données ou une autre source,
3. et créer dynamiquement des pages Web.

• Pour exécuter une application à base de servlets, il faut disposer
d’un conteneur de servlets. Son rôle est la :
1. gestion des requêtes client
2. transmission des requêtes à une servlet
3. envoi des réponses au client
CONTENEURDE SERVLETS

Etape 1 : Créer la servlet
• Le paramètre req de type
HttpServletRequest donne accès aux
paramètres de la requête, à l'en-tête HTTP,
aux informations du client.
• Le paramètre res de type
HttpServletResponse contient les données
de la réponse aux client. Elles peuvent être
de n'importe quel type.
• Le type de réponses est précisé par la
méthode setContentType()
• La méthode getWriter retourne un objet
de type PrintWriter, flux de sortie pour le
texte HTML de la réponse
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class Hello extends HttpServlet {
protected void doGet(
HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException
{
res.setContentType("text/html");
PrintWriter page = res.getWriter();
page.println("<HTML>");
page.println("<HEAD><TITLE>Hello
World</TITLE></HEAD>");
page.println("<BODY>");
page.println("<H1>Hello World</H1> );
page.println("<H2>Bienvenue au cours de
Servlet</H2>");
page.println("</BODY></HTML>");
}
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws
ServletException, IOException
{ doGet(request, response); }
}
1ÈRE SERVLET

• Etape 2 : Déclarer la servlet dans le web.xml
• Le fichier web.xml est un fichier au format XML permet de décrire le déploiement de l’application au
serveur.
• Il permet de configurer : l'application, les servlets, les sessions, les bibliothèques de tags personnalisés, les
paramètres de contexte, les types Mimes, les pages par défaut, les ressources externes, la sécurité de
l'application et des ressources JEE.
<?xml version= 1.0 encoding= UTF-8 ?>
<web-app xmlns:xsi= http://www.w3.org/2001/XMLSchema-instance
xmlns= http://xmlns.jcp.org/xml/ns/javaee xsi:schemaLocation=
http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-
app_3_1.xsd id= WebApp_ID version= 3.1 >
<servlet>
<servlet-name>hello</servlet-name>
<servlet-class>chemin.servlets.Hello </servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
</web-app>
1ÈRE SERVLET
La déclaration de notre Servlet Hello
Le mapping de notre servlet sur
l'URL relative /hello

• Etape 3 : Appel de la servlet
L'exécution de cette servlet répond à une requête HTTP. Par exemple:
http://localhost:8080/CoursServlet/hello
1ÈRE SERVLET
Context-path url-patternserveur

 Cycle de vie d’une servlet
• Il y a 5 étapes dans le cycle de vie d'une Servlet :
1. Charger la classe Servlet dans la mémoire.
2. Créer l'instance de la Servlet.
3. Appeler la méthode init() de Servlet.
4. Appeler la méthode service() de Servlet.
5. Appeler la méthode destroy() de Servlet.
• Les étapes 1, 2 et 3 sont exécutées une seule fois, lorsque
la Servlet est initialement chargée. Par défaut, la Servlet
n'est pas chargée jusqu'à ce que la première requête soit
reçue par l'utilisateur.
• L'étape 4 est exécutée plusieurs fois - une fois pour chaque
requête HTTP vers la Servlet.
• L'étape 5 est exécutée lorsque le conteneur de servlet
(Servlet Container) décharge (unloaded) la Servlet.
Prof Y.BOUKOUCHI - ENSA d'Agadir 35

Pour chaque requête effectuée, un lien est
créé entre le client et la servlet avec :
A. appel de la méthode service(…), qui
détermine le type de requête envoyée
(POST ou GET),
B. création de deux objets :
• HttpServletRequest: sert à extraire les
paramètres envoyés avec la requête.
• HttpServletResponse: sert à construire
la réponse pour le client.
C. Invocation de la méthode correspondante
doGet(…) ou doPost(…)
 Cycle de vie d’une servlet Prof Y.BOUKOUCHI - ENSA d'Agadir 36

LA CLASSE HTTPSERVLET
• public abstract class HttpServlet extends GenericServlet {
HttpServlet ()
// methodes repondant aux différents types de requêtes
protected void doDelete ( HttpServletRequest req , HttpServletResponse resp )
protected void doGet ( HttpServletRequest req , HttpServletResponse resp )
protected void doHead ( HttpServletRequest req , HttpServletResponse resp )
protected void doOptions ( HttpServletRequest req , HttpServletResponse resp )
protected void doPost ( HttpServletRequest req , HttpServletResponse resp )
protected void doPut ( HttpServletRequest req , HttpServletResponse resp )
protected void doTrace ( HttpServletRequest req , HttpServletResponse resp )
protected void service ( HttpServletRequest req , HttpServetResponse resp )
void service ( ServletRequest req , ServletResponse res )
Etc.
}

MéthodesGetetPost
Pour transmettre des paramètres du client au serveur, il faut choisir entre deux
démarches :
1. Transmission des paramètres via un formulaire html et dans ce cas, il faut choisir
entre deux méthodes de transmission:
• la méthode GET : envoie les paramètres via l’URL, ils sont visibles dans le navigateur;
• la méthode POST : envoie les paramètres via l’en-tête http, ils sont masqués.
• Les paramètres de formulaires sont récupérables via HttpServletRequest, La
récupération se fait par les méthodes suivantes :
• Enumeration getParameterNames()
• String getParameterValues(String name)
• String getParameter(String name)
2. Transmission des paramètres via un URL et dans ce cas, leurs valeurs seront
récupérées par la méthode doGet.
http://localhost:8080/context-path/nomServlet?par1=val1&par2=val2
 Les formulaires Prof Y.BOUKOUCHI - ENSA d'Agadir 39

Les composants du formulaire :
<form method="post" id="form" action="FormStudent">
<fieldset>
<legend> Formulaire d'inscription</legend>
<label for="nom">Nom</label>
<input id="nom" name="nom" type="text" placeholder="Votre nom">
<textarea id="adresse" name="adresse" placeholder="Votre adresse" ></textarea>
<select id="pays" name="pays" >
<option value="Maroc">Maroc</option>
<option value="France">France</option>
</select>
<input type="radio" name="sexe" value="H" checked="checked"> Homme
<input type="checkbox" name="comptences" id="comptences-0"
value="JEE">Développement JEE
<input type="submit" name="S'enregistrer" value= " Valider" />

public class FormStudentServlet extends HttpServlet {
protected void doPost(HttpServletRequest req, HttpServletResponse res) throws
ServletException, IOException {
PrintWriter out= res.getWriter();
String nom=req.getParameter("nom");
…
String comptences[]=req.getParameterValues("comptences");
out.println("<HTML><HEAD><TITLE>Fiche Inscription</TITLE></HEAD>");
out.println("<BODY>");
out.println("<b>Nom : </b><b>"+nom+" "+prenom+ "("+sexe+")</b>");
out.println("<p>Email et mot de passe : "+email+" "+motpass+"</p>");
out.println("<p>Adresse et pays : "+adresse+" ("+pays+")</p>");
out.println("<p>Compténces:");
for(String s:comptences){
out.println(s+" ");
}
out.println("</p>");
out.println("</BODY></HTML>");
}
}
Attention: Si aucun paramètre
nommé n’a été fourni lors de
l’appel, on obtiendra en retour
de l’appel de getParameter la
valeur null.

Informationsàpartirl’objetdeServletRequest
• Informations à propos du client:
• getRemoteAddr(): récupère l'adresse IP de l'hôte qui a initié la requête.
• getRemoteHost(): renvoie le nom de la machine hôte qui a initié la requête.
• Informations à propos du serveur:
• getServerName(): permet d'obtenir le nom du serveur
• getServerPort(): permet d'obtenir le numéro du port
• Informations à propos de l’URL:
• getRequestURI(): permet d'obtenir l'URL sur lequel porte la requête.
• Autres informations de l’en-tête:
• getHeaderNames() : de récupérer une liste des noms des entêtes passés par le client lors de la requête.
Cette méthode renvoie un objet de type Enumeration.
 Les objets informations Prof Y.BOUKOUCHI - ENSA d'Agadir 43
De nombreuses informations en provenance du client peuvent être extraites de l'objet
ServletRequest passé en paramètre par le serveur.

• Exemple ‣ http://localhost/exemples/servlets/TraceServlet/tutu?toto=titi
• getMethod() → GET
• getPathInfo() → /tutu
• getQueryString() → toto=titi
• getRequestURI() → /exemples/servlets/TraceServlet/tutu
• getServletPath() → /servlets/TraceServlet
• getContextPath() → /exemples
Informationsàpartirl’objetdeServletRequest
out.println("<b>Quelques informations fournies par l'objet requête</b><br>");
out.print("Adresse IP de l'hote :"+req.getRemoteAddr()+"<br>");
out.print("Nom de la machine hote :"+req.getRemoteHost()+"<br>");
out.print("Nom du serveur:"+req.getServerName()+"<br>");
out.print("Port du serveur:"+req.getServerPort()+"<br>");
out.print("URL de la requête:"+req.getRequestURI()+"<br>");
out.println("---------- Les en-têtes de la requete -----<br>");
String entete;
while(headers.hasMoreElements()){
entete=headers.nextElement();
out.println("En-tête : "+entete +", sa valeur : "+req.getHeader(entete)+"<br>");}

La servlet peut obtenir des informations à partir d'un objet ServletContext retourné par la
méthode getServletContext() d'un objet ServletConfig.
• getServerInfo(): Retourne le nom et le numéro de version du moteur de servlet
• getContextPath() : Retourne le contexte de l’application
• getSessionTimeout(): Retourne la durée de vie des sessions
• getRealPath("nomFichier"): Retourne le chemin d’un fichier dans le serveur.
• getInitParameter(String name):Retourne la valeur d’un paramètre d’initialisation.
• getInitParameterNames(): Retourne la liste des paramètres d’initialisation.
• setAttribute(String name,Object object): Définie un objet comme attribue de l’application.
• Etc.
Informationsàpartirl’objetdeServletContext
ServletContext context=getServletContext();
out.println("<b>Quelques informations fournies par l'objet requête</b><br>");
out.print("Serveur utilisé :"+context.getServerInfo()+"<br>");
out.print("Contexte path :"+context.getContextPath()+"<br>");
out.print("Session Timeout :"+context.getSessionTimeout()+"<br>");
out.print("Chemin réel du fichier
:"+context.getRealPath("HeaderInfosServlet")+"<br>");

• La transmission du contrôle permet :
• une servlet de traiter en partie une requête et transmettre le contrôle à une autre
servlet pour la suite du traitement.
• une servlet de transmettre le contrôle à une page JSP pour générer la réponse.
• Pour transmettre le contrôle on utilise l’objet de type RequestDispatcher, obtenu en
invoquant la méthode getRequestDispatcher("Chemin") de la requête.
• RequestDispatcher dispatcher = req. getRequestDispatcher("/Welcome");
• Le chemin doit correspondre à une ressource se trouvant dans la même application web,
il ne peut pas référencer de ressource externe. La ressource désignée par ce chemin peut
être statique (une image, ou un fichier), ou dynamique (une servlet).
 Transmission du contrôle Prof Y.BOUKOUCHI - ENSA d'Agadir 47

• L’objet RequestDispatcher expose deux méthodes:
• forward() redirige la requête vers la ressource désignée.
• include() inclut cette ressource dans la réponse courante.
• Ces deux méthodes prennent en paramètre la requête et la réponse courantes.

String login=req.getParameter("login");
String motpass=req.getParameter("motpass");
if(login.equals("boukouchi")&&motpass.equals("admin")){
RequestDispatcher dispatcher = req. getRequestDispatcher("/Welcome");
dispatcher. forward(req, res);
} else{
PrintWriter out= res.getWriter();
out.println("<b>Email ou mot de pass est invalide</b>");
RequestDispatcher dispatcher = req. getRequestDispatcher("/index.html");
dispatcher. include(req, res);
}

• La 3e méthode de transmission du contrôle est la méthode sendRedirect appelée par l’objet
HttpServletResponse.
• Le serveur envoie une réponse 302 au navigateur qui initie une nouvelle requête sur le même
serveur ou sur un autre serveur vers l’URL transmis dans la réponse (URL relative ou absolue).
• Lorsqu’il s’agit de continuer sur le même serveur forward est préférable, car plus rapide.
public void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
// construction redirection par le client
response .sendRedirect("http://www.ensa-agadir.ac.ma");
//Ou interne : response .sendRedirect("WelcomeStudent");
// le traitement de la requête courante continue
}
LaméthodesendRedirect

LES PARAMÈTRES & LES ATTRIBUTS

Paramètresd'initialisationdelaservlet
 Les paramètres et les attributs Prof Y.BOUKOUCHI - ENSA d'Agadir 52
• Les paramètres d'initialisation d’une servlet sont
déclarés dans l'élément servlet du
fichier web.xml, et sont lus dans la
méthodes init(), via l'objet ServletConfig.
• Les valeurs de ces paramètres peuvent être
retrouvées dans le code de la servlet grâce à la
méthode getInitParameter() de l'objet
ServletConfig.
• On peut également accéder à la liste de tous les
paramètres d'initialisation par appel à la méthode
getInitParameterNames(), qui retourne
un Enumeration.
private String databaseUser;
private String databasePW;
public void init( ServletConfig config) throws ServletException {
databasePW= config .getInitParameter ("dbUserPw");
databaseUser = config .getInitParameter ("dbUser");
}
<servlet>
<servlet-name>ParametersServlet</servlet-name>
<servlet-class>...ParametersServlet</servlet-class>
<init-param>
<param-name>dbUser</param-name>
<param-value>infoDB</param-value>
</init-param>
<init-param>
<param-name>dbUserPw</param-name>
<param-value>admin</param-value>
</init-param>
</servlet>

• Ces paramètres peuvent être association à un
ensemble de Servlets:
• contrairement aux paramètres d'initialisation de
Servlet précédents,
• ceux-ci sont commun à toutes les Servlets de
l'application web.
Paramètresd'initialisationducontexte
String databaseName ;
String databaseDriver ;
public void init(ServletConfig config) throws ServletException {
ServletContext context =config . getServletContext();
databaseName = context . getInitParameter ("databaseName");
databaseDriver = context . getInitParameter ("databaseDriver");
}
<context-param>
<param-name>databaseName</param-name>
<param-value>GestionDB</param-value>
</context-param>
<context-param>
<param-name>databaseDriver</param-name>
<param-value>MySQL</param-value>
</context-param>

PortéedesObjets
• la portée des objets souvent appelée visibilité, ou
scope en anglais, elle définit tout simplement leur
durée de vie.
• Il existe au total quatre portées différentes dans
une application :
1. page (JSP seulement) : les objets dans cette portée
sont uniquement accessibles dans la page JSP en
question ;
2. requête (HttpServletRequest): les objets dans
cette portée sont uniquement accessibles durant
l'existence de la requête en cours ;
3. Session (HttpSession) : les objets dans cette
portée sont accessibles durant l'existence de la
session en cours ;
4. Application (ServletContext): les objets dans cette
portée sont accessibles durant toute l'existence de
l'application.

• Il est possible d’ajouter des attributs personnels soit au
niveau de la requête , la session ou bien le contexte
(l’application).
• Ces attributs sont des paires clé/valeur, la clé étant une
chaîne de caractères et la valeur étant un objet de
n’importe quel type.
• Il y a des méthodes qui permet de stocker, récupérer et
détruire ces attributs:
• La méthode setAttribute(nom, objet). Si le nom de
l’attribut existe déjà, la valeur existante est remplacée par
la nouvelle.
• La méthode getAttribute(nom) est utilisée pour récupérer
la valeur d’un attribut de type quelconque dans
l’application ou la valeur null si l’attribut n’existe pas.
• La méthode getAttributesNames() permet de récupérer
le nom de tous les attributs.
• la méthode removeAttribute(nom) permet la suppression
de l’attribut indiqué.
Lesattributs
request.setAttribute("att_req", "valeur");
String att = (String)request.getAttribute("att_req");
request.removeAttribute("att_req");
ServletContext context=getServletContext();
context.setAttribute("att_app", "valeur");
String att = (String)context.getAttribute("att_app");
context.removeAttribute("att_app");
HttpSession session=request.getSession();
session.setAttribute("att_sess", "valeur");
String att = (String)session.getAttribute("att_sess");
session.removeAttribute("att_sess");

 Les paramètres et les attributs Prof Y.BOUKOUCHI - ENSA d'Agadir<web-app …>
<context-param>
<param-name>societe</param-name>
<param-value>ENSA d'Agadir</param-value>
</context-param>
<servlet>
<servlet-name>compteur</servlet-name>
<servlet-class>...CompteurServlet</servlet-class>
<init-param>
<param-name>role</param-name>
<param-value>administrateur</param-value>
</init-param>
</servlet>
...
</web-app>
56
public class CompteurServlet extends HttpServlet {
private ServletConfig config;
private ServletContext context;
private int compteurServlet = 0;
public void init(ServletConfig config) throws ServletException {
this.config = config;
this.context = config.getServletContext();}
protected void doGet(HttpServletRequest req, HttpServletResponse res) …{
HttpSession session = req.getSession(true);
Integer compteurSession = (Integer) session.getAttribute("compteur");
if (compteurSession == null) {compteurSession = 1;
session.setAttribute("compteur", compteurSession);
} else {compteurSession++;
session.setAttribute("compteur", compteurSession); }
String role = config.getInitParameter("role");
String societe = context.getInitParameter("societe");
compteurServlet++;
PrintWriter page = res.getWriter();
page.println("<HTML><HEAD><TITLE>Compteur</TITLE></HEAD><BODY>");
page.println("<h2>Paramètres et Attributs</h2>");
page.println("<h3>Etablissement :" + societe + "</h3>");
page.println("<h3>Role :" + role + "</h3>");
page.println("<b>Nombre totale des requetes/servlet: </b><b>" + compteurServlet + "</b></br>");
page.println("<b>Nombre totale des requetes/servlet/Session: </b><b>" + compteurSession + "</b>");

• Le protocole HTTP est un protocole non connecté ( protocole sans états, en anglais
stateless protocol), cela signifie que chaque requête est traitée indépendamment
des autres et qu'aucun historique des différentes requêtes n'est conservé.
• →le serveur web ne peut pas se "souvenir" de la requête précédente: panier,
login, préférences, etc.
• Alors, le suivi de session (session tracking) ou bien la gestion de la session (session
management) est un mécanisme de gestion des états, permet de maintenir la
cohésion entre l'utilisateur et la requête, c'est-à-dire :
• reconnaître les requêtes provenant du même utilisateur
• associer un profil à l'utilisateur
• connaître les paramètre de l'application (nombre de produits vendus, panier, ...)
• Il y a quatre techniques pour assurer le Session Tracking:
1. en utilisant les cookies
2. en passant en paramètre un champ de formulaire caché
3. en ajoutant à l'URL des variables d'identification
4. en utilisant le HttpSession
 Session Tracking Prof Y.BOUKOUCHI - ENSA d'Agadir 58
Techniquesde SessionTracking

• Les cookies sont des petits fichiers textes stockés sur le
disque du client, permettant de stocker des paires
clés/valeur.
• Les cookies concernant le domaine du site sur lequel un
utilisateur surfe sont automatiquement envoyés dans les
en-têtes HTTP lors de chaque requête du client.
• Lorsque le serveur désire créer un cookie sur le
navigateur du client, il lui suffit d'envoyer des
instructions dans les en-têtes de la réponse HTTP.
Lescookies

• un cookie a obligatoirement un nom et une valeur associée.
• Propriétés optionnelles importantes
• Max Age : durée de rétention de l’information (date
d'expiration)
• Domain : domaine auquel l’information peut –être associée
• Path: chemin où le client doit renvoyer l’information
• Avantage des cookies
• Technique la plus simple de maintien de l'état.
• Les cookies sont conservés côté client.
• Inconvénient des cookies
• Cela ne fonctionnera pas si le cookie est désactivé à partir du
navigateur.
• Seules les informations textuelles peuvent être définies dans
l'objet Cookie.
Lescookies

La classe javax.servlet.http.Cookie fournit un ensemble de fonction pour la gestion d’un
cookie:
• Cookie() : constructeur.
• Cookie(String name, String value) : Constructeur créant un objet Cookie de nom Name et de
valeur Value).
• public String getName() : Retourne le nom du cookie
• public String getValue() : Retourne la valeur du cookie.
• public void setName(String name) : Redéfinit le nom du cookie.
• public void setValue(String value) : Redéfinit la valeur du cookie.
• public void setMaxAge(int expiry): Définit la durée de validité du cookie (en secondes).
• int getMaxAge() : Retourne la durée de validité du cookie (en secondes)
• String getDomain() : Retourne le domaine pour lequel le cookie est valide
• void setDomain(String Domain) : Définit le domaine pour lequel le cookie est valide
• String getPath() : Retourne le chemin pour lequel le cookie est valide
• void setPath(String Chemin) : Définit le chemin pour lequel le cookie est valide
• int getVersion() : Retourne la version du cookie
• void setVersion(int Version) : Définit la valeur du cookie
Lescookies

Pour ajouter un cookie ou obtenir sa valeur, nous avons besoin de méthodes fournies par d'autres
interfaces. Elles sont:
• public void addCookie(Cookie ck) : la méthode de HttpServletResponse utilisée pour ajouter le cookie
à la réponse.
• public Cookie[] getCookies() : la méthode de HttpServletRequest utilisée pour récupérer tous les
cookies à partir de navigateur
• Créer un Cookie:
Cookie ck=new Cookie("user","boukouchi"); //créer un objet cookie
ck.setMaxAge(30*60) //Max Age : durée de rétention de l’information
response.addCookie(ck); //ajouter une cookie à la réponse
• Supprimer un Cookie (Il est principalement utilisé pour déconnecter l'utilisateur.)
Cookie ck=new Cookie("user",""); //supprimer la valeur du cookie
ck.setMaxAge(0); //changer l'âge max à 0
response.addCookie(ck); //ajouter un cookie à la réponse
• Récupérer des Cookies:
Cookie ck[]=request.getCookies();
for(int i=0;i<ck.length;i++){ out.print("<br>"+ck[i].getName()+" "+ck[i].getValue()); //afficher le nom et la valeur }
Lescookies

Servlet1 Servlet2
Cookie invalide après 60 secondes
<form action="servlet1" method="get">
<label for="email">Adresse Email</label>
<input type="email" name="email" >
<button type="submit">Envoyer</button>
</form>
String email = request.getParameter("email");
Cookie ck = new Cookie("email", email);
ck.setMaxAge(1 * 60);
response.addCookie(ck);
response.setContentType("text/html");
page.println("<HTML><HEAD><TITLE>Session
Tracking</TITLE></HEAD><BODY>");
…
Cookie cks[] = request.getCookies();
int indice = -1;
for (int i = 0; i < cks.length; i++) {
if (cks[i].getName().equals("email"))
indice = i;
}
if (indice != -1 && cks[indice].getValue() != null) {
...
page.println("<h3>Bienvenue : " +
cks[indice].getValue() + "</h3>");
...
} else {
response.sendRedirect("login.html");
}
Dans cet exemple, nous stockons l’adresse email de
l'utilisateur dans l'objet cookie et nous y accédons dans
une autre servlet.

• Dans le cas d'un champ de formulaire masqué (Hidden Form Field), un champ de texte
masqué (invisible) est utilisé pour conserver l'état d'un utilisateur.
• Dans ce cas, nous stockons les informations dans le champ caché et les récupérons à
partir d'un autre servlet.
• Cette approche est préférable si nous devons soumettre le formulaire dans toutes les
pages et que nous ne voulons pas dépendre du navigateur.
• <input type="hidden" name=“name" value=“Boukouchi">
• Avantage du champ de formulaire caché
• fonctionne toujours.
• Inconvénient du champ de formulaire masqué:
• Il est maintenu côté serveur.
• Un formulaire supplémentaire est requis sur chaque page.
• Seules les informations textuelles peuvent être utilisées.
Champdeformulairecaché

Champdeformulairecaché
</form>
…
page.println("<form action="servlet2"
method="get">");
page.println("<input type="hidden"
name="email" value="" + email + "">");
page.println("<button
type="submit">Envoyer</button></form>");
if (email != null) {
…
page.println("<h3>Bienvenue : " + email +"</h3>");
page.println("<p>Session Tracking par Hidden
Form Field</p>");
…
} else {
}
l'utilisateur dans un champ caché et nous y accédons dans
une autre servlet.
Servlet1 Servlet2
Champ invalide (null)

• Dans la réécriture d'URL(URL rewriting), nous ajoutons les données à l'URL du prochain
servlet ou de la prochaine ressource.
• Nous pouvons envoyer des paires nom / valeur de paramètre en utilisant le format
suivant: url? name1 = valeur1 & name2 = valeur2
• Lorsque l'utilisateur clique sur le lien hypertexte, les paires nom / valeur de paramètre
sont transmises au serveur. À partir d'un servlet, nous pouvons utiliser la méthode
getParameter () pour obtenir une valeur de paramètre.
• Avantage de la réécriture d'URL
• fonctionne toujours.
• Pas de formulaire supplémentaire.
• Inconvénient de la réécriture d'URL
• Cela fonctionnera uniquement avec des liens.
• Il peut envoyer uniquement des informations textuelles.
laréécritured'URL

laréécritured'URL
</form>
…
page.println("<h3>Bienvenue : " + email +
"</h3>");
page.println("<hr>");
page.println("<a href='servlet2?email=" + email +
"'>suivant</a>");
…
page.println("<h3>Bienvenue : " + email +"</h3>");
page.println("<p>Session Tracking par Réécriture
d'URL</p>");
…
} else {
}
l'utilisateur dans un lient et nous y accédons dans une
autre servlet.
Servlet1 Servlet2
Paramètre invalide (null)

• la session représente un espace mémoire alloué pour chaque utilisateur, permettant de
sauvegarder des informations tout le long de leur visite ;
• le contenu d'une session est conservé jusqu'à ce que l'utilisateur ferme son navigateur,
reste inactif trop longtemps, ou encore lorsqu'il se déconnecte du site ;
• L’objet HTTPSession permet :
• Gestion des objets dans la session : ajout, modification, retrait, recherche, etc.
• Gestion des méta-information à propos de la session elle-même : date de création, id
de la session, etc.
HttpSession
Nom :JSESSIONID, Valeur :295C0FB721251D83BACD24AD7E34EF36

• L'objet HttpSession s'obtient grâce à la méthode getSession() de l'objet HttpServletRequest,
chaque utilisateur se voit attribuer un Session ID
• Utiliser cette méthode : HttpServletRequest.getSession() // par défaut true
HttpSession session = request.getSession(true);
• Retourne la session en cours, ou crée une (true) si il n’en existe pas.
HttpSession session = request.getSession(false);
• Retourne la session en cours, ou null si il n’en existe pas.
• Méthodes pour le cycle de vie d’une session:
• Récupérer le session ID -> public String getId();
• Voir si la session vient juste d’être créée -> public boolean isNew();
• Récupérer la date de création -> public long getCreationTime();
• Dernière fois que la session a été activée-> public long getLastAccessedTime();
• Terminer (invalider) une session -> public void invalidate(); Les sessions peuvent se terminer
automatiquement lors de périodes d’inactivité
HttpSession

• Récupérer des données de la session :
Integer accessCount = (Integer) session.getAttribute(" nom");
• Récupérer toutes les « clés » de tous les objets dans la session :
Enumeration attributes = request.getAttributeNames();
• Mettre des données dans la session:
HttpSession session = request.getSession();
session.setAttribute("nom", "Boukouchi");
• Et on peut les supprimer :
session.removeAttribute("name");
HttpSession

• Retourne l'intervalle de temps maximum (timeout)entre deux requête avant que la
session n'expire (en seconde)
public int getMaxInactiveInterval();
• Si on spécifie cet intervalle, la session sera fermée (invalidée) automatiquement
lorsqu’un utilisateur ne fait rien pendant un temps plus long
public void setMaxInactiveInterval( int secondes )
• Si la valeur est négative : jamais d’interruption
• Le timeout par défaut peut-être codé dans le descripteur de déploiement
(fichierweb.xml) en ajoutant les balises :
• <session-config>
<session-timeout>
120 <!-- en minutes -- >
</session-timeout>
</session-config>
HttpSession

• Le Session ID est communiqué au client:
• Option 1: si le navigateur supporte les cookies,
la Servlet créée un cookie avec le session ID,
dans Tomcat, ce cookie est appelé JSESSIONID
• Cookie : contient les cookies HTTP stockés
précédemment envoyés par le serveur à
l'aide de l'en-tête Set-Cookie.
• Set-Cookie : envoie des cookies du serveur
à l'agent utilisateur.
HttpSession

• Option 2: si le navigateur ne supporte pas les cookies, la servlet va essayer de récupérer le
session ID depuis l’URL (la servlet doit réécrire URL locale avant de l’envoyer au client en
utilisant les fonctions suivantes encodeURL() ou encodeRedirectURL () de
HttpServletResponse.
• La servlet peut déterminer si l’identifiant de session est valide par la fonction suivante:
• public boolean HttpServletRequest.isRequestedSessionIdValid()
• La servlet peut détecter si l’identifiant de la session vient d’un cookie ou d’une URL codée
en utilisant :
• public boolean HttpServletRequest.isRequestedSessionIdFromURL()
• public boolean HttpServletRequest.isRequestedSessionIdFromCookie()
HttpSession
page.println("<h3>Session ID : " + session.getId() + "</h3>");
page.println("<hr>");
page.println("<a href='" + response.encodeUrl("servlet8?email=" + email) + "'>suivant</a>");

HttpSession
</form>
Date dateCreationS = new
Date(session.getCreationTime());
Date dateInactiviteS = new
Date(session.getLastAccessedTime());
session.setAttribute("email", email);
…
page.println("<h4>Session ID : " + session.getId() +
"</h4>");
…
Date dateCreationS = new
Date(session.getCreationTime());
Date dateInactiviteS = new
Date(session.getLastAccessedTime());
String email = (String)
session.getAttribute("email");
…
} else {
}
Dans cet exemple, nous stockons l’adresse email de l'utilisateur
dans une session et nous y accédons dans une autre servlet.
Servlet1 Servlet2
Attribut Session invalide (null)

• Un objet listener (écouteur, observateur) est un objet qui écoute certains événements
dans une application.
• Pour le conteneur Web Java EE, un listener designe une classe qui implémente une des
interfaces définies dans l’API servlet.
• Lorsque l'événement qu'il écoute se déclenche, alors ce listener s'active : une de ses
méthodes particulière (callback) est invoquée, avec en paramètre un objet portant les
informations sur cet événement (ServletContextEvent, HttpSessionEvent , etc.).
• Ces objets doivent implémenter des interfaces standard, fournies par l'API Servlet
(ServletContextListener, HttpSessionListener, etc.), et être déclarés dans le descripteur
d'une application web :
• le fichier web.xml
<listener>
<listener-class>
package.maClasseListener
</listener-class>
</listener>
• ou bien annotée avec @WebListener
 Les listeners Prof Y.BOUKOUCHI - ENSA d'Agadir 76
@WebListener
public class MaClasseListener implements APIServletListener {
public MaClasseListener() { }
public void methodeCallback 1 (APIServletEvent event) {
// traitement
}
}

Voici quelques événements définis par l'API Servlet:
• Ajout ou le retrait d'un attribut (Changes to attributes) sur
un contexte, une session ou une requête :
• Événements : ServletContextEvent, HttpSessionEvent et
ServletRequestEvent.
• Listeners: ServletContextAttributeListener,
ServletRequestAttributeListener et
HttpSessionAttributeListener.
• la création ou à la destruction (LifeCycle) du contexte,
d’une session, ou d'une requête:
• Événements : ServletContextEvent, HttpSessionEvent
et ServletRequestEvent.
• Listener : HttpContextListener, HttpRequestListener,
HttpSessionListener et HttpSessionActivationListener.
• Etc.

• L’exemple ci-dessous présente ContextListener qui implémente ServletContextListener dont
le rôle est de réaliser un log applicatif signalant respectivement le lancement et l’arrêt de
l’application Web.
@WebListener
public class ContextListener implements ServletContextListener {
public ContextListener() {
}
public void contextDestroyed(ServletContextEvent sce) {
sce.getServletContext().log("## Arrêt de l'application ##");
}
public void contextInitialized(ServletContextEvent sce) {
sce.getServletContext().log("## Lancement de l'application ##");
}
}

• L’exemple ci-dessous présente SessionListener qui implémente HttpSessionListener dont le
rôle est de compter le nombre de visiteur connectés à l’application web.
@WebListener
public class SessionListener implements HttpSessionListener {
private int compteurVisiteur = 0;
public SessionListener() {}
public void sessionCreated(HttpSessionEvent se) {
synchronized (this) {
compteurVisiteur++;
System.out.println("Nombre de Visiteur : " + compteurVisiteur);
}
}
public synchronized void sessionDestroyed(HttpSessionEvent se) {
compteurVisiteur--;
System.out.println("Nombre de Visiteur : " + compteurVisiteur);
}
}

• Les filtres sont des codes exécutés entre les requêtes et les servlets ou pages JSP, pour
faire un pré- ou post-traitement sur les requêtes ou les réponses.
• Il est déclaré dans le descripteur de l'application web.xml, et posé sur une ou plusieurs
servlets.
• Lorsqu'une requête doit être traitée par une servlet sur laquelle un filtre est déclaré, alors
le serveur, plutôt que d'invoquer directement la méthode doGet() ou doPost() de la
servlet, va invoquer la méthode doFilter() de ce filtre.
• Un filtre peut agir sur tous les aspects du cycle requête / réponse, en modifiant l'un ou
l'autre
• Nombreuses utilisations des filtres :
• Authentification,
• redirection,
• modification des entêtes,
• cryptage des données,
• contrôle des accès effectués par les clients,
• journalisation des accès
• …
 Les Filtres Prof Y.BOUKOUCHI - ENSA d'Agadir 81

• un filtre est une classe qui doit implémenter
l'interface Filter.
• Cette interface définit trois méthodes :
• init(FilterConfig) : méthode callback, appelée
lors de la construction de cet objet par le
serveur d'applications.
• destroy() : méthode callback, appelée lors de la
destruction de cet objet par le serveur
d'applications.
• doFilter(ServletRequest, ServletResponse,
FilterChain) : cette méthode est appelée sur
requête HTTP, au lieu de l'appel d'une servlet
sur lequel ce filtre est déclaré.
• La propagation de la requête au filtre suivant, ou
à la servlet est faite en invoquant
filterChain.doFilter(request, response).
public class TransparentFilter implements Filter {
public void init(FilterConfig filterConfig) {
// l'objet filterConfig encapsule les paramètres
// d'initialisation de ce filtre
}
public void destroy() {
// callback de destruction de ce filtre
}
public void doFilter(ServletRequest request, ServletResponse
response, FilterChain filterChain)
throws IOException, ServletException {
// propagation de la requête le long de la chaîne
filterChain.doFilter(request, response) ;
}
}
Cycledevied'unFiltre

• Un filtre doit être déclaré dans le fichier web.xml
de l'application.
• De même qu'une servlet, un filtre est déclaré en
deux temps :
• d'une part par sa classe d'implémentation,
• d'autre part par l'URL qu'il filtre.
<web-app>

<filter>
<filter-name>nomFilter</filter-name>
<filter-class>chemin.classFilter</filter-class>
</filter>

<filter-mapping>
<filter-name>nomFilter</filter-name>
</filter-mapping>

<servlet>
<servlet-class>chemin.classServlet</servlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
Déclarationd'unFiltre

• Filtrage d'une requête pour
la journalisation
• il s'agit juste d'enregistrer
les informations du client
qui a soumis la requête.
@WebFilter("/*")
public class LoggerFilter implements Filter {
private Logger log = Logger.getLogger("LoggerFilter");
public LoggerFilter() {
log.log(Level.INFO, "Création de filtre");
}
public void init(FilterConfig fConfig) throws ServletException {
log.log(Level.INFO, "Initialisation de filtre");
}
public void destroy() {
log.log(Level.INFO, "Destruction de filtre");
}
public void doFilter(ServletRequest request, ServletResponse
response, FilterChain chain) throws IOException, ServletException
{
HttpServletRequest httpRequest = (HttpServletRequest) request;
String host = httpRequest.getRemoteHost();
String url = httpRequest.getRequestURL().toString();
log.log(Level.INFO,"L'hôte["+host+"] fait une requête sur ["+url+
"]");
chain.doFilter(request, response);
}
}
<filter>
<filter-name>Logger</filter-name>
<filter-class>
ma.boukouchi.filter.LoggerFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>Logger</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
OU

• Les annotations sont une nouveauté apportée par la version 5 de Java pour ajouter
des métadonnées à un code source.
• Elle peut s'appliquer à un package, une classe, une interface, un constructeur, une
méthode, un champ, un argument de méthode, une variable locale ou encore à une autre
annotation.
• Lors de la compilation des codes sources, le compilateur Java stocke les métadonnées
d'annotation dans les fichiers classes. Plus tard, la JVM ou d'autres programmes peuvent
accéder à ces métadonnées pour déterminer comment interagir avec les composants du
programme ou changer leur comportement.
• La syntaxe d'une annotation est la suivante :
@annotation-type[ (name=value) * ]
• Exemple:
• @Deprecated : Cette annotation marque une entité obsolète.
• @Override : Cette annotation marque une méthode redéfinie.
• @SuppressWarnings : Cette annotation signale au compilateur de supprimer certains avertissements à la
compilation de l'entité.
 web.xml et les annotations Prof Y.BOUKOUCHI - ENSA d'Agadir 86
Principeetfonctionnement

• Le fichier web.xml contient un
nombre important d’informations
concernant l’application web Java.
• Servlet 3.0 a apporté de
nombreuses annotations qui
évitent de remplir le fichier
web.xml.
• Pour des applications simples, le
fichier web.xml est facultatif mais
pour d’autre il est nécessaire
encore pour certaines tâches.
Les Annotations introduites par Servlet 3.0
1 @WebServlet
2 @WebInitParam
3 @WebFilter
4 @WebListener
5 @HandlesTypes
6 @HttpConstraint
7 @HttpMethodConstraint
8 @MultipartConfig
9 @ServletSecurity
Principeetfonctionnement

• Elle permet de déclarer une
servlet.
• Attributs:
• name
• value
• urlPatterns: obligatoire !
• loadOnStartup
• initParams
• asyncSupported
• smallIcon, largeIcon
• description
• displayName
Annotation@WebServlet <servlet>
<servlet-name> Inscription</servlet-name>
<servlet-class>chemin.Inscription</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Inscription</servlet-name>
<url-pattern>/inscription</url-pattern>
</servlet-mapping>
@WebServlet( "/inscription" )
public class Inscription extends HttpServlet {
...
@WebServlet( name="Inscription", urlPatterns = "/inscription" )
...
@WebServlet(urlPatterns = {"/inscription", "/registration "})
...

• Elle permet de définir les
paramètres d’initialisation d’une
servlet ou d’un filtre.
• Elle est dans l’annotation
@WebFilter ou @WebServlet.
• Attributs:
• name
• value
• description
Annotation@WebInitParam <servlet>
<servlet-name>Download</servlet-name>
<servlet-class>packages.Download</servlet-class>
<init-param>
<param-name>chemin</param-name>
<param-value>/fichiers/</param-value>
</init-param>
</servlet>
...
@WebServlet( urlPatterns = "/fichiers/*", initParams =
@WebInitParam( name = "chemin", value = "/fichiers/" ) )
public class Download extends HttpServlet {
...

• @WebFilter permet de définir un
filtre.
• Attributs:
• urlPatterns
• initParams
• filterName
• servletNames
• urlPatterns
• dispatcherTypes
• @WebListener permet de définir un
observateur.
Annotation@WebFilteret@WebListener <filter>
<filter-name>RestrictionFilter</filter-name>
<filter-class>...RestrictionFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>RestrictionFilter</filter-name>
<url-pattern>/restreint/*</url-pattern>
</filter-mapping>
...
@WebFilter( urlPatterns = "/restreint/*" )
public class RestrictionFilter implements Filter {
...
<listener>
<listener-class>...InitialisationDaoFactory</listener-class>
</listener>
...
@WebListener
public class InitialisationDaoFactory implements
ServletContextListener {
...

• La JavaServer Pages ou JSP est une technique basée sur Java qui permet de créer
dynamiquement des pages web.
• un JSP est une page HTML dans laquelle sont introduits des morceaux de code
Java nommés script .
• il existe plusieurs sortes de script: scriptlet, déclarations, commentaires,
Expressions, etc.
• Il faut minimiser le code java dans une page JSP (refactoriser le code, modèle
MVC, etc.)
• il existe d’autres balises spécifiques aux JSP qui permettent l’emploi de
JavaBeans , bibliothèque personnalisé (JSTL), etc.
• Les JSP sont enregistrés avec l’extension .jsp.
 Le JavaServer Pages Prof Y.BOUKOUCHI - ENSA d'Agadir 93
ConceptsJSP

<%@page import="java.time.LocalDate"%>
<%@ page language="java" contentType="text/html;
charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01
Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;
charset=UTF-8">
<title>Hello</title>
</head>
<body>
<% LocalDate date= LocalDate.now();%>
<h2>Hello ENSA</h2>
Aujourd'hui, c'est le : <%=date.toString()%>
</body>
</html>
ConceptsJSP

• Quelques objets sont prédéfinies dans une page JSP, ils peuvent être utilisées sans déclaration.
• request : contient une référence sur l’objet de type HttpServletRequest qui contient la requête
à cette page.
• response : référence sur le flux sortant de la servlet (HttpServletResponse).
• config : il s’agit de la variable de type ServletConfig utilisée pour initialiser la page.
• pageContext : objet de type PageContext, elle contient des méthodes qui permettent d’accéder
à toutes les variables déclarées par défaut.
• session : variable de type HttpSession, cette variable représente la session dans laquelle se
trouve la requête.
• application : variable de type ServletContext, cette variable modélise l'application web dans
laquelle on se trouve.
• out : cette variable est de type Writer. C’est celle qui sert à envoyer les données vers le client.
C’est une instance de la classe JspWriter.
• page : variable qui modélise la page dans laquelle on se trouve.
ObjetsprédéfiniesdansunepageJSP

• Pour exécuter notre JSP nous pouvons
indifféremment:
• saisir l’adresse du JSP dans le navigateur,
en l’accompagnant de la valeur du
paramètre
• utiliser un formulaire HTML
• Transmission de paramètres à une JSP via
l’objet request
• Dans la JSP, la distinction entre Get et Post
n’existe plus. La servlet générée par une JSP
est formée essentiellement d’une méthode
(nommée souvent _jspService).
<html>
<head>
<title> JSP Bonjour </title>
</head>
<body>
<%
String nom = request.getParameter ("prenom");
if (nom == null) {out.println ("BONJOUR");}
else{out.println ("BONJOUR"+ nom);}
%>
</body>
</html>
<html>
<head>
<title> Appel de JSP bonjourVous </title>
</head>
<body>
<form action ="bonjourVous.jsp" method="GET">
Vous vous appelez <input type="text" size="24"
name="prenom">
<input type="submit" value="OK">
</form>
</body></html>
JSPetFormulaire

• Pour pouvoir exécuter un JSP, le serveur reçoit une
requête de la forme :
http://.../nomJSP.jsp?Paramètres
• Lorsqu’il reçoit cette requête pour la première fois, le
moteur de JSP compile le fichier JSP correspondant
en une servlet et en lance l’exécution.
• Si, par la suite le moteur de JSP reçoit une nouvelle
requête concernant la même JSP, la servlet en
question est directement exécutée, sans qu’aucune
nouvelle compilation ne soit nécessaire.
• C’est l’ensemble du JSP qui est compilé en servlet, il
est traduit en instructions Java sous la forme :
out.println ( texte_ou_balise_HTML )
• tous les codes Java sont incorporés à une unique
méthode _jspService
public void _jspService (HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType( text/html );
JspWriter out = response.getWriter();
out.println( ... );
}
Cycledevied’uneJSP

• Le cycle de vie d'une Java Server Page est
identique à une Servlet:
• La méthode jspInit() est appelée après le
chargement de la page
• La méthode _jspService() est appelée à chaque
requête
• La méthode jspDestroy() est appelé lors du
déchargement
• Possibilité de redéfinir dans le code JSP les
méthodes jspInit() et jspDestroy() en utilisant
un élément de scripts déclaration <%!...%>.
<%@ page language="java" contentType="text/html; charset=UTF-
8"
<!DOCTYPE html>
<html>
<head>
charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<%!public void jspInit() {
/* Redéfinition de la méthode jspInit()*/
ecole = "ENSA d'Agadir";
}%>
<%!String ecole;%>
Bienvenue à <%=ecole%>
</body>
</html>
Cycledevied’uneJSP

• Il existe au total quatre portées différentes
dans une application :
1. page (JSP seulement) : les objets dans cette
portée sont uniquement accessibles dans la
page JSP en question ;
2. requête : les objets dans cette portée sont
uniquement accessibles durant l'existence de la
requête en cours ;
3. session : les objets dans cette portée sont
accessibles durant l'existence de la session en
cours ;
4. application : les objets dans cette portée sont
accessibles durant toute l'existence de
l'application.
PortéedesObjets

scriptlet
• Un scriptlet est un morceau de code Java
figurant entre les balises spéciales <% et %>.
Commentaire
• des commentaires : <%-- ... --%>
<%@page import="java.time.LocalDate"%>
<%@ page language="java"
contentType="text/html; charset=UTF-8"
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type"
content="text/html; charset=UTF-8">
<title>Hello</title>
</head>
<body>
<%-- ceci un commentaire --%>
<%
out.println("BONJOUR");
%>
</body>
</html>
LesscriptsJavad’uneJSP
Directives
des directives au moteur JSP :
<%@ directive attribut= valeur %>
où directive vaut page, include ou taglib.
<%@page contentType= text/html pageEncoding= UTF-8 import= java.util.List %>
<%@include file= copyright.html %>

• Elle permet d’introduire la valeur d’une expression Java
dans le ﬂux HTML sous la forme suivante :
<%= expression %>
• Dans l’élément de script <%= expression %>, on peut
placer n’importe quelle expression valide en Java, et qui
puisse être convertie en chaîne.
• Exemple :
• BONJOUR<%=request.getParameter("prenom")%>
• <%= session.getId()%>
BONJOUR
<% out.println (nom) ;
%>
BONJOUR <%= nom %>
<html>
<head>
<title>JSP Bonjour</title>
</head>
<body>
<%
String nom =
request.getParameter("prenom");
if (nom == null) {
%>
BONJOUR
<%
} else {
%>
BONJOUR<%=nom%>
<%
}
%>
</body>
</html>
Les expressions

• <%! Déclarations_Variables_Methodes %>
• Ce script permet d’introduire des
déclarations de variables ou de méthodes.
• Une variable déclarée dans un scriptlet est
une variable locale (dont le scriptlet est
incorporé généralement dans la méthode
_jspService)
• les déclarations fournies dans la balise <%! ...
%> vont figurer en dehors de cette méthode,
dans la classe elle-même.
• Elles correspondent donc à des champs
(variables d’instance) ou à des méthodes de
la classe.
Les balises de déclaration
…
<html>
<head>
<title> Compteur d'appels </title>
</head>
<body>
<%! int compte=0; %>
<h2>Compteur d'appels</h2>
<%
compte++ ;
out.println ("numéro d'appel : "+compte);
%>
</body>
</html>

• L’emplacement de la balise <%! ... %> dans
la JSP n’est pas important.
• La déclaration de méthode dans un scriptlet
(les méthodes locales à une méthode
n’existent pas en Java) conduirait à une
erreur au moment de la compilation de la
JSP.
• À la création de la classe servlet générée
par la JSP, les méthodes déclarées seront
des méthodes d’instance utilisables par
n’importe quelle autre méthode de la
classe.
Les balises de déclaration
...
<!DOCTYPE html>
<html>
<%-- méthode de calcul de factorielle --%>
<%!int fact(int n) {
int fac = 1;
for (int i = 1; i <= n; i++) fac *= i;
return fac;
}%>
<%--code de détermination de la valeur de nombre--%>
<%
String sNbr = request.getParameter("nombre");
int nbr;
if (sNbr == null || sNbr=="") nbr = 1;
Else nbr = Integer.parseInt(sNbr);
%>
<html> <head> <title>Calcul de factorielles</title>
</head>
<body>
<h3>Calcul de factorielles</h3>
<form action="test.jsp" method="get">
<label for="nombre">Nombre 1</label>
<input type="number" name="nombre" value="<%=nbr%>">
<button type="submit">Calculer</button>
</form>
<h4> Factorielles de<%=nbr%> ! =<%=fact(nbr)%> </h4>
</body></html>

• Lors de l'exécution d'une page JSP, des erreurs peuvent survenir. Chaque erreur se traduit
par la levée d'une exception.
• Si cette exception est capturée dans un bloc try/catch de la JSP, celle-ci est traitée.
• Si l'exception n'est pas capturée dans la page, il y a deux possibilités selon qu'une page
d'erreur est associée à la page JSP ou non :
• sans page d'erreur associée, la pile d'exécution de l'exception est affichée
• avec une page d'erreur associée, une redirection est effectuée vers cette JSP
Techniquedegestiondeserreurs

• La définition d'une page d'erreur permet de
la préciser dans l'attribut errorPage de la
directive page des autres JSP de
l'application.
• Si une exception est levée dans les
traitements d'une de ces pages, la JSP va
automatiquement rediriger l'utilisateur vers
la page d'erreur précisée.
• La valeur de l'attribut errorPage de la
directive page doit contenir l'URL de la page
d'erreur.
<%@ page errorPage="error.jsp" %>
errorPage="error.jsp"
contentType="text/html; charset=UTF-8"%>
<!DOCTYPE html>
<html>
<html>
<head>
<title>Calcul</title>
</head>
<body>
<h3>Calcul</h3>
<%
int a = 1, b = 0, c;
if (b != 0) {
c = a / b;
out.println(a + " / " + b + " = " + c);
} else
throw new Exception("Division par Zéro !");
%>
</body>
</html>

• Une page d'erreur est une JSP dont l'attribut
isErrorPage est égal à true dans la directive page.
• Une telle page dispose d'un accès à la variable
implicite nommée exception de type Throwable qui
encapsule l'exception qui a été levée.
• Il est possible dans une telle page d'afficher un
message d'erreur personnalisé mais aussi d'inclure
des traitements liés à la gestion de l'exception :
• ajouter l'exception dans un journal,
• envoyer un mail pour son traitement, ...
• Elle n'est pas conçue pour être accessible
directement aux utilisateurs du site et se trouve donc
dans la zone privée <WEB-INF>
contentType="text/html"%>
<%@ page isErrorPage="true"%>
<html>
<body>
<h1>Une erreur est survenue lors
des traitements</h1>
<p><%=exception.getMessage()%></p>
</body>
</html>

<body>
<%
String login = "youness";
String codeAcces;
%>
<%-- traitement normal --%>
<%
if (login.equals("youness")) {
codeAcces = "ABC45";
%>
<%-- renvoi paramètre code --%>
<jsp:forward page="WEB-INF/PageAcces.jsp">
<jsp:param name="code" value="<%=codeAcces%>" />
</jsp:forward>
<%
}
else{
%>
<%-- renvoi un message d’erreur --%>
<jsp:forward page="WEB-INF/login.jsp">
<jsp:param name="message" value="Login invalide" />
</jsp:forward>
<%
}
%>
</body>
 Transfer de contrôle Prof Y.BOUKOUCHI - ENSA d'Agadir 108
Inclusion dynamique
• Une page JSP peut donner le contrôle à une
autre page JSP en utilisant deux méthodes :
• En utilisant la directive <jsp:forward.../> de la
première page vers la seconde.
• En utilisant le bouton d’un formulaire avec les
données associées, ou un lien avec paramètres
• la balise jsp:forward offre des possibilités plus
riches de chaînage qui peut être conditionnel
ou itératif
• la balise jsp:forward assortit de paramètres
(par name et value) qui sont transmis d’un JSP
à l’autre.
<jsp:forward page="page.jsp">
<jsp:param name="nom" value="valeur" />
</jsp:forward>

Inclusion dynamique
• On peut utiliser le code Java d’une JSP dans un
autre (après compilation) à l’aide de la balise
jsp:include.
• Elle dispose du même mécanisme de paramètres
que la balise jsp:forward.
• Cette fois, le mécanisme s’apparente à un appel
de fonction (il y a bien retour dans le JSP
appelant) avec éventuel transfert d’arguments.
• L’inclusion est sans impact sur la page principale,
qui n’est donc pas modifiable.
• Il permet donc véritablement un développement
modulaire.
<body>
<h2>Ceci est un appel et inclusion de la JSP
factorielle</h2>
<div style="background-color:silver; border-
style: double;">
<jsp:include page="factorielle.jsp">
<jsp:param name="nombre" value="5" />
</jsp:include>
</div>
</body>
</html>

Inclusion statique
• La balise : <%@ include ﬁle ="RéférencePageJSP"/> recopie le texte de la page
JSP mentionnée à l’emplacement où elle figure.
• Il s’agit d’une simple recopie de texte, avant compilation des JSP concernés. Une
seule servlet est généré.
• Cela permet de réutiliser des contenus et de rendre modulaires les pages.
• Cette technique est utile pour inclure du contenu comme des en-têtes, pieds de
page ou menus dans toutes les pages.

JSTL & EL
La Java Standard Tag Library & Expression Language

• La JavaServer Pages Standard Tag Library (JSTL) est un composant de la plate-
forme JEE de développement.
• Elle étend la spécification JSP en ajoutant une bibliothèque de balises pour les
tâches courantes, comme :
• le travail sur des fichiers XML,
• l'exécution conditionnelle,
• les boucles
• l'internationalisation.
• …
• La JSTL, en tant que bibliothèque de balises JSP, propose de développer une page
JSP sans y utiliser de code Java directement ce qui permet aux web designers de
concevoir des pages dynamiques complexes sans connaissances préalable du
langage Java.
 JSTL & EL Prof Y.BOUKOUCHI - ENSA d'Agadir 112
JSTL

• JSTL propose un langage nommé EL (Expression Langage) qui permet de faire
facilement référence à des objets Java accessibles dans les différents contextes
de la JSP (page, requête, session ou application).
• Il permet de placer à n'importe quel endroit d'une page JSP des expressions qui
sont évaluées et remplacées par le résultat de leur évaluation.(à la place d'une
expression <%=expressionJava%>)
• La syntaxe est la suivante : ${ expression }
ExpressionLanguage
<%= session.getAttribute("personne").getNom()%>
${sessionScope.personne.nom}

• EL possède par défaut les variables suivantes :
ExpressionLanguage
Variable Rôle
PageScope variable contenue dans la portée de la page (PageContext)
RequestScope variable contenue dans la portée de la requête (HttpServletRequest)
SessionScope variable contenue dans la portée de la session (HttpSession)
ApplicationScope variable contenue dans la portée de l'application (ServletContext)
Param paramètre de la requête http
ParamValues paramètres de la requête sous la forme d'une collection
Header en-tête de la requête
HeaderValues en-têtes de la requête sous la forme d'une collection
InitParam paramètre d'initialisation
Cookie cookie
PageContext objet PageContext de la page

• EL ne permet pas l'accès aux variables locales.
• Pour pouvoir accéder à de telles variables, il faut obligatoirement en créer
une copie dans une des portées particulières : page, request, session ou
application
ExpressionLanguage
<% String nom="boukouchi"; %>
Bonjour : ${nom}
<% String nom="boukouchi";
pageContext.setAttribute("nom", nom);
%>
Bonjour : ${nom}

• L'EL fournit les opérateurs de comparaison
suivants:
Concept Condition EL Résultat
Numérique inférieur à ${1 < 2} vrai
Numérique inférieur à (Less than) ${1 lt 2} vrai
Numérique supérieur à (Greater than) ${1 gt 2} faux
Numérique supérieur ou égal à ${1 >= 1} vrai
Numérique inférieur ou égal à (Less equals) ${1 le 1} vrai
Numérique égal à ${1 == 1} vrai
Numérique égal à (equal) ${1 eq 1} vrai
Numérique non égal à ${1 != 2} vrai
Numérique non égal à (not equal) ${1 ne 2} vrai
Alphabétique supérieur que ${'abe' > 'ade'} faux
Alphabétique égal à (Equals) ${'abe' eq 'abe'} vrai
Alphabétique non égal à (Not equals) ${'abe' ne 'ade'} vrai
ExpressionLanguage

• L'EL fournit les opérateurs de comparaison suivants:
égaux à (equals) == eq
Pas égaux (Not equals) != ne
Moins que (Less than) < lt
Plus grand que(Greater than) > gt
Moins que ou égaux à
(Less than or equals)
<= le
Plus grand ou égaux à
(Greater than or equals)
>= ge
Opérateur Description
&& Et
|| Ou
${(guess >= 10) && (guess <= 20)}
${ guess >= 10 || guess <= 20 }
ExpressionLanguage
Operateur Rôle Exemple
. Obtenir une propriété d'un objet ${param.nom}
[] Obtenir une propriété par son nom ou son indice
${param[" nom "]}
${row[1]}
Empty
Teste si un objet est null ou vide si c'est une chaîne de
caractère. Renvoie un booléen
${empty param.nom}

• La JSTL étend la spécification JSP en ajoutant de nombreuses balises pour des tâches
courantes.
• Elle est composée de plusieurs bibliothèques :
• Core Tags (préfixe c) exposent tous les tags de base de la JSTL pour l’affichage, la gestion des
variables, les boucles, les conditionnelles, etc.,
• <%@ taglib prefix="c " uri= "http://java.sun.com/jsp/jstl/core"%>
• Formatting Tags (préfixe fmt) exposent toutes les fonctionnalités d'affichage de données non
triviales : les dates formatées, les nombres formatés, les messages internationalisés, etc.
• <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix= "fmt"%>
• XML tags (préfixe x) pour l’analyse et la transformation (XSLT) des pages XML. Cette librairie
permet par exemple de lire des flux XML via HTTP, de les analyser, de les transformer par XSLT,
puis de les afficher sous différentes formes.
• <%@ taglib uri="http://java.sun.com/jsp/jstl/xml" prefix="x "%>
• SQL tags (préfixe sql) pour la connexion aux bases de données, les requêtes, les transactions, etc.,
• <%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql"%>
• Functions Tags (préfixe fn) présentent des fonctions standards dont la majorité sont pour la
manipulation des chaine de caractères
• <%@ tagl uri="http://java.sun.com/jsp/jstl/functions" prefix="fn"%>
JSTL

• Télécharger les bibliothèques :
• taglibs-standard-impl-1.2.5.jar
• taglibs-standard-spec-1.2.5.jar
• (http://tomcat.apache.org/download-taglibs.cgi)
<%@ page language="java" contentType="text/html;
charset=UTF-8"
<%@ taglib prefix="c"
uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
charset=UTF-8">
<title>Exemples de JSTL</title>
</head>
<body>
<c:out value="Bonjour" /><br/>
</body>
</html>
Hello JSTL

JSTLCoreTags
1. Le tag set permet de stocker une variable dans une portée particulière (page, request,
session ou application).
2. Le tag out permet d’afficher la valeur d’une variable, ce tag est équivalent à <%= ...%>.
3. Le tag remove permet de supprimer une variable.
4. Le tag catch permet de gérer les exceptions.
5. Le tag if est utilisé pour réaliser une condition.
6. Le tag choose est utilisé pour des cas mutuellement exclusifs (équivalent du switch).
7. Le tag foreach est utilisé pour réaliser des itérations.
8. Le tag forTokens est utilisé pour découper une chaîne selon un ou plusieurs séparateurs.
9. Le tag import permet d’accéder à une ressource via son URL pour l’inclure ou l’utiliser
dans la page JSP.
10. Le tag redirect permet de réaliser une redirection vers une nouvelle URL

<c:out> : permet d’afficher la valeur d’une variable, ce tag est équivalent à <%= ...%>
<c:out value= ${'Bonjour ENSA'} /><br/>
JSTLCoreTags
<c:set>: permet de stocker une variable dans une portée particulière (page, request, session ou
application)
<c:set var= "montantHT" scope="session" value='${6600}' />
<c:set var="TVA" scope="session" value='${0.20}' />
<p>Montant HT: <c:out value='${montantHT}' /><p>
<p>Montant TTC: <c:out value= '${montantHT*(1+TVA)}' /><p>

• <c:choose>:Traitement conditionnel exclusif
<c:set var="note" scope="session" value="${16.75}" />
<p> Votre note est :<c:out value="${note}" /></p>
<c:choose>
<c:when test="${note>= 0 && note < 10}">Ajourné.</c:when>
<c:when test="${note>= 10 && note <12}">Mention Passable.</c:when>
<c:when test="${note>= 12 && note <14}">Mention Assez-Bien.</c:when>
<c:when test="${note>= 14 && note <16}">Mention Bien.</c:when>
<c:when test="${note>= 16 && note <=20}">Mention Très Bien.</c:when>
<c:otherwise>Note invalide ...</c:otherwise>
</c:choose>
JSTLCoreTags • <c:if>:Traitement conditionnel
<c:set var="montantHT" scope="session" value="${1000}" />
<p>Montant HT:<c:out value="${montantHT}" /><p>
<c:if test="${montantHT >= 6000}">
<p>Montant TTC:<c:out value="${montantHT*1.2}" /><p>
</c:if>
<c:if test="${montantHT < 6000}">
<p>Montant TTC:<c:out value="${montantHT*1.1}" /><p>
</c:if>

<c:forEach>: Itérer sur une collection
<%@page import="org.exemples.beans.UserBeans"%>
<%@page import="java.util.ArrayList"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE html><html><head>
charset=UTF-8"><title>Exemples de JSTL</title></head>
<body>
<%!List<UserBeans> users = new
ArrayList<UserBeans>();%>
<%
users.add(new UserBeans("youness", "BOUKOUCHI", "PA"));
users.add(new UserBeans("mohammed", "ELYAKOUBI", "PA"));
users.add(new UserBeans("mohammed", "NOUHI", "PA"));
request.setAttribute("users", users);
%>
<table style="border: 1px"solid; >
<tr bgcolor=#ccffcc>
<td size=12>nom</td><td>prenom</td><td>role</td>
</tr>
<c:forEach var="user" items="${users}" >
<tr bgcolor=#e6ffff>
<td>${user.nom}</td>
<td>${user.prenom}</td>
<td>${user.role}</td>
</tr>
</c:forEach>
</table></body></html>
JSTLCoreTags
<c:forEach var="i" begin="1" end ="5" >
Item <c:out value ="${i}" /><p>
</c:forEach>
<c:forTokens>:Itérer sur des éléments d'une
String
<c:forTokens items="GInf-GInd-GElec"
delims="-" var="opt">
<c:out value="${opt}"/><p>
</c:forTokens>

<c:redirect>: permet de réaliser une redirection vers une nouvelle URL
<c:redirect url="hello.jsp"/>
JSTLCoreTags
<c:import>: permet d’accéder à une ressource via son URL pour l’inclure ou
l’utiliser dans la page JSP
<c:import var="data" url= "hello.jsp" />
<c:out value="${data}"/>

<fmt:formatDate>
<%@page import= java.util.Date %>
<%@ taglib prefix="c" uri= http://java.sun.com/jsp/jstl/core %>
<%@ taglib prefix="fmt" uri= http://java.sun.com/jsp/jstl/fmt %>
<html> <head> <title>Hello JSTL</title></head>
<body>
<c:set var="date" value= <%=new Date()%> />
<p> Objet Date :
<c:out value= ${date} ></c:out>
<p> Format Date :
<fmt:formatDate type="date" value="${date} "/>
<p> Format Date :
<fmt:formatDate type="time" value="${date} "/>
<p> Format Date et Temps style(short) :
<fmt:formatDate type="both" dateStyle="short" timeStyle="short" value="${date} "/>
<p> Format Date et Temps style(medium) :
<fmt:formatDate type="both" dateStyle="medium" timeStyle="medium" value="${date} " />
<p> Format Date et Temps style(long) :
<fmt:formatDate type="both" dateStyle="long" timeStyle="long" value="${date} " />
</body></html>
JSTLFormattingTags

<fmt:formatNumber>
<%@ taglib prefix= c uri= http://java.sun.com/jsp/jstl/core %>
<%@ taglib prefix= fmt uri= http://java.sun.com/jsp/jstl/fmt %>
<body>
<c:set var= "montant " value= "39800.34567 " />
<p>Montant :<c:out value= "${montant} " ></c:out>
<p> Monétaire:
<fmt:formatNumber type= "number" pattern= "###.## DH " value= "${montant} " />
<p>Porcentage %:
<fmt:formatNumber type= "percent" maxIntegerDigits= "5" maxFractionDigits= "2" value= "${montant} " />
</body></html>
JSTLFormattingTags

• <fn:>
<%@ taglib prefix= c uri= http://java.sun.com/jsp/jstl/core %>
<%@ taglib prefix= fn uri= http://java.sun.com/jsp/jstl/functions%>
<body>
<c:set var="ensa" value="Ecole Nationale des Sciences Appliquées" />
Longuer ENSA: ${fn:length(ensa)}<br>
ENSA en miniscule : ${fn:toLowerCase(ensa)}<br>
ENSA en majuscule : ${fn:toUpperCase(ensa)}<br>
</body>
</html>
JSTLFunctionTags

• Un design pattern ou un modèle de conception est en quelque sorte une ligne de
conduite qui permet de décrire les grandes lignes d’une solution (bonnes pratiques de
développement ).
• Le modèle MVC proposée par Sun est la solution de développement Web côté serveur
qui permet de séparer la partie logique/métier de la partie présentation dans une
application Web.
• L’objectif principal est de diviser l’application en trois parties:
• Le modèle qui est représenté par les EJB, JavaBeans, systèmes de persistances.
• La vue qui est représentée par les JSP, Html, CSS, etc.
• Le contrôleur qui est représenté par les Servlets et les filtres.
 Le modèle MVC Prof Y.BOUKOUCHI - ENSA d'Agadir 129
LeModèle MVC(ModelViewController)

• La couche Contrôleur : chargée de router les informations, elle va décider qui va
récupérer l’information et la traiter. Elle gère les requêtes des utilisateurs et retourne
une réponse avec l’aide de la couche Modèle et Vue.
• La couche Vue : s’occupe de la présentation des données à l’utilisateur, c’est elle qui est
responsable de produire les interfaces de présentation de votre application à partir des
informations qu’elle dispose (page HTML par exemple).
• La couche Modèle : exécute la logique métier de l’application, elle est responsable de
la manipulation des données(le traitement, la validation, l’association, etc.). Elle est
également responsable de l’interaction avec la base de données (se connecter et
d’exécuter les requêtes CRUD sur une base de données).
ArchitectureMVC(ModelViewController)

1. Le client envoie une requête HTTP au serveur. C’est en général une Servlet qui traite la demande.
2. La Servlet récupère les informations transmises par le client et délègue le traitement à
un composant métier adapté.
3. Les composants du modèle manipulent ou non des données du système d’information (lecture,
écriture, mise à jour, suppression).
4. Une fois les traitements terminés, les composants rendent la main à la Servlet en lui
retournant un résultat. La Servlet stocke alors le résultat dans un contexte adapté (session,
requête, réponse...).
5. La Servlet appelle la JSP adéquate qui peut accéder au résultat.
6. La JSP s’exécute, utilise les données transmises par la Servlet et génère la réponse au client.

• Pour déployer une application dans un conteneur, il faut lui fournir dans une
archive deux éléments :
• les fichiers de l’application : Servlets, JSPs, classes compilées (.class), ressources statiques
(pages HTML statiques, images, CSS, pdf, txt, . . . ), . . .
• un fichier XML descripteur de déploiement : précise au conteneur la configuration pour
exécuter l’application
• Chaque conteneur possède son propre format d’archive :
 Déploiement au serveur Prof Y.BOUKOUCHI - ENSA d'Agadir 134
FichierWAR

• Pour créer le fichier WAR, dans eclipse on clique File/Export
FichierWAR
Pour exporter les fichiers
sources .java

• Pour déployer une application web
JEE, on utilise l’outil manager de
Tomcat qui permet de déployer une
application avec une interface Web.
• Le lien Tomcat Manager ouvre une
fenêtre d’authentification Les
informations de connexion
correspondent aux données insérées
lors de l’installation du serveur.
• Nous obtenons une page qui liste
toutes les applications actuellement
déployées sur le serveur.
DéploiementauserveurTomcat

• Pour déployer une nouvelle
application, on utilise l’option
Fichier WAR à déployer en
précisant les le fichier .war qui
contient l’application,
• Le fichier WAR doit d’abord être
créé avant le déploiement de
l’application et il doit respecter
l’arborescence Java EE (répertoire
WEBINF...).
• Le déploiement a eu pour effet
d’ajouter une copie complète du
projet dans le répertoire des
webapps de Tomcat /webapps.

Notre application est alors accessible à l’adresse suivante :
dans le serveur local http://localhost:8080/CoursServlet/
Ou bien à partir de l’extérieur après paramétrage du serveur de l’entreprise : www.soft-skills.com

Appalications JEE avec Servlet/JSP

Contenu connexe

Tendances (20)

Similaire à Appalications JEE avec Servlet/JSP (20)

Plus de Youness Boukouchi (11)

Appalications JEE avec Servlet/JSP