TOC

Guide des pages JavaServer (JSP)

Table des matières

  • link: #overview[ 1. Overview]

  • lien: #jsp[ 2. Pages JavaServer]

  • link: #syntax[ 2.1. Syntax JSP]

  • link: #contents[ 2.2. Contenu statique et dynamique]

  • link: #implicit[ 2.3. Objets implicites]

  • link: #implicit[ 2.4. Autres objets implicites]

  • link: #directives[ 2.5. Directives]

  • link: #page[ 2.6. Directives de page]

  • link: #threeExamples[ 3.0. Trois exemples]

  • link: #htmlRendered[ 3.1. HTML rendu dans Servlet]

  • link: #staticJava[ 3.2. Java dans un contenu statique JSP]

  • link: #forwarding[ 3.3. JSP With Forwarding]

  • link: #tryIt[ 3.4. Essayez-le!]

  • link: #conclusion[ 4. Conclusion]

1. Vue d’ensemble

  • Les pages JavaServer (JSP) permettent l’injection de contenu dynamic dans le contenu static à l’aide de servlets Java et Java . Nous pouvons adresser des requêtes à un Servlet Java, effectuer une logique appropriée et rendre une vue spécifique côté serveur à consommer côté client ** . Cet article fournit un aperçu complet des pages JavaServer utilisant Java 8 et Jave 7 EE.

Nous allons commencer par explorer quelques concepts clés concernant JSP, à savoir la différence entre les contenus dynamic et static , le cycle de vie JSP et la syntaxe JSP ainsi que les directives et les objets implicites créés lors de la compilation!

2. Pages JavaServer

JSP (JavaServer Pages) permet de transmettre ou de placer des données spécifiques à Java dans une vue .jsp et de les utiliser côté client.

  • Les fichiers JSP sont essentiellement des fichiers .html ** avec une syntaxe supplémentaire et quelques différences initiales mineures:

    1. le suffixe .html est remplacé par .jsp (considéré comme un fichier .jsp

filetype) et . la balise suivante est ajoutée en haut des éléments de balisage .html: 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

Passons en revue certains des concepts clés de JSP.

2.1. Syntaxe JSP

Il existe deux manières d’ajouter du code Java à un fichier .jsp. Premièrement, nous pouvons utiliser la syntaxe de base des scripts Java, qui implique de placer des blocs de code Java dans deux balises Scriptlet: 

<% Java code here %>

La seconde méthode est spécifique à XML: 

<jsp:scriptlet>
    Java code here
</jsp:scriptlet>

Il est important de noter que vous pouvez utiliser la logique conditionnelle côté client avec JSP en utilisant les clauses if , then et else , puis en encapsulant les blocs de balisage pertinents avec ces crochets. 

<% if (doodad) {%>
    <div>Doodad!</div>
<% } else { %>
    <p>Hello!</p>
<% } %>

Par exemple, si doodad est à true, nous afficherions le premier élément, div , sinon nous afficherions le deuxième, p !

2.2. Static et Dynamic Contents

Les contenus Web Static sont des actifs fixes consommés indépendamment des demandes RESTful, SOAP, HTTP, HTTPS ou de toute autre information soumise par l’utilisateur.

Le contenu de Static est cependant fixe et n’est pas modifié par les entrées de l’utilisateur.

Les contenus Web Dynamic sont les actifs qui répondent, sont modifiés ou sont modifiés à la lumière des actions ou des informations des utilisateurs!

La technologie JSP permet de séparer clairement les responsabilités entre les contenus dynamic et static .

Le serveur (servlet) gère le contenu dynamic et le client (la page .jsp proprement dite) est le contexte static dans lequel le contenu dynamique est injecté.

Jetons un coup d’œil aux objets implicites créés par JSP et permettant d’accéder au serveur de données correspondant à JSP!

2.3. Objets implicites

Les objets implicites sont générés automatiquement par le moteur JSP lors de la compilation.

Les objets implicites incluent les objets HttpRequest et HttpResponse et exposent diverses fonctionnalités côté serveur à utiliser dans votre servlet et à interagir avec votre fichier .jsp! Voici la liste des objets implicites créés:

  • request ** quest appartient à la classe javax.servlet.http.HttpServletRequest

L’objet request expose toutes les données saisies par l’utilisateur et le rend disponible côté serveur.

  • response ** response appartient à la classe javax.servlet.http.HttpServletResponse et détermine ce qui est renvoyé par le client après la création d’une demande.

Examinons de plus près les objets implicites request et response car ils sont les plus importants et les plus utilisés.

L’exemple ci-dessous illustre une méthode de servlet très simple et incomplète pour traiter les demandes GET. J’ai omis la plupart des détails pour pouvoir nous concentrer sur l’utilisation des objets request et response : 

protected void doGet(HttpServletRequest request,
  HttpServletResponse response) throws ServletException, IOException {
    String message = request.getParameter("message");
    response.setContentType("text/html");
    . . .
}

Tout d’abord, nous voyons que les objets request et response sont transmis en tant que paramètres à la méthode, ce qui les rend disponibles dans son étendue.

Nous pouvons accéder aux paramètres de requête à l’aide de la fonction .getParameter () .

Ci-dessus, nous accrochons le paramètre message et initialisons une variable chaîne afin de pouvoir l’utiliser dans notre logique côté serveur. Nous pouvons également accéder à l’objet response qui détermine ce que seront les données transmises à la vue et comment.

Ci-dessus, nous définissons le type de contenu. Nous n’avons pas besoin de renvoyer l’objet response pour que sa charge apparaisse sur la page JSP lors du rendu!

  • out ** out appartient à la classe javax.servlet.jsp.JspWriter et est utilisé pour écrire du contenu sur le client.

Il existe au moins deux façons d’imprimer sur votre page JSP et il est utile de discuter des deux ici. out est créé automatiquement et vous permet d’écrire en mémoire, puis dans l’objet response : 

out.print(“hello”);
out.println(“world”);

C’est tout!

La seconde approche peut être plus performante puisqu’elle vous permet d’écrire directement dans l’objet response ! Ici, nous utilisons PrintWriter : 

PrintWriter out = response.getWriter();
out.println("Hello World");

2.4. Autres objets implicites

Voici quelques autres "objets implicites" qui sont aussi intéressants à connaître!

  • session ** + session appartient à la classe javax.servlet.http.HttpSession conserve les données utilisateur pendant la durée de la session.

  • application ** application appartient à la classe javax.servlet.ServletContext stocke les paramètres à l’échelle de l’application définis lors de l’initialisation ou devant être accessibles à l’ensemble de l’application.

  • exception ** exception appartient à la classe javax.servlet.jsp.JspException est utilisé pour afficher les messages d’erreur sur les pages JSP portant la balise <% @ page isErrorPage = "true"%> .

  • page ** page appartient à la classe java.lang.Object permet d’accéder ou de référencer les informations de servlet actuelles.

  • pageContext ** pageContext appartient à la classe javax.servlet.jsp.PageContext par défaut à page scope mais peut être utilisée pour accéder aux attributs request , application et session .

  • config ** config appartient à la classe javax.servlet.ServletConfig est l’objet de configuration du servlet permettant d’obtenir le contexte, le nom et les paramètres de configuration du servlet.

Maintenant que nous avons couvert les objets implicites fournis par JSP, passons à directives qui permet aux pages .jsp d’accéder (indirectement) à certains de ces objets.

2.5. Directives

JSP fournit des directives prêtes à l’emploi qui peuvent être utilisées pour spécifier les fonctionnalités de base de nos fichiers JSP. Les directives JSP comportent deux parties: (1) la directive elle-même et (2) l’attribut de cette directive auquel une valeur est attribuée.

Les trois types de directives pouvant être référencés à l’aide des balises de directive sont <% @ page …​%> , qui définit les dépendances et les attributs de la JSP, y compris content type et language , <% @ include …​%> qui spécifie une importation ou un fichier à utiliser, et <% @ taglib …​%> qui spécifie une bibliothèque de balises définissant les actions personnalisées à utiliser par une page.

Ainsi, à titre d’exemple, une directive de page serait spécifiée à l’aide de balises JSP de la manière suivante: <% @ page attribut = "valeur"%>

Et nous pouvons le faire en utilisant XML comme suit: <jsp: directive.page attribut = ”valeur”/>

2.6. Attributs de directive de page

Il y a beaucoup d’attributs qui peuvent être déclarés dans une directive de page:

  • autoFlush _ <% @ page autoFlush = "false"%> _ **

autoFlush contrôle la sortie de la mémoire tampon, la supprimant lorsque la taille de la mémoire tampon est atteinte. La valeur par défaut est true .

  • tampon _ <% @ page buffer = "19 Ko"%> _ **

buffer définit la taille du tampon utilisé par notre page JSP. La valeur par défaut est 8 Ko.

  • errorPage _ <% @ page errorPage = "errHandler.jsp"%> _ **

errorPage spécifie une page JSP en tant que page d’erreur.

  • extend _ <% @ page extend = "org.apache.jasper.runtime.HttpJspBase"%> _ + **

extends spécifie la super classe du code de servlet correspondant.

  • info ** <% @ page info = "Ceci est mon JSP!"%>

info est utilisé pour définir une description textuelle pour le JSP.

  • isELIgnored ** <% @ page isELIgnored = "true"%>

isELIgnored indique si la page ignorera ou non Expression Language (EL) dans JSP. EL permet à la couche de présentation de communiquer avec les beans gérés Java en utilisant la syntaxe $ \ {…​} . Même si nous n’entrerons pas dans les détails de EL, nous avons ci-dessous plusieurs exemples suffisants. pour construire notre exemple d’application JSP! La valeur par défaut de isELIgnored est false .

  • isErrorPage ** <% @ page isErrorPage = "true"%>

isErrorPage indique si une page est une page d’erreur ou non. Nous devons spécifier une page d’erreur si nous créons un gestionnaire d’erreurs pour notre page dans l’application.

  • isThreadSafe ** <% @ page isThreadSafe = "false"%>

isThreadSafe a une valeur par défaut de true . isThreadSafe détermine si le JSP peut ou non utiliser le multi-threading Servlet. En général, vous ne voudrez jamais désactiver cette fonctionnalité.

  • language ** <% @ page language = "java"%>

language détermine quel langage de script utiliser dans le JSP. La valeur par défaut est Java .

  • session ** <% @ page session = ”valeur”%> __

session détermine s’il faut ou non maintenir la session HTTP. La valeur par défaut est true et accepte les valeurs true ou false .

  • trimDirectiveWhitespaces ** <% @ page trimDirectiveWhitespaces = "true"%>

trimDirectiveWhitespaces raye les espaces dans la page JSP en condensant le code dans un bloc plus compact au moment de la compilation. Définir cette valeur sur true peut aider à réduire la taille du code JSP. La valeur par défaut est false .

3. Trois exemples

Maintenant que nous avons examiné les concepts fondamentaux de JSP, appliquons-les à quelques exemples simples qui vous aideront à mettre en service votre premier servlet de service JSP!

Il existe trois méthodes principales pour injecter Java dans un fichier .jsp. Nous allons explorer chacune de ces méthodes ci-dessous à l’aide des fonctionnalités natives de Java 8 et Java EE.

Premièrement, nous allons rendre notre balisage côté serveur affiché à côté client.

Deuxièmement, nous verrons comment ajouter du code Java directement dans notre fichier .jsp indépendamment des objets javax.servlet.http ’s request et response .

Troisièmement, nous montrerons comment transférer un HttpServletRequest vers un fichier .jsp spécifique et y associer un fichier Java traité côté serveur.

Configurons notre projet dans Eclipse en utilisant le type Fichier/Nouveau/Projet/Web/Projet Web dynamique/ pour être hébergé sur Tomcat!

Vous devriez voir après la création du projet: 

|-project
  |- WebContent
    |- META-INF
      |- MANIFEST.MF
    |- WEB-INF
      |- lib
      |- src

Nous allons ajouter quelques fichiers à la structure de l’application afin de nous retrouver avec: 

|-project
  |- WebContent
    |- META-INF
      |- MANIFEST.MF
    |- WEB-INF
      |-lib
      ** -web.xml
        |- ExampleTree.jsp
        |- ExampleTwo.jsp
        ** - index.jsp
      |- src
        |- com
          |- baeldung
            ** - ExampleOne.java
            ** - ExampleThree.java

Configurons index.jsp qui sera affiché lorsque nous accéderons au contexte de l’URL dans Tomcat 8: 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>JSP Examples</title>
    </head>
    <body>
        <h1>Simple JSP Examples</h1>
        <p>Invoke HTML rendered by Servlet: <a href="ExampleOne" target="__blank">here</a></p>
        <p>Java in static page: <a href="ExampleTwo.jsp" target="__blank">here</a></p>
        <p>Java injected by Servlet: <a href="ExampleThree?message=hello!" target="__blank">here</a></p>
    </body>
</html>

Il y a trois a , chacun se rapportant à l’un des exemples que nous verrons plus loin dans les sections 4.1 à 4.4.

Nous devons également nous assurer que notre web.xml est configuré: 

<welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<servlet>
    <servlet-name>ExampleOne</servlet-name>
    <servlet-class>com.baeldung.ExampleOne</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>ExampleOne</servlet-name>
    <url-pattern>/ExampleOne</url-pattern>
</servlet-mapping>

La note principale est la suivante: comment mapper correctement chacun de nos servlets sur un mappage de servlets particulier. Cela permet d’associer chaque servlet à un point de terminaison spécifique sur lequel il peut être consommé! Maintenant, nous allons parcourir chacun des autres fichiers ci-dessous!

3.1. HTML rendu dans Servlet

Dans cet exemple, nous allons ignorer la construction d’un fichier .jsp!

À la place, nous allons créer une représentation sous forme de chaîne de notre balisage, puis l’écrire dans la réponse GET avec PrintWriter après que ExampleOne Servlet ait reçu une demande GET: 

public class ExampleOne extends HttpServlet {
  @Override
  protected void doGet(HttpServletRequest request,
    HttpServletResponse response) throws ServletException, IOException {
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();
      out.println(
    "<!DOCTYPE html><html>" +
    "<head>" +
    "<meta charset=\"UTF-8\"/>" +
    "<title>HTML Rendered by Servlet</title>" +
    "</head>" +
    "<body>" +
    "<h1>HTML Rendered by Servlet</h1></br>" +
    "<p>This page was rendered by the ExampleOne Servlet!</p>" +
    "</body>" +
    "</html>"
     );
   }
}

Ce que nous faisons ici consiste à injecter notre balisage directement dans notre requête de servlet. Au lieu d’une balise JSP, nous générons notre code HTML, ainsi que toutes les données spécifiques à Java à insérer, uniquement côté serveur, sans JSP statique!

Plus tôt, nous avons examiné l’objet out qui est une fonctionnalité de JspWriter .

Ci-dessus, j’ai utilisé l’objet PrintWriter qui écrit directement dans l’objet response .

JspWriter met en mémoire tampon la chaîne à écrire dans la mémoire, qui est ensuite écrite dans les objets response après le vidage de la mémoire tampon en mémoire.

PrintWriter est déjà attaché à l’objet response . J’ai préféré écrire directement à l’objet response dans les exemples ci-dessus et ci-dessous pour ces raisons.

3.2. Java dans un contenu statique JSP

Nous créons ici un fichier JSP nommé ExampleTwo.jsp avec une balise JSP. Comme indiqué ci-dessus, cela permet d’ajouter Java directement dans notre balisage. Ici, nous imprimons au hasard un élément d’un String[] : 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
    <head>
        <title>Java in Static Page Example</title>
    </head>
    <body>
        <h1>Java in Static Page Example</h1>
        <%
              String[]arr = {"What's up?", "Hello", "It's a nice day today!"};
          String greetings = arr[(int)(Math.random() **  arr.length)];
            %>
        <p><%= greetings %></p>
    </body>
</html>

Ci-dessus, vous verrez cette déclaration de variable dans les objets balises JSP:

type variableName et une initialisation exactement comme Java.

J’ai inclus l’exemple ci-dessus pour montrer comment ajouter Java à une page statique sans recourir à un servlet spécifique. Ici, Java est simplement ajouté à une page et le cycle de vie JSP s’occupe du reste.

3.3. JSP avec renvoi

Maintenant, pour notre exemple final et le plus impliqué! Ici, nous allons utiliser l’annotation @ WebServlet sur ExampleThree, ce qui élimine le besoin de mappages de servlets dans server.xml . 

@WebServlet(
  name = "ExampleThree",
  description = "JSP Servlet With Annotations",
  urlPatterns = {"/ExampleThree"}
)
public class ExampleThree extends HttpServlet {
  @Override
  protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
      String message = request.getParameter("message");
      request.setAttribute("text", message);
      request.getRequestDispatcher("/ExampleThree.jsp").forward(request, response);
   }
}

ExampleThree prend un paramètre d’URL transmis sous la forme message , le lie à l’objet request , puis redirige cet objet request vers ExampleThree.jsp .

Ainsi, nous avons non seulement réalisé une expérience Web dynamique vraiment dynamique, mais nous l’avons également fait dans une application contenant plusieurs fichiers .jsp.

getRequestDispatcher (). forward () est un moyen simple de s’assurer que la page .jsp correcte est rendue.

Toutes les données liées à l’objet request ont été envoyées (le fichier .jsp) sera alors affiché! Voici comment nous traitons cette dernière partie: 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
    <head>
        <title>Java Binding Example</title>
    </head>
    <body>
        <h1>Bound Value</h1>
        <p>You said: ${text}</p>
    </body>
</html>

Notez la balise JSP ajoutée en haut de ExampleThree.jsp . Vous remarquerez que j’ai changé les tags JSP ici. J’utilise le langage d’expression (que j’ai déjà mentionné) pour rendre notre paramètre set (qui est lié à $ \ {text} )!

3.4. Essaye le!

Nous allons maintenant exporter notre application dans un fichier .war qui sera lancé et hébergé sur Tomcat 8! Trouvez votre server.xml et nous mettrons à jour notre Context pour: 

<Context path="/spring-mvc-xml" docBase="${catalina.home}/webapps/spring-mvc-xml">
</Context>

Ce qui nous permettra d’accéder à nos servlets et JSP sur localhost: 8080/spring-mvc-xml/jsp/index.jsp ! Procurez-vous une copie de travail à:

GitHub

Félicitations!

4. Conclusion

Nous avons couvert pas mal de terrain! Nous avons appris ce que sont les pages JavaServer, ce qu’elles ont été introduites pour accomplir, leur cycle de vie, comment les créer et enfin différentes manières de les implémenter!

Ceci conclut l’introduction à JSP! Sois bien et code dessus!

Related