Java Edition Entreprise

Java Edition Entreprise
Introduction de qq Bases sur

Programmation Web
Les composants d’une application web
Pages Web dynamique
Une page html pourrait être générée dynamiquement
par un script côté serveur,
Les langages et les serveurs utilisés sont diverses,
La technologie des servlets Java et page JSP
fonctionnant avec différents serveurs (Tomcat,
Apache,..) et sur différentes plate-formes (Windows,
Linux),
Une page html peut également contenir des scripts qui
seront exécutés par le navigateur,
Les langages de script côté navigateur sont nombreux
PerlScript, JavaScript,..
Un script JSP
<%@ page import="java.util.*" %>
<% // code java%>
<%
Calendar calendrier = Calendar.getInstance();
int mn= calendrier.get(Calendar.MINUTE);
int h = calendrier.get(Calendar.HOUR_OF_DAY);
int s = calendrier.get(Calendar.SECOND);
%>
<% // code html %>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page affichant l heure</title>
</head>
<body>
<h1>Il est <%=h%>:<%=mn%>:<%=s%></h1>
</body>
</html>
JavaScript côté navigateur
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page affichant l heure</title>
<script language="javascript">
function réagir(){
alert ("vous avez cliqué sur le bouton ok");
}
</script>
</head>
<body>
<form action="index.jsp" method="get">
<input type="submit" value="ok" onclick="réagir()">
</form>
<h1>Il est <%=h%>:<%=mn%>:<%=s%></h1>
</body>
</html>
Les échanges client/serveur
Les applications web se trouvent sans la couche

Application et s’appuient donc sur les protocoles TCP-
IP (couche Application, Transport, Réseau, Interface
réseau).
Les couches des machines client et serveur utilisent le
protocole HTTP pour s’échanger des messages et se
comprendre. Ces messages sont normalisés et ont la
forme suivante:
Entêtes HTTP
Ligne Vide
Document
Le modèle TCP/IP
Application Application
| ---HTTP--- |
Transport Transport
| |
Réseau Réseau
| |
Interface réseau Interface réseau
| --réseau physique-- |
Les méthodes HTTP
Le protocole HTTP dispose de « méthodes »; ce sont des mots que le

navigateur utilise pour dialoguer avec le serveur.
Nous nous intéressons à trois en particulier: GET,POST et HEAD.
 GET: permet de récupérer une ressource web du serveur via une URL ou en
cliquant sur un lien. La réponse consiste à retourner la ressource demandée,
accompagnée d'informations diverses à son sujet (la taille des donnée, la date d
‘envoi…) dans ce qui s'appelle les en-têtes. Des paramètres peuvent être placés
dans l’URL ou dans des cookies pour ensuite être transmises au serveur.
 POST: permet de soumettre au serveur des données de tailles variables et
volumineuses, parfait pour envoyer des fichiers par exemple.
 HEAD: Cette méthode est identique à la méthode GET, la réponse du serveur
contient seulement les en-têtes HTTP.
La requête HTTP part du client et arrive sur le serveur.
Alors le serveur HTTP (on parle également de serveur web) entre en jeu…
Pour l’écoute de la requête sur un port (en générale 80), il la transmet
ensuite à un autre élément le conteneur …
Java Framework
La plateforme Java est composée de trois éditions, destinées à des usages différents :
Java ME : Java Micro Edition est prévu pour le développement d'applications
embarquées, notamment sur des terminaux mobiles ;
Java SE : anciennement Java 2 Standard Edition est destiné au développement
d'applications pour ordinateurs personnels, poste de travail ;
Java EE : Java Enterprise Edition, destiné à des applications entreprises en
fournissant un ensemble de composants sous forme d’API.
Chaque édition propose un environnement complet pour le développement et

l'exécution d'applications basées sur Java et comprend notamment une machine
virtuelle Java (Java virtual machine) ainsi qu'un ensemble de classes.
Java EE (Java Enterprise Edition) est une norme proposée par la société Sun, portée
par un consortium de sociétés internationales, visant à définir un standard de
développement d'applications d'entreprises multi-niveaux, basées sur des composants.
On parle généralement de la plateforme JEE pour désigner les services offerts
(API), les composants et l’infrastructure d’exécution.
La plateforme JEE
 La plateforme JEE comprend:
 Les spécifications du serveur d'application, c'est-à-dire de l'environnement
d'exécution:
J2EE définit finement les rôles et les interfaces pour les applications ainsi que
l'environnement dans lequel elles seront exécutées. Ces recommandations permettent
ainsi à des entreprises tierces de développer des serveurs d'application conformes aux
spécifications ainsi définies, sans avoir à redévelopper les principaux services.
 Les service, c'est-à-dire des extensions Java indépendantes permettant d'offrir
en standard un certain nombre de fonctionnalités. Ils pouvent être classés par
catégories :
Les services d'infrastructures : JDBC,JNDI…
Les services de communication : JavaMail,JAAS…
 Les composants, on distingue habituellement deux familles de composants :
 Les composants web : Servlet et JSP.
 Les composants métier : EJB (Enterprise Java Beans). Il s'agit de
composants spécifiques chargés des traitements des données propres à un
secteur d'activité (on parle de logique métier ou de logique applicative) et de
l'interfaçage avec les bases de données.
Architecture Java EE
API Servlet
un des composants de base pour le développement d'applications Web;

Peut servir à créer dynamiquement des pages HTML;
Bien sûr d’autres solutions existent pour les pages web dynamiques;
Les servlets* peuvent servir à d’autres usages;
Ecrite sur le langage Java, elle a tous les avantages du langage:
Portabilité, l’accès aux APIs Java dont le JDBC…
* Sevlet est masculin selon le grand dictionnaire terminologique, féminin selon le livre Servlets Java: guide des
programmeurs
Une servlet
Un programme java qui s'exécute côté serveur:
la portabilité, l'accès à toutes les API de java dont JDBC pour l'accès aux bases de
données, ...
Effectue les traitements et renvoie le résultat correspondant à la requête du
client. Elle agit selon le modèle requête/réponse.
Cette interaction peut être directe ou via un serveur http, ftp, etc
La principale utilisation actuelle est la génération de pages html dynamiques
utilisant le protocole http et donc un serveur web,
Mais n'importe quel protocole reposant sur le principe de requête/réponse peut
faire usage d'une servlet.
Une servlet peut être invoquée plusieurs fois en même temps pour répondre à
plusieurs requêtes simultanées.
La servlet se positionne dans une architecture Client/Serveur trois tiers dans le
tiers du milieu entre le client léger chargé de l'affichage et la source de données.
La version actuelle de la spécification servlet est 3.1 depuis Mai 2013.
Serveur d’application
 Un serveur d'application permet de charger et d'exécuter les servlets
dans une JVM. C'est une extension du serveur web qui a ses limites:
Pas de contenu dynamique, Pas de sauvegarde de données sur le
serveur
 Ce serveur d'application contient entre autre un moteur de servlets qui
se charge de manager les servlets qu'il contient: un conteneur
 La notion de conteneur se retrouve dans de nombreuses technologies
– Servlet, Applet, MIDlet, Xlet, (*-let), EJB, …
 Un conteneur est un composant logiciel système qui contrôle d’autres
composants, dits métier
– Tomcat est un exemple de conteneur
– Les servlets n’ont pas de méthode main(), ils sont contrôlés
par le conteneur Tomcat
– Les requêtes ne sont pas adressées aux servlets mais au
conteneur dans lequel ils sont déployés.
Pourquoi un conteneur ?
 Un conteneur web est un moteur de servlet prend en charge l’instanciation et
le chargement de la servlet, gestion de son cycle de vie, passage des requêtes et
des réponses ... Un conteur web peut être intégré dans un serveur d'application
qui va contenir d'autre conteneur et éventuellement proposer d'autres services..
 Pourquoi? Pour oublier le cours de « réseau » et faciliter la tâche du programmeur
 Un conteneur fournit pour les Servlets
– Un support pour la communication
– La gestion du cycle de vie
– Un support pour le Multithreading
– Un support pour la sécurité
– Un support pour les JSP
Notion de module Web
 Un servlet ne peut pas être déployé directement dans un conteneur, il doit faire
partie d’un module Web
 Un module Web est un ensemble de librairies, de fichiers de configurations, de
code Java (bytecode des servlets…), …
 Le module Web est l’unité de déploiement dans le conteneur
Le fonctionnement d’une servlet
Remarque 1: Le chargement et l'instanciation d'une servlet se font selon le paramétrage soit au

lancement du serveur soit à la première invocation de la servlet. Dès l'instanciation, la servlet est
initialisée une seule et unique fois avant de pouvoir répondre aux requêtes. Cette initialisation peut
permettre de mettre en place l'accès à des ressources tel qu'une base de données.
Pour exécuter une servlet, il suffit de saisir une URL qui désigne la servlet dans un navigateur.
1. Le serveur reçoit la requête http qui nécessite une servlet de la part du navigateur
2. Si c'est la première sollicitation de la servlet, le serveur l'instancie. Les servlets sont stockées (sous
forme de fichier .class) dans un répertoire particulier du serveur. Ce répertoire dépend du serveur
d'application utilisé. La servlet reste en mémoire jusqu'à l'arrêt du serveur.
Remarque 2: La servlet en mémoire, peut être appelée par plusieurs threads lancés par le serveur pour
chaque requête. Ce principe de fonctionnement évite d'instancier un objet de type servlet à chaque
requête et permet de maintenir un ensemble de ressources actives tel qu'une connexion à une base de
données.
3. le serveur créé un objet qui représente la requête http et objet qui contiendra la réponse et les envoie à
la servlet
4. la servlet créé dynamiquement la réponse sous forme de page html transmise via un flux dans l'objet
contenant la réponse. La création de cette réponse utilise bien sûre la requête du client mais aussi un
ensemble de ressources incluses sur le serveur tels de que des fichiers (bean) ou des bases de données.
5. le serveur récupère l'objet réponse et envoie la page html au client.
Les outils pour développer
 Il faut utiliser le Java Server Development Kit (JSDK) qui est une
extension du JDK.
 Pour exécuter des application web, il faut un serveur d’application:

Versions commerciales mais aussi des versions libres telles que Tomcat du projet
GNU Jakarta.
 Ce serveur d’application doit inclure un serveur web http dont le plus

utilisé est Apache.
 Le choix d’un serveur d’application doit tenir compte de la version du

JSDK qu’il supporte.
 Pour développer des servlets, le choix d’un des deux serveurs Apache
Tomcat ou Glassfish se justifie pleinement de part sa gratuité et sa
« légèreté »
L'API servlet
L'API servlets est une extension du jdk de base, regroupe dans des packages préfixés par
javax
Il en a deux:
 javax.servlet : contient les classes pour développer des serlvets génériques indépendantes
d'un protocole
 javax.servlet.http : contient les classes pour développer des servlets qui reposent sur le
protocole http utilisé par les serveurs web.
L'interface Servlet
 Une servlet est une classe Java qui implémente l'interface javax.servlet.Servlet.
 Cette interface définit 5 méthodes qui permettent au conteneur web de dialoguer avec la
servlet .
La requête et la réponse
 Dans l’interface ServletRequest, plusieurs méthodes permettent d’obtenir des données sur
la requête du client :
 L’interface ServletResponse
Servlets HTTP
GenericServlet fournie un niveau d'abstraction permettant de développer facilement

des servlets avec le protocole http.
Requêtes et Réponses HTTP
Servlet (http) en 4 étapes (1/4)
Créer l’arborescence suivante

Projet Dynamic web project
src WebContent
WEB-INF Imposé par

la spécification
des servlets
Clock.java
Web.xml
Servlet en 4 étapes (2/4)
package ensat.cours.tp;
Ecrire servlet Clock et le mettre dans
import java.io.*;
import javax.servlet.http.*;
src
import javax.servlet.*;
public class Clock extends HttpServlet { Redéfinition

public void doGet(HttpServletRequest request, HttpServletResponse reponse) de la méthode
throws IOException, ServletException{
doGet
String title = "Clock";
String doctype = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Strict//EN \" \"
http://www.w3.org/TR/html4/strict.dtd \" >" ;
reponse.setContentType("text/html");
PrintWriter out = reponse.getWriter();
out.println(doctype +
Code html"<html><head><title>"+title+"</title></head>"+
incorporé"<body><h1>Time On Server</h1>"+"<br>"+
new java.util.Date() +"</body></html>");
dans du out.close();
java }
}
Créer un descripteur de déploiement et le
<?xml version="1.0" encoding="UTF-8"?> mettre dans WEB-INF
<web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-
app_2_4.xsd">
<display-name>WebModule1</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list> Servlet-name permet de lier <servlet
>et <servlet-mapping>
<servlet>
<servlet-name>The Clock</servlet-name>
<servlet-class>ensat.cours.tp.Clock</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>The Clock</servlet-name>
nom utilisé par
<url-pattern>/Serv1</url-pattern>
l’utilisateur dans sa
</servlet-mapping>
requête
Dans les projet web version 3 d’Eclipse, ce fichier est remplacé par des annotations
</web-app>
@WebServlet("/Controle")
 Démarrer le serveur (Tomcat)
 Compiler la servlet
 Lancer un navigateur et taper http://localhost:8080/Projet/Serv1
Premier TP
Le but est de créer une première application web:
 Comment la créer, la déployer sur Tomcat (notre conteneur de servlet) et la tester?
 Comme IDE, nous utiliserons Netbeans. En premier, il faut installer le plugins Java Web
Application.
Exemples de Servlet
Entêtes d’une requête GET
public class ShowRequestHeaders extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response) throws
IOException {
//...
out.println(doctype +
"<html>\n<head><title>" + title + "</title></head>\n" +
"<body>\n<h1>" + title + "</h1>\n" +
"<b>Request Method: </b>" + request.getMethod() + "<br />\n" +
"<b>Request URI: </b>" + request.getRequestURI() + "<br />\n" +
"<b>Request Protocol: </b>" + request.getProtocol() + "<br />)
out.println("<table>\n" +"<tr><th>Header Name</th><th>Header Value</th></tr>");
Enumeration<String> headerNames = request.getHeaderNames();
while(headerNames.hasMoreElements()) {
String headerName = headerNames.nextElement();
out.println("<tr><td>" + headerName + "</td>");
out.println("<td>" + request.getHeader(headerName) +"</td></tr>");
}
out.println("</table>\n</body></html>");
out.close();
}
}
Entêtes d’une requête GET (2) changer
Entêtes d’une requête POST
public class ShowRequestHeaders extends HttpServlet {

public void doPost(HttpServletRequest request, HttpServletResponse response)
throws IOException {
doGet(request,response);
}
}
Formulaire GET
<form action="Serv2">
<table border="0">
<tr>
<td>Nom: </td><td><input type="text" name="nom"></td>
</tr>
<tr>
<td>Prénom:</td><td><input type="text" name="prenom"></td>
</tr>
<tr>
<td colspan="2" align="center"><input type="submit" value="
Envoyer" </td>
</tr>
</table>
</form>
Traitement formulaire GET
Get http://localhost:8080/WebModule1/Serv2? nom=houda&prenom=Belmokadem
HTTP/1.1
host:localhost:8080
user-agent:Mozilla/4.0 GET
accept:image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms-excel,
application/vnd.ms-powerpoint, application/msword, application/x-shockwave-flash, */*
accept-language:fr
...
public class LogServlet extends HttpServlet {

public void doGet(HttpServletRequest request,HttpServletResponse response) throws IOException {
String login = request.getParameter("nom") ;
String password = request.getParameter("prenom") ;
//WhatYouWant
if (checkUserAndPassword(login, password)) {
grantAccessTo(login);
} else {
sendAuthentificationFailure(login);
}
}
}
Formulaire POST
<form method="post" action="Serv2">

<table border="0">
<tr>
<td>Nom: </td><td><input type="text" name="nom"></td>
</tr>
<tr>
<td>Prénom:</td><td><input type="text" name="prenom"></td>
</tr>
<tr>
<td colspan="2" align="center"><input type="submit" value=" Envoyer"
</td>
</tr>
</table>
</form>
Traitement formulaire Post
Post http://localhost:8080/WebModule1/Serv2 HTTP/1.1
host:localhost:8080
user-agent:Mozilla/4.0
accept:image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms-excel,
GET
application/vnd.ms-powerpoint, application/msword, application/x-shockwave-flash, */*
accept-language:fr
...
content-type:application/x-www-form-urlencoded
content-length:27

public void doPost(HttpServletRequest request,HttpServletResponse response)
throws IOException {
doGet(request, reponse);
}
}
Paramètres de formulaires
public class ParametresFormulaire extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse reponse) throws IOException, ServletException{
…
out.println(doctype+ "<html><head><title>"+title+"</title><head>"+ "<body>");
Enumeration<?> paramètres = request.getParameterNames();
if(!paramètres.hasMoreElements())
out.println("il n'existe pas de paramètre dans la requête du client" +"</body>+</html>");
else{
out.println(request.getQueryString()+
"<br><table border=\"0\"><tr><th>Paramètre</th><th>Valeur</th></tr>");
while(paramètres.hasMoreElements()){
String param = (String) paramètres.nextElement();
out.println("<tr><td>"+param+"</td>");
String[] paramValues = request.getParameterValues(param);
for(int i=0; i<paramValues.length ; i++){
out.println("<td>"+ paramValues[i]+ ";"+"</td>");
}
out.println("</tr>");
}
out.println("</table>");
}
out.println("</body></html>");
out.close();
}
Vérification de données manquantes
 Champ manquant dans le formulaire
• getParameter retourne null
 Champ renvoyé vide
• getParameter retourne une chaine vide (ou une chaine avec des
espacements)
String param = request.getParameter("someName");

if ((param == null) || (param.trim().equals(""))) {
doSomethingForMissingValues(...);
} else {
doSomethingWithParameter(param);
}
Réponse HTTP (rappel)
 Une réponse HTTP peut contenir du HTML
 HTTP rajoute des (meta)informations en entête du contenu de la réponse
Les méthodes pour les Status Codes
response.setStatus(int statusCode)
– Utiliser les constantes, pas d’entiers directement
– Noms dérivés du message standard
• Ex : SC_OK, SC_NOT_FOUND, etc
• response.sendError(int code, String msg)

– Englobe le message dans un petit document HTML
• response.sendRedirect(String url)
– Le code de status est alors 301
– L’attribut « Location » est également généré dans
l’entête de la réponse
Exemple sendError
public void doGet(HttpServletRequest request, HttpServletResponse response) throws
IOException {
String login = request.getParameter("param1") ;
String password = request.getParameter("param2") ;
if ((login == null) || (login.trim().equals(""))) {
response.sendError(HttpServletResponse.SC_NOT_FOUND,“champs login
vide");
return;
}
if (checkUserAndPassword(login, password)) {
grantAccessTo(login);
} else {
response.sendError(HttpServletResponse.SC_UNAUTHORIZED, “accès refuser
au compte" + login);
}
}
}
Exemple sendRedirect
public class WrongDestination extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String userAgent = request.getHeader("User-Agent");
if ((userAgent != null) &&(userAgent.contains("MSIE")) {
response.sendRedirect("http://home.netscape.com");
}
else {
response.sendRedirect("http://www.microsoft.com");
}
}
}
Même URL de départ ensuite une redirection ...

Générer un fichier Excel
public class FichierExcel extends HttpServlet {
public void doGet(HttpServletRequest requete, HttpServletResponse reponse)
throws IOException,ServletException{
reponse.setContentType("application/vnd.ms-excel");
PrintWriter out = reponse.getWriter();
out.println("\tQ1\tQ2\tQ3\tQ4\tTotal");
out.println("Apples\t78\t87\t92\t29\t=SOMME(B2:E2)");
out.println("Oranges\t77\t86\t93\t30\t=SOMME(B3:E3)");
}
}
Upload de fichiers (avec Commons FileUpload )
 Formulaire HTML
– <input type="file" name="nameFile" />
– <form method="post" enctype="multipart/form-data" action="/servlet">
– Le choix du enctype impacte les autres champs du formulaire
• request.getParameter("name") ne fonctionne plus
 Côté Servlet
– utiliser une librairie
Commons FileUpload du projet Jakarta
(http://commons.apache.org/fileupload/)
 Développement
– import org.apache. tomcat.util.http.fileupload.*
– import org.apache. tomcat.util.http.fileupload.servlet.*
 Déploiement
– Dans le module Web de l’application…
– …dans le répertoire WEB-INF/lib
• commons-fileupload-1.2.1.jar
• commons-io-1.4.jar
Exemple : Upload simple (½)
//Télécharger un fichier txt et l’afficher dans la réponse de la servlet
if ( ServletFileUpload.isMultipartContent(request) ) {
// create a factory for disk-based (large) file items

FileItemFactory varr = new DiskFileItemFactory() ;
((DiskFileItemFactory) fileItemFactory).setSizeThreshold(40960); //the unit is bytes
// create a new file upload handler

ServletFileUpload var = new ServletFileUpload(varr);
servletFileUpload.setSizeMax(81920); // the unit is bytes
Exemple : Upload simple (2/2)
try {
List<?> fileItemsList = var.parseRequest(request);
// Process file items
Iterator<?> it = fileItemsList.iterator();
while (it.hasNext()){
DiskFileItem fileItem = (DiskFileItem)it.next();
if (fileItem.isFormField()){ // classic form field (name=value)
out.println("<b>Champs:</b><br />\n" + fileItem.getFieldName() +"=" +
fileItem.getString()+ "<br/>");
}
else{ // uploaded file
out.println("<b>Fichier:</b><br />\n<pre>" + fileItem.getString() + "</pre><br/>");
}
}
} catch (FileUploadException e) {
out.println("Impossible de télécharger ce fichier");
e.printStackTrace();}}
Introduction aux JSP
JSP: Java Server Pages

Introduction
Que sont les pages JSP?
 Technologie basée sur Java qui simplifie le développement de sites web dynamique.
 Offre la possibilité d’incorporer rapidement des éléments dynamiques dans les pages web en intégrant
du code java et en utilisant des balises (tags) simples.
 Ainsi, les développeurs HTML peuvent accéder aux données et à la logique métier encapsulée dans
des objets Java sans devoir maîtriser toutes la complexité de développement des applications Java.
Les avantages des JSP

basé sur un langage orienté objet fortement typé:
L’encapsulation, la gestion automatique de la mémoire, le traitement des exceptions…
La portabilité du bytecode ne limite pas à l’utilisation exclusive d’un seul type de plate-forme matérielle:
Si l’un des serveurs doit être remplacé, les pages JSP peuvent être réutilisées telles quelles
Outre, les JSPs présentent leur propres avantages : une séparation nette entre les éléments de présentation
de l ‘application web et son implémentation.
Les composants réutilisables

Plusieurs balises permettent d’interagir avec des objets java résidant dans le serveur, en particulier avec
les javaBeans côté serveur.
La séparation de la présentation et de l’implémentation

L’avantage de dissocier ces deux aspects tient à ce que les modification apportées à l’un ne se répercutent
pas sur l’autre.
Une JSP en 1 étape
 Ecrire une JSP Clock.jsp et la mettre à la racine du dossier web au même
endroit que les fichier HTML.
webContent
Que contient une JSP?
Fichier texte combinant du HTML standard et de nouvelles balises de script.

Compilées en servlet lors de leur première invocation.
Exécutée par un moteur JSP ou conteneur (un plug-in pour des serveurs web
existants)
Lorsque un client demande une ressource JSP, le conteneur enveloppe cette
requête et la transmet à JSP en compagnie d’un objet réponse. JSP traite la
requête et modifie l’objet réponse pour y incorporer la communication avec le
client.
Mais au final une JSP n’est autre qu’une servlet

Correspondance JSP/Servlet
• JSP d’origine
• Servlet générée par Tomcat

• $ECLIPSEWORKDIR\.metadata\.plugins\org.eclipse.wst.server.core\tmpX\
work\Catalina\localhost\MonProjet\org\apache\jsp
Cycle de vie d’une JSP
Exemple d’une première JSP: Hello
<body>
<% String visitor= request.getParameter(request.getParameter("name"));
if(visitor== null) visitor="World";%>
Hello, <%=visitor %>!
</body>
<body>
<jsp:useBean id="Bean" class="ensat.cours.HelloBean" />
<jsp:setProperty name="Bean" property="name" param="x"/>
Hello, <jsp:getProperty name="Bean" property="name"/>
</body>
Les conventions des balises
Deux types de balises:

Les balises orientées-script inspirées des ASP (Active Server Pages):
Reconnaissables leur délimiteurs : débutent par <% et se terminent par %>
Dans certain cas les caractères sont suivis par !, =, @ pour affiner le sens de la balise.
Les balises basées sur XML:

Ils tiennent compte de la casse.
Les attribut qui paraissent dans la balise doit être entourée d’apostrophes ou de
guillemets.
Une balise sans corps est close par un chevron simple de fermeture (/>).
Par contre les balise ayant un corps adopte les même convention que HTML.
<jsp:useBean id="Bean" class="ensat.cours.HelloBean" />
<jsp:useBean id="Bean" class="ensat.cours.HelloBean" >

…..
</jsp:useBean>
Les balise JSP
Quatre catégories:
 Les directives: utilisées pour transmettre au conteneur de JSP des informations

de traitement spécifiques à une page. Par exemple, insérer le contenu d’une
autre page ou indiquer que la page utilise une bibliothèque de balises
personnalisées, importer un package…
 Les commentaires : utilisés pour insérer du texte explicatif à une JSP.
 Les éléments de script: utilisés pour intégrer des instructions de

programmation, sont exécutés pour chaque requête du client.
 Les actions : permettent de transférer le contrôle entre les pages, interagir avec
les composants JavaBeans côté serveur.
Les directives 1
Il en existe trois : taglib, page et include.
Elles sont toujours comprises entre les balises <%@ et %>, et hormis la directive
d'inclusion de page qui peut être placée n'importe où, elles sont à placer en tête de
page JSP.
1. Directive Taglib
<%@ taglib prefix=”lib" uri=”/TagLib.tld" %>
l’attribut uri précise où se trouve la librairie, l’attribut préfixe est unique pour chaque
librairie précise que le tags de cette librairie sera précédé par lib:
2. Directive page
<%@ page attribut1= “valeur1” attribut2= “valeur2” attribut3=“valeur3” …%>
 L’attribut info: <%@ page info="the ensat homepage by h.bel" %> Le texte descriptif
fourni sera renvoyé par la méthode getServletInfo() de la servlet générée.
 L’attribut language: : <%@ page language="java” %> définit le langage utilisé pour écrire
le code dans la JSP. La seule valeur autorisée actuellement est «java».
 L’attribut contentType est équivalente à <% response.setContentType("mimeType"); %>

Les directives 2
 L’attribut extends="package.class” permet de préciser la classe qui sera la super
classe de l'objet Java créé à partir de la JSP.
 L’attribut import= ”package.class , ...” équivalente à l'instruction import dans un

code source Java. Chaque classe ou package est séparée par une virgule.
 L’attribut isErrorPage="true|false” permet de préciser si la JSP est une page

d'erreur. La valeur true permet d’avoir accès à l'objet implicite Exception dans la
JSP.
 L’attribut errorPage="relativeURL” permet de préciser la JSP appelée au cas où une

exception est levée. Si l'URL commence pas un '/', alors l'URL est relative au
répertoire principale du serveur web sinon elle est relative au répertoire qui
contient la JSP
 L’attribut “session= true/false” Permet de définir si la page actuelle peut accèder

aux données stockées dans la session. Cet attribut est true par défaut.
Les directives 3
 La directive include permet d'inclure un fichier dans le code source JSP. Le fichier
inclus peut être un fragment de code JSP, HTML ou Java. Le fichier est inclus dans
la JSP avant que celle-ci ne soit interprétée par le moteur de JSP.
 Ce tag est particulièrement utile pour insérer un élément commun à plusieurs pages
tel qu'un en-tête ou un bas de page.
 Si le fichier inclus est un fichier HTML, celui-ci ne doit pas contenir de tag
<HTML>, </HTML>, <BODY> ou </BODY> qui ferait double emploi avec ceux
présents dans le fichier JSP. Ceci impose d'écrire des fichiers HTML particuliers
uniquement pour être inclus dans les JSP : ils ne pourront pas être utilisés seuls.
 La syntaxe est la suivante :
<%@ include file="chemin relatif du fichier" %>
 Si le chemin commence par un '/', alors le chemin est relatif au contexte de

l'application, sinon il est relatif au fichier JSP.
Les commentaires
 Texte HTML
<h1>Blah</h1>
Passé au client. Réellement traduit en servlet par le code
out.print("<h1>Blah<h1>");
 Commentaires HTML
Pareil que les autres éléments HTML : passés au client
 Commentaires JSP
<%-- Commentaires --%>Ne sont pas envoyés au client
 Pour obtenir <% dans la sortie, utiliser <\%

Les éléments de script:
 Expressions
 Format : <%= expression %>
 Evaluée et insérée dans la sortie du servlet se traduit par
out.print(expression)
 Scriptlets
 Format : <% code %>
 Inséré tel quel dans la méthode _jspService du servlet (appelée par
service)
 Déclarations
 Format : <%! code %>
 Insérée telle quelle dans le corps de la classe servlet, en dehors de toute
méthode existante
Expressions JSP:
<%= valeur %>
Expressions JSP
 Format
<%= Expression Java %>
 Résultat
 Expression évaluée, convertie en String, et placée dans la page HTML à la
place qu’elle occupe dans la JSP
 L’expression est placée dans _jspService en paramètre du out.print()
 Exemples
 Heure courante : <%= new java.util.Date() %>
 Hostname: <%= request.getRemoteHost() %>
 JSP d’origine
<h1>Un nombre aléatoire</h1>

<%= Math.random() %>
 Code du servlet résultant de la traduction
public void _jspService(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

response.setContentType("text/html");
JspWriter out = response.getWriter();
out.println("<h1>Un nombre aléatoire</h1>");
out.println(Math.random());
...
}
Variables prédéfinies
Les spécifications des JSP définissent plusieurs objets utilisables dans le code dont
les plus utiles sont :
request
Instance de HttpServletRequest (1e argument de service/doGet)
response
Instance de HttpServletResponse (2e argument de service/doGet)
out
Intance de JspWriter (une version bufferisée de Writer) utilisée pour envoyer des
donnés sur la sortie vers le client
session
Instance de HttpSession associée à la requête (sauf si désactivée avec l’attribut
session de la directive de la page)
Scriptlets JSP:
<% Code %>

Scriptlets JSP
 Format
<% Code Java %>
 Résultat
Code inséré tel quel dans _jspService()
 Exemple
<%
String queryData = request.getQueryString();
out.println("Attached GET data: " + queryData);
%>
<% response.setContentType("text/plain"); %>
Scriptlets JSP: Exemple
 On veut permettre à l’utilisateur de choisir la couleur de fond de la page HTML
<!DOCTYPE …>
<html>
<head>
<title>Color Testing</titl>
</head>
<%
String bgColor = request.getParameter("bgColor");
if ((bgColor == null)||(bgColor.trim().equals(""))){
bgColor = "WHITE";
}
%>
<body bgcolor="<%= bgColor %>">
<h2 align="CENTER">Testing a Background of "<%= bgColor %>".</h2>
</body></html>
Utilisation des scriptlets pour
créer des parties conditionnelles
 Postulat
– Les scriplets sont insérés tels quels dans le servlet
– Pas besoin d’avoir des expressions Java complètes
– Cependant, les expressions complètes sont la plupart du temps plus claires et
faciles à maintenir
 Exemple
<% if (Math.random() < 0.5) { %>
Vous avez <b>gagné</b> !
<% } else { %>
Vous avez <b>perdu</b> !
<% } %>
 Code du servlet résultant de la traduction
if (Math.random() < 0.5) {
out.println("Vous avez <b>gagné</b> !");
} else {
out.println("Vous avez <b>perdu</b> !");}
Déclaration JSP
<%! Code %>
Déclarations JSP
Format
<%! Java Code %>
Résultat
Insérées telle quelle dans la définition de la classe du servlet, en
dehors de toute méthode existante
Exemples
<%! private int someField = 5; %>
<%! private void someMethod(...) {...} %>
Remarque de conception
Les attributs sont clairement utiles. Pour les méthodes, il est la
plupart du temps préférable de les définir dans une classe Java
Séparée
 JSP d’origine
<h1>Some Heading</h1>
<%!
private String randomHeading() {
return("<h2>" + Math.random() + "</h2>");
}
%>
<%= randomHeading() %>
(Alternative : créer randomHeading en méthode statique dans

une classe Java séparée)
Code du servlet résultant de la traduction
public class MyJSP_jsp implements HttpJspPage {

private String randomHeading() {
return("<h2>" + Math.random() + "</h2>");
}
public void _jspService(HttpServletRequest request, HttpServletResponse

response) throws ServletException, IOException {
response.setContentType("text/html");
HttpSession session = request.getSession();
JspWriter out = response.getWriter();
out.println("<h1>Some Heading</h1>");
out.println(randomHeading());
…
}
…
}
Méthodes jspInit et jspDestroy
1. jspInit()
 La phase d’exécution de la jsp compilée est l’appel de trois méthodes du cycle du vie.
jspInit() jspService() jspDestroy()
 Une fois la jsp compilée, le conteneur appel la méthode jspinit() pour initialiser la
classe.
 Cette méthode est appelée une seule fois pendant le cycle de vie de l’objet.
 Elle peut être redéfinie par le programmeur pour les initialisations de ressources
comme la connexion à la une base de donnée.
 On peut utiliser un constructeur au lieu de jspInit, mais on aura pas accès à ces deux
objet ServletConfig et ServletContext.
2. jspDestroy()
 La méthode jspDestroy est appelé par le conteneur au moment où la ressource est sur
le point d’être détruite.
Déclarations JSP et variables prédéfinies
 Rq1: Problème
– Les variables prédéfines (request, response, out, session, etc.)
sont locales à la méthode _jspService.
Ainsi, elles ne sont pas disponibles pour les méthodes définies par
des déclarations JSP et les méthodes des classes externes.
– Que peut-on faire ?
 Solution : les passer en paramètres. Ex :
<%!
private void someMethod(HttpSession s) {
doSomethingWith(s);
}
%>
<% someMethod(session); %>
 Rq 2 : println de JSPWriter lance une IOException
– Utiliser “throws IOException” pour les méthodes qui utilisent println
Intégration
des servlets et des JSP :
Application du design pattern
Model-View-Controller (MVC)
Pourquoi combiner Servlets & JSP?
 Classiquement : utilisation des JSP pour faciliter le
développement et la maintenance du contenu HTML
– Pour du code dynamique simple, appel du code d’un

servlet à
partir de scripts JSP
– Pour des applications un peu plus complexes, utilisation de
classes appelées à partir de scripts JSP
 Mais ça n’est pas suffisant

– Pour des traitements complexes, démarrer avec des JSP
n’est
pas pratique du tout
Pourquoi combiner Servlets & JSP?
Servlet seuls. Marche bien quand :
– L’output est de type binaire. Ex : une image
– Il n’y a pas d’output. Ex : redirections
– La forme/présentation est variable. Ex : portail
JSP seules. Marche bien quand :
– L’output est de type caractère. Ex : HTML
– La forme/présentation est stable.
Architecture MVC. Nécessaire qd:
– Une même requête peut donner des résultats visuels réellement
différents
– On dispose d’une équipe de développement conséquente avec
une partie pour le dev. Web et une autre pour la logique métier
– On a un traitement complexe des données mais une présentation
relativement fixe.
Design-pattern: MVC
MVC model 2: Application dans le cadre d’Internet
Exemple: liste de promotion
MVC : étape 1
Le client récupère un formulaire (form.html) pour
passer une requête avec paramètres (1, 2 puis 3).
Formulaire : form.html
<body>
<h1>L'école virtuelle de L'ENSAT</h1>
<form action="controller">
<table>
<tr><td>Sélectionner la promo à afficher</td>
<td><SELECT name= "promo">
<OPTION VALUE="info3">info3</OPTION>
<OPTION VALUE="gstr3">gstr3</OPTION>
<OPTION VALUE="gsea3">gsea3</OPTION>
</SELECT>
</td>
</tr>
<tr>
<td colspan="2"><input type="submit" value="Envoyer"></td>
</tr>
</table>
</form>
</body>
MVC : étape 2
1. Le client envoie son formulaire (GET/POST avec paramètres)
2. Le conteneur transmet au servlet correspondant (le controller)
Controller : SelectPromo.java
import javax.servlet.http.HttpServletResponse;
import ensat.cours.logiquemetier.Promo;
public class SelectPromo extends HttpServlet {
public void doGet(HttpServletRequest re, HttpServletResponse
pe)
throws IOException, ServletException{
...
String param = re.getParameter("promo");
...
}
}
MVC : étape 3
3. La servlet controller interroge le model sur « info3 »
4. Le model retourne au controller le résultat correspondant
Model: une classe Java
public class Promo {

public List<String> getPromo(String param){
List<String> reponse = new ArrayList<String>();
if(param.equals("info3")){
reponse.add("Houda");
reponse.add("Rachida");
}
else if(param.equals("gsea3")){
reponse.add("Saida");
reponse.add("Ahmed");
}
else
reponse = null;
return reponse;
}
}
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
String param = request.getParameter("fonction");

//Promo retourn la liste correpondante au controleur
Promo ob = new Promo();
List<String> list = ob.getPromo(param);
System.out.println(" " + (list == null));
//construit la requête puis l'envoie à la vue
request.setAttribute("liste", list);
request.getRequestDispatcher("reponse.jsp").forward(request,reponse);
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: resultat.jsp
<body>
<%
List<String> l = (List<String>) request.getAttribute("liste");
System.out.println(l==null);
Iterator i = l.iterator();
while(i.hasNext()){
out.println("<br>" + i.next());
}
%>
</body>
Cookies et suivi de session
TP Cookies
 Introduction
 L'API javax.servlet.http.Cookie
 Travail à réaliser
Introduction
 Un cookie est une information envoyée par un serveur web à un navigateur et
sauvegardée par celui-ci sur le disque de sa machine
 Le navigateur retourne cette information (inchangée) lorsqu'il visite de nouveau le même
site.
 Ayant lu cette information, le serveur peut identifier le client et lui fournir un certain
nombre de facilités :
 achat en ligne
 authentification
 personnalisation de portail
 diriger les recherches d'un moteur
 Pas de menace sécuritaire
 Etant donné Limité à 4K. Un navigateur accepte 20 cookies/site et 300 au total

 Cette technique est utilisée pour le suivi de session. Il mémorise l'identifiant de session
(sessionid) pour le navigateur
 Pour stocker un cookie sur un navigateur, la servlet doit ajouter le cookie dans l'en-tête de
sa réponse
 Pour récupérer l'information à partir d'un cookie, la servlet doit extraire le cookie de l'en-
tête de la requête
 Ceci est réalisé par l'API Cookie et ses méthodes d'accès : addCookie() et getCookies()
 Les navigateurs n'acceptent pas toujours les cookies ( WAP, ...). Il est possible de les
API javax.servlet.http.Cookie
 Constructeur :
public Cookie(String name,String value)
 Envoi d'un cookie à un client par une servlet :
public void HttpServletResponse.addCookie(Cookie cookie)
 Récupération des cookies. Il est impossible de récupérer un cookie connaissant son nom. On ne
peut que récupérer un tableau de tous les cookies envoyés par le navigateur :
public Cookie[] HttpServletRequest.getCookies()
 Modification de la valeur d'un cookie :
public void setValue(String newValue)
 Utilisation
 Création d'un cookie (res est l'objet réponse)
Cookie unCookie = new Cookie("nom","martin");
res.addCookie(unCookie);
 Récupération d'un cookie (req est l'objet requête)
Cookie[] cookies = req.getCookies();
if (cookies != null)
for ( int i=0;i<cookies.length;i++ ){
if (cookies[i].getName().equals("nom")){
String valeur = cookies[i].getValue();
Break;}}}
Attributs des cookies (1/2)
 Un cookie est défini par son nom auquel est associée une valeur.
 Il est possible d'y ajouter certains attributs
void setDomain(String pattern)

-précise le domaine pour lequel le cookie est valide
-par défaut, le cookie est retourné seulement au serveur qui l'a sauvé
void setMaxAge(int expiry)

- spécifie l'age maximum du cookie en secondes
- expiry<0 => le cookie expire avec le navigateur
- expiry=0 => le cookie est détruit immédiatement
void setPath(String uri)

- définit le chemin dans le domaine pour lequel le cookie est valide
- par défaut, le cookie est valide pour la page qui le définit et toutes les pages du répertoire du dessous
 si uri="/", le cookie est valide pour toutes les pages du serveur
void setComment(String comment)

- définit un commentaire qui décrit le rôle du cookie
Exemple (1/2) - l'interface demandée
 L’exemple présente une page d’inscription.

 Le mot saisi doit être conservé dans un cookie.
Exemple (2/2) - l'interface demandée
Ainsi chaque fois que la page

est demandée (après rechargement),
le dernier mot saisi est affiché.
De même si une requête à cette page
est réalisée à travers une autre instance
du navigateur
Après déconnexion, la valeur du cookie est

réinitialisée
Suivi de session
Introduction
Solutions
Support Session de l'API Servlet

Introduction
 Le protocole HTTP est un protocole sans état =>
Le serveur ignore qu'une séquence de requêtes provient d'un même client

Le serveur HTTP voit les requêtes, pas les clients.
 En effet une adresse IP n'est pas suffisante pour identifier un utilisateur
 Exemple : un serveur web de commerce électronique gère un panier. Les articles achetés,
ajoutés au panier, donnent lieu à différentes requêtes.
 La notion de session permet d'associer un ensemble de requêtes et de les identifier comme
appartenant à un même client.
 La technique de la session est utilisée pour maintenir un lien entre plusieurs requêtes
L’API suivi de session

 A chaque utilisateur est associé implicitement un objet utilisé par les servlets pour
sauvegarder un ensemble d’objets (un panier par exemple)
 Cet objet de type HttpSession permet donc de suivre l'activité d'un client sur plusieurs
pages
 Les requêtes provenant d'un même utilisateur sont associées à un même objet
 Chaque ServletContext gère ses propres instances de HttpSession
L’API suivi de session 1/2
HttpSession HttpServletRequest.getSession()
pour récupérer l’objet session courant
void HttpSession.setAttribute(String name, Object value)

ajoute un couple (name, value) à cette session
Object HttpSession.getAttribute( String name )

retourne l'objet associé à la clé name ou null
void HttpSession.removeAttribute( String name )

enlève le couple de clé name
java.util.Enumeration HttpSession.getAttributeNames()
retourne tous les noms d'attributs associés à la session
void HttpSession.setMaxIntervalTime( int seconds )

spécifie la durée de vie maximum d'une session
L’API suivi de session 2/2
A la première requête vers une application web :
1. un objet HttpSession est créé
2. ainsi qu’un identifiant unique pour cet objet
L’identifiant est stocké dans un cookie appelé JSESSIONID => seul l’identifiant
de session est envoyé au client.
Cet identifiant permet au serveur de déterminer l’objet session correspondant à la

requête courante: A toute nouvelle requête émise par l'utilisateur, le cookie est
transmis vers le serveur web et accédé par la méthode : public String
HttpSession.getId() et (non getSession())
Cycle de vie
 A sa création, une période de temps est affectée à la session. Elle expire
automatiquement à la fin de cette période (par défaut 30mns avec Tomcat)
 Elle peut être invalidée explicitement par la servlet :
HttpSession.invalidate() permet de fermer une session
 A l'expiration (invalidation), les données de l'objet session (HttpSession) sont
retournées au moteur de servlets
 Les sessions ne sont donc pas invalidées à la fermeture du navigateur
 Une valeur de timeout peut aussi être affectée à chaque session en informant
l'objet session par la méthode :
public void HttpSession.setMaxInactiveInterval(int secs)
TP à réaliser
Après avoir tapé 5 fois le mot "vu" et un nombre indéterminé

d'autres mots
Puis, à partir d'une nouvelle instance du navigateur, on

accède à la même URL
A partir d'un autre navigateur, la session est perdue

Les pages JSP et les JavaBeans
Architecture Web JEE: model2
(MVC)
Relation indirecte
Architecture Web JEE: model1
(pas MVC)
JavaBeans ?
Les JavaBeans sont des classes Java (POJO) qui suivent
certaines conventions :
– Doivent avoir un constructeur vide (zero argument)
• On peut satisfaire cette contrainte soit en définissant explicitement un tel
constructeur, soit en ne spécifiant aucun constructeur
– Ne doivent pas avoir d’attributs publics
• Une bonne pratique réutilisable par ailleurs…
– La valeur des attributs doit être manipulée à travers des méthodes
getXxx et setXxx
• Si une classe possède une méthode getTitle qui retourne une String, on dit que
le bean possède une propriété String nommée title
• Les propriétés Boolean utilisent isXxx à la place de getXxx
Référence sur les beans, cf.

http://java.sun.com/beans/docs/
Pourquoi faut-il utiliser des
accesseurs ?
Dans un bean, on ne peut pas avoir de champs publics
Donc, il faut remplacer
public String prenom;
par
private String prenom;
public String getPrenom () {
return(prenom);
}
public void setprenom (String prenom) {
This.prenom = prenom ;
}
Pourquoi faut-il faire cela pour tout code Java ?
Pourquoi faut-il utiliser des
accesseurs ?
1. On peut imposer des contraintes sur les données
2. On peut rajouter du code annexe
public void setPrenom(String prenom) {

this.prenom = prenom.substring(0, 1).toUpperCase()
+ prenom.substring(1, prenom.length()).toLowerCase();
enregistrerBD();
}
3. On peut changer de représentation interne sans changer d’interface
public void setPrenom(String prenom) {

this.prenom = prenom.toUpperCase()
enregistrerBD();
}
Utilisation basique des Beans
jsp:useBean
– Cet élément permet de rendre un JavaBean accessible dans la page
JSP.
Utilisation :
<jsp:useBean id="beanName" class="package.Class" />
 jsp:setProperty
– Cet élément modifie une propriété d’un bean (i.e., appel d’une
méthode setXxx).
Utilisation :
<jsp:setProperty name="beanName" property="propertyName"
value="propertyValue" />
jsp:getProperty
– Cet élément lit et retourne la valeur d’une propriété d’un bean.
Utilisation :
<jsp:getProperty name="beanName" property="propertyName" />
Approche générale avec des JSP
et les tags jsp:useBean …
Dans les pages JSP, il est toujours très difficile de lire le mélange à la fois
de code HTML et de code Java.
 L’approche la plus judicieuse est d'utiliser une écriture plus proche du
HTML en utilisant la syntaxe du XML tout en faisant référence, malgré
tout, à des classes Java.
Ex: <jsp:useBean id="beanName" class="package.Class" />
Le webmaster s'occuperait alors des balises à mettre en place sur ces
différentes pages Web dynamiques, alors que le développeur s'occuperait
essentiellement de mettre en place toutes les classes nécessaires à
l'application Web.
Les JavaBeans permettent de composer une structure particulière sur ces
classes respectant un schémas standard afin qu'ils puissent être utilisés
par le webmaster au moyen de balises spécifiques et donc sans code Java.

Approche générale avec des JSP
et les tags jsp:useBean …
 L’utilisateur soumet un formulaire vers une JSP
– <FORM ACTION="SomePage.jsp">
 La page JSP instancie un bean

– <jsp:useBean id= " Personne" class="…"/>
 On passe des données de la requête au bean

– <jsp:setProperty name="Personne"property="prenom"
value="…"/>
 On affiche des valeurs issues des données de la requête

– <jsp:getProperty name=“Personne" property="prenom"/>
Création de Beans: jsp:useBean
Format:
– <jsp:useBean id="name" class="package.Class" />
But:
– Permettre l’instanciation de classes Java sans programmation Java
explicite (syntaxe compatible XML)
Remarques:
– Interpretation simple :
<jsp:useBean id="book1" class="coreservlets.Book" />
peut être vu comme équivalent au scriptlet :
<% coreservlets.Book book1 = new coreservlets.Book(); %>
Mais jsp:useBean a deux avantages supplémentaires :

1. Facilite l’utilisation des paramètres de requête
2. Facilite le partage des objets entre pages ou servlets
Modification de propriétés de Bean : jsp:setProperty
Format
–<jsp:setProperty name="name"
property="property"value="value" />
But
– Permettre de modifier les propriétes d’un bean properties
(i.e.,
appel de méthodes setXxx) sans programmation Java
explicite
Remarques
– <jsp:setProperty name="book1" property="title" value=" JEE " />
est équivalent au scriptlet :
– <% book1.setTitle(“JEE"); %>
Accès aux propriétés de Bean :
jsp:getProperty
Format
– <jsp:getProperty name="name" property="property" />
But
– Permettre d’accéder propriétés d’un bean (i.e., appel de
méthodes getXxx) sans programmation Java explicite
Remarques
– <jsp:getProperty name="book1" property="title" />
est équivalent à l’expression JSP :

– <%= book1.getTitle() %>
Exemple d’utilisation: étape 1
package serverbeans;
public class StringBean {
private String message = "No message specified";
public String getMessage() {
return(message);
}
public void setMessage(String message) {
this.message = message;
}
}
• Les Beans doivent être déployés dans le même répertoire que les
autres
classes Java
– WEB-INF/classes/serverbeans
• Les Beans doivent toujours être dans des packages !
Exemple d’utilisation: étape 2
<jsp:useBean id=“testBean" class=“serverbeans.StringBean" />
<OL>
<LI>Initial value (from jsp:getProperty):
<I><jsp:getProperty name=“testBean" property="message" /></I>
<LI>Initial value (from JSP expression):
<I><%= testBean.getMessage() %></I>
<jsp:setProperty name=“testBean" property="message" value=“Exemple d’un autre
message" />
<LI> Value after setting property with jsp:setProperty:
<I><jsp:getProperty name=“testBean" property="message" /></I>
<% stringBean.setMessage(“Mon message favoris est bonjour"); %>

<LI> Value after setting property with scriptlet:<I><%=
stringBean.getMessage()%></I>
</OL>
jsp:setProperty (cas1) :
conversion explicite & affectation (as
String)
<!DOCTYPE ...>
...
<jsp:useBean id=“monBean" class=“Ensat.Personne" />
<%-- setItemID expects a String --%>

<jsp:setProperty name="monBean" property= "prénom"
value='<%= request.getParameter(“champ1") %>' />
conversion explicite & affectation (type int)
<%
try {
age = Integer.parseInt(request.getParameter(“champ2"));
} catch(NumberFormatException nfe) {}
%>
<%-- setNumItems expects an int --%>
<jsp:setProperty name="monBean" property= "age" value="<%= age %>" />

conversion explicite & affectation (type double)
<%
try {
double salaire = Double.parseDouble(request.getParameter(“champs3"));
} catch(NumberFormatException nfe) {}
%>
<%-- setDiscountCode expects a double --%>
<jsp:setProperty name=" monBean" property=" salaire " value="<%= salaire

%>" />
association propriété/paramètre
Utilisation de l’attribut param de jsp:setProperty
– On indique que la valeur doit provenir du paramètre de

requête spécifié
– Une conversion automatique de type est opérée pour les

valeurs de types standard
boolean, Boolean, byte, Byte, char, Character, double, Double, int,
Integer,
float, Float, long, ou Long.
association propriété/paramètre
<jsp:useBean id = "utilisateur" class = "Personne" />
<jsp:setProperty name = "utilisateur" property = "nom" value = "REMY" />
<jsp:setProperty name= "utilisateur" property = "prénom"
value = '<%= request.getParameter("prénom") %>' />
...
<jsp:setProperty name
= "utilisateur" property = "prénom" param = "prénom" />
...
<jsp:setProperty name = "utilisateur" property = "prénom" />
jsp:setProperty (cas3) : associer
toutes les propriétés aux paramètres
 Utilisation de "*" pour la valeur de l’attribut property de jsp:setProperty
– On indique que la valeur doit provenir des paramètres de requête qui
correspondent aux noms des propriétés
– Un conversion automatique de type est également opérée
– Particulièrement pratique pour réaliser des « Beans formulaires » --
objets dont les propriétés sont remplies par les données d’un formulaire
– Ce processus peut même être décomposé entre différents formulaires,
chaque soumission remplissant une partie de l’objet
<jsp:useBean id= "monBean" class=" serverBean.Personne" />

<jsp:setProperty name="monBean" property="*" />
Implémentation du MVC avec
RequestDispatcher
1. Définir les beans pour représenter les données
2. Utiliser une servlet pour gérer les requêtes
– La servlet lit les paramètres de requêtes, vérifie les données
manquantes ou malformées, appelle le code métier, etc.
3. Créer les beans
– La servlet invoque le code métier (spécifique à l’application) ou
accède à une base de données pour obtenir les résultats. Les résultats
sont dans les beans définis à l’étape 1
4. Placer le bean dans la requête, la session, ou le servlet context
– La servlet appelle setAttribute sur la requête, la session, ou le
servlet context pour garder une référence sur les beans qui
représentent le résultat de la requête
Implémentation du MVC avec
RequestDispatcher
5. Transmettre la requête à la JSP (forward)
– La servlet détermine quelle JSP est appropriée à la situation et
utilise la méthode forward du RequestDispatcher pour
transférer le contrôle à la JSP
6. Extraire les données des beans
– JSP 1.2: la JSP accède aux beans avec jsp:useBean et l’attribut
scope correspondant au choix de l’étape 4. La JSP utilise
ensuite jsp:getProperty pour afficher les propriétés des beans
– JSP 2.0: la JSP utilise ${nameFromServlet.property} pour
afficher les propriétés des beans
– La JSP ne crée pas ou ne modifie pas les beans : c’est la
vue du MVC !
Utilisation de jsp:useBean : MVC
La JSP ne doit pas créer les objets
– La servlet, pas la JSP, doit créer tous les objets-données.
Donc,
pour guarantir qu’une JSP ne créera pas d’objets, il faut
utiliser
<jsp:useBean ... type="package.Class" />
au lieu de
<jsp:useBean ... class="package.Class" />
La JSP ne doit pas modifier les objets

– Il faut donc utiliser jsp:getProperty mais pas
jsp:setProperty.
Différents scopes pour jsp:useBean
request
– <jsp:useBean id="..." type="..." scope="request" />
session
– <jsp:useBean id="..." type="..." scope="session" />
application
– <jsp:useBean id="..." type="..." scope="application" />
page
– <jsp:useBean id="..." type="..." scope="page" />
ou juste
<jsp:useBean id="..." type="..." />
– Ce scope n’est pas utilisé dans MVC
Exemple : Partage de données sur requête
Servlet
ValueObject value = new ValueObject(...);
request.setAttribute("key", value);
RequestDispatcher dispatcher =
request.getRequestDispatcher("SomePage.jsp");
dispatcher.forward(request, response);
JSP 1.2
<jsp:useBean id="key" type="somePackage.ValueObject"
scope="request" />
<jsp:getProperty name="key" property="someProperty" />
JSP 2.0
${key.someProperty}
Partage de données sur requête :
exemple simple
Servlet
Customer myCustomer = new
Customer(request.getParameter("customerID"));
request.setAttribute("customer", myCustomer);
 JSP 1.2
<jsp:useBean id="customer" type="somePackage.Customer"
scope="request" />
<jsp:getProperty name="customer" property="firstName"/>
JSP 2.0
${customer.firstName}
Partage de données sur session
Servlet
ValueObject value = new ValueObject(...);
HttpSession session = request.getSession();
session.setAttribute("key", value);
JSP 1.2
<jsp:useBean id="key" type="somePackage.ValueObject"
scope="session" />
<jsp:getProperty name="key" property="someProperty" />
 JSP 2.0
${key.someProperty}

Java Edition Entreprise

Transféré par

Droits d'auteur :

Formats disponibles

Java Edition Entreprise

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Java Edition Entreprise

Transféré par

Droits d'auteur :

Formats disponibles

Java Edition Entreprise

Introduction de qq Bases sur

Les applications web se trouvent sans la couche

Interface réseau Interface réseau

Le protocole HTTP dispose de « méthodes »; ce sont des mots que le

Chaque édition propose un environnement complet pour le développement et

un des composants de base pour le développement d'applications Web;

Remarque 1: Le chargement et l'instanciation d'une servlet se font selon le paramétrage soit au

 Pour exécuter des application web, il faut un serveur d’application:

 Ce serveur d’application doit inclure un serveur web http dont le plus

 Le choix d’un serveur d’application doit tenir compte de la version du

GenericServlet fournie un niveau d'abstraction permettant de développer facilement

Créer l’arborescence suivante

WEB-INF Imposé par

public class Clock extends HttpServlet { Redéfinition

out.println("<table>\n" +"<tr><th>Header Name</th><th>Header Value</th></tr>");

Enumeration<String> headerNames = request.getHeaderNames();

public class ShowRequestHeaders extends HttpServlet {

public class LogServlet extends HttpServlet {

<form method="post" action="Serv2">

public class LogServlet extends HttpServlet {

String param = request.getParameter("someName");

• response.sendError(int code, String msg)

Même URL de départ ensuite une redirection ...

// create a factory for disk-based (large) file items

// create a new file upload handler

JSP: Java Server Pages

Les avantages des JSP

Les composants réutilisables

La séparation de la présentation et de l’implémentation

Fichier texte combinant du HTML standard et de nouvelles balises de script.

Mais au final une JSP n’est autre qu’une servlet

• Servlet générée par Tomcat

Deux types de balises:

Les balises basées sur XML:

<jsp:useBean id="Bean" class="ensat.cours.HelloBean" >

 Les directives: utilisées pour transmettre au conteneur de JSP des informations

 Les commentaires : utilisés pour insérer du texte explicatif à une JSP.

 Les éléments de script: utilisés pour intégrer des instructions de

 L’attribut contentType est équivalente à <% response.setContentType("mimeType"); %>

 L’attribut import= ”package.class , ...” équivalente à l'instruction import dans un

 L’attribut isErrorPage="true|false” permet de préciser si la JSP est une page

 L’attribut errorPage="relativeURL” permet de préciser la JSP appelée au cas où une

 L’attribut “session= true/false” Permet de définir si la page actuelle peut accèder

 La syntaxe est la suivante :

<%@ include file="chemin relatif du fichier" %>

 Si le chemin commence par un '/', alors le chemin est relatif au contexte de

 Pour obtenir <% dans la sortie, utiliser <\%

<h1>Un nombre aléatoire</h1>

 Code du servlet résultant de la traduction

public void _jspService(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

<% Code %>

(Alternative : créer randomHeading en méthode statique dans

public class MyJSP_jsp implements HttpJspPage {

public void _jspService(HttpServletRequest request, HttpServletResponse

– Pour du code dynamique simple, appel du code d’un

 Mais ça n’est pas suffisant

public class Promo {

String param = request.getParameter("fonction");