Servlet - Définition

!  Servlet : Server-side applet

!  Applet est une classe s’exécutant chez le client alors que la
servlet s’exécute chez server.
!  Une classe java s’exécutant coté serveur
!  reçoit et répond aux requêtes de clients web,
!  généralement via HTTP " servlet web ou servlet (pour simplifier)
!  Permettre la programmation d'applications web en Java

requête requête
Serveur

SERVLETS Web Servlet

réponse réponse

Navigateur Web

2013/2014 heithem.abbes@gmail.com

Environnement d’exécution de servlets Squelette de base de servlet

!  Les servlets s'exécutent dans un conteneur de servlets, appelé aussi conteneur import javax.servlet.*;
web
public class MyServlet implements Servlet {
!  Conteneur web = serveur web + moteur de servlet
!  Etablit le lien entre le serveur web et la servlet public void init(ServletConfig config) throws ServletException {
…
}

requête
public void service( ServletRequest request, ServletResponse response )
requête
Serveur throws ServletException, IOException {
Web Servlet
réponse réponse …

Navigateur Web Conteneur

}
de servlets
public void destroy() {
!  Exemples de conteneur de servlets …
!  Tomcat (Implantation de référence)
}
!  Jetty
!  Weblogic
!  ...
Cycle de vie d’une servlet
!  Le conteneur gère le cycle de vie :
!  charge la classe de servlet et initialise une instance de cette classe
!  chaque requête du client est traitée par une instance de servlet
dans un thread séparé
Cycle de vie d’une servlet
!  Lorsque la servlet est instancié, le conteneur appelle la méthode init() pour
initialiser la servlet
!  Sur demande du client, le conteneur appelle la méthode service()
!  Avant la suppression de la servlet, le conteneur appelle la méthode destroy()

Traitement de requêtes:
Browser appel de la méthode
Servlet
Browser Server
Instance Appel de la methode service
init
Browser

Détruire la Servlet:
!  peut supprimer la servlet appel de la méthode
Instance de ServletConfig destroy
!  peut garder la servlet pour traiter d’autres requêtes Servlet

Garbage
Classe Servlet Collection
6

Modèle de programmation Servlet web

!  Une servlet doit implémenter !  Pour faciliter le traitement particulier des requêtes web, la classe
l’interface javax.servlet.Servlet Servlet est affinée en javax.servlet.http.HttpServlet
!  soit directement,
!  des méthodes remplacent la méthode service() de la classe mère
!  soit en dérivant d’une classe #  doGet() pour les requêtes http de type GET
implémentant cette interface :
#  doPost() pour les requêtes http de type POST
#  javax.servlet.GenericServlet : une classe
abstraite indépendante du protocole #  ....
#  javax.servlet.http.HttpServlet : une !  La classe servlet doit OBLIGATOIREMENT implémenter l’une des méthodes
classe abstraite spécifique au protocole redéfinies, choisies selon le mode d’envoi du formulaire html qui l’exécute
HTTP !  service() de HttpServlet appelle automatiquement la bonne méthode
!  l’interface javax.servlet.Servlet en fonction du type de requêtes http
possède les méthodes pour
!  initialiser la servlet : init()
!  recevoir et répondre aux requêtes des
clients : service()
!  détruire la servlet et ses ressources :
destroy()
HTTP Développement de Servlet
!  HTTP décrit les échanges entre navigateur web (client) et serveur !  Une Servlet web
web : le navigateur effectue une requête HTTP; le serveur la traite
et envoie une réponse HTTP. !  étend la classe
!  Une requête HTTP a le format suivant : javax.servlet.http.HttpServlet
Ligne de commande (Commande, URL, Version de protocole)
En-tête de requête !  implémente des méthodes spécifiques au
[Ligne vide]
Corps de requête
protocole HTTP remplacent la méthode
!  Une réponse HTTP a le format suivant :
service() : doGet(), doPost()…
Ligne de statut (Version, Code-réponse, Texte-réponse)
En-tête de réponse
!  La servlet reçoit les requêtes et renvoie les
[Ligne vide] réponses via 2 objets :
Corps de réponse
!  Objet requête : javax.servlet.ServletRequest
!  Les commandes essentielles sont GET (obtenir un document) et POST #  contient les informations nécessaires pour une
(envoyer du contenu). communication du client vers le serveur
!  Les données de la requête sont passées dans l’URL pour un GET et !  Objet réponse : javax.servlet.ServletResponse
dans le corps pour un POST.
#  contient les informations nécessaires pour une
communication du serveur vers le client

Développement de Servlet Développement de Servlet

import javax.servlet.*;
!  Si la méthode utilisée est GET, il suffit de redéfinir la méthode : import javax.servlet.http.*;
public void doGet( HttpServletRequest request, import java.io.*;
HttpServletResponse response ) public class ServletName extends HttpServlet {
public void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException {
!  Si la méthode utilisée est POST, il suffit de redéfinir la // lecture de la requête
méthode : // traitements
// envoi de la réponse
public void doPost( HttpServletRequest request, }
HttpServletResponse response) public void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException {
// lecture de la requête
// traitements
// envoi de la réponse
}
}
Principe de fonctionnement Exemple - HelloServlet
!  Les fichiers de bytecode (.class) sont stockés sur le serveur
(comme des docs)
!  Ils sont désignés par une URL
!  http://depinfo-fst.rnu.tn/MaServlet
!  Le chargement de l'URL provoque l'exécution de la servlet

Exemple - HelloServlet Exemple - HelloServlet

Paramètres des méthodes doGet() et doPost()
!  Utiliser les objets HttpServletRequest et
HttpServletResponse passés en paramètres de ces
méthodes pour implanter le service
!  HttpServletRequest contient les informations sur le formulaire
html initial (utile pour doPost())
!  La méthode getParameter() récupère les paramètres
d’entrée
!  HttpServletResponse contient le flux de sortie pour la
génération de la page html résultat (getWriter())
Aperçu de l’API servlet
!  Méthodes importantes d’un objet HttpServletRequest
!  String getParameter(String param)
#  Retourne la valeur du champ param transmis dans les données du formulaire
!  java.util.Enumeration getParameterNames()
#  retourne l'ensemble des noms de paramètres transmis à la servlet
!  String getMethod()
#  retourne la méthode HTTP (GET ou POST) utilisée pour invoquer la servlet
!  Méthodes importantes d’un objet HttpServletResponse
!  void setContentType(String type)
#  définit le type MIME du document retourné par la servlet
!  PrintWriter getWriter()
#  retourne un flux de sortie permettant à la servlet de produire son résultat
#  la servlet écrit le code HTML sur ce flux de sortie
!  void sendRedirect(String location)
#  permet de rediriger vers l’url location

Aperçu de l’API servlet Déploiement d’une Servlet

Autres méthodes appelables sur un objet HttpServletRequest !  Une servlet doit faire partie d’un module web pour être déployée
!  String getProtocol() !  Un module Web est un ensemble de librairies, de fichiers de
!  retourne le protocole implanté par le serveur (ex. : HTTP/1.1) configurations, de code Java (bytecode des servlets...), ...
!  String getServerName() / String getServerPort()
!  retourne le nom/port de la machine serveur !  Pour déployer une application dans
!  String getRemoteAddr() / String getRemoteHost() un conteneur, il faut lui fournir deux
!  retourne l'adresse/nom de la machine cliente (ayant invoqué la servlet)
éléments :
!  Tous les composants (classes
!  String getScheme() compilées, ressources ...) regroupée
!  retourne le protocole utilisé (ex. : http ou https) par le client dans une archive ou module
!  java.io.BufferedReader getReader() !  Descripteur de déploiement contenu
!  retourne un flux d'entrée permettant à une servlet chaînée de récupérer dans le module qui précise au
conteneur des options pour exécuter
le résultat produit par la servlet précédente l'application
!  permet à la servlet chaînée de modifier le résultat
Déploiement d’une application web Descripteur de déploiement web.xml
!  Web Application Archive : une application web (*.html, *.jsp, <web-app>
servlets, ...) packagée dans un archive (.war) et est paramétrée dans <servlet>
le fichier WEB-INF/web.xml <servlet-name> nom de servlet </servlet-name>
<servlet-class> nom de la classe de servlet </servlet-class>
!  Structure <init-param>
!  Fichiers web de l’application (HTML, JSP, js, css...) < param-name> nom du paramètre d’initialisation </param-name>
!  Répertoire « META-INF » : fichiers de configuration < param-value> valeur du paramètre d’initialisation </param-value>
#  MANIFEST.MF : informations sur le zip </init-param>
</servlet>
!  Répertoire « WEB-INF » : contenu de l’application
#  WEB-INF/web.xml <servlet-mapping>
#  Descripteur de déploiement
<servlet-name> nom de servlet </servlet-name>
#  WEB-INF/classes/
<url-pattern> url d’invocation de servlet </url-pattern>
#  class des servlets et des classes (JavaBean, ...) associées
</servlet-mapping>
#  WEB-INF/lib/
#  .jar additionnels provenant de tierce parties (comme des drivers JDBC, TagLib (JSF, ...),
</web-app>
#  WEB-INF/tlds/
#  .tld décrivant les TagLibs

Descripteur de déploiement web.xml Initialisation de servlet

<web-app> !  La méthode est invoquée pour initialiser la servlet
<servlet> !  Les paramètres d’initiation sont définis dans web.xml
<servlet-name> HelloServlet </servlet-name> !  peuvent être changés sans avoir à recompiler l'application
<servlet-class> server.HelloServlet </servlet-class> !  La méthode, getInitParameter() de l’interface ServletConfig permet de
récupérer ces paramètres d’initialisation
<init-param>
< param-name> compteur </param-name>
< param-value> 0 </param-value> <web-app>
</init-param> …
<servlet>
</servlet>
<servlet-name>InitExample</servlet-name>
<servlet-class>ServletInit</servlet-class>
<servlet-mapping> <init-param>
<servlet-name> HelloServlet </servlet-name> <param-name>login</param-name>
<url-pattern> /hello </url-pattern> <param-value>snoopy</param-value>
</servlet-mapping> </init-param>
</web-app> </servlet>
…
</web-app>

Chaînage de servlets
!  Agrégation des résultats fournis par plusieurs servlets
!  Meilleure modularité
!  Meilleure réutilisation
!  Utilisation d'un RequestDispatcher
!  obtenu via un objet request de type HttpServletRequest
RequestDispatcher rd = request.getRequestDispatcher( "servlet2" );
!  Inclusion du résultat d'une autre servlet
rd.include(request, response);
!  Délégation du traitement à une autre servlet
rd.forward(request, response);
Sessions
!  HTTP protocole non connecté (sans état), ne gère pas les
sessions
!  Deux requêtes successives d'un même client sont
indépendantes pour le serveur
!  Notion de session : suivi de l'activité du client sur
plusieurs pages
!  un objet Session associé à toutes les requêtes d’un utilisateur
!  Les sessions expirent au bout d'un délai fixé (pas de requête
pendant n secondes ! expiration de la session)
!  La gestion des sessions utilise les techniques classiques
!  url rewriting, cookies, champs cachés dans les formulaires
Cookies
!  Cookie = donnée stockée par un serveur web chez un client
!  Moyen pour récupérer des informations sur le client
#  nom, adresse email, …
!  Eviter à l’utilisateur de taper ces informations chaque fois qu’il est
nécessaire
!  L'utilisateur a la possibilité d'interdire leur dépôt dans son navigateur
!  Définis dans la classe javax.servlet.http.Cookie
!  Créé en donnant un nom (String) et une valeur (String) Cookie
unCookie = new Cookie( "sonNom", "saValeur" );
!  Positionné via un objet response
response.addCookie( unCookie );
!  Récupéré via un objet request
Cookie[] desCookies = request.getCookies();
!  Quelques méthodes : String getName() / String getValue()
API de HttpServlet
!  Les servlets offrent une API simplifiant la gestion de sessions
!  L’objet request de HttpServletRequest maintient les informations sur
la session
!  Accessibles via les méthodes:
!  HttpSession session = request.getSession(boolean flag)
#  flag=true: retourne l'objet session courant ou en crée un s'il n'y en a pas.
#  flag=false: retourne l'objet session courant ou null s'il n'y en a pas
!  isRequestedSessionIdFromCookie()
#  vrai si l'id de la session vient d'un cookie
!  isRequestedSessionIdFromURL()
#  vrai si l'id de la session vient d'un URL
!  JSESSIONID est le nom du cookie, utilisé par le conteneur de servlet,
quimaintient un identifiant unique pour chaque session
Configuration de session Méthodes de session
!  Initialisation de la durée d'une session !  Méthodes appelables sur un objet de type HttpSession
!  dans le web.xml (en minutes) !  void setAttribute( String name, Object value );
<session-config> #  ajoute un couple (name, value) pour cette session
<session-timeout>30</session-timeout>
!  Object getAttribute( String name );
</session-config>
#  retourne l'objet associé à la clé name ou null
!  avec la méthode void setMaxInactiveInterval( int seconds ); de
HttpSession qui spécifie le temps avant la fermeture d’une session !  void removeAttribute( String name );
#  enlève le couple de clé name
!  Terminaison de session !  java.util.Enumeration getAttributeNames();
!  après expiration du timeout #  retourne tous les noms d'attributs associés à la session
!  avec la méthode void setMaxInactiveInterval( int seconds ); !  long getCreationTime(); /long getLastAccessedTime();
!  avec la méthode void invalidate() de l'objet HttpSession, #  retourne la date de création / de dernier accès de la session en
HttpSession session = request.getSession(true); ms

session.invalidate(); ou setMaxInactiveInterval(0);

Partage de données entre servlets Les listeners

!  Contexte d'exécution = ensemble de couples (name, value) partagées par toutes les
servlets instanciées
ServletContext ctx = getServletContext()
!  Méthodes appelables sur un objet de type ServletContext
!  void setAttribute( String name, Object value )
#  ajoute un couple (name, value) dans le contexte
!  Object getAttribute( String name )
#  retourne l'objet associé à la clé name ou null
!  void removeAttribute( String name )
#  enlève le couple de clé name
!  java.util.Enumeration getAttributeNames()
#  retourne tous les noms d'attributs associés au contexte
!  Les listeners sont des objets dont les méthodes sont invoquées en fonction
du cycle de vie d'une servlet
!  A la création et à la destruction d'un contexte (une application)
Javax.servlet.ServletContextListener
!  Quand on modifie les attributs du contexte
Javax.servlet.ServletContextAttributeListener
!  A la création, la suppression, d'une session
Javax.servlet.HttpSessionListener
!  A la création, modification, suppression d'un attribut de session
Javax.servlet.HttpSessionAttributeListener
 Les listeners du contexte Les listeners de session
ServletContextListener HttpSessionListener
Void contextDestroyed(ServletContextEvent sce)
Notification that the servlet context is about to be shut
down. Notification that a session was created.
void contextInitialized(ServletContextEvent sce)
Notification that the web application is ready to process Notification that a session was invalidated.
requests.
HttpSessionAttributeListener
ServletContextAttributeListener
void attributeAdded(ServletContextAttributeEvent scab) Notification that an attribute has been added to a
Notification that a new attribute was added to the servlet session.
context.
void attributeRemoved(ServletContextAttributeEvent scab)
Notification that an existing attribute has been remved from the Notification that an attribute has been removed from
servlet context. a session.
void attributeReplaced(ServletContextAttributeEvent scab)
Notification that an attribute on the servlet context has been Notification that an attribute has been replaced in a
replaced. session.

La déclaration d’un listener Exemple de classe de listener

!  Il faut informer le conteneur de la classe de listener, dans le
descripteur de déploiement web.xml

<listener>
<listener-class>
cours.exemple1.SessionCounter
</listener-class>
</listener>
 Filtres Filtres
!  Un filtre est un code exécuté entre la requête et le « endpoint »
!  Permettent de faire du pre et post-processing sur une requête
!  Lire la requête, modifier la requête, modifier la réponse, retourner des erreurs
au client
!  Ajouter des fonctions aux applications
#  Log, Compression, Cache
!  Même cycle de vie qu’une servlet
!  Init/doFilter/destroy
!  Implanter la méthode doFilter()
!  Déclarer le filtre dans web.xml
#  Filter
#  Filter-mapping
!  Le transfert à la suite de la chaine se fait par la fonction chain.doFilter()
!  Transfert à un autre filtre ou à une servlet ou une page HTML ou une page
JSP
!  La suite s’exécute au retour de doFilter()

Filtres Gestion des erreurs

public class LoginFilter extends GenericFilter { !
private FilterConfig filterConfig; ! !  Il est possible de définir les pages à afficher
!
public void doFilter(HttpServletRequest request, HttpServletResponse response,
!  En fonction d'erreurs http
! ! ! ! ! FilterChain chain){ ! !  En fonction d'exceptions java
System.out.println("Entering Filter");!
request.setAttribute("hello","Hello World!");!
!
!chain.doFilter(request,response);!
Pour une
!
!System.out.println("Exiting HelloWorldFilter"); !
Dans web.xml exception
} } ! <error-page> java
<exception-type>
cours.event.EventException
</exception-type>
<location>/erreur.html</location>
</error-page> Pour une
erreur Http
<error-page>
<error-code>404</error-code>
<location>/404.html</location>
</error-page>
Gestion de concurrence
!  Par défaut les servlets sont exécutées de façon multi-threadée
!  Si une servlet doit être exécutée en exclusion mutuelle (ex. :
accès à des ressources partagées critiques)
!  implantation de l'interface SingleThreadModel
public class CompteurServlet extends HttpServlet implements SingleThreadModel{
public void doGet( ServletRequest request, ServletResponse response )
throws ServletException, IOException {
/* Tout le code de la Servlet est en exclusion avec lui-même */
}
}
!  Autre solution : définir du code synchronized dans la servlet
#  Attention aux inter-blocages
Conclusion
!  Servlets : étendent le comportement des serveurs Web avec
des programme Java
!  Portabilité
!  facilité d'écriture (Java)
!  Définition du code, du paquetage, du déploiement
!  Exécutée en // avec des processus légers (threads)
!  Limites
!  Difficile d’écrire du code HTML dans du code Java
#  Introduction de la technologie Java Server Pages (JSP)
!  Pas de mécanisme intégré de distribution
#  Introduction de la technologie Enterprise Java Beans (EJB)

Servlet & JSP

!  Servlet : une classe java
!  Java Server Pages : insertion du code Java dans
une page HTML
!  JSP ont les mêmes fonctionnalités que HttpServlet
!  Implémentation du mécanisme requête/réponse
!  Accéder aux mêmes données/objets qu’une servlet
!  Inclure ou rediriger la requête vers une autre servlet/
JSP
!  Génération de différents types de contenus : HTML,
XML, SVG..
JAVA SERVER PAGES (JSP) !  Gestion des méthodes, headers, cookies, sessions...
Servlet & JSP JSP : illustration du fonctionnement
!  Traitement d’une JSP par le serveur
!  Une JSP est compilée en servlet à la première utilisation
!  Se transforme en classe implémentant:
javax.servlet.jsp.HttpJspPage
!  Lors du premier chargement d’une jsp
!  Génération d’une servlet à partir de la jsp
!  Compilation de la servlet
!  Instanciation de la servlet
!  Délai d’attente lors de la première consultation
!  En cas d’erreur de syntaxe, message envoyé au
navigateur (erreurs détectées à l’exécution)
!  Lors des chargements suivants
!  Exécution de la servlet dans un thread

JSP : illustration du fonctionnement JSP : illustration du fonctionnement

JSP: Syntaxe Scriptlets <% %>
contient du code Java
!  4 parties d'une JSP ! 

!  insérer dans _jspservice() de la servlet, donc peut utiliser out,

!  Scriptlets <% %> ! request, response, …
!  Déclarations <%! %> <html> <body>
<%
!  Expressions <%= %> String[] langages = {"Java", "C++", "Smalltalk", "Simula 67"};
out.println("<h3>Principaux langages orientés objets : </h3>");
!  Directives <%@directive %> for (int i=0; i < langages.length; i++) {
out.println("<p>" + langages[i] + "</p>"); }
%>
</body> </html>

Expressions <%= ... %> Déclarations <%! … %>

!  <%= expr %> génère l'affichage d'une valeur de
l'expression expr
!  expr : expression en Java qui renvoie un objet String ou un type
primitif.
!  raccourci pour <% out.println(expr); %>
!  Méthodes et variables d'instance
!  Des méthodes et des variables d'instance peuvent être
associées à une JSP entre les directives <%! et %>
!  Méthodes et variables d’instance de la servlet générée
Déclarations <%! … %> Directive <%@directive... %>
!  Méthodes et variables d’instance !  Fournit des informations globales relatives à la page
!  Méthode d’instance de la servlet générée à partir de la jsp <%@ directive attribut="valeur" %>
!  Pas d’accès aux objets implicites (out, request, page...) : ce !  Trois types de directives:
sont des objets définis dans la méthode principale de la
servlet (_jspService()) !  page : modifier les données de la page (import de packages, spécification
d’un type de contenu, gestion des sessions)
Attention! #  Forme générale :
<%@ page import="java.io.*, java.sql.*">
<%@ page isErrorPage="false" %>
<%@ page contentType="text/html" %>
!  include : inclure des fichiers ou autres servlets/JSP, C’est comme si le
contenu du fichier à inclure était directement copié dans le fichier courant.
<%@ include page="/monJSP.jsp" %>
<%! ... %> : définie une variable d’instance (persiste entre deux invocations)
<% ... %> : définie une variable locale à la jsp (réinitialisée à chaque invocation) !  taglib : utiliser des bibliothèques de balises personnalisées
<%@ taglib uri="..." prefix="..." %>

Objets implicites Objets implicites

!  Objets pré-déclarés utilisables dans le code Java des
JSPs
!  out : le flux de sortie pour générer le code HTML
!  request : la requête qui a provoqué le chargement de la JSP

!  response : la réponse à la requête de chargement de la JSP

!  page : l'instance de servlet associée à la JSP courante ( this)

!  exception : l'exception générée en cas d'erreur sur une page

!  session : suivi de session pour un même client

!  application : espace de données partagé entre toutes les JSP

<HTML>
<BODY BGCOLOR="#ffffcc">
<CENTER>
<% if (request.getParameter("nom")==null
Gestion des erreurs
&& request.getParameter("email")== null) { %>
<H2>Information utilisateur</H2>
<FORM method="GET" action="/exemple2/web/process.jsp"> !  Erreur de syntaxe
<P>Votre nom: <input type="text" name="nom" size=26>
<P>Votre email: <input type="text" name="email" size=26>
!  Dans le code HTML
<P><input type="submit" value="Envoyer"> !  Dans les directives JSP (ex. : oubli d'une directive %>)
</FORM>
!  Dans le code Java (ex : oubli de ;)
<% } else { %> !  Erreur d’ exécution du code Java (ex. : NullPointerException)
<%! String nom, email; %>
<% nom = request.getParameter("nom"); !  Dans tous les cas, erreur récupérée dans le navigateur client
email = request.getParameter("email");
%>
!  Conserver la page par défaut construite par le moteur
<P><B>Vous avez fourni les informations suivantes:</B> !  En concevoir une adaptée aux besoins particuliers de l'application
<P><B>Name</B>: <%= nom %>
<P><B>Email</B>: <%= email %> !  Utilisation des directives :
<% } %> #  <%@ page errorPage="..." %> : URL du gestionnaire d’erreurs
</CENTER>
#  <%@ page isErrorPage="..." %> : vrai si page est un gestionnaire
</BODY>
</HTML>
d’erreurs

Gestion des erreurs Gestion des erreurs

Balises de commentaires La directive <%@include %>
!  2 manières de placer des commentaires dans une page JSP <%@include file="/chemin/relatif/auContexte"%>
<!-- mon commentaire -->
!  Cette inclusion se fait au moment de la conversion,
!  dans ce cas les commentaires sont transmis à la réponse. Ils pendant la création de la servlet correspondante.
sont donc visibles lorsqu'on visualise le code source de la !  Le contenu du fichier externe est inclus comme s’il était
page HTML.
saisi directement dans la page JSP
!  ou
!  Les ressources à inclure doivent être contenues dans le
<%-- mon commentaire --%>
contexte de l'application web
!  Le serveur JSP ne les prend pas en compte. Leur intérêt est
uniquement de commenter le code JSP

Exemple <%@include %> TagLib

!  Un tag JSP est une simple balise XML à laquelle est associée une classe Java.
!  A la compilation d'une page JSP, ces tags sont remplacés par l'utilisation de
ces classes Java qui implémentent une interface particulière.
<prefixe:nomDuTag attribut="valeur">
Corps du tag
</prefix:nomDuTag>
#  Un préfixe, qui permet de distinguer les différentes taglibs utilisées.
#  Le nom du tag de la librairie
#  un certain nombre de couple d'attribut/valeur
#  un corps.
!  Une JSP Taglib est une collection d'actions prédéfinies destinée à être utilisée
dans une page JSP sous forme de tags.
!  Elle se compose:
!  d'un descripteur de taglib (Tag Librarie Descriptor)
!  d'un ensemble de classes Java implémentant l'interface JspTag
TagLib usuels
!  jsp:useBean associe une instance d’objet Java Bean
!  jsp:setProperty positionne la valeur d’une propriété d’un bean
!  jsp:getProperty récupère la valeur de la propriété d’un bean
!  jsp:include inclut le contenu du page statique ou dynamique
!  jsp:invoke invoque l’exécution d’un fragment (JSP, ...)
!  jsp:forward redirige le traitement de la requête à un autre script
!  jsp:element insère un élément (XML) dans le document
!  jsp:attribute attribut d’un élément
!  jsp:output configure le prélude du document XML
!  jsp:param paramètre (key/value) pour jsp:forward et jsp:include
!  jsp:text ajoute le texte à la sortie
!  jsp:plugin insère un objet externe
!  jsp:fallback alternative en cas d’échec du jsp:plugin
!  jsp:params liste les jsp:param dans un jsp:plugin
Le tag <jsp:include>
!  Agrégation des résultats fournis par plusieurs JSP
!  Inclusion dynamique (délégation de servlets : deux servlets, l’une appelle
l’autre)
Fichierinc.jsp
Le tag <jsp:include>
!  permet d'inclure le contenu généré par une JSP ou une servlet
dynamiquement au moment ou la JSP est exécutée.
!  Contrairement à la directive <@include page= > avec laquelle le fichier
est inséré dans la JSP avant la génération de la servlet.
!  Syntaxe <jsp:include page= "URL" flush="true" />
!  L'attribut page permet de préciser l'URL relative de l'élément à insérer.
!  L'attribut permet d'indiquer si le tampon doit être envoyé au client est vidé
avant de l’inclure.
!  Par défaut : flush = false
!  Si flush = true : le serveur envoie le tampon de sortie de la page en cours (la
partie de la page qui a déjà été traitée) dans le navigateur avant de traiter le
fichier inclus.
Le modèle de composants Java
!  Le modèle de composants Java (Java beans) permet
de construire une application en assemblant des entités
logicielles par programme (ou visuellement)
!  Ce modèle de composants est décrit par un ensemble
d'APIs
!  Pour fonctionner, ce modèle repose sur un ensemble
d'outils formant un environnement dans lequel les
composants interagissent
!  Ce modèle utilise des conteneurs qui fixe un cadre
pour la coopération des composants
!  Dans l'architecture des applications web (3-tiers), les
composants métiers sont implantés par des Java beans
Persistance - JavaBean
!  Un bean est un objet Java
!  Comme tout objet, il possède un état
!  Cet état doit être mémorisé pour toute utilisation
ultérieure du bean
!  Tout bean doit donc utiliser un mécanisme de
persistance universel défini par leur conteneur
!  Ils doivent d'implémenter l'interface java.io.Serializable
Exemple de JavaBean
JavaBean
!  Les JavaBeans sont des classes Java qui respectent les directives
suivantes :
!  un constructeur public sans argument
!  les propriétés d'un Bean sont accessibles au travers de méthodes
getXXX (lecture) et setXXX (écriture) portant le nom de la propriété
!  Méthodes de lecture des propriétés :
!  type getNomDeLaPropriété()
!  boolean isNomPropriété()
!  Méthodes d'écriture des propriétés :
!  void setNomDeLaPropriété(type) : un seul argument du type de la
propriété et son type de retour est void
!  Un JavaBean implémente l'interface java.io.Serializable
!  permettant la sauvegarde de l'état du Bean
Bean et JSP
!  Un bean est inclus dans une page JSP par la balise :
<jsp:useBean>
!  permet de localiser une instance ou d'instancier un bean pour l'utiliser
dans la JSP
!  Un bean peut encapsuler des traitements complexes et être réutilisable
par d'autre JSP ou composants
!  Après exécution, un bean rend son résultat à la page JSP ou à la
servlet
!  L'utilisation de beans évite l'emploi de la méthode
getRequestParameter(...)
!  La valeur du paramètre d'une requête peut être utilisée directement
pour renseigner la propriété d'un bean
!  Un serveur peut gérer la portée (scope) d'un bean en le liant soit à
une page, une requête, une session ou une application
 JavaBeans - Syntaxe JSP et Java Beans
<jsp:useBean id="nomInstanceJavaBean"
class="nomClasseDuBean"
scope="request|session|application|page">
</jsp:useBean>

!  Le bean est alors identifié et accessible par : "nomInstanceJavaBean"

!  L'attribut scope indique la portée du bean.

JSP et Java Beans JSP et Java Beans

!  Récupération des propriétés du bean: !  Positionner les propriétés du bean dans une JSP
!  Par appel de méthode getXXX() ou par la balise<jsp:getProperty…> !  Par appel de méthode setXXX(...) ou par la balise <jsp:setProperty…>
Exemple Exemple
!  La page JSP qui suit affiche le texte : Bonjour suivi de la valeur du
paramètre nom de la requête.
!  La classe HelloBean est stockée dans le répertoire entites.
!  La propriété nom du bean HelloBean est alimentée par le
paramètre de la requête passé dans son en-tête si celui-ci est
renseigné
!  Sinon c'est sa valeur par défaut qui est utilisée
!  L'exécution de la page JSP provoque l'affichage du texte bonjour
suivi du contenu de la propriété nom du bean HelloBean
!  Intérêt :
!  pas de code Java dans la page JSP
!  modularité dans la construction de l'application

Exemple JSP et JavaBeans – Centré page!

!  La logique de l’application est dans

les pages JSP
!  Mixité de la présentation et la logique
métier

!  L’enchainement des pages est codé memu.jsp catalog.jsp checkout.jsp

dans les pages JSP
!  Contrôle de flux pris en charge par les
JSP

dataBase

page–centric catalog application

Modèle MVC Modèle MVC en JAVA
!  Le modèle Model-View-Controller a pour objectif !  Controlleur : Servlet
d ’organiser une application interactive en séparant :
!  les données !  View : JSP
!  la représentation des données !  Model : JavaBean
!  le comportement de l’application

!  Le Model représente la structure des données dans

l ’application et les opérations spécifiques sur ces données
!  Une Vue présente les données sous une certaine forme à
l ’utilisateur, suivant un contexte d ’exploitation.
!  Un Controller traduit les interactions utilisateur par des appels
de méthodes (comportement) sur le modèle et sélectionne la
vue appropriée basée sur l’état du modèle.

Exemple - MVC : étape 1 index.html

!  Le client récupère un formulaire (index.html)
!  pour passer une requête avec paramètres (1, 2, puis 3)
MVC : étape 2 Controller : SelectPromo.java
1. Le client envoie son formulaire (GET/POST avec paramètres)
2. Le conteneur transmet au servlet correspondant (le controller)

Configuration : web.xml MVC : étape 3

3. La servlet controller interroge le model sur «ing2»
4. Le model retourne au controller le résultat correspondant
Model : Promo.java MVC : étape 4
5. Le controller utilise les données du model pour sa réponse
6. Le controller transmet sa réponse à la view (JSP)

Controller : SelectPromo.java MVC : étape 5

7. La JSP (view) traite la réponse transmise par le controller
8. La page HTML résultante est reçue par le client
View : result.jsp Ex : AREL V6 - liste des promos