 |
|
15) Informatique distribuée |
|
|
|
|
| Texte original |
|
Traducteur :
Jean-Pierre Vidal, Alban Peignier |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
The first time a JSP is loaded by the JSP
container (which is typically associated with, or even part of, a Web server),
the servlet code necessary to fulfill the JSP tags is automatically generated,
compiled, and loaded into the servlet container. The static portions of the HTML
page are produced by sending static String objects to
write( ). The dynamic portions are included directly into the
servlet.
|
|
La première fois qu'une JSP est chargée par un conteneur JSP (qui est
typiquement associé à un serveur Web, ou bien en fait partie), le code nécessaire à la réalisation
des tags JSP est automatiquement généré, compilé, et chargé dans le conteneur de la servlet. Les
parties invariables de la page HTML sont créées en envoyant des objets String à
write( ). Les parties dynamiques sont incluses directement dans la
servlet.
|
|
|
|
From then on, as long as the JSP source
for the page is not modified, it behaves as if it were a static HTML page with
associated servlets (all the HTML code is actually generated by the servlet,
however). If you modify the source code for the JSP, it is automatically
recompiled and reloaded the next time that page is requested. Of course, because
of all this dynamism you’ll see a slow response for the first-time access
to a JSP. However, since a JSP is usually used much more than it is changed, you
will normally not be affected by this delay.
|
|
À partir de là, et tant que le code source JSP de la page n'est pas
modifié, tout se passe comme si on avait une page HTML statique associée à des servlets (en
réalité, le code HTML est généré par la servlet). Si on modifie le code source de la JSP, il est
automatiquement recompilé et rechargé dès que cette page sera redemandée. Bien entendu, à cause de
ce dynamisme le temps de réponse sera long lors du premier accès à une JSP. Toutefois, étant donné
qu'une JSP est généralement plus utilisée qu'elle n'est modifiée, on ne sera pas généralement
affecté par ce délai.
|
|
|
|
The structure of a JSP page is a cross
between a servlet and an HTML page. The JSP tags begin and end with angle
brackets, just like HTML tags, but the tags also include percent signs, so all
JSP tags are denoted by
|
|
La structure d'une page JSP est à mi-chemin d'une servlet et d'une page
HTML. Les tags JSP commencent et finissent comme les tags HTML, sauf qu'ils utilisent également le
caractère pourcent (%), ainsi tous les tags JSP ont cette structure :
|
|
|
|
|
<% JSP code here %>
|
|
<% ici, le code JSP %>
|
|
|
|
|
The leading percent sign may be followed by other characters that determine the precise type of JSP code in the tag. |
|
Le premier caractère pourcent doit être suivi d'un autre caractères qui définit précisément le type du code JSP du tag.
|
|
|
|
Here’s
an extremely simple JSP example that uses a standard Java library call to get
the current time in milliseconds, which is then divided by 1000 to produce the
time in seconds. Since a JSP expression (the <%= ) is used, the
result of the calculation is coerced into a String and placed on the
generated Web page:
|
|
Voici un un exemple extrêmement simple de JSP utilisant un appel standard à
une bibliothèque Java pour récupérer l'heure courante en millisecondes, et diviser le résultat par
1000 pour produire l'heure en secondes. Une expression JSP (<%= ) est
utilisée, puis le résultat du calcul est mis dans une String et intégré à la page
Web générée :
|
|
|
|
|
//:! c15:jsp:ShowSeconds.jsp
<html><body>
<H1>The time in seconds is:
<%= System.currentTimeMillis()/1000 %></H1>
</body></html>
///:~
|
|
//:! c15:jsp:ShowSeconds.jsp
<html><body>
<H1>The time in seconds is:
<%= System.currentTimeMillis()/1000 %></H1>
</body></html>
///:~
|
|
|
|
In the JSP examples in this book, the
first and last lines are not included in the actual code file that is extracted
and placed in the book’s source-code tree.
|
|
Dans les exemples JSP de ce livre, la première et la dernière ligne ne font
pas partie du fichier code réel qui est extrait et placé dans l'arborescence du code source de ce
livre.
|
|
|
|
When the client creates a request for the
JSP page, the Web server must have been configured to relay the request to the
JSP container, which then invokes the page. As mentioned above, the first time
the page is invoked, the components specified by the page are generated and
compiled by the JSP container as one or more servlets. In the above example, the
servlet will contain code to configure the HttpServletResponse object,
produce a PrintWriter object (which is always named out), and then
turn the time calculation into a String which is sent to out. As
you can see, all this is accomplished with a very succinct statement, but the
average HTML programmer/Web designer will not have the skills to write such
code.
|
|
Lorsque le client demande une page JSP, le serveur Web doit avoir été
configuré pour relayer la demande vers le conteneur JSP, qui à son tour appelle la page. Comme on
l'a déjà dit plus haut, lors du premier appel de la page, les composants spécifiés par la page sont
générés et compilés par le conteneur JSP en tant qu'une ou plusieurs servlets. Dans les exemples
ci-dessus, la servlet doit contenir le code destiné à configurer l'objet
HttpServletResponse, produire un objet PrintWriter (toujours
nommé out), et enfin transformer le résultat du calcul en un objet
String qui sera envoyé vers out. Ainsi qu'on peut le voir, tout
ceci est réalisé au travers d'une instruction très succincte, mais en moyenne les programmeurs
HTML/concepteurs de site Web ne seront pas qualifiés pour écrire un tel code.
|
|
|
|
Implicit objects
|
|
Les objets implicites
|
|
|
|
Servlets include classes that provide
convenient utilities, such as HttpServletRequest,
HttpServletResponse, Session, etc. Objects of these classes are
built into the JSP specification and automatically available for use in your JSP
without writing any extra lines of code. The implicit objects in a JSP are
detailed in the table below.
|
|
Les servlets comportent des classes fournissant des utilitaires pratiques,
comme HttpServletRequest, HttpServletResponse,
Session, etc. Les objets de ces classes font partie de la spécification JSP et
sont automatiquement disponibles pour vos JSP sans avoir à écrire une ligne de code supplémentaire.
Les objets implicites d'une JSP sont décrits dans le tableau ci-dessous.
|
|
|
|
Implicit variable
|
Of Type
(javax.servlet)
|
Description
|
Scope
|
request
|
protocol dependent subtype of
HttpServletRequest
|
The request that triggers the service
invocation.
|
request
|
response
|
protocol dependent subtype of
HttpServletResponse
|
The response to the
request.
|
page
|
pageContext
|
jsp.PageContext
|
The page context encapsulates
implementation-dependent features and provides convenience methods and namespace
access for this JSP.
|
page
|
session
|
Protocol dependent subtype of
http.HttpSession
|
The session object created for the
requesting client. See servlet Session object.
|
session
|
application
|
ServletContext
|
The servlet context obtained from the
servlet configuration object (e.g., getServletConfig(),
getContext( ).
|
app
|
out
|
jsp.JspWriter
|
The object that writes into the output
stream.
|
page
|
config
|
ServletConfig
|
The ServletConfig for this
JSP.
|
page
|
page
|
java.lang.Object
|
The instance of this page’s
implementation class processing the current request.
|
page
|
|
|
|
Variable implicite
|
"text-decoration: none">Du Type
(javax.servlet)
|
Description
|
Visibilité
|
|
demande (request)
|
Sous-type de HttpServletRequest dépendant du
protocole
|
La demande qui déclenche l'appel du service.
|
demande
|
|
réponse
|
Sous-type de HttpServletResponse dépendant du
protocole
|
La réponse à la demande.
|
page
|
|
pageContext
|
jsp.PageContext
|
Le contexte de page encapsule les choses qui dépendent de l'implémentation
et fournissent des méthodes commodes ainsi que l'accès à un espace de nommage pour ce
JSP.
|
page
|
|
session
|
Sous-type de http.HttpSession dépendant du
protocole
|
L'objet session créé pour le client demandeur. Voir l'objet Session pour
les servlets.
|
session
|
|
application
|
ServletContext
|
Le contexte de servlet obtenu depuis l'objet configuration de servlet
(e.g., getServletConfig(), getContext( ).
|
app
|
|
out
|
jsp.JspWriter
|
L'objet qui écrit dans le flux sortant.
|
page
|
|
config
|
ServletConfig
|
Le ServletConfig pour ce JSP.
|
page
|
|
page
|
java.lang.Object
|
L'instance de cette classe d'implémentation de page.s gérant la demande
courante.
|
page
|
|
|
|
|
The scope of each object can vary
significantly. For example, the session object has a scope which exceeds
that of a page, as it many span several client requests and pages. The
application object can provide services to a group of JSP pages that
together represent a Web
application.
|
|
La visibilité de chaque objet est extrêmement variable. Par exemple,
l'objet session a une visibilité qui dépasse la page, car il englobe plusieurs
demandes client et plusieurs pages. L'objet application peut fournir des services
à un groupe de pages JSP représentant une application Web.
|
|
|
|
JSP directives
|
|
Les directives JSP
|
|
|
|
Directives are messages to the JSP
container and are denoted by the “@”:
|
|
Les directives sont des messages adressés au conteneur de JSP et sont
reconnaissables au caractère » @] :
|
|
|
|
|
<%@ directive {attr="value"}* %>
|
|
<%@ directive {attr="value"}* %>
|
|
|
|
Directives do not send anything to the
out stream, but they are important in setting up your JSP page’s
attributes and dependencies with the JSP container. For example, the
line:
|
|
Les directives n'envoient rien sur le flux out, mais sont
importantes lorsqu'on définit les attributs et les dépendances de pages avec le conteneur JSP. Par
exemple, la ligne :
|
|
|
|
|
<%@ page language="java" %>
|
|
<%@ page language="java" %>
|
|
|
|
says that the scripting language being
used within the JSP page is Java. In fact, the JSP specification only
describes the semantics of scripts for the language attribute equal to
“Java.” The intent of this directive is to build flexibility into
the JSP technology. In the future, if you were to choose another language, say
Python (a good scripting choice), then that language would have to support the
Java Run-time Environment by exposing the Java technology object model to the
scripting environment, especially the implicit variables defined above,
JavaBeans properties, and public methods.
|
|
exprime le fait que le langage de scripting utilisé dans la page JSP est
Java. En fait, la spécification JSP décrit seulement "font-style: normal">la sémantique
des scripts pour un atttribut de langage égal à [Java. « La raison d'être de cette directive est
d'introduire la flexibilité dans la technologie JSP. Dans le futur, si vous aviez à choisir un
autre langage, par exemple Python (un bon choix de langage de sripting), alors ce langage devra
supporter le Java Run-time Environment en exposant la technologie du modèle objet Java à
l'environnement de scripting, en particulier les variables implicites définies plus haut, les
propriétés JavaBeans, et les méthodes publiques.
|
|
|
|
The most important directive is the page
directive. It defines a number of page dependent attributes and communicates
these attributes to the JSP container. These attributes include:
language, extends, import, session, buffer,
autoFlush, isThreadSafe, info and errorPage. For
example:
|
|
La directive la plus importante est la directive de page. Elle définit un
certain nombre d'attributs dépendant de la page et les communique au conteneur JSP. Parmi ces
attributs : language, extends, import,
session, buffer, autoFlush,
isThreadSafe, info et errorPage. Par
exemple :
|
|
|
|
|
<%@ page session=”true” import=”java.util.*” %>
|
|
<%@ page session=]true « import=]java.util.* « %>
|
|
|
|
This line first indicates that the page
requires participation in an HTTP session. Since we have not set the language
directive the JSP container defaults to using Java and the implicit script
language variable named session is of type
javax.servlet.http.HttpSession. If the directive had been false then the
implicit variable session would be unavailable. If the session
variable is not specified, then it defaults to
“true.”
|
|
Cette ligne indique tout d'abord que la page nécessite une participation à
une session HTTP. Puisque nous n'avons pas décrit de directive de langage le conteneur JSP
utilisera Java par défaut et la variable de langage de scripting implicite appelée session sera du
type javax.servlet.http.HttpSession. Si la directive avait été false alors la
variable implicite session n'aurait pas été disponible. Si la variable
session n'est pas spécifiée, sa valeur par défaut est » true.]
|
|
|
|
The import attribute describes the
types that are available to the scripting environment. This attribute is used
just as it would be in the Java programming language, i.e., a comma-separated
list of ordinary import expressions. This list is imported by the
translated JSP page implementation and is available to the scripting
environment. Again, this is currently only defined when the value of the
language directive is
“java.”
|
|
L'attribut import décrit les types disponibles pour
l'environnement de scripting. Cet attribut est utilisé tout comme il le serait dans le langage de
programmation Java, c'est à dire une liste d'expressions import ordinaires
séparées par des virgules. Cette liste est importée par l'implémentation de la page JSP traduite et
reste disponible pour l'environnement de scripting. À nouveau, ceci est actuellement défini
uniquement lorsque la valeur de la directive de langage est » java.]
|
|
|
|
JSP scripting elements
|
|
Les éléments de scripting JSP
|
|
|
|
Once the directives have been used to set
up the scripting environment you can utilize the scripting language elements.
JSP 1.1 has three scripting language elements—declarations,
scriptlets, and expressions. A declaration will declare elements,
a scriptlet is a statement fragment, and an expression is a complete language
expression. In JSP each scripting element begins with a
“<%”. The syntax for each is:
|
|
Une fois l'environnement de scripting mis en place au moyen des directives
on peut utiliser les éléments du langage de scripting. JSP 1.1 possède trois éléments de langage de
scripting declaration, scriptlet, et expression. Une déclaration déclare
des éléments, un scriptlet est un fragment d'instruction, et une expression est une expression
complète du langage. En JSP chaque élément de scripting commence par » <%].
Voici la syntaxe de chacun :
|
|
|
|
|
<%! declaration %>
<% scriptlet %>
<%= expression %>
|
|
<%! declaration %>
<% scriptlet %>
<%= expression %>
|
|
|
|
White space is optional after
“<%!”, “<%”, “<%=”, and before
“%>.”
|
|
L'espace est facultatif après » <%!], » <%], » <%=], et avant
[%>.]
|
|
|
|
All these tags are based upon XML; you
could even say that a JSP page can be mapped to a XML document. The XML
equivalent syntax for the scripting elements above would be:
|
|
Tous ces tags s'appuient sur la norme XML ; on pourrait dire qu'une
page JSP est un document XML. La syntaxe équivalente en XML pour les éléments de scripting
ci-dessus serait :
|
|
|
|
|
<jsp:declaration> declaration </jsp:declaration>
<jsp:scriptlet> scriptlet </jsp:scriptlet>
<jsp:expression> expression </jsp:expression>
|
|
<jsp:declaration> declaration </jsp:declaration>
<jsp:scriptlet> scriptlet </jsp:scriptlet>
<jsp:expression> expression </jsp:expression>
|
|
|
|
In addition, there are two types of
comments:
|
|
De plus, il existe deux types de commentaires :
|
|
|
|
|
<%-- jsp comment --%>
<!-- html comment -->
|
|
<%-- jsp comment --%>
<!-- html comment -->
|
|
|
|
The first form allows you to add comments
to JSP source pages that will not appear in any form in the HTML that is sent to
the client. Of course, the second form of comment is not specific to
JSPs—it’s just an ordinary HTML comment. What’s interesting is
that you can insert JSP code inside an HTML comment and the comment will be
produced in the resulting page, including the result from the JSP
code.
|
|
La première forme crée dans les pages sources JSP des commentaires qui
n'apparaîtront jamais dans la page HTML envoyée au client. Naturellement, la deuxième forme n'est
pas spécifique à JSP, c'est un commentaire HTML ordinaire. Ceci est intéressant car on peut insérer
du code JSP dans un commentaire HTML, le commentaire étant inclus dans la page résultante ainsi que
le résultat du code JSP.
|
|
|
|
Declarations are used to declare
variables and methods in the scripting language (currently Java only) used in a
JSP page. The declaration must be a complete Java statement and cannot produce
any output in the out stream. In the Hello.jsp example below, the
declarations for the variables loadTime, loadDate and
hitCount are all complete Java statements that declare and initialize new
variables.
|
|
Les déclarations servent à déclarer des variables et des méthodes dans les
langages de scripting utilisés dans une page JSP (uniquement Java pour le moment). La déclaration
doit être une instruction Java complète et ne doit pas écrire dans le flux out.
Dans l'exemple ci-dessous Hello.jsp, les déclarations des variables
loadTime, loadDate et hitCount sont toutes des
instructions Java complètes qui déclarent et initialisent de nouvelle variables.
|
|
|
|
|
//:! c15:jsp:Hello.jsp
<%-- This JSP comment will not appear in the
generated html --%>
<%-- This is a JSP directive: --%>
<%@ page import="java.util.*" %>
<%-- These are declarations: --%>
<%!
long loadTime= System.currentTimeMillis();
Date loadDate = new Date();
int hitCount = 0;
%>
<html><body>
<%-- The next several lines are the result of a
JSP expression inserted in the generated html;
the '=' indicates a JSP expression --%>
<H1>This page was loaded at <%= loadDate %> </H1>
<H1>Hello, world! It's <%= new Date() %></H1>
<H2>Here's an object: <%= new Object() %></H2>
<H2>This page has been up
<%= (System.currentTimeMillis()-loadTime)/1000 %>
seconds</H2>
<H3>Page has been accessed <%= ++hitCount %>
times since <%= loadDate %></H3>
<%-- A "scriptlet" that writes to the server
console and to the client page.
Note that the ';' is required: --%>
<%
System.out.println("Goodbye");
out.println("Cheerio");
%>
</body></html>
///:~
|
|
//:! c15:jsp:Hello.jsp
<%-- This JSP comment will not appear in the
generated html --%>
<%-- This is a JSP directive: --%>
<%@ page import="java.util.*" %>
<%-- These are declarations: --%>
<%!
long loadTime= System.currentTimeMillis();
Date loadDate = new Date();
int hitCount = 0;
%>
<html><body>
<%-- The next several lines are the result of a
JSP expression inserted in the generated html;
the '=' indicates a JSP expression --%>
<H1>This page was loaded at <%= loadDate %> </H1>
<H1>Hello, world! It's <%= new Date() %></H1>
<H2>Here's an object: <%= new Object() %></H2>
<H2>This page has been up
<%= (System.currentTimeMillis()-loadTime)/1000 %>
seconds</H2>
<H3>Page has been accessed <%= ++hitCount %>
times since <%= loadDate %></H3>
<%-- A "scriptlet" that writes to the server
console and to the client page.
Note that the ';' is required: --%>
<%
System.out.println("Goodbye");
out.println("Cheerio");
%>
</body></html>
///:~
|
|
|
|
When you run this program you’ll
see that the variables loadTime, loadDate and hitCount hold
their values between hits to the page, so they are clearly fields and not local
variables.
|
|
Lorsque ce programme fonctionne, on constate que les variables
loadTime, loadDate et hitCount gardent leurs
valeurs entre les appels de la page, il s'agit donc clairement de champs et non de variables
locales.
|
|
|
|
At the end of the example is a scriptlet
that writes “Goodbye” to the Web server console and
“Cheerio” to the implicit JspWriter object out.
Scriptlets can contain any code fragments that are valid Java statements.
Scriptlets are executed at request-processing time. When all the scriptlet
fragments in a given JSP are combined in the order they appear in the JSP page,
they should yield a valid statement as defined by the Java programming language.
Whether or not they produce any output into the out stream depends upon
the code in the scriptlet. You should be aware that scriptlets can produce side
effects by modifying the objects that are visible to them.
|
|
À la fin de l'exemple un scriplet écrit « Goodbye « sur la console du
serveur Web et » Cheerio « sur l'objet JspWriterimplicite out.
Les scriptlets peuvent contenir tout fragment de code composé d'instructions Java valides. Les
scriptlets sont exécutés au moment du traitement de la demande. Lorsque tous les fragments de
scriptlet d'une page JSP donnée sont combinés dans l'ordre où ils apparaissent dans la page JSP,
ils doivent contenir une instruction valide telle que définie dans le langage de programmation
Java. Le fait qu'ils écrivent ou pas dans le flux out dépend du code du scriplet.
Il faut garder à l'esprit que les scriplets peuvent produire des effets de bord en modifiant les
objets se trouvant dans leur champ de visibilité.
|
|
|
|
JSP expressions can found intermingled
with the HTML in the middle section of Hello.jsp. Expressions must be
complete Java statements, which are evaluated, coerced to a String, and
sent to out. If the result of the expression cannot be coerced to a
String then a ClassCastException is
thrown.
|
|
Les expressions JSP sont mêlées au code HTML dans la section médiane de
Hello.jsp. Les expressions doivent être des instructions Java complètes, qui sont
évaluées, traduites en String, et envoyées à out. Si le résultat
d'une expression ne peut pas être traduit en String alors une exception
ClassCastException est lancée.
|
|
|
|
Extracting fields and values
|
|
Extraire des champs et des valeurs
|
|
|
|
The following example is similar to one
shown earlier in the servlet section. The first time you hit the page it detects
that you have no fields and returns a page containing a form, using the same
code as in the servlet example, but in JSP format. When you submit the form with
the filled-in fields to the same JSP URL, it detects the fields and displays
them. This is a nice technique because it allows you to have both the page
containing the form for the user to fill out and the response code for that page
in a single file, thus making it easier to create and maintain.
|
|
L'exemple suivant ressemble à un autre vu précédemment dans la section
servlet. La première fois que la page est appelée il détecte s'il n'existe pas de champ et renvoie
une page contenant un formulaire, en utilisant le même code que dans l'exemple de la servlet, mais
au format JSP. Lorsque le formulaire contenant des champs remplis est envoyé à la même URL JSP, il
détecte les champs et les affiche. C'est une technique agréable parce qu'elle permet d'avoir dans
un seul fichier, le formulaire destiné au client et le code de réponse pour cette page, ce qui rend
les choses plus simples à créer et maintenir.
|
|
|
|
|
//:! c15:jsp:DisplayFormData.jsp
<%-- Fetching the data from an HTML form. --%>
<%-- This JSP also generates the form. --%>
<%@ page import="java.util.*" %>
<html><body>
<H1>DisplayFormData</H1><H3>
<%
Enumeration flds = request.getParameterNames();
if(!flds.hasMoreElements()) { // No fields %>
<form method="POST"
action="DisplayFormData.jsp">
<% for(int i = 0; i < 10; i++) { %>
Field<%=i%>: <input type="text" size="20"
name="Field<%=i%>" value="Value<%=i%>"><br>
<% } %>
<INPUT TYPE=submit name=submit
value="Submit"></form>
<%} else {
while(flds.hasMoreElements()) {
String field = (String)flds.nextElement();
String value = request.getParameter(field);
%>
<li><%= field %> = <%= value %></li>
<% }
} %>
</H3></body></html>
///:~
|
|
//:! c15:jsp:DisplayFormData.jsp
<%-- Fetching the data from an HTML form. --%>
<%-- This JSP also generates the form. --%>
<%@ page import="java.util.*" %>
<html><body>
<H1>DisplayFormData</H1><H3>
<%
Enumeration flds = request.getParameterNames();
if(!flds.hasMoreElements()) { // No fields %>
<form method="POST"
action="DisplayFormData.jsp">
<% for(int i = 0; i < 10; i++) { %>
Field<%=i%>: <input type="text" size="20"
name="Field<%=i%>" value="Value<%=i%>"><br>
<% } %>
<INPUT TYPE=submit name=submit
value="Submit"></form>
<%} else {
while(flds.hasMoreElements()) {
String field = (String)flds.nextElement();
String value = request.getParameter(field);
%>
<li><%= field %> = <%= value %></li>
<% }
} %>
</H3></body></html>
///:~
|
|
|
|
The most interesting feature of this
example is that it demonstrates how scriptlet code can be intermixed with HTML
code, even to the point of generating HTML within a Java for loop. This
is especially convenient for building any kind of form where repetitive HTML
code would otherwise be required.
|
|
Ce qui est intéressant dans cet exemple est de montrer comment le code
scriptlet et le code HTML peuvent être entremêlés, au point de générer une page HTML à l'intérieur
d'une boucle Java for. En particulier ceci est très pratique pour construire tout
type de formulaire qui sans cela nécessiterait du code HTML répétitif.
|
|
|
|
JSP page attributes and scope
|
|
Attributs et visibilité d'une page JSP
|
|
|
|
By poking around in the HTML
documentation for servlets and JSPs, you will find features that report
information about the servlet or JSP that is currently running. The following
example displays a few of these pieces of data.
|
|
En cherchant dans la documentation HTML des servlets et des JSP, on trouve
des fonctionnalités donnant des informations à propos de la servlet ou de la page JSP actuellement
en cours. L'exemple suivant montre quelques-unes de ces données.
|
|
|
|
|
//:! c15:jsp:PageContext.jsp
<%--Viewing the attributes in the pageContext--%>
<%-- Note that you can include any amount of code
inside the scriptlet tags --%>
<%@ page import="java.util.*" %>
<html><body>
Servlet Name: <%= config.getServletName() %><br>
Servlet container supports servlet version:
<% out.print(application.getMajorVersion() + "."
+ application.getMinorVersion()); %><br>
<%
session.setAttribute("My dog", "Ralph");
for(int scope = 1; scope <= 4; scope++) { %>
<H3>Scope: <%= scope %> </H3>
<% Enumeration e =
pageContext.getAttributeNamesInScope(scope);
while(e.hasMoreElements()) {
out.println("\t<li>" +
e.nextElement() + "</li>");
}
}
%>
</body></html>
///:~
|
|
//:! c15:jsp:PageContext.jsp
<%--Viewing the attributes in the pageContext--%>
<%-- Note that you can include any amount of code
inside the scriptlet tags --%>
<%@ page import="java.util.*" %>
<html><body>
Servlet Name: <%= config.getServletName() %><br>
Servlet container supports servlet version:
<% out.print(application.getMajorVersion() + "."
+ application.getMinorVersion()); %><br>
<%
session.setAttribute("My dog", "Ralph");
for(int scope = 1; scope <= 4; scope++) { %>
<H3>Scope: <%= scope %> </H3>
<% Enumeration e = pageContext.getAttributeNamesInScope(scope);
while(e.hasMoreElements()) {
out.println("\t<li>" +
e.nextElement() + "</li>");
}
}
%>
</body></html>
///:~
|
|
|
|
This example also shows the use of both
embedded HTML and writing to out in order to output to the resulting HTML
page.
|
|
Cet exemple montre également l'utilisation du mélange de code HTML et
d'écriture sur out pour fabriquer la page HTML résultante.
|
|
|
|
The first piece of information produced
is the name of the servlet, which will probably just be “JSP” but it
depends on your implementation. You can also discover the current version of the
servlet container by using the application object. Finally, after setting a
session attribute, the “attribute names” in a particular scope are
displayed. You don’t use the scopes very much in most JSP programming;
they were just shown here to add interest to the example. There are four
attribute scopes, as follows: The page scope (scope 1), the request
scope (scope 2), the session scope (scope 3—here, the only
element available in session scope is “My dog,” added right before
the for loop), and the application scope (scope 4), based upon the
ServletContext object. There is one ServletContext per “Web
application” per Java Virtual Machine. (A “Web application” is
a collection of servlets and content installed under a specific subset of the
server’s URL namespace such as /catalog. This is generally set up using a
configuration file.) At the application scope you will see objects that
represent paths for the working directory and temporary
directory.
|
|
La première information générée est le nom de la servlet, probablement »
JSP « mais cela dépend de votre implémentation. On peut voir également la version courante du
conteneur de servlet au moyen de l'objet application. Pour finir, après avoir déclaré les attributs
de la session, les noms d'attributs sont affichés avec une certaine visibilité. On n'utilise pas
beaucoup les visibilités dans la plupart des programmes JSP ; on les a montré ici simplement
pour donner de l'intérêt à l'exemple. Il existe quatre attributs de visibilité, qui sont : la
visibilité de page (visibilité 1), la visibilité de demande (visibilité 2), la
visibilité de session (visibilité 3 : ici, le seul élément disponible dans la
visibilité de session est » My dog, « ajouté juste après la boucle for), et la
visibilité d'application (visibilité 4), basée sur l'objet
ServletContext. Il existe un ServletContext pour chaque
application » Web tournant sur une Machine Virtuelle Java (une application » Web est une collection
de servlets et de contenus placés dans un sous-ensemble spécifique de l'espace de nommage de l'URL
serveur tel que /catalog. Ceci est généralement réalisé au moyen d'un fichier de configuration). Au
niveau de visibilité de l'application on peut voir des objets représentant les chemins du
répertoire de travail et du répertoire temporaire.
|
|
|
|
Manipulating sessions in JSP
|
|
Manipuler les sessions en JSP
|
|
|
|
Sessions were introduced in the prior
section on servlets, and are also available within JSPs. The following example
exercises the session object and allows you to manipulate the amount of
time before the session becomes invalid.
|
|
Les sessions ont été introduites dans les sections précédentes à propos des
servlets, et sont également disponibles dans les JSP. L'exemple suivant utilise l'objet
session et permet de superviser le temps au bout duquel la session deviendra
invalide.
|
|
|
|
|
|
|
|
|
|
|
|
|
