Les page
JSP
56
Les pages JSP sont une des technologies de la plate-
forme Java EE les plus puissantes, simples à utiliser et à
mettre en place.
Le langage JSP combine à la fois les technologies HTML,
XML, servlet et JavaBeans (un objet Java) en une seule
solution permettant aux développeurs de créer des vues
dynamiques.
Le modèle MVC recommande une séparation nette entre
le code de contrôle et la présentation.
Le modèle MVC recommande une séparation nette entre
le code métier et la présentation.
57
les pages JSP sont des documents au format texte, à
l'opposé des classes Java que sont les servlets. Elles
contiennent des balises qui combinent à la fois simplicité
et puissance, via une syntaxe simple, semblable au HTML
et donc aisément compréhensible par un humain ;
la simplicité d'accès aux objets Java;
des mécanismes permettant l'extension du langage utilisé
au sein des pages JSP.
58
Conteneur de
Servlets
Requête Oui
JSP a Page JSP
HTTP été
changé (.JSP)
?
Traduction de la JSP en
Servlet
Non Servlet
(.java)
Compilation de la
Servlet
Réponse
Instance
HTTP Servlet
de
Servlet (.class)
servlet
chargée
59
Serveur
d’application
Requête Servlet
HTTP
Requête HTTP
JSP
public void doGet( HttpServletRequest request, HttpServletResponse response )
throws ServletException, IOException {
request.getRequestDispatcher( "/WEB-INF/test.jsp" ).forward( request,
response );
}
60
L’objet de requête (HttpServletRequest ):
◦ setAtribute();
◦ getAtribute();
public void doGet( HttpServletRequest request, HttpServletResponse response
) throws ServletException, IOException{
String message = "Transmission de variables";
request.setAttribute( "message", message );
request.getRequestDispatcher( "/WEB-INF/test.jsp" ).forward(request,
response );
}
61
<%@ page pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html>
<head> la méthode getAttribute() renvoie un objet
<meta charset="utf- global de type
8" /> Object=>Transtypage(casting)
<title>Test</title>
<body>
</head>
<p>Ceci est une page générée depuis une JSP.</p>
<p>
<%
String attribut = (String)
request.getAttribute("message");
out.println( attribut );
%>
</p>
</body>
</html>
62
Ils sont envoyés par le client au serveur directement au sein de l'URL
Il est uniquement possible d'y accéder en lecture
L’objet de requête (HttpServletRequest ):
◦ getParameter(); http://localhost:8080/test/index.do?
// retourne un
nom=mohame
String d
public void doGet( HttpServletRequest request, HttpServletResponse response ) throws
ServletException, IOException{
String nom= request.getParameter("nom");
String login="Bienvenue " + nom
request.setAttribute( "login", login);
request.getRequestDispatcher( "/WEB-INF/test.jsp" ).forward(request,
response );
}
63
Un attribut de requête est en réalité un objet stocké
dans l'objet HttpServletRequest, et peut contenir
n'importe quel type de données.
Les attributs de requête sont utilisés pour permettre à
une servlet de transmettre des données à d'autres
servlets ou à des pages JSP.
Un paramètre de requête est une chaîne de caractères
placée par le client à la fin de l'URL de la requête HTTP.
Les paramètres de requête sont utilisés pour permettre à
un client de transmettre des données au serveur.
64
JavaBea
n
65
Le JavaBean, Souvent raccourci en "bean", désigne
un composant réutilisable.
Un bean est un simple objet Java qui suit certaines
contraintes, et représente généralement des données
du monde réel.
Un bean peut par exemple être transmis d'une servlet
vers une page JSP (ou une autre servlet) en tant
qu'attribut de requête.
66
Un bean :
◦ doit être une classe publique ;
◦ doit avoir au moins un constructeur par défaut, public et sans
paramètres. Java l'ajoutera de lui-même si aucun constructeur
n'est explicité ;
◦ peut implémenter l'interface Serializable, il devient ainsi
persistant et son état peut être sauvegardé ;
◦ ne doit pas avoir de champs publics ;
◦ peut définir des propriétés (des champs non publics), qui doivent
être accessibles via des méthodes publiques getter et setter,
suivant des règles de nommage.
67
public class Client public String getPrenom() {
{ private String nom; return prenom;
private String prenom; }
private String email; public void setPrenom(String prenom) {
public String getNom() this.prenom = prenom;
{ }
return nom; public String getEmail() {
} return email;
public void setNom(String nom) { }
this.nom = nom; public void setEmail(String email) {
} this.email = email;
}}
68
Une page JSP peut être formée par les éléments
suivants
◦ Les :
expressions
◦ Les
déclarations
◦ Les directives
◦ Les scriptlets
◦ Les actions
◦ Les JSTL
Les expressions JSP sont, des expressions Java qui vont être
évaluées à
l'intérieur d'un appel de méthode print.
Une expression commence par les caractères <%= et se
termine par les caractères %>.
Comme l'expression est placée dans un appel de méthode, il
est interdit de terminer l'expression via un point-virgule.
Syntaxe: <%=expression%>
Equivalent à:
out.println(expression) ; Exemple : <
%=new Date()%>
Equivalent à: out.println(new
Date()) ;
Dans certains cas, un peu complexe, il est nécessaire d'ajouter
des méthodes et des attributs à la servlet qui va être générée
(en dehors de la méthode de service).
Une construction JSP particulière permet de répondre à ces
besoins. Elle commence par les caractères <%! et se termine,
par les caractères %>. Voici un petit exemple
d'utilisation.
Exemple:
<%@ page language="java" %>
<HTML>
<%! private int userCounter = 0; %>
<BODY>
Vous êtes le <%= ++userCounter %><SUP>ième</SUP> client
du site</P>
</BODY><HTML>
Une directive permet de spécifier des informations qui
vont servir à configurer et à influer sur le code de la
servlet générée.
Ce type de construction se repère facilement étant donné
qu'une directive commence par les trois
caractères <%@.
Notons principalement deux directives :
◦ <%@ page ... %>
◦ <%@ include ... %>
◦ <%@ taglib ... %>
Voyons de plus près quelques unes des
possibilités qui vous sont offertes.
La directive page définit des informations relatives à la
page JSP. Voici par exemple comment importer des
classes Java;
En fait, cette directive accepte de nombreux paramètres
dont les principaux sont:
◦ <%@ page language="java" %>
◦ <%@ page import="package|classe %>
◦ <%@ page session="true|false" %>
◦ <%@ page extends="classe" %>
◦ <%@ page errorPage="url" %>
◦ <%@ page isErrorPage="true|false"%>
La directive <%@ include ... %> est très utile si plusieurs pages se
doivent de
partager une même ensemble d'information.
C'est souvent le cas avec les entêtes et les pieds de pages. Dans
ce cas, codez ces parties dans des fichiers séparés et injectez les,
via cette directive, dans tous les autre fichiers qui en ont besoin.
Voici un petit exemple d'utilisation de cette directive:
<%@ page language="java" %>
<HTML>
<BODY>
<%@ include file="header.jsp" %>
<!-- Contenu de la page à générer -->
<%@ include file="footer.jsp" %>
</BODY><HTML>
Les scriptlets correspondent aux blocs de code introduit par le caractères <%
et se
terminant par %>.
Ils servent à ajouter du code dans la méthode de service.
Le code Java du scriptlet est inséré tel quel dans la servlet générée: la
vérification, par le
compilateur, du code aura lieu au moment de la compilation totale de la
servlet équivalent.
L'exemple complet de JSP présenté précédemment, comportait quelques
out.println("<H" + i + " align=\"center\">Heading "</H" + i +
scriptlets :
" +i+ ">");
<%
}
for(int i=1; i<=6; i++) {
%>
Les actions constituent une autre façon de générer
du code Java à partir d'une page JSP.
Les actions se reconnaissent facilement,
syntaxiquement parlant : il s'agit de tag XML
ressemblant à <jsp:tagName
... />.
Enfin, le tag peut, bien entendu comporter
plusieurs
attributs.
Cette action vous permet de rediriger une requête vers
une autre page au niveau du serveur.
Syntaxe: <%
request.getRequestDispatcher(
<jsp:forward "/page.jsp" ).forward( request, response );
page="relativeURL"/> ou %>
<jsp:forward page="relativeURL" >
<jsp:param name="parameterName"
value="parameterValue"/>
</jsp:forward>
On récupère les paramètres par la
méthode getParameter() de l’objet
request
◾ Comme vu précédemment, l’action include vous permet d’insérer
un
fichier de manière "dynamique".
<jsp:include page="relative URL" />
<% request.getRequestDispatcher( "page.jsp" ).include( request, response );
%>
◾ Contrairement à la directive include qui insère les fichiers au
moment où le fichier JSP est compilé sur le serveur et transformé
en servlet, l’action include insère les fichiers seulement lorsqu’une
requête est placée sur la page demandée. Ceci en coûte une
légère perte en performance mais gagne en flexibilité.
Le tag <jsp:useBean> permet de localiser une instance ou d'instancier un bean
pour
l'utiliser dans la JSP.
<%
com.beans.Etudiant etudiant=null;
etudiant= (com.beans.Etudiant) request.getAttribute( " etudiant
" ); if (etudiant == null ){
etudiant = new com.beans.Etudiant();
request.setAttribute( " etudiant ", etudiant
);
} %>
L'attribut id permet de donner L'attribut class L'attribut scope
un nom à la variable qui va permet d'indiquer la permet de définir la
contenir la référence sur le classe du bean. portée durant
bean. laquelle le bean est
défini et utilisable
<jsp:useBean id="etudiant" class="com.midvi.web.beans.Etudiant" scope="request" />
L'attribut scope permet de définir la portée durant laquelle le bean
est défini et utilisable. La valeur de cette attribut détermine la
manière dont le tag localise ou instancie le bean. Les valeurs
possibles sont : Rôle
Valeur
page Le bean est utilisable dans toute la page JSP ainsi
que dans les fichiers statiques inclus. C'est la
valeur par défaut.
request le bean est accessible durant la durée de vie de la
requête. La méthode getAttribute() de l'objet
request permet d'obtenir une référence sur le
bean.
session le bean est utilisable par toutes les JSP qui
appartiennent à la même session que la JSP qui a
instanciée le bean. Le bean est utilisable tout au long
de la session par toutes les pages qui y participent.
application le bean est utilisable par toutes les JSP qui
appartiennent
81
Personne.jav
TestBean.jsp a package
<html> test;
<HEAD> public class Personne
<TITLE>Essai d'instanciation d'un bean dans { private String nom;
une JSP</TITLE> private String
</HEAD> prenom; public
Personne() {
<body> this.nom = "nom par
<p>Test d'utilisation d'un Bean dans une JSP defaut";
</p> this.prenom =
<jsp:useBean id="personne" "prenom par defaut";
scope="request" class="test.Personne" /> }
<p>nom initial = <%=personne.getNom() public void setNom (String nom)
%></p> { this.nom = nom;
}
<% public String getNom() {
personne.setNom("mon nom"); return (this.nom);
%> }
<p>nom mise à jour = <%= public void setPrenom (String
personne.getNom() prenom) { this.prenom = prenom;
%></p> }
</body> public String getPrenom ()
{ return (this.prenom);
</html> }
}
Le tag <jsp:getProperty> permet d'obtenir la valeur d'une
des propriétés d’un bean.
<jsp:useBean id="etudiant" class="com.midvi.web.beans.Etudiant"
scope="request" />
<jsp:getProperty name="etudiant" property="nom"/>
Même effet que
<%= etudiant.getPrenom()
%>
83
Le tag <jsp:setProperty> permet de modifier une propriété
du bean utilisé.
<jsp:useBean id="etudiant" class="com.midvi.web.beans.Etudiant"
scope="request" />
<jsp:setProperty name=“etudiant" property="prenom" value=“mohamed" />
Même effet que
<%= etudiant.setPrenom(« mohamed");
%>
84
La technologie EL est fondée sur les JavaBeans et sur les
collections Java, et existe depuis la version 2.4 de l'API
Servlet.
Les expressions EL remplacent les actions standard
de manipulation des objets.
Une expression EL permet d'effectuer des tests,
interprétés à la volée lors de l'exécution de la page.
la syntaxe d'une expression EL:
${ expression }
85
opérateurs arithmétiques, applicables à des nombres : +, -,
*,
/, % ;
${ 10 / 4 } ${ 10 mod 4 }
opérateurs logiques, applicables à des booléens : &&, ||, ! ;
${ !true || false }
opérateurs relationnels, basés sur l'utilisation des
méthodes equals() et compareTo() des objets comparés :
== ou eq, != ou ne, < ou lt, > ou gt, <= ou le, >= ou
ge.
<p>12 est inférieur à 8 : ${ 12 lt 8 }.</p> 86
Deux autres types de test sont fréquemment utilisés au
sein des expressions EL :
les conditions ternaires, de la forme : test ? si oui : sinon ;
${ 'a' > 'b' ? 'oui' :
'non' }
les vérifications si vide ou null, grâce à l'opérateur empty.
${ empty 'test' ? 'vide' : 'non vide' }
87
pour accéder à une propriété d'un bean d’une manière
simple et efficace:
${ bean.propriete }
<jsp:useBean id="etudiant"
class="com.beans.Etudiant" / $
> {etudiant.nom
<jsp:getProperty name=" }
etudiant" où
property="nom" />
$
{etudiant.getNom()
}
88
<% ${ modules.get(1) }
java.util.List<String> modules= new ${modules[1] }
java.util.ArrayList<String>(); ${modules['1'] }
modules.add( "Java EE" );
${modules["1"] }
modules.add( "programmation mobile" );
modules.add( "web sémantique");
modules.add( "Web dynamique" );
request.setAttribute( "modules" , modules);
%>
89
<% ${modules[1] }
String[] modules= {"Java EE" , ${modules['1'] }
"programmation mobile" , "web ${modules["1"] }
sémantique", "Web dynamique" };
request.setAttribute( "modules" , modules);
%>
90
Il existe deux types :
◦ ceux qui sont mis à disposition via la technologie JSP ;
🞄 pageContext, application, session, request, response, exception, out,
config, page.
◦ ceux qui sont mis à disposition via la technologie EL:
🞄il s'agit d'objets gérés automatiquement par le conteneur lors
de l'évaluation des expressions EL.
91
92
pour param et header, une seule valeur est associée à
chaque nom de paramètre, via une Map<String,String> ;
Langue est un paramètre
$ passé dans la
{param.langue requête
}
pour paramValues et headerValues par contre, ce sont
plusieurs valeurs qui vont être associées à un même nom
de paramètre, via une Map<String,String[]>.
http://localhost:8080/test/t
$
est.jsp?
{paramValues.langue[1]
langue=fr&langue=ar
}
93
