2. Un premier exemple

2.1. Une première JSP statique

Écrivons une première page JSP simple.

Exemple 36. Une première page JSP simple

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">

 <html>
     <head>
         <meta  http-equiv="Content-Type"  content="text/html; charset=UTF-8">
         <title>Une première JSP</title>
     </head>
     <body>
         <h1>Bonjour le monde !</h1>
     </body>
 </html>

Cette page peut être sauvegardée dans un fichier bonjour.jsp, et rangée à la racine de notre application web. On y accède par l'URL de cette application web, à laquelle il suffit d'ajouter le nom du fichier : bonjour.jsp. Nous avons donc partiellement résolu notre problème : nous n'avons plus à écrire du code HTML dans du code Java pour produire nos pages web. Cela dit, les JSP proposent de nombreuses fonctionnalités supplémentaires.

2.2. Une première JSP dynamique

Incluons le code suivant à notre page.

Exemple 37. Une première JSP dynamique

<p>Bonjour, il est <%=new java.util.Date()%></p>

On observe cette fois-ci un affichage qui ressemble à ça :
Il est Thu Oct 28 14:00:58 CEST 2010
Il est possible d'inclure des variables Java dans une page JSP, en les plaçant entre les marqueurs <%= et %>. Ce code Java est alors invoqué, et le résultat placé dans la réponse. Voyons un dernier exemple, qui nous permet d'écrire trois fois "Bonjour le monde" sans effort.

Exemple 38. Une deuxième JSP dynamique

<p>Trois fois <br>
<%  for (int i =  0 ; i <  3 ; i++) { %>
	Bonjour le monde ! <br>
<% } %>
sans effort !</p>

Le tag ouvrant utilisé ici est légèrement différent : <%. Il indique que la suite est du code Java, qui doit être exécuté en l'état. D'où l'affichage :
Trois fois
Bonjour le monde !
Bonjour le monde !
Bonjour le monde !
sans effort !

2.3. Fonctionnement interne des JSP

Comment tout ceci fonctionne-t-il ? Si l'on explore l'arborescence de Tomcat (ou d'un projet Eclipse ou Netbeans, si l'on travaille avec l'un de ces deux IDE), on se rend compte de la présence de deux fichiers : index_jsp.java et index_jsp.class. Dans une installation standard de Tomcat, ces deux fichiers sont dans la sous-arborescence du répertoire work. Le premier fichier index_jsp.java contient le code d'une servlet classique, dans laquelle on trouve le code suivant :

Exemple 39. Génération d'une servlet à partir d'une JSP

out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"\n");
out.write("   \"http://www.w3.org/TR/html4/loose.dtd\">\n");
out.write("\n");
out.write("<html>\n");
out.write("  <head>\n");
out.write("    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\n");
out.write("    <title>JSP Page</title>\n");
out.write("  </head>\n");
out.write("  <body>\n");
out.write("    <h1>Bonjour le monde !</h1>\n");
out.write("  </body>\n");
out.write("</html>\n");

Pour chaque page JSP, Tomcat génère automatiquement une servlet, dans laquelle se trouve le code que l'on aurait eu à écrire pour générer le contenu HTML de notre page. Cette servlet est ensuite compilée, et publiée sous le nom de notre page JSP. C'est bien cette servlet qui nous répond quand on invoque l'URL "index.jsp". Chaque modification de notre page JSP est détectée par Tomcat, qui reprend la génération de ce code Java et sa compilation. Ce traitement est donc un surcoût sur la première requête. Observons le nouveau code généré lorsque nous avons ajouté <%= new java.util.Date()%> dans notre JSP. On ne reproduit ici que le contenu de la balise <h1>

Exemple 40. Modification du code généré - 1

out.write("<h1>Bonjour le monde !");
out.print(new java.util.Date() );
out.write("</h1>\n");

On constate bien que le contenu de la balise <%= ... %> a été ajouté en paramètre des appels à out.write(). Observons enfin la modification du code généré lorsque nous avons ajouté notre boucle.

Exemple 41. Modification du code généré - 2

out.write("<p>Trois fois <br>\n");
 for (int i =  0 ; i <  3 ; i++) { 
   out.write("\tBonjour le monde ! <br>\n");
} 
out.write("sans effort</p>\n");

Cette fois, le contenu du code Java placé dans les balises <% ... %> a été recopié sans modification dans le code de la servlet. C'est ainsi que ces deux balises fonctionnent.
Java servlet et JSP
Retour au blog Java le soir
Cours & Tutoriaux
Table des matières
Introduction
1. Position de l'API Servlet
2. Présentation
Présentation de Tomcat
1. Un peu d'histoire
2. Organisation des répertoires de Tomcat
2.1. Répertoire bin
2.2. Répertoire conf
2.3. Répertoire lib
2.4. Répertoire log
2.5. Répertoire temp
2.6. Répertoire webapp
2.7. Répertoire work
3. Lancement de Tomcat
3.1. Lancement par défaut
3.2. Accéder à l'administration de Tomcat
3.3. Plusieurs instances de Tomcat
4. Configuration de Tomcat
4.1. Introduction
4.2. Élément Server
4.3. Élément Service
4.4. Élément Connector
4.5. Élément Engine
4.6. Élément Host
4.7. Élément Context
4.8. Élément GlobalNamingResources
4.9. Élément Realm
4.10. Élément Valve
5. Définition et chargement des applications web
5.1. Introduction
5.2. Prise en compte des éléments Context
5.3. Chargement et mise à jour à chaud
6. Utilisation de Tomcat avec Apache
API Servlet
1. Introduction
2. Une première servlet
2.1. Le code
2.2. Création de l'application web
2.3. Déploiement dans Tomcat
3. Concepts, cycle de vie
3.1. Requête
3.2. Réponse
3.3. Session
3.4. Application web
3.5. Contexte d'exécution
3.6. Cycle de vie
3.7. Filtre
4. Présentation générale de l'API
4.1. Introduction
4.2. Interfaces disponibles
5. Notion de servlet
5.1. Interfaces servlet
5.2. Cycle de vie d'une servlet
5.3. Paramètres d'initialisation d'une servlet
6. Notion de requête
6.1. Accès aux paramètres d'une requête
6.2. Accès aux éléments de l'en-tête HTTP
6.3. Accès aux éléments de l'URL
6.4. Accès aux paramètres du client
6.5. Accès aux informations de sécurité
6.6. Accès à la session, au contexte et aux informations d'initialisation
7. Notion de réponse
7.1. Contrôle du buffer de sortie
7.2. Contrôle de la réponse HTTP
8. Notion de session HTTP
9. Redirection ou inclusion d'une ressource
10. Listeners
10.1. Introduction
10.2. Événements de l'API Servlet
10.3. Ajout ou retrait d'un attribut
10.4. Création et destruction d'un contexte
10.5. Notification d'un objet attaché à un contexte
10.6. Déclaration d'un listener dans une application web
11. Connexion à une base
11.1. Introduction
11.2. Connexion manuelle
11.3. Connexion par utilisation de source de données
Filtrage
1. Filtrage de servlets
2. Mise en place d'un filtre
2.1. Écriture d'un filtre
2.2. Déclaration du filtrage
3. Filtrage d'une requête
4. Filtrage d'une réponse
4.1. Fonctionnement de ce filtrage
Java Server Pages
1. Introduction
2. Un premier exemple
2.1. Une première JSP statique
2.2. Une première JSP dynamique
2.3. Fonctionnement interne des JSP
3. JSP scriplet
3.1. Les expressions
3.2. Les déclarations
3.3. Variables prédéfinies
3.4. Scriplet de directives
4. Utilisation de beans
4.1. Introduction
4.2. Déclaration d'un bean existant
4.3. Création d'un nouveau bean
4.4. Utilisation des propriétés d'un bean
5. Inclure un contenu externe dans une JSP
5.1. Introduction
5.2. Inclusion au lancement de l'application
5.3. Inclusion au traitement de la requête
6. Utilisation de bibliothèques de tags
6.1. Introduction
6.2. Bibliothèque core
7. Internationalisation
7.1. Notion de bundle
7.2. Internationalisation de pages JSP
Projet exemple
1. Présentation du projet