t
t
t
t
t t 15) Informatique distribuée
tttt
15) Informatique distribuée
Texte original t Traducteur : Jean-Pierre VIDAL, Alban PEIGNIER
t
t
///
Ce chapitre contient 12 pages
1 2 3 4 5 6 7 8 9 10 11 12
\\\
t t t
t t t
t
t t t
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. t 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.
t t t
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. t À 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.
t t t
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 t 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 :
t t t
<% JSP code here %>

t
<% ici, le code JSP %>
t t t
The leading percent sign may be followed by other characters that determine the precise type of JSP code in the tag. t 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.
t t t
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:

t 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 :
t t t
//:! c15:jsp:ShowSeconds.jsp
<html><body>
<H1>The time in seconds is:
<%= System.currentTimeMillis()/1000 %></H1>
</body></html>
///:~
t
//:! c15:jsp:ShowSeconds.jsp
<html><body>
<H1>The time in seconds is:
<%= System.currentTimeMillis()/1000 %></H1>
</body></html>
///:~
t t t
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. t 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.
t t t
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. t 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.
t t t

Implicit objects

t

Les objets implicites

t t t
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. t 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.
t t t
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
t
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
t t t
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. t 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.
t t t

JSP directives

t

Les directives JSP

t t t
Directives are messages to the JSP container and are denoted by the “@”: t Les directives sont des messages adressés au conteneur de JSP et sont reconnaissables au caractère » @] :
t t t
<%@ directive {attr="value"}* %>
t
<%@ directive {attr="value"}* %>
t t t
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:

t 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 :
t t t
<%@ page language="java" %>
t
<%@ page language="java" %>
t t t
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.
t 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.
t t t
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:

t 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 :
t t t
<%@ page session=”true” import=”java.util.*” %>
t
<%@ page session=]true « import=]java.util.* « %>
t t t
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.”
t 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.]
t t t
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.”
t 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.]
t t t


JSP scripting elements


t

Les éléments de scripting JSP

t t t
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:

t 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 :
t t t
<%! declaration %>
<%  scriptlet   %>
<%= expression %>
t
<%! declaration %>
<%  scriptlet   %>
<%= expression  %>
t t t
White space is optional after “<%!”, “<%”, “<%=”, and before “%>.” t L'espace est facultatif après » <%!], » <%], » <%=], et avant [%>.]
t t t
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: t 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 :
t t t
<jsp:declaration> declaration </jsp:declaration>
<jsp:scriptlet>   scriptlet   </jsp:scriptlet>
<jsp:expression> expression </jsp:expression>
t
<jsp:declaration> declaration </jsp:declaration>
<jsp:scriptlet>   scriptlet   </jsp:scriptlet>
<jsp:expression>  expression  </jsp:expression>
t t t
In addition, there are two types of comments: t De plus, il existe deux types de commentaires :
t t t
<%-- jsp comment --%>
<!-- html comment -->
t
<%-- jsp comment --%>
<!-- html comment -->
t t t
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. t 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.
t t t
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. t 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.
t t t
//:! 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>
///:~
t
//:! 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>
///:~
t t t
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. t 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.
t t t
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. t À 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é.
t t t
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. t 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.
t t t

Extracting fields and values

t

Extraire des champs et des valeurs

t t t
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. t 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.
t t t
//:! 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>
///:~
t
//:! 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>
///:~
t t t
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. t 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.
t t t

JSP page attributes and scope

t

Attributs et visibilité d'une page JSP

t t t
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. t 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.
t t t
//:! 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>
///:~
t
//:! 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>
///:~
t t t
This example also shows the use of both embedded HTML and writing to out in order to output to the resulting HTML page. t Cet exemple montre également l'utilisation du mélange de code HTML et d'écriture sur out pour fabriquer la page HTML résultante.
t t t
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. t 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.
t t t

Manipulating sessions in JSP

t

Manipuler les sessions en JSP

t t t
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. t 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.
t t t
t t t
t t
\\\
///
t t t
t
     
Sommaire Le site de Bruce Eckel