S. BEN YAHIAFaculté des Sciences de Tunis, Tunisie
[email protected] http://www.fst.rnu.tn/sbenyahia
Connexion Web et Bases de Données :Technique canevas de fichiers HTML
JSP (JAVA Server Page)
JSP 2Sadok Ben Yahia
Programme Java s'exécutant côté serveur (au même titre que
les CGI et les langages de script côté serveur tels que ASP ou
bien PHP) capable gérer des requêtes HTTP et de fournir au
client une réponse HTTP dynamique (création de pages web
dynamiques).
servlet : programme "autonome" stockés dans un
fichier .class sur le serveur
Java Server Pages : programme source Java embarqué dans une
page .html
Introduction
JSP 3Sadok Ben Yahia
côté client côté serveur
.class autonome applet servlet
embarqué dans .html JavaScript JSP
Servlet et JSP
exécutable avec tous les serveurs Web (Apache, IIS, ...)� auxquels on a ajouté un "moteur" de servlet/ JSP (le plus connu : �
Tomcat )
JSP compilées automatiquement en servlet par le moteur�
JSP : Introduction
JSP 4Sadok Ben Yahia
JSP : Principe
du code Java embarqué dans une page HTML entre les balises <% et %>
extension .jsp pour les pages JSP les fichiers .jsp sont stockés sur le serveur (comme des docs) ils sont désignés par une URL http:// www. lip2. tn/ prog. Jsp le chargement de l'URL provoque l' exécution de la servlet
Client
ExplorerNetscape…..
Serveur
IISApache...
Tom
cat
JVMSunMicrosoft
test1. JSP
JSP 5Sadok Ben Yahia
Principe de fonctionnement
<HTML> <BODY><H1> Table des factorielles</ H1><%int i, fact;for ( i= 1, fact= 1 ; i< 4 ; i++, fact*= i ) {out. print( i + "! =" + fact + "< BR>" );}%>
</ BODY> </ HTML>
résultat = HTML généré via l'objet prédéfini out
du code Java
JSP 6Sadok Ben Yahia
Principe de fonctionnement
ce qui estrenvoyéau client
<HTML> <BODY><H1> Table des factorielles</ H1>1! = 1< BR>2! = 2< BR>3! = 6< BR></ BODY> </ HTML>
JSP 7Sadok Ben Yahia
JSP : Mécanismes mis en œuvre
Plusieurs zones <% ... %> peuvent cohabiter dans une même JSP�
Lors du premier chargement d'une JSP (ou après modification), le �
moteur :
- rassemble tous les fragments <% ... %> de la JSP dans une classe
- la compile
- l'instancie
Puis, ou lors des chargements suivants, le moteur�
- exécute le code dans un thread
délai d'attente lors de la 1ère invocation dû à la compilation
en cas d'erreur de syntaxe dans le code Java de la JSP : le
message récupéré dans le navigateur
JSP 8Sadok Ben Yahia
La directive <%= ... %>
La directive <%= expr %> génère l'affichage d'une �valeur de l'expression expr
! <%= expr %> raccourci pour <% out. print (expr); %>
<HTML> <BODY><% int aleat = (int) (Math. random() * 5); %><H1> <%= aleat %> </ H1></ BODY> </ HTML>
JSP 9Sadok Ben Yahia
Méthodes et variables d'instance
Des méthodes et des variables d'instance peuvent être associées à une JSP entre les directives <%! et %>
<HTML> <BODY><H1> Compteur</ H1><%!int cpt = 0;
int getCpt() {return cpt++;}%><H1> <%= getCpt() %> </ H1></ BODY> </ HTML>
Variable d'instance- initialisée à l'instanciation de la JSP- persiste entre 2 invocationstant que la JSP ne change pas
Méthode d'instance- attachée à l'objetcorrespondant à la JSP
JSP 10Sadok Ben Yahia
JSP variables d'instance�Attention !!
variable d'instance de la JSP ( persiste ) variable locale à la JSP ( réinitialisée à chaque invocation de la JSP)�
Exemple
<%! int cpt = 0; %> <% int cpt = 0; %>#
1ère invocation 2ème invocation
JSP 11Sadok Ben Yahia
La directive <%@ page ... %>
Donne des informations sur la JSP (non obligatoire, valeurs par défaut)
<%@ page language=" java" %> : le langage utilisé dans la JSP ( java seule
valeur possible pour l'instant)
<%@ page import="..." %> : les "import" nécessaires au code Java de la
JSP (ex. <%@ page import=" java. io.*" %> )
<%@ page isThreadSafe="..." %> :
true la JSP peut être exécutée par +sieurs clients à la fois (valeur par défaut)
false la JSP ne peut être exécutée que par un seul client à la fois
<%@ page errorPage="..." %> : fournit l'URL de la JSP à charger en cas
d'erreur (ex. <%@ page errorPage=" err. jsp" %> )
<%@ page isErrorPage="..." %>
true la JSP est une page invoquée en cas d'erreur
false la JSP est une page normale (valeur par défaut)
JSP 12Sadok Ben Yahia
Les 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
JSP 13Sadok Ben Yahia
Récupération des données d'un formulaireMéthode String getParameter(String) de l'objet prédéfini
requestretourne le texte saisi
ou null si le nom de paramètre n'existe pas
<HTML> <BODY><FORM ACTION=" http://..."METHOD= POST>Nom <INPUT NAME="nom" > <P>Prénom <INPUT NAME="prenom" > <P><INPUT TYPE= SUBMIT VALUE=" Envoi"><INPUT TYPE= RESET VALUE=" Remise à zéro"></ FORM></ BODY> </ HTML>
JSP 14Sadok Ben Yahia
Récupération des données d'un formulaire
<HTML> <BODY><H1> Exemple de résultat</ H1>Bonjour<%= request. getParameter("prenom") %><%= request. getParameter("nom") %></ BODY> </ HTML>
JSP 15Sadok Ben Yahia
Exemple JSP<HTML>
<BODY BGCOLOR="#ffffcc">
<CENTER>
<% if (request.getParameter("nom")==null &&
request.getParameter("email")== null) { %>
<H2>Information utilisateur</H2>
<FORM method="GET" action="/exemple2/web/process.jsp">
<P>Votre nom: <input type="text" name="nom" size=26>
<P>Votre email: <input type="text" name="email" size=26>
<P><input type="submit" value="Envoyer">
</FORM>
<% } else { %>
<%! String nom, email; %>
<%
nom = request.getParameter("nom");
email = request.getParameter("email");
%>
<P><B>Vous avez fourni les informations suivantes:</B>
<P><B>Name</B>: <%= nom %>
<P><B>Email</B>: <%= email %>
<% } %>
</CENTER>
</BODY>
</HTML>
Si on accède à process.jsp après avoir entré son URL dans le navigateur
Si on accède à process.jsp après avoir appuyé sur Envoyer
JSP 16Sadok Ben Yahia
Gestion des erreurs
Erreur de syntaxe�
- dans les directives JSP (ex. : oubli d'une directive %> )
- dans le code Java
Erreur d'exécution du code Java (ex. : NullPointerException )
dans tous les cas, erreur récupérée dans le navigateur client
2 possibilités
conserver la page par défaut construite par le moteur�
en concevoir une adaptée aux besoins particuliers de l'application�
utilisation des directives <%@ page errorPage="..." %> et
<%@ page isErrorPage="..." %>
JSP 17Sadok Ben Yahia
Exemple de gestion d'erreur
<HTML> <BODY><H1> Pourvu ... !!</ H1><% int hasard =(int) ( Math. random() * 5 );%><H1> <%= 12 / hasard %> </
H1></ BODY> </ HTML>
Si hasard = 0
page d'erreur par défaut
JSP 18Sadok Ben Yahia
Exemple de gestion d'erreur : définition d’une page d’erreur
<HTML>
<BODY>
<H1> Pourvu ... !!</ H1>
<%@ page errorPage=" err. jsp" %>
<% int hasard = ... %>
<H1> <%= 12 / hasard %> </ H1>
</ BODY>
</ HTML>
JSP 19Sadok Ben Yahia
Exemple de gestion d'erreur : définition d’une page d’erreur
<HTML> <BODY><%@ page isErrorPage="true" %><h1> Le 0 est sorti !!</ h1>Erreur :<%= exception. getMessage() %></ BODY> </ HTML>
Si hasard = 0page d'erreur err. jsp Récupération de l'erreur via l'objet prédéfini exception
page d'erreur err. jsp
JSP 20Sadok Ben Yahia
Inclusion de JSP
<HTML> <BODY>
<H1> JSP principale</ H1>
<jsp: include page=" inc. jsp“ flush=" true" >
</ jsp: include>
</ BODY> </ HTML>
agrégation des résultats fournis par plusieurs JSPmeilleure modularité meilleure réutilisation
Directives <jsp: include> et </ jsp: include>
JSP 21Sadok Ben Yahia
Inclusion de JSP
Résultat<HTML> <BODY><H1> JSP principale</ H1><B> JSP incluse</ B><P><%= (int) (Math. random()* 5) %></ P></ BODY> </ HTML>
<B> JSP incluse</ B>
<P>
<%= (int) (Math. random()* 5) %>
</ P>
Pas de <HTML> <BODY>
Fichier inc. jsp
JSP 22Sadok Ben Yahia
Compléments sur l'API
Méthodes appelables sur l'objet prédéfini request
String getProtocol() : retourne le protocole implanté par le
serveur (ex. : HTTP/ 1.1)
String getServerName() / String getServerPort() :
retourne le nom/ port de la machine serveur
String getRemoteAddr() / String getRemoteHost() :
retourne l'adresse/ nom de la machine cliente (ayant invoqué la
servlet)
String getScheme() : retourne le protocole utilisé (ex. : http ou
https) par le client
JSP 23Sadok Ben Yahia
Suivi de session
HTTP protocole non connecté : pour le serveur, 2 requêtes successives
d'un même client sont indépendantes Objectif : être capable de "suivre"
l'activité du client sur plusieurs pages
Notion de session
les requêtes provenant d'un utilisateur sont associées à une même
session
les sessions ne sont pas éternelles, elles expirent au bout d'un délai
fixé
Objet prédéfini session de type HttpSession initialisable avec les
méthodes
- session = request. getSession(true) : retourne la session
courante pour cet utilisateur ou une nouvelle session
- session = request. getSession(false) : retourne la session
courante pour cet utilisateur ou null
JSP 24Sadok Ben Yahia
Suivi de session
Méthodes appelables sur l'objet prédéfini session
void setAttribute( String name, Object value ) : ajoute un
couple ( name , value ) pour cette session
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 à la session
void setMaxIntervalTime(int seconds) : spécifie la durée de vie
maximum d'une session
long getCreationTime() / long getLastAccessedTime() :
retourne la date de création / de dernier accès de la session en ms depuis le 1/ 1/
1970, 00h00 GMT
JSP 25Sadok Ben Yahia
Partage de données entre JSP
Notion de contexte d'exécution
= ensemble de couples ( name , value) partagées par toutes les JSP instanciées
objet prédéfini application
Méthodes appelables sur l'objet prédéfini application
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
JSP 26Sadok Ben Yahia
• Ecrire un programme JSP qui se comporte différemment en fonction des paramètres qu’il récupère depuis l’URL d’appel du programme.
– Le premier appel du programme JSP s’effectue en lançant une requête par l’intermédiaire d’une URL simple, n’utilisant aucun paramètre, comme : http://localhost:8080/MaWebApp/MaJSP.jsp.
– Le navigateur affiche en réponse un formulaire demandant à l’utilisateur de remplir le formulaire, puis valider son choix en cliquant sur le boutant OK.
JSP est structures de la programmation Java (1/13)
JSP 27Sadok Ben Yahia
• Exemple 1: Programme JSP appelé QuiFaitQuoi_if.jsp :• Formulaire avec bouton radio,• Manipulation de la structure Java if-else.
JSP est structures de la programmation Java (2/13)
JSP 28Sadok Ben Yahia
• Exemple 1 (suite) :
JSP est structures de la programmation Java (3/13)
<%@page import="java.util.*"%><!-- Script JSP Créé le : <%=new Date()%>--><html><head><%! String [] lRealisateur = {"Jean-Jaques Beineix","Luc Besson", "Jean-Jaques Arnaud", "Jean-Pierre Jeunet" }; int i;%><% String parametre = request.getParameter("valeur"); if (parametre == null) { out.println("<TITLE> Question ....</TITLE>"); out.println("</head>"); out.println("<Body bgcolor=white <BR>");%> <!-- Début du formulaire html avec bouton radio --> <form name=ques action=http://localhost:8080/MICE/QuiFaitQuoi_if.jsp method=Get> <p><h1> Quel est le réalisateur du film <i> La guerre du feu <i/>?</h1><BR></p> <input type="Radio" name="valeur" value="0"> Jean-Jacques Beinex <BR><BR> <input type="Radio" name="valeur" value="1"> Luc Besson <BR><BR> <input type="Radio" name="valeur" value="2"> Jean-Jacques Arnaud <BR><BR> <input type="Radio" name="valeur" value="3"> Jean-Pierre Jeunet <BR><BR> <input type="submit" value="Ok"> </p> </form> <!-- Fin du formulaire html -->
QuiFaitQuoi_if.jsp
JSP 29Sadok Ben Yahia
• Exemple 1 (suite) :
JSP est structures de la programmation Java (4/13)
<% } else { i= Integer.parseInt(parametre); out.println("<Title> Réponse....</TITLE>"); out.println("</head>"); out.println("<Body bgcolor=white <BR>"); out.println("Votre réponse est :"+ lRealisateur[i]+"<BR><BR>"); out.println("La bonne réponse est : Jean-Jacques Arnaud"); }%></head></html>
QuiFaitQuoi_if.jsp (suite)
JSP 30Sadok Ben Yahia
• Exemple 2: Programme JSP appelé QuiFaitQuoi_switch.jsp :
• Formulaire avec bouton radio,• Manipulation de la structure Java switch.
JSP est structures de la programmation Java (5/13)
JSP 31Sadok Ben Yahia
• Exemple 2 (suite) :
JSP est structures de la programmation Java (6/13)
<%@page import="java.util.*"%><!-- Script JSP Créé le : <%=new Date()%>--><html><head><%! String lRealisateur [] = {"Jean-Jaques Beineix","Luc Besson", "Jean-Jaques Arnaud", "Jean-Pierre Jeunet" }; int i;%><% String parametre = request.getParameter("valeur"); if (parametre == null) { out.println("<TITLE> Question ....</TITLE>"); out.println("</head>"); out.println("<Body bgcolor=white <BR>");%> <!-- Début du formulaire html avec bouton radio --> <form name=ques action=http://localhost:8080/MICE/QuiFaitQuoi_switch.jsp method=Get> <p><h1> Quel est le réalisateur du film <i> La guerre du feu <i/>?</h1><BR></p> <input type="Radio" name="valeur" value="0"> Jean-Jacques Beinex <BR><BR> <input type="Radio" name="valeur" value="1"> Luc Besson <BR><BR> <input type="Radio" name="valeur" value="2"> Jean-Jacques Arnaud <BR><BR> <input type="Radio" name="valeur" value="3"> Jean-Pierre Jeunet <BR><BR> <input type="submit" value="Ok"> </p> </form> <!-- Fin du formulaire html -->
QuiFaitQuoi_switch.jsp
JSP 32Sadok Ben Yahia
• Exemple 2 (suite) :
JSP est structures de la programmation Java (7/13)
<% } else { i= Integer.parseInt(parametre); out.println("<Title> Réponse....</TITLE>"); out.println("</head>"); out.println("<Body bgcolor=white <BR>"); switch (i) { case 0 : case 1: case 3 : out.println("vous avez perdu ! "); break; case 2 : out.println("vous avez gagnez ! "); break; }
}%></head></html>
QuiFaitQuoi_switch.jsp (suite)
JSP 33Sadok Ben Yahia
• Exemple 3: Programme JSP appelé QuiFaitQuoi_do_while.jsp :
• Formulaire avec liste de choix,• Manipulation de la structure Java do while.
JSP est structures de la programmation Java (8/13)
Vous avez perdu
JSP 34Sadok Ben Yahia
• Exemple 3 (suite) :
JSP est structures de la programmation Java (9/13)
<%@page import="java.util.*"%><!-- Script JSP Créé le : <%=new Date()%>--><html><head><%! String lRealisateur [] = {"Jean-Jaques Beineix","Luc Besson", "Jean-Jaques Arnaud", "Jean-Pierre Jeunet" }; int i=0;%><% String parametre = request.getParameter("valeur"); if (parametre == null) { out.println("<TITLE> Question ....</TITLE>"); out.println("</head>"); out.println("<Body bgcolor=white <BR>");%> <!-- Début du formulaire html avec bouton radio --> <form name=ques action=http://localhost:8080/MICE/QuiFaitQuoi_do_while.jsp method=Get> <h1> Quel est le réalisateur du film <i> La guerre du feu <i/>?</h1><BR> <% String chaineR="< select name=auteur>\n"; do { chaineR+="<option value=" +i+">"+lRealisateur[i]+"</option>\n"; i++; } while (i<lRealisateur.length); chaineR+="</select>"; %>
QuiFaitQuoi_do_while.jsp
JSP 35Sadok Ben Yahia
• Exemple 3 (suite) :
JSP est structures de la programmation Java (10/13)
<%=chaineR%><input type="submit" value="Ok"></form><!-- Fin du formulaire html --><% } else { int j= Integer.parseInt(parametre); out.println("<Title> Réponse....</TITLE>"); out.println("</head>"); out.println("<Body bgcolor=white <BR>"); if(j==2) outprintln("vous avez gagné"); else outprintln("vous avez perdu");
}%></head></html>
QuiFaitQuoi_switch.jsp (suite)
JSP 36Sadok Ben Yahia
• Exemple 3: Programme JSP appelé QuiFaitQuoi_fonction.jsp :
• Formulaire avec 2 listes de choix,• Manipulation de fonction Java.
JSP est structures de la programmation Java (11/13)
JSP 37Sadok Ben Yahia
• Exemple 3 (suite) :
JSP est structures de la programmation Java (12/13)
<%@page import="java.util.*"%><!-- Script JSP Créé le : <%=new Date()%>--><html><head><%! String lRealisateur [] = {"Jean-Jaques Beineix","Luc Besson", "Jean-Jaques Arnaud", "Jean-Pierre Jeunet" }; String lFilm [] = {"Le grand bleu","Le fabuleux destin de ...", "La guerre du feu", "37° le matin" }; %><%! public String fSelect(String[] liste, String nom) { String chaine="<select name="+nom+">"; int i=0; while(i<liste.length){ chaine+="<option value="+i+">"+liste[i]+"</option>"; i++; } chaine=chaine+"</select>"; return chaine; }%> <% String parametreR = request.getParameter("auteur"); String parametreF = request.getParameter("film"); if (parametreF == null || parametreR == null) { out.println("<TITLE> Question ....</TITLE>"); out.println("</head>"); out.println("<Body bgcolor=white <BR>");%>
QuiFaitQuoi_fonction.jsp
JSP 38Sadok Ben Yahia
• Exemple 3 (suite) :
5- JSP est structures de la programmation Java (13/13)
<form name=ques action=http://localhost:8080/MICE/QuiFaitQuoi_fonction.jsp method=Post>
<% String chaineR=fSelect(lRealisateur,"auteur"); String chaineF=fSelect(lFilm,"film");
%><p><h1> Quel réalisateur ?</h1><BR></p>
<%=chaineR%><p><h1> Quel film?</h1><BR></p>
<%=chaineF%><BR><input type="submit" value="Ok"></form><!-- Fin du formulaire html -->
<% } else { out.println("<Title> Réponse....</TITLE>"); out.println("</head>"); out.println("<Body bgcolor=white <BR>"); int valeurR=Integer.parseInt(parametreR); int valeurF=Integer.parseInt(parametreF); if(valeurR==valeurF) out.println("vous avez gagné"); else out.println("vous avez perdu"); }
%></head></html>
QuiFaitQuoi_fonction.jsp (suite)
JSP 39Sadok Ben Yahia
• Agrégation de traitements fournis par des JSP :– meilleure modularité,– meilleure réutilisation.
Collaboration entre JSP et Servlets : L’Interface RequestDispatcher (1/2)
Servlet
jsp1
jsp2
jsp3
JSP 40Sadok Ben Yahia
• Obtention d’un RequestDispatcher :– dans la méthode de traitement de requête de
Servlet
– Redirection d’une requête• dans méthode de traitement de requête, demande à un JSP
de répondre au client
Collaboration entre JSP et Servlets : L’Interface RequestDispatcher (2/2)
……………..
RequestDispatcher rd;
rd = getServeletContext().getRequestDispatcher("/*****.jsp");
if(rd==null) res.sendError(404);………….
rd.forward(req, res);
JSP 41Sadok Ben Yahia
Les tags d'actions
• Les tags d'actions permettent de réaliser des traitements
couramment utilisés.
Le tag <jsp:useBean>
• Le tag <jsp:useBean> permet de localiser une instance ou
d'instancier un bean pour l'utiliser dans la JSP.
• L'utilisation d'un bean dans une JSP est très pratique
car il peut encapsuler des traitements complexes et être
réutilisable par d'autre JSP ou composants
JSP 42Sadok Ben Yahia
JavaBean
• Classe Java–Encapsule des propriétés XXX
uniquement accessible au travers de setXXX et getXXX
–Constructeur sans argument–Support de la persistance en
implémentant l’interface Serializable
JSP 43Sadok Ben Yahia
Exemple JavaBeanpackage clientele;
import java.io.*;
public class ClientBean implements Serializable {
private String nom;
private String email;
public ClientBean() {
nom = null;
email = null;
}
public void setNom(String nom) { this.nom = nom; }
public String getNom() { return nom; }
public void setEmail(String email) { this.email = email; }
public String getEmail() { return email; }
}
JSP 44Sadok Ben Yahia
JavaBeans & JSP• Plusieurs portées possibles
– application : Créé une fois et partagé par tous les clients
– session : S’il n’existe pas encore dans la session courante, créé et placé dans la session client. Réutilisé jusqu’à ce que la session soit invalidée
– request : Utilisable dans les pages de redirection de la requête (<jsp:forward>). Détruit à la fin de la requête.
– page : Comme request, mais pas transmis aux pages de redirection <jsp:forward>. Portée par défaut
JSP 45Sadok Ben Yahia
Tags d’actions<jsp:useBean> Instanciation d’un bean
<jsp:useBean id="clientbean" class="clientele.ClientBean " />
<jsp:setProperty> Modification d’une propriété<%! String tonNom; %>
<% tonNom = request.getParameter("nom"); %><jsp:setProperty
name= "clientbean" property="nom"value="<%=tonNom %> "
/>
<jsp:getProperty> Affiche une propriété
JSP 46Sadok Ben Yahia
Exemple JSP/JavaBean<jsp:useBean id= "clientBean" class="clientele.ClientBean"/><jsp:setProperty name="clientBean" property="*"/><%@ page contentType="text/html" import="clientele.*" %><%-- * alimente automatiquement les propriétés du bean avec les paramètres de la
requête. Le nom des propriétés et le nom des paramètres doivent être identiques --%>
<HTML> <BODY BGCOLOR="#ffffcc"> <CENTER> <% if (request.getParameter("nom")==null && request.getParameter("email") == null) { %> <H2>Information utilisateur</H2> <FORM method="GET" action="/exemple3/web/process.jsp"> <P>Votre nom: <input type="text" name="nom" size=27> <P>Votre email: <input type="text" name="email" size=27> <P><input type="submit" value="Envoyer"> </FORM> <% } else { %> <P><B>Vous avez fourni les informations suivantes:</B> <P><B>Name</B>: <jsp:getProperty name="clientBean" property="nom"/> <P><B>Email</B>: <jsp:getProperty name="clientBean" property="email"/> <% } %> </CENTER> </BODY></HTML>
JSP 47Sadok Ben Yahia
Le tag de redirection <jsp:forward>• Le tag <jsp:forward> permet de rediriger la requête vers une
autre URL pointant vers un fichier HTML, JSP ou un servlet.• Dès que le moteur de JSP rencontre ce tag, il redirige le requête
vers l'URL précisée et ignore le reste de la JSP courante (tout ce qui a été généré par la JSP est perdu).
• La syntaxe est la suivante :• <jsp:forward page="{relativeURL | <%= expression %>}" />
ou• <jsp:forward page="{relativeURL | <%= expression %>}" >• <jsp:param name="parameterName" value="{ parameterValue | <
%= expression %>}" /> +
</jsp:forward>• Il est possible de passer un ou plusieurs paramètres vers la
ressource appelée grâce au tag <jsp :param>.
JSP 48Sadok Ben Yahia
<html>
<body>
<p>Page initiale appelée</p>
<jsp:forward page="forward.htm"/>
</body>
</html>
forward.htm<HTML><HEAD><TITLE>Page HTML</TITLE></HEAD><BODY><p><table border="1" cellpadding="4" cellspacing="0" width="30%" align=center ><tr bgcolor="#A6A5C2"><td align="center">Page HTML forwardée</Td></Tr></table></p></BODY></HTML>
JSP 49Sadok Ben Yahia
Le tag <jsp:include>
• Ce tag permet d'inclure le contenu généré par une JSP ou une servlet dynamiquement au moment ou la JSP est exécutée.
• C'est la différence avec la directive include avec laquelle le fichier est inséré dans la JSP avant la génération de la servlet.
• La syntaxe est la suivante :• <jsp:include page="relativeURL" flush="true" />• L'attribut page permet de préciser l'URL relative de l'élément à
insérer.• L'attribut flush permet d'indiquer si le tampon doit être envoyé au
client et vidé. Si la valeur de ce paramètre est true, il n'est pas possible d'utiliser certaines fonctionnalités dans la servlet ou la JSP appelée : il n'est pas possible de modifier l'entete de la réponse (header, cookies) ou renvoyer ou faire suivre vers une autre page.
JSP 50Sadok Ben Yahia
<html>
<body>
<jsp:include page="bandeau.jsp"/>
<H1>Bonjour</H1>
<jsp:include page="pied.jsp"/>
</body>
</html>
Il est possible de fournir des paramètres à la servlet ou à la JSP appelée en utilisant le tag <jsp:param>.
Les bibliothèques de tag personnalisées (custom taglibs)
JSP 52Sadok Ben Yahia
Les bibliothèques de tag personnalisées (custom taglibs)• Les bibliothèques de tags (taglibs) ou tags
personnalisés (custom tags) permettent de définir ses propres tags basés sur XML, de les regrouper dans une bibliothèque et de les réutiliser dans des JSP.
• C'est une extension de la technologie JSP apparue à partir de la version 1.1 des spécifications des JSP.
JSP 53Sadok Ben Yahia
Les tags personnalisées• Un tag personnalisé est un élément du langage JSP défini
par un développeur pour des besoins particuliers qui ne sont pas traités en standard par les JSP.
• Elles permettent de définir ses propres tags qui réaliseront des actions pour générer la réponse.
• Le principal but est de favoriser la séparation des rôles entre le développeur Java et concepteur de page web.
• L'idée maitresse est de déporter le code Java contenu dans les scriplets de la JSP dans des classes dédiées et de les appeler dans le code source de la JSP en utilisant des tags particuliers.
JSP 54Sadok Ben Yahia
• Les tags personnalisés sont adaptés pour enlever du code Java inclus dans les JSP est le déporter dans une classe dédiée.
• Cette classe est physiquement un javabean qui implémente une interface particulière.
• La principale différence entre un javabean et un tag personnalisé est que ce dernier tient compte de l'environnement dans lequel il s'exécute (notamment la JSP et le contexte de l'application web ) et interagit avec lui.
Les tags personnalisées
JSP 55Sadok Ben Yahia
Fonctionnalités • Les tags personnalisés possèdent des fonctionnalités
intéressantes :– ils ont un accès aux objets de la JSP notamment l'objet
de type HttpResponse. Ils peuvent donc modifier le contenu de la réponse générée par la JSP
– ils peuvent recevoir des paramètres envoyés à partir de la JSP qui les appelle
– ils peuvent avoir un corps qu'ils peuvent manipuler. Par extension de cette fonctionnalité, il est possible d'imbriquer un tag personnalisé dans un autre avec un nombre d'imbrication illimité
JSP 56Sadok Ben Yahia
Avantages
• Les avantages des bibliothèques de tags personnalisés sont :– un suppression du code Java dans la JSP remplacé par
un tag XML facilement compréhensible ce qui simplifie grandement la JSP
– une API facile à mettre en œuvre– une forte et facile réutilisabilité des tags développés– une maintenance des JSP facilitée
JSP 57Sadok Ben Yahia
La définition d’une biblio de tags
• La définition d'une bibliothèque de tags comprend plusieurs entités :1. une classe dit "handler" pour chaque tag
qui compose la bibliothèque
2. un fichier de description de la bibliothèque
JSP 58Sadok Ben Yahia
Les handlers de tags• Chaque tag est associé à une classe qui va contenir les
traitements à exécuter lors de l'utilisation du tag.
• Une telle classe est nommée "handler de tag" (tag handler).
• Pour permettre leur appel, une telle classe doit
obligatoirement implémenter directement ou indirectement
l'interface javax.servlet.jsp.tagext.Tag
• L'interface Tag possède une interface fille BodyTag qui doit
être utilisée dans le cas ou le tag peut utiliser le contenu de
son corps.
JSP 59Sadok Ben Yahia
Les handlers de tags• Pour plus de facilité, l'API JSP propose les classes
TagSupport et BodyTagSupport qui implémentent respectivement l'interface Tag et BodyTag.
• Ces deux classes, contenues dans le package javax.servlet.jsp.tagext, proposent des implémentations par défaut des méthodes de l'interface.
• Ces dernières proposent un traitement standard par défaut pour chacune des méthodes de l'interface qu'ils implémentent. Pour définir un handler de tag, il suffit d'hériter de l'une ou l'autre de ces deux classes.
• Les méthodes définies dans les interfaces Tag et BodyTag sont appelées, par la servlet issue de la compilation de la JSP, au cours de l'utilisation du tag.
JSP 60Sadok Ben Yahia
Le cycle de vie général d'un tag• Lors de la rencontre du début du tag, un objet du type du handler
est instancié• plusieurs propriétés sont initialisées (pageContext, parent, ...) en
utilisant les setters correspondants• si le tag contient des attributs, les setters correspondant sont
appelés pour alimenter leur valeur, alors la méthode doStartTag() est appelée
• si la méthode doStartTag() renvoie la valeur EVAL_BODYINCLUDE alors le contenu du corps du tag est évalué
• Lors de la rencontre de la fin du tag, alors appel de la méthode doEndTag()
• si la méthode doEndTag() renvoie la valeur EVAL_PAGE alors l'évaluation de la page se poursuit, si elle renvoie la valeur SKIP_PAGE elle ne se poursuit pas
JSP 61Sadok Ben Yahia
Le cycle de vie général d'un tag
• Un handler de tag possède un objet qui permet d'avoir un accès aux objets implicites de la JSP. Cet objet est du type javax.servlet.jsp.PageContext
• Comme le code contenu dans la classe du tag ne peut être utilisé que dans le contexte particulier du tag, il peut être intéressant de sortir une partie de ce code dans une ou plusieurs classes dédiées qui peuvent être éventuellement des beans.
JSP 62Sadok Ben Yahia
L'interface Tag• Cette interface définit les méthodes principales pour la gestion du cycle
de vie d'un tag personnalisé qui ne doit pas manipuler le contenu de son corps.
• Elle définit plusieurs constantes et méthodes:
Constante Rôle
EVAL_BODY_INCLUDE Continuer avec l'évaluation du corps du tag
EVAL_PAGE Continuer l'évaluation de la page
SKIP_BODY Empêcher l'évaluation du corps du tag
SKIP_PAGE Empêcher l'évaluation du reste de la page
Méthode Rôle
int doEndTag() Traitements à la rencontre du tag de début
int doStartTag() Traitements à la rencontre du tag de fin
setPageContext(Context) Sauvegarde du contexte de la page
JSP 63Sadok Ben Yahia
• La méthode doStartTag() est appelée lors de la rencontre du tag d'ouverture et contient les traitements à effectuer dans ce cas. Elle doit renvoyer un entier prédéfini qui indique comment va se poursuivre le traitement du tag :– EVAL_BODY_INCLUDE : poursuite du traitement avec évaluation
du corps du tag– SKIP_BODY : poursuite du traitement sans évaluation du corps du
tag
• La méthode doEndTag() est appelée lors de la rencontre du tag de fermeture et contient les traitements à effectuer dans ce cas. Elle doit renvoyer un entier prédéfini qui indique comment va se poursuivre le traitement de la JSP.– EVAL_PAGE : poursuite du traitement de la JSP– SKIP_PAGE : ne pas poursuivre le traitement du reste de la JSP
JSP 64Sadok Ben Yahia
L'accès aux variables implicites de la JSP
• Les tags ont accès aux variables implicites de la JSP dans laquelle ils s'exécutent via un objet de type PageContext. La variable pageContext est un objet de ce type qui est initialisé juste après l'instanciation du handler.
• Le classe PageContext est une classe abstraite dont l'implémentation des spécifications doit fournir une adaptation concrète.
JSP 65Sadok Ben Yahia
L'accès aux variables implicites de la JSP• Cette classe définit plusieurs méthodes :• Méthodes Rôles
JspWriter getOut() Permet un accès à la variable out de la JSP
Exception getException() Permet un accès à la variable exception de la JSP
Object getPage() Permet un accès à la variable page de la JSP
ServletRequest getRequest() Permet un accès à la variable request de la JSP
ServletResponse getResponse() Permet un accès à la variable response de la JSP
ServletConfig getServletConfig() Permet un accès à l'instance de la variable de type ServletConfig
ServletContext getServletContext() Permet un accès à l'instance de la variable de type ServletContext
HttpSession getSession() Permet un accès à la session
Object getAttribute(String) Renvoie l'objet associé au nom fourni en paramètre dans la portée de la page
setAttribute(String, Object) Permet de placer dans la portée de la page un objet dont le nom est fourni en paramètre
JSP 66Sadok Ben Yahia
Les handlers de tags sans corps
• Pour définir le handler d'un tag personnalisé sans corps, il suffit de définir une classe qui implémente l'interface Tag ou qui hérite de la classe TagSupport. Il faut définir ou redéfinir les méthodes doStartTag() et endStartTag()
• La méthode doStartTag() est appelée à la rencontre du début du tag. Cette méthode doit contenir le code à exécuter dans ce cas et renvoyer la constante SKIP_BODY puisque le tag ne contient pas de corps
JSP 67Sadok Ben Yahia
Les handlers de tags avec corps• Le cycle de vie d'un tel tag inclut le traitement du corps si la
méthode doStartTag() renvoie la valeur EVAL_BODY_TAG.• Dans ce cas, les opérations suivantes sont réalisées :
– la méthode setBodyContent() est appelée– le contenu du corps est traité
• la méthode doAfterBody() est appelée. Si elle renvoie la valeur EVAL_BODY_TAG, le contenu du corps est de nouveau traité
JSP 68Sadok Ben Yahia
Les paramètres d'un tag• Un tag peut avoir un ou plusieurs paramètres qui seront
transmis à la classe via des attributs. • Pour chacun des paramètres, il faut définir des getter et des
setter en respectant les règles et conventions des Java beans. Il est impératif de définir un champ, un setter et éventuellement un accesseur pour chaque attribut.
• La JSP utilisera le setter pour fournir à l'objet la valeur de l'attribut.
• Au moment de la génération de la servlet par le moteur de JSP, celui ci vérifie par introspection la présence d'un setter pour l'attribut concerné
JSP 69Sadok Ben Yahia
Définition du fichier de description de la bibliothèque de tags (TLD)
• Le fichier de description de la bibliothèque de tags (tag library descriptor file) est un fichier au format XML qui décrit une bibliothèque de tags. Les informations qu'il contient concernent la bibliothèque de tags elle même et concerne aussi chacun des tags qui la compose.
• Ce fichier est utilisé par le conteneur Web lors de la compilation de la JSP pour remplacer le tag par du code Java.
• Ce fichier doit toujours avoir pour extension .tld. Il doit être placé dans le répertoire web−inf du fichier war ou dans un de ces sous répertoires. (c’est plus pratique de tous les regrouper dans un répertoire nommé par exemple tags ou tld).
• Comme tout fichier XML bien formé, le fichier TLD commence par un prologue
JSP 70Sadok Ben Yahia
Exemple• Le tag racine du document XML est le tag <taglib>.• Ce tag peut contenir plusieurs tags qui définissent les
caractéristiques générales de la bibliothèque
<?xml version="1.0" encoding="ISO−8859−1" ?>
<!DOCTYPE taglib
PUBLIC "−//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
"http://java.sun.com/j2ee/dtds/web−jsptaglibrary_1_1.dtd">
JSP 71Sadok Ben Yahia
Les attributs de la baliseNom Rôle
tlib−version version de la bibliothèque
jsp−version version des spécifications JSP utilisée
short−name nom court la bibliothèque (optionnel)
uri URI qui identifie de façon unique la bibliothèque
display−name nom de la bibliothèque
description : description de la bibliothèque
validator (optionnel)
listener (optionnel)
tag il en faut autant que de tags qui composent la bibliothèque
JSP 72Sadok Ben Yahia
Les tags fils de la balise tag• Nom Rôle• name nom du tag : il doit être unique dans la bibliothèque• tag−class nom entièrement qualifié de la classe qui contient le handler
du tag• tei−class nom qualifié d'une classe fille de la classe
javax.servlet.jsp.tagext.TagExtraInfo (optionnel)• body−content : type du corps du tag. Les valeurs possibles sont :
– JSP :( valeur par défaut) le corps du tag contient des tags JSP qui doivent être interprétés
– tagdependent : l'interprétation du contenu du corps est faite par le tag– empty : le corps doit obligatoirement être vide
• display−name nom court du tag• small−icon nom relatif par rapport à la bibliothèque d'un fichier gif ou
jpeg contenant une icône. (optionnel)• description description du tag (optionnel)• attribute il en faut autant que d'attribut possédé par le tag (optionnel)• example un exemple de l'utilisation du tag (optionnel)
JSP 73Sadok Ben Yahia
• Pour chaque attribut du tag personnalisé, il faut utiliser un tag <attribute>. Ce tag décrit un attribut d'un tag et peut contenir les tags suivants :
• Nom Description
name : nom de l'attribut
required :booléen qui indique la présence obligatoire de l'attribut
Rtexprvalue : booléen qui indique si la page doit évaluer l'expression lors de l'exécution. Il faut donc mettre la valeur true, si la valeur de l'attribut est fournie avec un tag JSP d'expression <%= %>
JSP 74Sadok Ben Yahia
Exemple<?xml version="1.0" encoding="ISO−8859−1" ?>
<!DOCTYPE taglib PUBLIC "−//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
"http://java.sun.com/j2ee/dtds/web−jsptaglibrary_1_1.dtd">
<taglib>
<tlibversion>1.0</tlibversion>
<jspversion>1.1</jspversion>
<shortname>testtaglib</shortname>
<uri>http://perso.jmd.test.taglib</uri>
<info>Bibliotheque de test des taglibs</info>
<tag>
<name>testtaglib1</name>
<tagclass>perso.jmd.test.taglib.TestTaglib1</tagclass>
<info>Tag qui affiche bonjour</info>
</tag>
</taglib>
JSP 75Sadok Ben Yahia
Utilisation d'une bibliothèque de tags
• Pour utiliser une bibliothèque de classe, il y a des actions à réaliser au
niveau du code source de la JSP et au niveau de conteneur
d'application web pour déployer la bibliothèque de tags.
• Pour chaque bibliothèque à utiliser dans une JSP, il faut la déclarer en
utilisant la directive taglib avant son utilisation. Le plus simple est
d'effectuer ces déclarations tout au début du code de la JSP.
• Cette directive possède deux attributs :
– uri : l'URI de la bibliothèque telle que définie dans le fichier de description
– prefix : un préfix qui servira d'espace de noms pour les tags de la bibliothèque dans
la JSP
• Exemple :
<%@ taglib uri="/WEB−INF/tld/testtaglib.tld" prefix="maTagLib" %>
JSP 76Sadok Ben Yahia
L'attribut uri• Il permet de donner une identité au fichier de description de la
bibliothèque de tags (TLD). La valeur fournie peut être :– directe (par exemple le nom du fichier avec son chemin relatif)– Exemple : <%@ taglib uri="/WEB−INF/tld/testtaglib.tld" prefix="maTagLib" %>– ou indirecte (concordance avec un nom logique défini dans un tag taglib du
descripteur de déploiement de l'application web )– Exemple : <%@ taglib uri= "/maTaglib" prefix= "maTagbib" %>
• Dans ce dernier cas, il faut ajouter pour chaque bibliothèque un tag <taglib> dans le fichier de description de déploiement de l'application/WEB−INF/web.xml
• Exemple :
<taglib>
<taglib−uri>/maTagLibTest</taglib−uri>
<taglib−location>/WEB−INF/tld/testtaglib.tld</taglib−location>
</taglib>
JSP 77Sadok Ben Yahia
• L'appel d'un tag se fait en utilisant un tag dont le nom à la forme suivante : prefix:tag (le préfix est celui défini dans la directive taglib).
Exemple : un tag sans corps : <maTagLib:testtaglib1/>
un tag avec corps
<prefix:tag>
...
</prefix:tag>• Le corps peut contenir du code HTML, du code JSP ou d'autre tag
personnalisé.• Le tag peut avoir des attributs si ceux ci ont été définis. La syntaxe pour
les utiliser respecte la norme XML (la valeur de cet attribut peut être une donnée dynamiquement évaluée lors de l'exécution) :
Exemple : un tag avec un paramètre
<prefix:tag attribut="<%= uneVariable%>"/>
Connexion aux bases de données
Connexion à une base de données Mysql
JSP 79Sadok Ben Yahia79
Exemple d'un fichier de script
# Création d'une table 'Film'
CREATE TABLE Film (titre VARCHAR (30), annee INTEGER, nomMES VARCHAR (30), prenomMES VARCHAR (30), anneeNaiss INTEGER );
JSP 80Sadok Ben Yahia
Mysql: Mise en oeuvre
JSP 81Sadok Ben Yahia
Création de la table Film
Nom de la base
JSP 82Sadok Ben Yahia
Créer une classe de connexion multi-Use
L’interface d’un objet ASP
package connectBD;import java.sql.*;public class ConnexionBD implements java.io.Serializable{Connection con = null;ResultSet rs = null ;Statement stmt = null ;public ConnexionBD () {} ;//------------------------------------------------------public boolean driver(){ try{ Class.forName(" com.mysql.jdbc.Driver "); return true ; } catch(Exception e){ System.out.println("Erreur lors du chargement du pilote :"+ e.getMessage()); return false ; } }
1/5
JSP 83Sadok Ben Yahia
Exemple de classe génériques : ConnectionBean
L’interface d’un objet ASP
public boolean OpenConnexion()
{ try{
String url = " jdbc:mysql://localhost:3306/cinema ";
con = DriverManager.getConnection(url,“root",“root");
return true ;
}
catch (Exception e)
{
System.out.println("Echec de l'ouverture de la
connexion :"+ e.getMessage());
return false ; }}
2/5
JSP 84Sadok Ben Yahia
Exemple de classe génériques : ConnectionBean
L’interface d’un objet ASP
public boolean closeConnection()
{ try{ con.close();
return true ;
}
catch (Exception e){
System.out.println("Echec de la fermeture de la connexion :"+ e.getMessage());
return false ;
} }
//-------------------------------------------------
public ResultSet selectExec(String sql){
try{ stmt = con.createStatement();
rs = stmt.executeQuery(sql);
} catch(Exception e){
System.out.println("Echec de l'exécution de la requête sql :"+e.getMessage());
} return rs ; }
3/5
JSP 85Sadok Ben Yahia
Exemple de classe génériques : ConnectionBean
L’interface d’un objet ASP
public int updateExec(String sql)
{
int i = 0 ;
try{
con.setAutoCommit(false);
stmt = con.createStatement() ;
i = stmt.executeUpdate(sql) ;
con.commit();
}
catch(Exception e)
{
System.out.println("Echec de l'exécution de la requête sql :"+e.getMessage());
}
return i ;
}
4/5
JSP 86Sadok Ben Yahia
Exemple de classe générique : ConnectionBean
L’interface d’un objet ASP
public boolean closeResultSet(){
try{ rs.close();
return true ; }
catch (Exception e){
System.out.println("Echec de la fermeture de l'objet ResultSet :"+ e.getMessage());
return false ;
} }
public boolean closeStatement()
{ try{ stmt.close(); return true ;
}
catch (Exception e){ System.out.println("Echec de la fermeture de l'objet Statement :"+ e.getMessage()); return false ;
}
}
}
5/5
JSP 87Sadok Ben Yahia
Eclipse-: ajouter la classe de connexion dans un package
Ajouter un nouveau package qui contient la classe de connexion
JSP 88Sadok Ben Yahia
Il ajouter le driver mysql!!!!Copier le fichier .jar contenant le driver sous le répertoire Web-INF/lib
JSP 89Sadok Ben Yahia
mnt: a vous de jouer…<%@ page language="java" "%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<%@ page import="cx.Cx" %>
<%@ page import ="java.sql.*" %><html>
<head> <title> première cx avec une JSP</title> </head>
<body>
<% Cx c = new Cx();
c.driver();
c.OpenConnexion();
ResultSet rs= c.selectExec("select * from film");
while(rs.next()){
out.print(rs.getString(1)+ "<br>");
out.print(rs.getInt(2)+ "<br>");
out.print(rs.getString(3)+ "<br>");
}%>
</body>
</html>
JSP 90Sadok Ben Yahia90
Programmation MySQL/jsp : exemple avec formulaire
JSP 91Sadok Ben Yahia91
En association avec un formulaire <H1>Formulaire pour programme JSP</H1>
<FORM ACTION=“films.jsp” METHOD=“POST”>
<P>
Titre : <INPUT TYPE=TEXT SIZE=20 NAME = 'titre'> <P>
Année début : <INPUT TYPE=TEXT SIZE=4 NAME='anMin'>
Année fin :<INPUT TYPE=TEXT SIZE=4 NAME='anMax'> <P>
<P>
<B>Comment combiner ces critères. </B>
ET <INPUT TYPE=RADIO NAME='comb' VALUE='ET'>
OU <INPUT TYPE=RADIO NAME='comb' VALUE='OU'> ?
<INPUT TYPE=SUBMIT VALUE='Rechercher'>
</FORM>
JSP 92Sadok Ben Yahia
films.jsp : Etape 1 -Récupère les variables transmises<body><% String titre= request.getParameter(“titre”);String anMin= request.getParameter(“anMin”);String anMax= request.getParameter(“anMax”);String comb= request.getParameter(“comb”);
= ("<B>Titre”+ titre +” anMin = “+ anMin + “anMax= “+ anMax <br>“); =("Combinaison logique” + comb+ “<P></B><br> “);String requete; if (comb.equals(“ET”)requete = "SELECT * FROM Film " + "WHERE titre LIKE” +”‘”+ titre+ “‘” + "AND annee BETWEEN” + anMin+ ”and”+ anMax"; elserequete = "SELECT * FROM Film WHERE titre LIKE”+”‘”+ titre +”‘”+ "OR (annee BETWEEN”+ anMin + “and”+ anMax+”)";
JSP 93Sadok Ben Yahia
films.jsp Etape 2: Il reste à exécuter la requête <% Cx c = new Cx();c.driver();c.openConnexion();ResultSet rs= c.selectExec(requete); %><Table border=1><tr>
<th> Titre </th> <th> Année</th>
<th> Nom MES </th> </tr><% while(rs.next()){ %><tr>
<td> <%out.print(rs.getString(1))%></td> <td> <% = rs.getInt(2)%></td> <td> <% =rs.getString(3) %></td>
</tr><%}%><\Table></body> </html>
JSP 94Sadok Ben Yahia94
Programmation MySQL/JSP : mise à jour d’une base
JSP 95Sadok Ben Yahia95
Mises à jour de la base
• On utilise un formulaire de saisie, et on déclenche:
– Un ordre INSERT pour des insertions
– Un ordre UPDATE pour une modification
– Un ordre DELETE pour une destruction
JSP 96Sadok Ben Yahia
Exemple: mise à jour de la table FilmSimple
<FORM ACTION=“majfilm.jsp" METHOD=POST>
Titre : <INPUT TYPE=TEXT SIZE=20 NAME="titre"><BR> Année : <INPUT TYPE=TEXT SIZE=4 NAME="annee"> <P> Nom : <INPUT TYPE=TEXT SIZE=20 NAME="prenom"> <BR> Prénom : <INPUT TYPE=TEXT SIZE=20 NAME="nom"> <BR> Année : <INPUT TYPE=TEXT SIZE=4 NAME="anneeNaissance">
<H1>Votre choix</H1> <INPUT TYPE=SUBMIT VALUE="Insérer" NAME='inserer' > <INPUT TYPE=SUBMIT VALUE='Modifier" NAME='modifier' > <INPUT TYPE=SUBMIT VALUE="Détruire" NAME='detruire' > </FORM>
JSP 97Sadok Ben Yahia
MajFilm.jsp : L'action depend du bouton choisi par l'utilisateur
// Test du type de mise à jour effectuée<% out.print( "<HR><H2><br>“); if (request.getParameter(“inserer”)!=null) out.print ("Insertion du film”+ request.getParameter(“titre”)); else if (request.getParameter(“modifier”)!=null)
out.print ("Modification du film”+ request.getParameter(“titre”)) else
if request.getParameter(“detruire”)!=null) out.print(“Suppression du film ”+
request.getParameter(“titre”)); out.print ("</H2><HR> <br>”);
// Affichage des données du formulaire
out.print("Titre :”+ request.getParameter(“titre”)+”<BR> annee:”+ request.getParameter(“annee”)+”<BR>"; out.print("Mis en scène par”+ request.getParameter(“prenom”) request.getParameter(“nom”)+ “, né en”+ request.getParameter(“anneeNaiss”));
JSP 98Sadok Ben Yahia
Construction de la requête en fonction de l'action demandée
String requete; if (request.getParameter(“inserer”)!=null) requete = "INSERT INTO Film (titre, annee, " + "prenomMES, nomMES, anneeNaiss) " + "VALUES (.....) ";if (request.getParameter(“modifier”)!=null) requete = "UPDATE Film SET annee=request.getParameter(“annee”),“ + "prenomMES =“ +”‘”+request.getParameter(“prenom”)+”‘”,..... WHERE titre =“ +”‘”+ request.getParameter(“titre”) +”‘”; if (request.getParameter(“detruire”)!=null) requete = "DELETE FROM Film WHERE titre=‘”+ request.getParameter(“titre”) +”‘”; Cx c = new Cx(); c.driver(); c.openConnexion();out.print (c.updateExec(requete)+ ” tuples ont été mis à jour”) ;%> <\body> </html>
L’application gestion medecins itinérants
Gestion des sessions+ accès à une base de données
JSP 100Sadok Ben Yahia
La page Index.html<html>
<head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Page d’autentification</title></head><body>
<form action=”Authentif.jsp” method="post">
Nom <input type="text" name="nom"/><br> <br>
Prenom <input type="text" name="prenom"/>
<br> <br>
<input type="submit" name = "admin" value="Administrateur"/>
<input type="submit" name = "medecin" value="Medecin"/>
</form></body></html>
JSP 101Sadok Ben Yahia
La page authentif.jsp
<% Cx c = new Cx();
c.driver();
c.OpenConnexion();
String nom = request.getParameter("nom");
String prenom = request.getParameter("prenom");
if(request.getParameter("Medecin")!=null){
String sql = "select * from medecins where nom='"+nom+"' and prenom='"+prenom+"'";
ResultSet rst=c.selectExec(sql);
if(rst.next()){
String id = rst.getString(1);
HttpSession session = request.getSession();
session.setAttribute("nom",nom);
session.setAttribute("prenom",prenom);
session.setAttribute("id",id);
response.sendRedirect("AccueilMed.jsp");
}}
else{ if(nom.equals("admin")&&prenom.equals("admin"))
response.sendRedirect("Admin.jsp"); }
JSP 102Sadok Ben Yahia
La page AcceuilMed.jsp<%@ page language="java"
<title><Acceuil Medecin</title></head><body>
<%@ page session="true" %>
<%
String nom = (String) request.getSession().getAttribute("nom");
String prenom = (String) request.getSession().getAttribute("prenom");
out.println("Bonjour « + nom+" "+prenom+ " vous êtes connecté");
%>
<br>
<a href="ListeRv.jsp">Afficher la liste des rendez-vous</a>
<br>
<a href="AffecterRv.jsp">Affecter un rendez-vous</a>
</body>
</html>
JSP 103Sadok Ben Yahia
La page ListeRv.jsp
<%@ page import="java.sql.*" %>
<%@ page session="true" %>
<% Cx c = new Cx();
c.driver();
c.OpenConnexion();
String nom = (String) request.getSession().getAttribute("nom");
String prenom = (String) request.getSession().getAttribute("prenom");
out.println(nom+" "+prenom);
int id = Integer.parseInt((String) request.getSession().getAttribute("id"));
String sql = "select c.nom,c.prenom, e.hdebut,e.mdebut,e.hfin,e.mfin from clients c, creneaux e, rv s where s.id_creneaux=e.id and s.id_client=c.id and e.id_medecin='"+id+"'";
ResultSet rst =c.seclectExec(sql);
%>
JSP 104Sadok Ben Yahia
suite<table border="1">
<tr><td>Nom</td><td>Prenom</td><td>Heure debut</td><td>Heure fin</td></tr>
<%
if(rst!=null)
while(rst.next())
{
%>
<tr>
<td><%out.println(rst.getString(1));%></td>
<td><%out.println(rst.getString(2));%></td>
<td><%out.println(rst.getString(3)+":"+rst.getString(4));%></td>
<td><%out.println(rst.getString(5)+":"+rst.getString(6));%></td>
</tr>
<%
}%>
</table>
<% c.closeConnection(); %>
</html>
JSP 105Sadok Ben Yahia
Conclusion
Permettent d'étendre le comportement des serveurs Web avec des
prog. Java
Résumé des fonctionnalités
+ code embarqué dans un fichier HTML
+ portabilité, facilité d'écriture ( Java )
+ gestion des applications requièrant un suivi entre plusieurs
programmes
( persistance des données )
+ JSP chargée et instanciée une seule fois
+ JSP exécutée avec des processus légers ( threads )
JSP 106Sadok Ben Yahia
Merci