Comme vous le savez déjà, une JSP est une page web contenant du code Java.
Le dit code est introduit dans des pages web via des balises spécifiques
<% %>
; ensuite, tout ce que vous mettrez à l'intérieur est du pur code Java, voici un exemple :
Code : JSP1
2
3
4
5 | <html>
<body>
<% out.println("<h1>Une JSP !</h1>"); %>
</body>
</html>
|
Nous allons d'ailleurs l'ajouter dans notre projet !
Pour ce faire, il vous suffit de faire un clic droit sur votre projet et de choisir "
new/other/web/JSP".
Appelez-la "
firstJsp". Votre JSP se trouve donc à la racine du projet : à côté du fichier
index.html pour ceux qui auraient continué de travailler sur le même projet Tomcat.
Eclipse vous génère du code, beaucoup de code, toutes les entêtes HTML en fait... pour notre test nous n'en avons pas besoin : effacez le contenu du fichier et remplacez-le par mon code (non mais !
).
Ensuite, vous connaissez la musique, rendez-vous dans l'administration de Tomcat, rentrez dans votre projet !
Pour accéder à votre JSP, il suffit de rajouter son nom dans la barre d'adresse de votre navigateur :
Ce qui vous donne ceci :
Félicitations, vous avez votre première JSP !
Ici, nous avons affiché un message, mais on peut faire plein d'autres choses dans une JSP... Utiliser des objets, faire des boucles...
Voici notre JSP avec un peu plus de code :
Code : JSP 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 | <html>
<body>
<% out.println("<h1>Une JSP !</h1>"); %>
<p>Alors...</p>
<%
String[] list = new String[]{"Et de un", "Et de deux", "Et de trois"};
out.println("<ul>");
//On peut même y mettre des commentaires...
/*
Même des commentaires multilignes
*/
//Allons-y pour une boucle...
for(String str : list)
out.println("<li>" + str + "</li>");
out.println("</ul>");
%>
</body>
</html>
|
Ce qui nous donne :
Maintenant, je vous propose de voir comment faire en sorte qu'une servlet puisse utiliser une JSP afin de la fournir au client. Vous allez voir, c'est simple comme tout...
Pour ce faire, nous allons créer une nouvelle servlet que nous appellerons
InvokeJsp, toujours dans le package
com.servlet.test
, dont voici le contenu :
Code : Java 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 | package com.servlet.test;
import java.io.IOException;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class InvokeJsp extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException{
RequestDispatcher dispatch = request.getRequestDispatcher("firstJsp.jsp");
dispatch.forward(request, response);
}
}
|
Il vous faut ensuite modifier le fichier
web.xml comme ceci :
Code : XML 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 | <web-app>
<servlet>
<servlet-class>com.servlet.test.DoIt</servlet-class>
<servlet-name>firstServlet</servlet-name>
</servlet>
<servlet>
<servlet-class>com.servlet.test.InvokeJsp</servlet-class>
<servlet-name>invoke</servlet-name>
</servlet>
<servlet-mapping>
<servlet-name>firstServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>invoke</servlet-name>
<url-pattern>/invoke</url-pattern>
</servlet-mapping>
</web-app>
|
Nous avons conservé la configuration de notre première servlet et nous avons ajouté la configuration pour la seconde.
Vous devez remarquer l'ordre de la déclaration : le fichier commence par définir tous les noms internes de nos servlets (1) et ensuite tous les chemins (2) pour y accéder de l'extérieur :
Vous devez savoir une chose importante concernant Tomcat et le fichier
web.xml.
Si vous n'avez pas opté pour la solution d'utiliser le dossier webapps/ comme workspace, vous serez obligés de redémarrer Tomcat afin qu'il puisse prendre en compte les modifications apportées au fichier web.xml ! Il va donc le relire et le tour sera joué...
Pour ceux qui ont opté pour la solution fournie, s'ils attendent quelques secondes après avoir modifié le fichier
web.xml, un message identique à celui-ci s'affichera :
Ce qui signifie que Tomcat a rechargé le contexte de l'application
Test !
Vous pouvez aller à l'adresse suivante :
localhost:8080/Test/invoke et vous aurez le contenu de votre JSP mais cette fois, celui-ci nous a été fourni par notre servlet
InvokeJsp.
Vous avez compris que ceci se faisait par le biais de ces deux lignes de code :
Code : Java1
2
3 | RequestDispatcher dispatch = request.getRequestDispatcher("firstJsp.jsp");
dispatch.forward(request, response);
//en contracté : request.getRequestDispatcher("firstJsp.jsp").forward(request, response);
|
Ces lignes de codes signifient en gros que notre servlet, après avoir fait son travail (ici elle n'en fait aucun, mais bon...) confie le tout à la page
firstJsp.jsp. Cette page récupère les objets passés en paramètre de la servlet, le code Java à l'intérieur est interprété, ce qui génère du code HTML.
Au final, notre page JSP ne contiendra plus que du code HTML, elle est retournée à Tomcat, qui nous la retourne ! 
Tu veux dire que nous pouvons utiliser les objets HttpServletRequest et HttpServletResponse dans nos pages JSP ?
Oui, ainsi que tout autre objet Java !
Par contre, les deux objets cités ci-dessus mis à part, ainsi que l'objet
PrintWriter (
out est un objet
PrintWriter), un import sera nécessaire !
Je vous propose de modifier quelque peu votre JSP...
Code : JSP 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 | <%@ page import="java.util.Enumeration, java.text.SimpleDateFormat, java.util.Date" %>
<html>
<body>
<% out.println("<h1>Nous sommes le : " + new SimpleDateFormat("dd/MM/yyyy").format(new Date()) + "</h1>"); %>
<h1>il est : <%=new SimpleDateFormat("HH:mm:ss").format(new Date()) %></h1>
<%
//Nous allons récupérer les en-têtes
Enumeration e = request.getHeaderNames();
while(e.hasMoreElements()){
String element = e.nextElement().toString();
out.println("<pre>" + element + " : " + request.getHeader(element) + "</pre>");
}
%>
</body>
</html>
|
Si cette ligne de code,
<%=new SimpleDateFormat("HH:mm:ss").format(new Date()) %>
, vous turlupine, ne vous tracassez pas trop...
L'objet
SimpleDateFormat prend une chaîne de caractères ("HH:mm:ss") correspondant à "Heures : Minutes : Secondes". On invoque ensuite la méthode format qui met en forme un objet
Date :
cette ligne de code nous retourne donc l'heure courante.
Tandis que ce format de date : "dd/MM/yyyy"
nous retourne la date courante.
Rien ne vous empêche de faire vos imports où vous le souhaitez dans la JSP. Personnellement, je préfère les avoir en haut de page, mais ce n'est qu'un avis personnel !
Vous pouvez tout aussi bien ne pas faire d'import, mais vous devrez spécifier le nom complet de l'objet utilisé (avec le package !).
Donc, partant de ce postulat, ce code :
Code : JSP 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 | <%@ page import="java.util.Enumeration, java.text.SimpleDateFormat, java.util.Date" %>
<html>
<body>
<% out.println("<h1>Nous sommes le : " + new SimpleDateFormat("dd/MM/yyyy").format(new Date()) + "</h1>"); %>
<h1>il est : <%=new SimpleDateFormat("HH:mm:ss").format(new Date()) %></h1>
<%
//Nous allons récupérer les en-têtes
Enumeration e = request.getHeaderNames();
while(e.hasMoreElements()){
String element = e.nextElement().toString();
out.println("<pre>" + element + " : " + request.getHeader(element) + "</pre>");
}
%>
</body>
</html>
|
Nous donne le même résultat que ce code :
Code : JSP 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 | <html>
<body>
<% out.println("<h1>Nous sommes le : " +
new java.text.SimpleDateFormat("dd/MM/yyyy")
.format(new java.util.Date()) +
"</h1>"); %>
<h1>il est : <%= new java.text.SimpleDateFormat("HH:mm:ss")
.format(new java.util.Date()) %></h1>
<%
//Nous allons récupérer les en-têtes
java.util.Enumeration e = request.getHeaderNames();
while(e.hasMoreElements()){
String element = e.nextElement().toString();
out.println("<pre>" + element + " : " + request.getHeader(element) + "</pre>");
}
%>
</body>
</html>
|
Qui, au final, vous donnera à l'affichage :
Vous noterez la façon dont les imports sont faits avec les JSP :
<%@ page import="package.Class, autrepackage.AutreClass, ..." %>
:
retenez bien ceci !
Vous aurez remarqué que j'ai utilisé un raccourci pour écrire des données dans la page : <%= "Une chaîne"%>
. Ceci est équivalent à <% out.println("Une chaîne");%>
Par contre, avec ce raccourcis, vous ne DEVEZ PAS terminer votre instruction avec un ";" !
Ceci est correct :
<%= "coucou" %>
.
Alors que ceci ne l'est pas :
<%= "coucou" ; %>
.
Nous verrons pourquoi dans la partie II.
Voilà : vous venez de voir comment faire en sorte qu'une servlet délègue l'affichage à une page JSP ! Il reste encore un point à voir pour pouvoir utiliser MVC : le modèle.
Comme je vous l'avais dit plus haut, le modèle peut être divers et varié. Pour nous simplifier cet apprentissage, dans un premier temps, nous allons utiliser un simple objet Java, aussi appelé
POJO.
Qu'attendons-nous ? Je vous le demande !
Gérer l'affichage
ouanzai
Trouvez une formation
Suggestions
Flux RSS News
Twitter
Facebook
Google+