You are on page 1of 96

JSP : Java Server Page

Jean-Jacques LE COZ
Plan
 Technologie
 Syntaxe
 Template
 Directives
 Déclarations
 Objets Implicites
 Expressions
 Scriptlets
 Actions
Technologie
JSP technologie
 Création dynamique de contenus
 Côté serveur
 La technologie combine
 Java Servlet
 HTML
 XML
 JavaBeans

J2EE
Web Container







JSP Page
Servlet
Java 2 Standard Edition APIs
EJB Container







EJB
JDBC
JMS
JNDI
JTA
JavaMail
JAF
RMI-IIOP
Du point de vue HTML
 Extension de HTML
 Code Java embarqué.
 Le code Java génère du contenu dynamique.
 Le contenu est intégré dans du HTML/XML.
Du point de vue Java
 Une autre façon d'écrire des servlets
 Séparation du contenu de la présentation.
 L'environnement d'exécution compile le code
de la page JSP dynamiquement.
Contenus statiques
 HTML
 HyperText Markup Language
 SVG
 Scalable Vector Graphics
 WML
 Wireless Markup Language
 XML
 Extensible Markup Language
Accéder aux pages statiques
Navigateur




Uniform Resource Locator (URL)
Serveur Web




index.html
HTTP request
HTTP response
(contenu de index.html)
1
2
3
Contenus dynamiques
 Balises typiques JSP
 Directives, déclarations, expressions, scripts
java
 <%@, <%!, <%=, <%
 Commentaires
 <%-- le commentaire --%>
 Balises XML JSP
 Gestion des JavaBean
 <jsp:useBean, <jsp:setProperty, ...
Contenus dynamiques
 Balises JTL
 Standard (JSTL)
 Pseudo langage avec structures de contrôle
 <c:forEach, <c:when, <c:if, ...
 Personnalisé (JCTL)
 Référence à des librairies
 <f:uneFonction, ....
 Langage EL (Expression Language)
 Accès aux attributs des objets
 (${ objet.attribut } )
Accéder aux pages dynamiques

Navigateur

nom :



dupont
valider
Serveur Web









index.html
login.jsp
exécution
de
login.jsp
output.html
HTTP response
(contenu de output.html)
HTTP request (''dupont'', login.jsp)
1
2
3
5
4
6
Langage EL et EL unifié
Langage EL
 Simplification des expressions JSP
 Permet
 Accès aux objets implicites
 Accès aux classes Java
 Facilite la gestion des collections
 Syntaxe
 ${ expressionEL }
 Mécanisme d'évaluation immédiat
 Quand la page est transformée en flux HTML
 Read-only
Langage EL version JSP2.0
 Unified Expression Language
 Ajouté à la spécificationJavaServer Pages
Standard Tag Library (JSTL)
 Pour rendre le langage EL compatible avec
celui de JSF
 Pour permettre en plus du mode immédiat
le mode diférré
 Read-Write

Unified Expression Language
 Possibilités
 Évaluation diférrée des expressions
 Durant le cycle de vie
 Supporte les expressions qui peuvent
 Modifier des valeurs
 Invoquer des méthodes
 Utilisation des balises JSTL pour les
itérations avec les expressions diférrées
Évaluation diférrée (1)
 Exemple avec une expression JSF:
 <h:inputText id="nom" value="#{etudiant.nom}"/>
 Lors du chargement de la page
 Évaluation immédiate
 Lors de la soummission de la saisie
 Évaluation diférrée durant les phases JSF
Évaluation diférrée (2)
 Phases d 'évaluation de l'exemple
 apply request value
 La valeur saisie est récupérée de la requête
 process validation
 La valeur saisie est validée
 update model
 La valeur saisie met à jour le modèle, ici le nom de
l'étudiant
Types d'expression (1)
 Expression de valeur
 Left expression
 Lecture-écriture
 Syntaxe : #{expression diférrée}
 Right expression
 Lecture
 Syntaxe : ${expression immédiate}
Types d'expression (2)
 Expression de méthode
 Permet d'invoquer une méthode
 Syntaxe : #{nomObjet.nomMéthode}
 Exemple avec JSF
 <prefix:inputText id="id"
value="#{etudiant.id}"
 validator="#{student.validerId}"/>
 Le TLD qui définit la balise inputText spécifie la
signature de la méthode
 La méthode validerId est invoquée durant la
phase process validation du cycle de vie
Mécanisme extensible
 Concept de ELResolver
 Permet de déterminer si les
expressions sont résolues par JSP ou
JSF
 Classe générique ELResolver
 Un ensemble de ELResolver est fourni
 Mécanisme d'extension
 Il est possible d'écrire son propre Resolver
 Écrire le Resolver
 Enregistrer le Resolver auprès de l'application
 Utiliser les expressions
Une simple page JSP
BonjourLeMonde.jsp

<HTML>
<HEAD><TITLE>Bonjour Le Monde JSP Exemple</TITLE></HEAD>
<BODY>
Bonjour Le Monde.
</BODY>
</HTML>

Une page JSP dynamique
BonjourLeMondeBIS.jsp

<HTML>
<HEAD><TITLE>Bonjour Le Monde JSP Exemple</TITLE></HEAD>
<BODY>
Bonjour Le Monde. La date est : <%= new java.util.Date() %>.
</BODY>
</HTML>


Note : c'est la date du serveur qui s'affiche ici, pas celle du client.

Une autre syntaxe
BonjourLeMondeTER.jsp

<HTML>
<HEAD><TITLE>Bonjour Le Monde JSP Exemple</TITLE></HEAD>
<BODY>
Bonjour Le Monde. La date est :
<jsp:expression> new java.util.Date() </jsp:expression>
</BODY>
</HTML>

La syntaxe XML est plus claire mais ne change rien au code produit lors
de la compilation et rien au résultat.

Les pages JSP sont des
servlets
 Techniquement une page JSP est
compilée en une servlet :
 La page JSP est traduite en code source
Java d'une servlet.
 Le code source de la servlet est ensuite
compilée.
 Réalisé une seule fois lors de la première
invocation.
JSP : cycle de vie
navigateur
JSP container
JSP pages JSP page
contenu
statique
HTTP
request
HTTP
response
(Tomcat)
Traduite en
une servlet
et compilée
servlet
exécution
de la
servlet
servlet
output
Déploiement
 Préférable de déployer sous une forme
typique de fichier JAR.
 Fichiers WAR (Web App Repository) .
 A partir de la version 2.2 des spécifications.
 Contiennent les règles de déploiement :
 Correspondance entre URIs (Uniform Resource
Identifiers) et les ressources.
 Permet de déployer une application avec un
seul fichier binaire sans les sources.
Rappels sur les archives WAR
Étape 1:
$>mkdir application_web
$>mkdir application_web/src
$>mkdir -p application_web/WEB-INF/classes
Étape 2:
$>mv *.html application_web/
Étape 3:
$>mv web.xml application_web/WEB-INF/
Étape 4:
$>mv *.java application_web/src/
$>mv *.jsp application_web/
Étape 5:
$>mv *.class application_web/WEB-INF/classes/
Étape 6:
$>cd application_web
$>jar -cvfM applicationWeb.war
Interface JSP
 Interface JspPage
 Spécialise la classe Servlet.
 Contrat entre la page JSP et le serveur.
 Implémentation du protocole HttpJspPage.
 Méthode _jspService.
JSP syntaxe
Éléments (1)
 Contenu Template
 Tout ce qui, dans la page, n'est pas du JSP.
 Directives
 Les instructions pour préciser comment
construire la page.
Éléments (2)
 Éléments de script
 Déclarations, expressions et scriptlets.
 Actions
 Fonctionnalités offertes à partir de balises
spéciales XML. Le code de ces fonctionnalités
est masqué.
Résumé
Élément Syntaxe <% Syntaxe XML
Commentaire HTML
Commentaire JSP
Déclaration
Expression
Scriplet
Directive <%@ ... %>
<!-- commentaire --> <!-- commentaire -->
<%-- commentaire --%> <%-- commentaire --%>
<%! déclaration java %> <jsp:declaration> déclaration java </jsp:declaration>
<%= expression java %> <jsp:expression> expression java </jsp:expression>
<% instruction java %> <jsp:scriplet> instruction java </jsp:scriplet>
<jsp:directive type .../>
Template
Contenu « Template »
 Template content
 Tout ce qui n'est pas du JSP
 Template text
 HTML
 Non transformé
 Passé tel quel au flux de sortie
Exemple de template
<jsp:directive.page import="java.util.Date"/>
<HTML>
<HEAD><TITLE>Bonjour Le Monde</TITLE></HEAD>
<BODY>
Bonjour Le Monde. La date est <%= new Date() %>.
</BODY>
</HTML>

Commentaires
 Trois façons d'introduire un commentaire
 Commentaire HTML
 Commentaire JSP
 Commentaire dans un script
Commentaire HTML
 <!-- commentaire HTML -->
<!-- La date est <%= new java.util.Date() %> -->
<HTML>
<HEAD><TITLE>Bonjour Le Monde Exemple</TITLE></HEAD>
<BODY>
Bonjour Le Monde.
</BODY>
</HTML>

Commentaire JSP
 <%-- commentaire JSP --%>
<%-- Un nouvel exemple: --%>
<HTML>
<HEAD><TITLE>Bonjour Le MondeExemple</TITLE></HEAD>
<BODY>
Bonjour Le Monde.
</BODY>
</HTML>

Commentaire de script
<jsp:directive.page import="java.util.*"/>
<jsp:declaration>
/* date est une nouvelle variable, initialisée lors de son instantiation.
Elle peut aussi être utilisée de la façon suivante :
out.println(''instanciée à ''+ date); // affiche la date après le texte
*/
Date date = new Date();
</jsp:declaration>
<HTML>
<HEAD><TITLE>Bonjour Le Monde Exemple</TITLE></HEAD>
<BODY>
Bonjour Le Monde.<BR>
Cette page a été chargée en mémoire à <%= date %>.<BR>
La date est <%= new Date() %>
</BODY>
</HTML>

Règles de protection
Type d'élémentCaractère Protection
Template <% <\%
Script %> %\>
Attribut ' \'
Attribut ' \''
Attribut \ \\
Attribut <% <\%
Attribut %> %\>
Exemple de page JSP
<HTML>
<HEAD><TITLE>Bonjour Le Monde Escape Sequences</TITLE></HEAD>
<BODY>
<P>Bonjour Le Monde.<BR>
La date est <%= new java.util.Date() %>.<BR>
Le temps est calculé par l'expression JSP
<I>&lt;%=new Date()%&gt;.</I></P>
<P>Les protections JSP ne fonctionnent pas dans le code HTML.
Pourquoi ? Parce que HTML possède ses propres règles. </P>
<P>La règle HTML la plus importante est que '&lt;' est
codé ainsi <I>"&amp;lt;"</I>, '&gt;' est codé comme cela
<I>"&amp;gt;"</I>, et '&amp;' est codé ainsi <I>"&amp;amp;"</I>.
</P>
</BODY>
</HTML>
Règles de protection HTML
Caractère Protection HTML
< &lt;
> &gt;
& &amp;
Liste officielle des caractères d'échappement HTML :

http://www.w3.org/TR/html401/sgml/entities.html
Directives
Directives JSP
 Informations suplémentaires pour le
serveur :
 Imports de paquetage,
 Include de fichiers,
 Accès aux librairies de « custom tag »
 Syntaxe
 <%@ directive [...] %>
 <jsp:directive.directive [...] />
Résumé des directives
Directive Fonction
Page Contrôle les propriétés de la page JSP
Include Introduit le contenu d'un fichier dans la page JSP lors de la translation
Taglib Réalise le « custom tag » d'une librairie disponible pour la page JSP
Exemple de directive : page
<% page [attribut=''valeur''] %> ou <jsp:directive.page [attribut=''valeur''] />

Exemple :

<jsp:directive.page import="java.util.Date"/>
<HTML>
<HEAD><TITLE>Bonjour Le Monde JSP Exemple </TITLE></HEAD>
<BODY>
Bonjour Le Monde.
La date est <%= new Date() %>.
</BODY>
</HTML>
Attributs de la directive : page
Attribut Valeur Valeur par défaut
Language Java Java
Extends Superclass
Import
Session True | false True
Buffer Kilobytes ou non 8Kb
AutoFlush True | false True
IsThreadSafe True | false True
Info Text
ErrorPage URL pour la page erreur
IsErrorPage True | false False
ContentType MIME type Text/html
Directive : include
 Introduit le contenu d'un fichier dans la
page JSP.
 Lors de la translation ou compilation.
 Comme un #include en c/c++.
 Différent de l'action include.
 Opère au moment de la requête.
 Syntaxe
 <%@ include file=''nomFichier'' %>
 <jsp:include page=''nomFichier'' />
Exemple de directive : include
<jsp:include page="/copyright.html" />
<HTML>
<HEAD><TITLE>Bonjour Le Monde</TITLE></HEAD>
<BODY>
Bonjour Le Monde.
</BODY>
</HTML>

Exemple de construction
Équivalences entre écritures
 Il n'y a pas toujours égalité entre écritures
 Exemple
 La directive include
 <%@ include file=''fichier.html''%>
 Mécanisme de mise en cache de la ressource
 Statique
 <jsp:include page=''fichier.html'' flush=''true''
/>
 Attribut flush obligatoire en jsp1.1 pas en jsp1.2
 Dynamique
Directive : taglib
 Possibilité de créer ses propres balises
XML et de les utiliser dans une page JSP.
 Chaque taglib fait référence à une
librairie c'est à dire à une implémentation
Java.
 Permet de découpler la présentation de
la logique applicative contenue dans les
taglib.
Exemple d'utilisation de taglib
<jsp:directive.taglib uri="jdg.tld" prefix="jdg" />
<HTML>
<HEAD><TITLE>Bonjour Le Monde</TITLE></HEAD>
<BODY>
Bonjour Le Monde.
La date est <jdg:DATE />.
</BODY>
</HTML>

Mécanisme des taglib
JSP
web.xml
tags.tld
Tag Handler
(classe java)
<%@ taglib URI=''/tags'' prefix=''ex'' %>
<taglib>...
<tagclass>...
Déclarations
Déclaration JSP
 Permet de déclarer des données et des
fonctions.
 Utilisées dans la page JSP.
 Syntaxe
 <%! déclarations java %>
 <jsp:declaration> déclarations java
</jsp:declaration>
Exemple de déclaration
jsp:directive.page import="java.util.Date"/>
<jsp:declaration>
private static String loadTime = new Date().toString();
private static String getLoadTime() { return loadTime; }
private static String getCurrentTime() { return new Date().toString(); }
</jsp:declaration>
<HTML>
<HEAD><TITLE>Bonjour Le Monde</TITLE></HEAD>
<BODY>
Bonjour Le Monde.<BR>
Cette page a été chargée en mémoire à <%= getLoadTime()%>.<BR>
La date est <%= getCurrentTime() %>
</BODY>
</HTML>

Deux déclarations particulières
 Méthodes optionnelles
 Méthode: public void jspInit()
 Méthode: public void jspDestroy()
 Méthode jspInit()
 Appelée une seule fois lors du chargement de
la page JSP.
 Méthode jspDestroy()
 Appelée une seule fois lors du déchargement.
Exemple avec
jspInit() et jspDestroy()
<jsp:directive.page import="java.util.*, java.text.*" />
<jsp:declaration>
private static DateFormat formateur;
private static String loadTime;
private static String getLoadTime() { return loadTime; }
private static String getCurrentTime() { return toGMTString(new Date()); }
private static String toGMTString(Date date)
{
return formateur.format(date);
}
public void jspInit()
{
formateur = new SimpleDateFormat("d MMM yyyy HH:mm:ss 'GMT'", Locale.US);
formateur.setTimeZone(TimeZone.getTimeZone("GMT"));
loadTime = toGMTString(new Date());
}
public void jspDestroy() { formateur = null; }
</jsp:declaration>

<HTML>
<HEAD><TITLE>Bonjour Le Monde</TITLE></HEAD>
<BODY>
Bonjour Le Monde.<BR>
Cette page a été chargée en mémoire à <%= getLoadTime() %>.<BR>
La date est <%= getCurrentTime() %>
</BODY>
</HTML>

Objets implicites
Objets implicites
 Il y a un certain nombre d'objets
prédéfinis par l'architecture JSP.
 Ils permettent l'accès à l'environnement
d'exécution.
 Ils font partie de l'API servlet
 Les expressions et scriplets y ont accès.
Tableau des objets implicites
Objet Classe
out javax.servlet.jsp.JspWriter
request javax.servlet.ServletRequest
response javax.servlet.ServletResponse
session javax.servlet.http.HttpSession
pageContext javax.servlet.jsp.PageContext
config javax.servlet.ServletConfig
page java.lang.Object
application javax.servlet.ServletContext
exception java.lang.Throwable
Les objets implicites (1)
 L'objet « out »
 JspWriter émule java.io.PrintWriter.
 JspWriter supporte java.io.BufferedWriter.
 Exception par java.io.IOException.
 L'objet « request »
 Permet de récupérer des détails sur la requête et
le client.
 Méthode request.getParameter().
Les objets implicites (2)
 L'objet «response»
 Permet l'accès au flux de sortie.
 Il permet de positionner les entêtes (header)
 Cookies, content type, cache control, refresh,
redirection, ...
 L'objet «session»
 Permet de gérer une session avec le client.
Les objets implicites (3)
 L'objet «pageContext»
 Permet l'accès à l'environnement JSP et aux
beans.
 Permet de déterminer l'acquisition de l'objet out.
 Fournit l'interface pour “include” et “forward”.
 L'objet «config»
 Permet l'accès au ServletContext.
Les objets implicites (4)
 L'objet «page»
 Représente la page courante exécutant la
requête.
 Les méthodes de l'interface sont :
void jspInit(); // allows user action when initialized
void jspDestroy(); // allows user action when destroyed
public void _jspService(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException;

Note : la méthode _jspService() est générée alors que les deux autres méthodes
peuvent être déclarées.
Les objets implicites (5)
 L'objet « application »
 Instance de ServletContext.
 Permet d'obtenir le RequestDispatcher.
 L'objet «exception»
 Présent uniquement dans une page d'erreur.
Expressions
Les expressions
 Sont des instructions java dont le résultat est
une valeur.
 Évaluées lors de l'exécution.
 Converties en String.
 Écrites dans le flux de sortie (HTML, XML).
 Syntaxe
 <%= instruction java %>
 <jsp:expression>instruction java </jsp:expression>
Scriptlets
Les scriptlets
 Sont des instructions java.
 Implémentation de la logique applicative
 Contrôles algorithmiques
 Alternatives, itérations.
 Syntaxe
 <% instruction java %>
 <jsp:scriptlet> instruction java </jsp:scriptlet>
Exemple de page JSP avec
scriptlets
<jsp:scriptlet>
String userAgent = (String) request.getHeader("user-agent");
</jsp:scriptlet>
<HTML>
<HEAD><TITLE>JSP Scriptlet Exemple</TITLE></HEAD>
<BODY>
<jsp:scriptlet>
if (userAgent.indexOf("MSIE") != -1)
{
</jsp:scriptlet>
<p>Vous utilisez Internet Microsoft Explorer.</p>
<jsp:scriptlet>
}
else
{
</jsp:scriptlet>
<p>Vous n'utilisez pas Internet Microsoft Explorer. Vous utilisez <%= userAgent %></p>
<jsp:scriptlet>
}
</jsp:scriptlet>
</BODY>
</HTML>
Défaut des scriptlets
 Couplage fort entre le code java et le
code HTML.
 Non respect du patron MVC
 Séparation de la logique applicative de la
logique de présentation.
 Remplacer les « scriptlets » par des
« custom tag ».
 Car beaucoup de concepteurs graphique
web ne sont pas des programmeurs.
Actions
Les actions
 Plus haut niveau de fonctionnalité que :
 Déclarations, expressions et scriptlets.
 Indépendantes de tout langage script.
 Syntaxe
 Que la syntaxe XML : <jsp:
Catégories d'action
 Trois catégories d'actions standards
 Pour utiliser les composants JavaBean.
 Pour contrôler le forwarding/including.
 Pour préparer HTML pour les plug-in java.
 Extensible par les « taglib »
Page JSP et JavaBeans
 Intégration des JavaBeans et de HTML.
Action Fonctionnalité
<jsp:useBean> Préparation du bean
<jsp:setProperty> Valorisation des propriétés du bean (cast implicite)
<jsp:getProperty> Récupération des valeurs du bean sous forme de String
JavaBean
 Une classe java
 Peut implémenter Serializable.
 Encapsule un état.
 Propose une interface avec :
 Des méthodes d'accès get et set.
 Méthodes Type getDonnéeMembre().
 Méthodes void setDonnéeMembre().
<jsp:useBean
 Si le bean n'est pas trouvé alors il est
instancié.
 L'attribut scope indique la portée du bean.
 Portées : page, request, session, application.
 Syntaxe
 <jsp:useBean id=''nom'' scope=''portée'' spécification />
 <jsp:useBean id=''nom'' scope=''portée'' spécification
> corps
</jsp:useBean>
Portée du bean
Scope Cycle de vie
Page La page, la requête
Request La page courante(scope page) et les pages ''forwardées''
Session Session
Application Commun à toutes les sessions
Spécifications
 Spécification: class='' ''
 Classe du bean.
 Spécification: class='' '' et type='' ''
 Type et classe du bean.
 Spécification: type='''' et beanName='' ''
 Le type à utiliser dans la page.
 Nom d'un bean existant.
 Spécification: type=''''
 Le type à utiliser dans la page.
<jsp:setProperty
 Valorise les données membres du bean.
 Syntaxe
 <jsp:setProperty name=''nom '' expression
/>
 Exemple :
<jsp:useBean id = "leBean" ... />

...

<jsp:setProperty name = "leBean" ... />
Expressions de setProperty (1)
 Expression : property=''*''
 Tous les membres données du bean sont
valorisés par les ''request parameter''.
 Expression : property=''nom''
 Valorise uniquement le membre donnée.
Expressions de setProperty (2)
 Expression :
property=''nom''
param=''nom''
 Valorise le membre donnée par la valeur
issue du paramètre.
 Expression :
property=''nom''
value=''valeur''
 Valorise le membre donnée par la valeur.
 La valeur peut être une expression JSP.
<jsp:getProperty
 Récupération des valeurs des données
membres du bean.
 Syntaxe
 <jsp:getProperty name=''nom'' property=''nom''
 La valeur est convertie en String.
 Même comportement que pour une expression.
 (<%=nomBean.getProperty() %>
Exemple de JSP avec bean (1)
<HTML>
<jsp:declaration>
// Classe locale de bean
static public class BeanLocal
{
private String valeur;
public String getValeur() { return valeur;}
public void setValeur(String s) { valeur = s; }
}
</jsp:declaration>

<jsp:useBean id="BeanLocal" scope="page" class="BeanLocal" >

<%-- A chaque fois que le bean est créé il est initialisé par ''coucou'' --%>
<jsp:setProperty name="BeanLocal" property="valeur" value="coucou" />
</jsp:useBean>

<jsp:setProperty name="BeanLocal" property="*" />
Exemple de JSP avec bean (2)
<HEAD><TITLE>Bonjour Le Monde</TITLE></HEAD>
<BODY>
<CENTER>
<P><H1>Hello
<jsp:getProperty name=''BeanLocal'' property=''valeur''/></H1></P>
<FORM method=post>
Entrer un nom:
<INPUT TYPE="text" SIZE="32" NAME="valeur"
VALUE="<jsp:getProperty name=''BeanLocal'' property=''valeur''/>">
<BR>
<INPUT TYPE="submit" VALUE="Submit">
</FORM>
</CENTER>
</BODY>
</HTML>
Les autres actions
 Action jsp:include
 Insertion de la ressource dans le contenu de
la page en include.
 Action jsp:forward
 Insertion de la ressource dans le contenu de
la page en forward.
 Action jsp:param
 Passage d'un paramètre à la ressource.
<jsp:include
 Insertion d'une autre ressource dans le flux
de sortie.
 Statique : HTML
 Dynamique : page JSP, servlet, script CGI
 Syntaxe
 <jsp:include page=''URLrelative'' flush=''true''/>
 L'option flush est optionnelle
<jsp:forward
 Transfert de la request vers une autre
ressource.
 Le contenu de la ressource appelée se
substitue à celui de l'appelant.
 Syntaxe
 <jsp:forward page=''URLrelative'' />
<jsp:param
 Fournit des paramètres à la ressource
qui est incluse (include) ou appelée
(forward).
 Syntaxe
 <jsp:param name=''nom'' value=''valeur'' />
Exemple de page JSP
<HTML>
<jsp:include page="head.jsp" flush="true">
<jsp:param name="html-title" value="JSP Include Action" />
</jsp:include>
<BODY>
</BODY>
</HTML>


head.jsp

<HEAD>
<TITLE>
<%=(request.getParameter("html-title") != null) ?
request.getParameter("html-title") : "UNTITLED"%>
</TITLE>

<META HTTP-EQUIV="Copyright" NAME="copyright" CONTENT="Copyright (C) 2001
Noel J. Bergman/DEVTECH All Rights Reserved." >
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
</HEAD>

<jsp:plugin
 Permet la mise à jour de la JVM
supportée par le navigateur du client.
 Syntaxe
 <jsp:plugin type=''bean | applet'' code='' ''
codebase=''URL''....
</jsp:plugin>
Langage EL

Bibliographie
Livres
 Professional JSP Éditeur : Wrox Press - Auteur : Wrox Author
Team
 JSP Professionnel Éditeur : Eyrolles - Auteurs : K. Avedal, D.
Ayers
 Java Servlet and JSP Cookbook Éditeur : O'Reilly – Auteur
Bruce W. Perry
 Sites Web
 http://java.sun.com/products/jsp
 http://jakarta.apache.org