Qu'est-ce que JSP? Introduction aux pages JavaServer

JavaServer Pages (JSP) est une technologie standard Java qui vous permet d'écrire des pages dynamiques basées sur les données pour vos applications Web Java. JSP repose sur la spécification Java Servlet. Les deux technologies fonctionnent généralement ensemble, en particulier dans les anciennes applications Web Java. Du point de vue du codage, la différence la plus évidente entre eux est qu'avec les servlets, vous écrivez du code Java, puis intégrez un balisage côté client (comme HTML) dans ce code, alors qu'avec JSP, vous commencez par le script ou le balisage côté client, puis incorporez Balises JSP pour connecter votre page au backend Java.

JSP est également étroitement lié à JSF (JavaServer Faces), une spécification Java pour la création d'applications Web MVC (model-view-controller). JSP est une technologie relativement plus simple et plus ancienne que JSF, qui est la norme pour les frameworks Web Java tels que Eclipse Mojarra, MyFaces et PrimeFaces. Bien qu'il ne soit pas rare de voir JSP utilisé comme interface pour les anciennes applications JSF, Facelets est la technologie d'affichage préférée pour les implémentations JSF modernes.

Bien que JSP ne soit pas votre premier choix pour créer des pages Web dynamiques, il s'agit d'une technologie Web Java de base. Les pages JSP sont relativement rapides et faciles à créer, et elles interagissent de manière transparente avec les servlets Java dans un conteneur de servlet comme Tomcat. Vous rencontrerez JSP dans les anciennes applications Web Java, et de temps en temps, vous pourrez le trouver utile pour créer des pages Web Java simples et dynamiques. En tant que développeur Java, vous devez au moins être familiarisé avec JSP.

Cet article sera une introduction rapide aux pages JavaServer, y compris la bibliothèque de balises standard JSP (JSTL). Des exemples vous montrent comment écrire une page HTML simple, incorporer des balises JSP pour vous connecter à un servlet Java et exécuter la page dans un conteneur de servlet.

Consultez les articles précédents de cette série pour en savoir plus sur les servlets Java et les visages JavaServer.

JSP à Jakarta EE

Suite à la sortie de Java EE 8, Oracle a transféré la gestion de Java Enterprise Edition (Java EE) à la Fondation Eclipse. À l'avenir, la plate-forme d'entreprise Java a été rebaptisée Jakarta EE. Outre les spécifications Java Servlet et JSF, JSP est l'une des technologies Web Java incluses pour le support continu et les mises à niveau de Jakarta EE.

Écriture de pages JSP

Une page JSP simple (.jsp) consiste en un balisage HTML intégré à des balises JSP. Lorsque le fichier est traité sur le serveur, le HTML est rendu en tant que vue d'application, une page Web. Les balises JSP intégrées seront utilisées pour appeler le code et les données côté serveur. Le diagramme de la figure 1 montre l'interaction entre HTML, JSP et le serveur d'applications Web.

Matthew Tyson

Le listing 1 montre une simple page JSP.

Listing 1. Une simple page JSP

${2 * 2} should equal 4

Dans le listing 1, vous voyez un bloc de HTML qui inclut une expression JSP , qui est une instruction au serveur Java écrite à l'aide du langage d'expression (EL). Dans l'expression " ${2 * 2}", le " ${}" est la syntaxe JSP pour interpoler du code en HTML. Lorsqu'elle est exécutée, la JSP affichera les résultats de l'exécution de tout ce qui se trouve à l'intérieur de l'expression. Dans ce cas, la sortie sera le numéro 4.

JSP dans le conteneur de servlet

Les pages JSP doivent être déployées dans un conteneur de servlet Java. Afin de déployer une application Web Java basée sur JSP et servlets, vous allez empaqueter vos fichiers .jsp, votre code Java et vos métadonnées d'application dans un fichier .war, qui est un simple fichier .zip avec une structure conventionnelle pour les applications Web.

Une fois que vous avez chargé le JSP dans votre conteneur de servlet, il sera compilé dans un servlet. Les JSP et les servlets Java partagent des caractéristiques similaires, notamment la possibilité d'accéder aux objets de requête et d'y répondre. Apache Tomcat 9x est l'implémentation de référence pour les spécifications Servlet 4.0 et JSP 2.3. (Notez que les mises à jour entre JSP 2.2 et 2.3 sont relativement mineures.)

Conteneur de servlet vs serveur d'applications

Dans le monde Java, un conteneur de servlet , également appelé serveur Web, est comme une version allégée (bière) d'un serveur d'applications. Un conteneur de servlet gère les interactions de demande et de réponse et permet à ces interactions de s'interfacer avec un sous-ensemble de fonctionnalités d'entreprise Java pour les applications Web. Un serveur d'applications Java inclut le conteneur de servlet dans le cadre de la pile d'entreprise Java complète, y compris EJB, JPA, JMS, etc.

Exemple d'application pour JSP

Nous utiliserons un exemple d'application dans Tomcat pour vous aider à démarrer avec JavaServer Pages. Si vous n'avez pas encore installé Tomcat, accédez à la page de téléchargement Tomcat et sélectionnez l'installation Tomcat pour votre système d'exploitation. Au moment d'écrire ces lignes, Tomcat 9 est la version actuelle, compatible avec Servlet 4.0 et JSP 2.3.

Vous pouvez installer Tomcat en tant que service Windows ou l'exécuter à partir de la ligne de commande avec /bin/catalina.sh startou /bin/catalina.bat. Dans tous les cas, démarrez Tomcat, puis accédez à localhost:8080pour afficher la page d'accueil Tomcat illustrée à la figure 2.

Matthew Tyson

Objets implicites dans Tomcat

Sur la page d'accueil de Tomcat, cliquez sur le lien Exemples , puis sur Exemples JSP .

Ensuite, ouvrez l' application Web Implicit Objects Execute . La figure 3 montre la sortie de cette application. Prenez une minute pour étudier cette sortie.

Matthew Tyson

Paramètres de demande

Les objets implicites sont des objets intégrés accessibles via une page JSP. En tant que développeur de pages Web, vous utiliserez ces objets pour créer un accès à des éléments tels que les paramètres de requête , qui sont les données envoyées depuis le navigateur lors de l'émission d'une requête HTTP. Considérez l'URL du navigateur pour les objets implicites:

 //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=bar 

Le paramètre est ?foo=bar, et vous pouvez le voir reflété dans la sortie sur la page Web, où le tableau affiche «EL Expression» et la valeur est «bar». Pour tester cela, changez l'URL en //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=zork , appuyez sur Entrée et vous verrez le changement reflété dans la sortie.

Cet exemple est une introduction très simple à l'utilisation des balises JSP pour accéder aux paramètres de requête côté serveur. Dans ce cas, la page JSP utilise l'objet intégré (implicite) appelé parampour accéder aux paramètres de requête de l'application Web. L' paramobjet est disponible dans la syntaxe d'expression JSP que vous avez vue dans le listing 1.

Dans cet exemple, nous avons utilisé une expression pour faire des maths:, ${2 * 2}quelle sortie 4.

Dans cet exemple, l'expression est utilisée pour accéder à un objet et un champ sur cet objet: ${param.foo}.

JSP dans une application Web

Sur la page Objets implicites, cliquez sur la flèche de retour, suivie du lien Source . Cela vous mènera au code JSP pour l'application Web Objets implicites, qui est illustré dans le listing 2.

Listing 2. Code JSP pour l'application Web Objets implicites

     JSP 2.0 Expression Language - Implicit Objects   
    
This example illustrates some of the implicit objects available in the Expression Language. The following implicit objects are available (not all illustrated here):
  • pageContext - the PageContext object
  • pageScope - a Map that maps page-scoped attribute names to their values
  • requestScope - a Map that maps request-scoped attribute names to their values
  • sessionScope - a Map that maps session-scoped attribute names to their values
  • applicationScope - a Map that maps application-scoped attribute names to their values
  • param - a Map that maps parameter names to a single String parameter value
  • paramValues - a Map that maps parameter names to a String[] of all values for that parameter
  • header - a Map that maps header names to a single String header value
  • headerValues - a Map that maps header names to a String[] of all values for that header
  • initParam - a Map that maps context initialization parameter names to their String parameter value
  • cookie - a Map that maps cookie names to a single Cookie object.
Change Parameter foo =

EL Expression Result
\${param.foo} ${fn:escapeXml(param["foo"])}
\${param["foo"]} ${fn:escapeXml(param["foo"])}
\${header["host"]} ${fn:escapeXml(header["host"])}
\${header["accept"]} ${fn:escapeXml(header["accept"])}
\${header["user-agent"]} ${fn:escapeXml(header["user-agent"])}

JSP functions

If you're familiar with HTML, then Listing 2 should look pretty familiar. You have the expected HTML elements, followed by the ${ } JSP expression syntax introduced in Listing 1. But notice the value for param.foo: ${fn:escapeXml(param["foo"])} . The "fn:escapeXML()" is a JSP function.

A JSP function encapsulates a chunk of reusable functionality. In this case, the functionality is to escape XML. JSP offers a variety of functions, and you can also create functions yourself. To use a function, you import its library into your JSP page, then call the function.

In Listing 2, the escapeXML function is included with the line:

The syntax is pretty clear: it imports the required functions and assigns them a prefix (in this case "fn") that can be used in all following expressions.

The JSP Standard Tag Library (JSTL)

The import line in Listing 2 calls taglib, which is short for tag library, or (in this case) JSP Standard Tag Library (JSTL). Tag libraries define reusable bits of functionality for JSP. JSTL is the standard tag library, containing a collection of taglibs that ship with every servlet and JSP implementation, including Tomcat.

The "functions" library is just one of the taglibs included with JSTL. Another common taglib is the core library, which you import by calling:

Like "fn", the "c" designation is conventional, and you will see it across most JSP pages.

Securing JSP pages

An example tag from the core library is


    

which outputs the tag with the XML already escaped. This function is important because outputting content directly to a web page via ${variable} opens the door to script injection attacks. This simple function is used to protect web pages from such attacks.

The core library also includes various tags for iteration and flow control (like IF/ELSE handling).

JSTL tag classifications

There are five sets of tags included in JSTL, each designed for a specific area of web application functionality:

  • JSTL core: Dealing with logic and execution flow; conventional tag: "c"
  • JSTL formatting: Dealing with formatting (like dates) and internationalization; conventional tag: "fmt".
  • JSTL SQL: Dealing with querying SQL databases (this is usually discouraged in the view layer); conventional tag: "sql".
  • JSTL XML: Dealing with working with XML documents; conventional tag: "x".
  • JSTL functions: Dealing primarily with String manipulations; conventional tag: "fn".

Calling taglibs in JSP pages

Now that you've got a handle on JSP basics, let's make a change to the example application. To start, locate the Implicit Object app in your Tomcat installation. The path is: apache-tomcat-8.5.33/webapps/examples/jsp/jsp2/el.

Open this file and locate the functions include:

just below this line, add a new line:

Hit Return and add another new line:

Now reload the page at //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=bar.

Vous devriez voir vos mises à jour reflétées dans la sortie.