JSP ou Java Server Pages est une technologie Java qui permet de créer des pages Web dynamiques pour les applications Java. Dans cet article, nous parlerons plus en détail de ce qu'est JSP, discuterons de certaines des capacités de cette technologie, examinerons la structure des pages JSP et tenterons également d'avoir un aperçu pratique de ce que sont ces pages de serveur Java. Mais d’abord, parlons des avantages et de l’importance de JSP. JSP permet au développeur de :
recevoir des données d'une page Web en code Java ;
envoyer des données du code Java vers une page Web ;
écrivez du code Java directement dans du HTML (cependant, vous ne devez pas en abuser).
Le besoin de connaissances JSP peut être évalué de manière assez élevée pour plusieurs raisons :
JSP est l'une des principales technologies Web Java ;
JSP est largement utilisé dans la plupart des entreprises et des projets ;
JSP s'intègre parfaitement aux servlets Java dans un conteneur de servlets.
Définition JSP
Voici une définition tirée de Wikipédia : JSP (JavaServer Pages) est une technologie qui permet aux développeurs Web de créer du contenu comportant à la fois des composants statiques et dynamiques. Une page JSP contient deux types de texte : des données sources statiques, qui peuvent être dans l'un des formats de texte HTML, SVG, WML ou XML, et des éléments JSP, qui construisent du contenu dynamique. De plus, les bibliothèques de balises JSP peuvent être utilisées, ainsi que le langage d'expression (EL) pour intégrer du code Java dans le contenu statique des pages JSP. Le code de la page JSP est traduit en code Java de servlet à l'aide du compilateur de page Jasper JSP, puis compilé en bytecode Java Virtual Machine (JVM). Les conteneurs de servlets capables d'exécuter des pages JSP sont écrits dans le langage Java indépendant de la plate-forme. La technologie JSP est une technologie indépendante de la plate-forme, portable et facilement extensible pour le développement d'applications Web.
Structure des pages JSP
En général, JSP fait référence à des pages Web dynamiques dans lesquelles la partie dynamique est générée à l'aide de Java et la partie statique est générée à l'aide de langages de balisage, le plus souvent HTML. Une telle page est un document texte avec l'extension .jsp, écrit dans l'un des langages de balisage (tels que HTML, SVG, WML et XML), entrecoupé d'éléments JSP (ou balises JSP). Ces balises contiennent des appels au code du serveur (données) et effectuent également certains calculs. Ces fichiers sont traités sur le serveur, à la suite de quoi toutes les balises JSP sont converties en balises HTML et le résultat est une page HTML normale. Le schéma ci-dessous montre un schéma de la structure d'une page JSP et de son interaction avec le serveur. Un exemple de page JSP simple :
<html><body><p> ${2+2} равно 4</p></body></html>
Dans cet exemple, une expression JSP écrite dans un langage spécial, Expression Language (EL), est « intégrée » dans le code HTML . Il fournit un mécanisme important d'interaction entre la couche de présentation (pages Web) et la couche de logique métier de l'application (code Java). Comme vous pouvez le voir dans l'exemple, l'expression JSP est entourée d'accolades, précédées du signe dollar - ${...}. Tout ce qui se trouve à l'intérieur des accolades est évalué sur le serveur, et le résultat de cette expression est donné en HTML, à l'endroit où l'expression JSP a été initialement définie. Après avoir traité toutes les balises, la page ressemblera à ceci :
<html><body><p>4 равно 4</p></body></html>
Installation et exécution du conteneur de servlet
Étant donné que le code JSP est traduit en code de servlet Java, nous devons trouver une sorte de conteneur de servlet quelque part afin de pouvoir parler du fonctionnement du JSP. Sinon, sans conteneur, JSP ne fonctionnera pas. Mais d’abord, regardons la définition d’un conteneur de servlet. Un conteneur de servlets est un programme qui est un serveur qui assure le support système des servlets et assure leur cycle de vie conformément aux règles définies dans les spécifications. Il peut fonctionner comme un serveur Web indépendant à part entière, être un fournisseur de pages pour un autre serveur Web ou s'intégrer à un serveur d'applications Java EE. L'un des conteneurs de servlets les plus populaires est Apache Tomcat. Il convient de mentionner que Tomcat n'est pas un serveur d'applications Java EE à part entière. Cependant, pour les besoins vitaux des servlets et des pages JSP, le serveur Tomcat est largement suffisant. Commençons l'installation. Vous pouvez télécharger Tomcat depuis la page officielle . Pour le système d'exploitation Windows, vous pouvez installer Tomcat comme suit :
Téléchargez le programme d'installation du service Windows 32 bits/64 bits.
Exécutons le fichier.
Suivez ensuite la procédure d'installation habituelle :
N'oubliez pas de cocher la case Exemples dans la fenêtre d'installation correspondante :
et spécifiez le chemin d'accès au JRE préinstallé :
Après l'installation, lancez Tomcat et ouvrez le navigateur. Accédez à http://localhost:8080/ .
Si vous voyez la page de démarrage de Tomcat, cela signifie que l'installation a réussi et que le serveur est en cours d'exécution. Pour démarrer et arrêter Tomcat manuellement, vous pouvez exécuter l'un des deux fichiers exécutables dans le répertoire bin. Il se trouve dans le répertoire où Tomcat est installé :
Applications de démonstration. Objets cachés
Examinons quelques fonctionnalités JSP en action. L'un d'eux est l'accès aux objets dits cachés ( Implicit Objects ). Ce sont des objets accessibles à l’aide du langage d’expression (EL). Des exemples de tels objets sont les en-têtes HTTP ou les paramètres d'URL. Dévoilons (ou rafraîchissons notre mémoire) ce que sont les paramètres d'URL. L'exemple ci-dessous montre une URL avec des paramètres. Les paramètres sont en gras : http://example.net/foo/bar ?param1=value1¶m2=value2&a=1&name=Tom Les paramètres commencent toujours par un point d'interrogation (?). Ceci est suivi du nom du paramètre, suivi du signe égal - la valeur du paramètre est déterminée. Il peut y avoir plusieurs ou un seul paramètre. S'il y en a plusieurs, chaque paire nom-valeur est séparée par une esperluette (&). Dans l'exemple ci-dessus, plusieurs paramètres et leurs valeurs ont été définis :
Le nom du paramètre
Valeur du paramètre
paramètre1
valeur1
paramètre2
valeur2
un
1
nom
À M
Voyons comment accéder aux objets cachés dans JSP, y compris les paramètres d'URL. Pour cela, lancez Tomcat et ouvrez le navigateur sur la page http://localhost:8080/ Allez ensuite sur la page Exemples : Suivez ensuite le lien Exemples JSP : Sur la page exemples suivez le lien Objets implicites -> Exécuter : Sur ce sur la page, vous pouvez voir un exemple d'utilisation d'objets cachés. Ci-dessous une capture d'écran de la page avec des explications détaillées : Essayez de modifier la valeur du paramètre fooà l'aide du champ correspondant sur la page, puis remarquez que la valeur de ce paramètre a également changé dans la barre d'adresse. La page présentée n'a pas beaucoup de fonctionnalités, mais c'est une bonne référence à laquelle vous pourrez vous référer à l'avenir lorsque vous aurez besoin d'accéder à un objet caché particulier. Cette page contient une liste d'objets cachés accessibles. Et ci-dessous, dans le tableau, il est démontré comment accéder à un objet particulier.
Fonctions JSP
Revenons maintenant à la page précédente et regardons le code source de la page « objets cachés » : Le voici :
<%@page contentType="text/html; charset=UTF-8"%><%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%><html><head><title>JSP 2.0ExpressionLanguage-ImplicitObjects</title></head><body><h1>JSP 2.0ExpressionLanguage-ImplicitObjects</h1><hr>This example illustrates some of the implicit objects available
in the ExpressionLanguage. The following implicit objects are
available (not all illustrated here):<ul><li>pageContext - the PageContext object</li><li>pageScope - a Map that maps page-scoped attribute names totheir values</li><li>requestScope - a Map that maps request-scoped attribute names
totheir values</li><li>sessionScope - a Map that maps session-scoped attribute names
totheir values</li><li>applicationScope - a Map that maps application-scoped attribute
names totheir values</li><li>param - a Map that maps parameter names toa single String
parameter value</li><li>paramValues - a Map that maps parameter names toaString[] of
all values for that parameter</li><li>header - a Map that maps header names toa single String
header value</li><li>headerValues - a Map that maps header names toaString[] of
all values for that header</li><li>initParam - a Map that maps context initialization parameter
names totheirString parameter value</li><li>cookie - a Map that maps cookie names toa single Cookie object.</li></ul><blockquote><u><b>ChangeParameter</b></u><form action="implicit-objects.jsp" method="GET">
foo =<input type="text" name="foo" value="${fn:escapeXml(param["foo"])}"><input type="submit"></form><br><code><table border="1"><thead><td><b>EL Expression</b></td><td><b>Result</b></td></thead><tr><td>\${param.foo}</td><td>${fn:escapeXml(param["foo"])}</td></tr><tr><td>\${param["foo"]}</td><td>${fn:escapeXml(param["foo"])}</td></tr><tr><td>\${header["host"]}</td><td>${fn:escapeXml(header["host"])}</td></tr><tr><td>\${header["accept"]}</td><td>${fn:escapeXml(header["accept"])}</td></tr><tr><td>\${header["user-agent"]}</td><td>${fn:escapeXml(header["user-agent"])}</td></tr></table></code></blockquote></body></html>
Si vous êtes familier avec HTML, le code source de la page devrait être assez clair pour vous. Faites attention à ces lignes :
Ici, nous voyons les balises HTML <tr>et <td>. Les balises sont suivies de <td>balises JSP, entourées d'accolades ${ }. Cependant, remarquez comment la valeur du paramètre URL est affichéefoo :
${fn:escapeXml(param["foo"])}
La valeur est générée via l'utilisation d'une fonction JSP fn:escapeXml(). Les fonctions JSP encapsulent certaines fonctionnalités qui peuvent être réutilisées. Dans ce cas, il s'agit d'un échappement XML. La technologie JSP offre un large éventail de fonctions parmi lesquelles choisir, ainsi que la possibilité de créer vos propres fonctions. Pour utiliser une fonction dans un JSP, vous devez importer la bibliothèque appropriée dans laquelle la fonction est définie dans le fichier JSP.
Bibliothèques de balises
Jetons un coup d'œil à une autre ligne de code source (deuxième ligne) ci-dessus :
C'est ainsi que les bibliothèques de balises sont importées. La syntaxe est intuitive. Nous définissons plusieurs choses :
taglib(bibliothèque de balises - bibliothèque de balises) ;
url, où se trouve cette bibliothèque ;
un préfixe (dans ce cas fn) grâce auquel il sera possible d'appeler des fonctions définies dans cette bibliothèque.
Dans l’exemple ci-dessus, nous avons examiné l’importation de fonctions. Plus précisément, dans notre exemple, nous avons importé la bibliothèque JSTL (JSP Standard Tag Library). JSTL est une bibliothèque de balises standard qui contient un ensemble de bibliothèques différentes fournies avec chaque implémentation de servlet et JSP, y compris Tomcat. Une autre bibliothèque de balises populaire est core, qui peut être importée comme ceci :
<%@ taglib uri ="http://java.sun.com/jsp/jstl/core" prefix ="c"%>
Comme pour fn, la notation cest facultative et généralement acceptée. Cette désignation se retrouve presque partout où ces bibliothèques sont utilisées. Voici un exemple de fonction de la bibliothèque principale :
<c:out value ="${'<div>'}"/>
Cette fonction affichera simplement la balise <div>. Cette fonction effectue déjà l'échappement XML. Cette fonction est importante du point de vue de la sécurité, car en sortant directement la valeur des variables, via ${variable}, nous ouvrons la porte à l'injection de scripts.
Édition JSP
Maintenant, armés de nouvelles connaissances, essayons d'apporter des modifications à l'application de démonstration dans Tomcat. Pour ce faire, nous retrouverons le code source de cette page à l'intérieur du dossier dans lequel ce conteneur de servlet a été installé. Ce fichier se trouve à l'adresse suivante : ...\Apache Software Foundation\Tomcat 9.0\webapps\examples\jsp\jsp2\el Ouvrez ensuite le fichier implicit-objects.jsp dans n'importe quel éditeur de texte Ajoutez l'import de la bibliothèque principale , puis utilisons-le. Générons du texte : Actualisons maintenant la page des objets cachés et examinons les modifications apportées :
Résultats
Nous avons donc examiné superficiellement une technologie telle que JSP. Nous avons discuté:
qu'est-ce que JSP ;
Structure des pages JSP ;
procédure d'installation et d'exécution du conteneur de servlet Tomcat ;
application de démonstration pour accéder aux objets cachés, incluse dans le package de distribution du serveur Tomcat ;
Fonctions JSP et bibliothèques de balises.
Et après?
Pour sécuriser le matériel, vous pouvez :
Répétez tout ce qui est décrit dans cet article.
Considérez d'autres applications de démonstration incluses avec le serveur Tomcat.
Un exemple de page JSP simple :
Il convient de mentionner que Tomcat n'est pas un serveur d'applications Java EE à part entière. Cependant, pour les besoins vitaux des servlets et des pages JSP, le serveur Tomcat est largement suffisant. Commençons l'installation. Vous pouvez télécharger Tomcat depuis la page officielle . Pour le système d'exploitation Windows, vous pouvez installer Tomcat comme suit :
Suivez ensuite le lien Exemples JSP : 
Sur la page exemples suivez le lien Objets implicites -> Exécuter : 
Sur ce sur la page, vous pouvez voir un exemple d'utilisation d'objets cachés. Ci-dessous une capture d'écran de la page avec des explications détaillées : 
Essayez de modifier la valeur du paramètre 
Le voici :
Actualisons maintenant la page des objets cachés et examinons les modifications apportées : 
GO TO FULL VERSION