JavaServer Pages (JSP) est une extension Java standard définie au-dessus des extensions de servlet. Le but de JSP est de faciliter la création et la gestion de pages Web dynamiques.

Comme mentionné précédemment, l'implémentation gratuite de Tomcat de jakarta.apache.org prend automatiquement en charge JSP.

JSP vous permet de combiner des pages Web HTML avec des morceaux de code Java dans un seul document. Le code Java est entouré de balises spéciales qui indiquent au conteneur JSP qu'il doit utiliser le code pour générer un seul document ou une partie de celui-ci. L'avantage de JSP est que vous pouvez contenir un seul document qui représente à la fois la page et le code Java qui y est inclus.

L'inconvénient est que celui qui gère la page JSP doit avoir une expérience à la fois en HTML et en Java (cependant, les constructeurs visuels de pages JSP devraient devenir disponibles au fil du temps).

Lorsque le JSP est chargé pour la première fois, il est chargé par le conteneur JSP (qui est généralement associé à, ou fait partie d'un serveur Web), puis le code du servlet, qui est nécessairement mis en évidence avec des balises JSP, est automatiquement généré, compilé et chargé dans le conteneur de servlet. La partie statique d'une page HTML se fait en passant un objet statique de type String à la méthode write(). La partie dynamique est incluse directement dans la servlet.

La structure d'une page JSP se situe entre un servlet et une page HTML. Les balises JSP commencent et se terminent par un crochet angulaire, tout comme le code HTML, mais les balises incluent également des signes de pourcentage, donc toutes les balises JSP sont écrites comme ceci :

Le signe de pourcentage en tête peut être suivi d'autres caractères identifiant le type exact de code JSP dans la balise.

Voici un exemple JSP extrêmement simple qui utilise un appel de bibliothèque Java standard pour obtenir l'heure actuelle en millisecondes, qui est ensuite divisée par 1 000 pour obtenir l'heure en secondes. Puisque l'expression JSP (<%=), результат вычислений преобразуется в строку, а затем поместится в сгенерированную Web страницу:

// : ! c15:jsp:ShowSeconds.jsp< html >< body > < H1 >Le temps en secondes est :<%= System . currentTimeMillis ()/ 1000 %> ///:~

Dans les exemples JSP de ce livre, un point d'exclamation dans la première « ligne de commentaire » signifie que la première et la dernière ligne ne seront pas incluses dans le fichier de code réel placé dans l'arborescence du code source de ce livre.

Lorsqu'un client envoie une requête à une page JSP, le serveur Web doit être configuré pour transmettre la requête au conteneur JSP, qui inclut alors la page. Comme mentionné précédemment, lors du premier accès à une page, les composants spécifiés sur la page sont générés et un ou plusieurs servlets sont compilés par le conteneur JSP. Dans l'exemple ci-dessus, le servlet contiendrait du code pour configurer l'objet HTTPServletResponse, produisant un objet PrintWriter (qui est toujours appelé), puis activerait le timing avec une instruction très courte, mais le programmeur HTML/concepteur Web moyen n'a aucune expérience en écriture. tel code.

Objets implicites

Les servlets incluent des classes qui fournissent des utilitaires pratiques tels que HttpServletRequest, HttpServletResponse, Session, etc. Les objets de ces classes sont intégrés à la spécification JSP et sont automatiquement disponibles pour une utilisation dans votre JSP sans écrire de lignes de code supplémentaires. Les objets JSP implicites sont répertoriés en détail dans le tableau ci-dessous.

Variables implicites	Tapez (javax.servlet)	Description	Portée
demande	Sous-type dépendant du protocole de HttpServletRequest	La demande qui a effectué l'appel de service.	demande
réponse	Sous-type dépendant du protocole de HttpServletResponse	Réponse à la demande.	page
pageContext	jsp.PageContext	Un contexte de page qui encapsule les fonctionnalités dépendantes de l'implémentation et fournit des méthodes pratiques et un accès à l'espace de noms à ce JSP.	page
session	Sous-type http.HttpSession dépendant du protocole	Un objet de session créé pour la demande du client.	session
Voir Objet Session pour le servlet.	application	Le contexte du servlet obtenu à partir de l'objet de configuration du servlet (par exemple getServletConfig(), getContext()).	application
dehors	jsp.JspWriter	Un objet qui écrit dans le flux de sortie.	page
configuration	ServletConfig	ServletConfig pour cette JSP.	page
page	java.lang.Object	Instance de la classe d'implémentation de cette page qui traite la requête actuelle.	page

La zone de visibilité de chaque objet peut varier considérablement.

Par exemple, un objet de session a une portée plus grande qu'une page car il peut s'étendre sur plusieurs requêtes et pages client. Un objet application peut fournir un service à un groupe de pages JSP qui représentent ensemble une application Web.

Directives JSP

<% @ directive { attr = "value" }* %>

Les directives sont des messages envoyés au conteneur JSP et sont désignées par le symbole « @ » :

<% @ page language = "java" %>

Les directives n'envoient rien au flux de sortie, mais elles sont importantes pour définir les attributs de votre page JSP et les dépendances du conteneur JSP. Par exemple, la ligne :

rapporte que le langage de script utilisé dans la page JSP est Java.

<% @ page session = "true" import =" java . util .*" %>

En fait, la spécification JSP décrit uniquement la sémantique de script pour les attributs de langage équivalents à « Java ». Le but de cette directive est d'intégrer de la flexibilité dans la technologie JSP. À l'avenir, si vous choisissez un autre langage, par exemple Python (un bon choix pour les scripts), alors ce langage devrait prendre en charge l'environnement d'exécution Java, exposant le modèle objet technologique Java pour l'environnement de script, en particulier pour les variables implicites. définis ci-dessus, les propriétés JavaBeans et les méthodes publiques.

L'attribut import décrit les types disponibles pour l'environnement de script. Cet attribut est utilisé de la même manière que dans le langage de programmation Java, c'est-à-dire une liste d'instructions d'importation séparées par des virgules. Cette liste est importée par l'implémentation traduite de la page JSP et est disponible pour l'environnement de script. Disons encore que cela n'est actuellement défini que si la valeur de la directive langage est "java".

Éléments de script JSP

Une fois que vous avez utilisé des directives pour configurer un environnement de script, vous pouvez utiliser des éléments de script. JSP 1.1 comporte trois éléments de langage de script : déclaration, scriptlet et expression. Les déclarations déclarent des éléments, les scriptlets sont des fragments d'instructions et les expressions sont des expressions de langage complètes. Dans JSP, chaque élément de script commence par "<%". Синтаксис каждого из них:

<%! declaration %> <% scriptlet %> <%= expression %>

Espaces après "<%!", "<%", "<%=" и перед "%>" ne sont pas obligatoires.

Toutes ces balises sont basées sur XML ; on peut même dire qu'une page JSP peut être reflétée dans un document XML. La syntaxe équivalente pour les éléments de script ci-dessus pourrait être :

< jsp : declaration >déclaration < jsp : scriptlet >scriptlet < jsp : expression >expression

De plus, il existe deux types de commentaires :

<%-- jsp comment --%>

Le premier formulaire permet d'ajouter des commentaires au code source JSP qui n'apparaîtront sous aucune forme dans la page HTML envoyée au client. Bien entendu, la deuxième forme de commentaires n'est pas spécifique à JSP : il s'agit d'un commentaire HTML classique. Ce qui est intéressant, c'est que vous pouvez insérer du code JSP dans un commentaire HTML et le résultat sera affiché dans la page résultante.

Les déclarations sont utilisées pour déclarer des variables et des méthodes dans un langage de script (actuellement uniquement en Java) utilisé dans une page JSP.

La déclaration doit être une expression Java complète et ne peut produire aucune sortie dans le flux de sortie. Dans l'exemple Hello.jsp ci-dessous, les déclarations des variables LoadTime, LoadDate et hitCount sont des expressions Java complètes qui déclarent et initialisent de nouvelles variables.<%-- // : ! c15:jsp:Bonjour.jsp%> <%-- Ce commentaire JSP n'apparaîtra pas dans le code HTML généré --%> <%@ page import="java.util.*" %> <%-- Voici la directive JSP : --%> <% ! long loadTime = System.currentTimeMillis (); Date loadDate = new Date (); int hitCount = 0 ; %> <%-- Cette déclaration: --%>

Les lignes suivantes sont le résultat d'expressions JSP insérées dans le code HTML généré ; Le signe "=" indique une expression JSP --<%= loadDate %>

Cette page a été chargée<%= new Date () %>

Bonjour le monde! C'est<%= new Object () %>

Voici un objet :<%= (System.currentTimeMillis ()- loadTime )/ 1000 %>Cette page est en ligne

secondes<%= ++ hitCount %>La page a été consultée<%= loadDate %>

<%-- fois depuis%> <% System.out.println ("Goodbye" ); out.println ("Cheerio" ); %> ///:~

Lorsque vous exécutez ce programme, vous verrez que les variables LoadTime, LoadDate et hitCount conservent leurs valeurs entre les pages consultées, ce sont donc clairement des champs et non des variables locales.

À la fin de l'exemple se trouve un scriptlet qui écrit « Goodbye » sur la console du serveur Web et « Cheerio » sur l'objet de sortie implicite JspWriter. Un scriptlet peut contenir n'importe quel fragment de code qui constitue une instruction Java valide. Les scriptlets sont exécutés pendant le traitement de la demande. Lorsque tous les fragments de scriptlet d'une JSP donnée sont combinés dans l'ordre dans lequel ils apparaissent dans la page JSP, ils doivent produire une instruction valide spécifique au langage de programmation Java. Le fait que le scriptlet produise ou non une sortie dans le flux de sortie dépend uniquement du code du scriptlet. Vous devez savoir qu'un scriptlet peut affecter les objets qui lui sont visibles.

Les expressions JSP peuvent être trouvées mélangées avec du HTML dans la section centrale de Hello.jsp.

Les expressions doivent être des instructions Java complètes qui sont évaluées, converties en chaîne et envoyées en sortie. Si le résultat de l'instruction ne peut pas être converti en chaîne, une ClassCastException sera levée.

Extraction de champs et de valeurs

L'exemple suivant est similaire à celui donné plus tôt dans la section sur les servlets. La première fois que vous affichez la page, il détecte que vous n'avez aucun champ et renvoie une page contenant le formulaire en utilisant le même code que dans l'exemple de servlet, mais au format JSP. Lorsque vous soumettez un formulaire avec des champs renseignés sur la même URL JSP, la page détecte les champs et les affiche. Il s'agit d'une technique intéressante car elle vous permet d'avoir deux pages, l'une contenant le formulaire à remplir par l'utilisateur, et l'autre. l'autre contenant le code de réponse de cette page dans un seul fichier, facilitant ainsi sa création et sa maintenance.<%-- // : ! c15:jsp:DisplayFormData.jsp%> <%-- Extraire des données d'un formulaire HTML. --%> <%@ page import="java.util.*" %>

Cette JSP génère également le formulaire. --

<% Enumeration flds = request.getParameterNames (); if (! flds.hasMoreElements ()) { // Нет полей %>

<% for (int i = 0 ; i < 10 ; i ++) { %>AfficherFormulaireDonnées<%= i %> :
<% } %>

<% } else { while (flds.hasMoreElements ()) { String field = (String ) flds.nextElement (); String value = request.getParameter (field ); %>

<%= field %> = <%= value %>

<% } } %>

///:~

Soumettre

La chose la plus intéressante à propos de cet exemple est qu'il montre comment le code de scriptlet peut être mélangé au code HTML même au moment où le HTML est généré dans une boucle Java. Ceci est particulièrement utile pour créer des formulaires de toute nature qui, autrement, vous obligeraient à insérer du code HTML en double.

En parcourant la documentation HTML sur les servlets et les JSP, vous trouverez une fonctionnalité qui rapporte des informations sur le servlet ou la JSP en cours d'exécution.

L'exemple suivant affiche certaines de ces données.<%-- // : ! c15:jsp:PageContext.jsp%> <%-- Afficher les attributs pageContext--%> <%@ page import="java.util.*" %> Notez que vous pouvez inclure n'importe quelle quantité de code dans les balises scriptlet --<%= config.getServletName () %>
Nom de la servlet :<% out.print (application.getMajorVersion () + "." + application.getMinorVersion ()); %>
<% session.setAttribute ("My dog" , "Ralph" ); for (int scope = 1 ; scope <= 4 ; scope ++) { %>

Le conteneur de servlet prend en charge la version du servlet :<%= scope %>

<% Enumeration e = Portée: pageContext.getAttributeNamesInScope

(portée); while (e.hasMoreElements()) ( out.println("\t

" ); } } %>

///:~

" + e.nextElement() + "

Cet exemple montre également l'utilisation du HTML en ligne et l'écriture sur out pour produire une page HTML.

La première information produit le nom du servlet, qui sera probablement simplement "JSP", mais cela dépend de votre implémentation.

Vous pouvez également déterminer la version actuelle du conteneur de servlet à l'aide de l'objet application. Enfin, après avoir défini l'attribut de session, les "noms d'attribut" sont affichés dans la portée normale. En règle générale, vous n'utilisez pas scope dans la plupart des JSP ; ils sont présentés ici simplement pour ajouter de l'intérêt à cet exemple.

Il existe trois attributs de portée : portée de la page (portée 1), portée de la demande (portée 2), portée de la session (portée 3 - un seul élément disponible ici est "Mon chien", ajouté juste avant la boucle) et portée de l'application (portée 4). , basé sur l'objet ServletContext. Il existe un ServletContext par « Application Web » dans chaque machine Java. (Une « application Web » est un ensemble de servlets et de contenu installés sous un sous-ensemble spécifique d'URL de serveur, telles que /catalog. Celles-ci sont installées à l'aide d'un fichier de configuration.) Dans la portée de l'application, vous verrez des objets qui représentent les chemins d'accès pour le répertoire de travail et le catalogue de répertoires temporaire.<%-- Manipulation de session dans JSP%>

Les sessions ont été présentées dans la section précédente sur les servlets et sont également disponibles dans JSP. Les exemples suivants examinent les objets de session et vous permettent de manipuler la durée avant qu'une session ne devienne invalide.<%= session.getId () %>

// : ! c15:jsp:SessionObject.jsp<%= session.getCreationTime () %>

Obtenir et définir les valeurs des objets de session --<%= () %>

<% Identifiant de la session :(5 ); %>

Cette séance a été créée à<%= Ancien MaxInactiveInterval =() %>

session.setMaxInactiveInterval

Nouveau MaxInactiveInterval=<%= session.getAttribute ("My dog" ) %>

<%-- session.getMaxInactiveInterval%> <% session.setAttribute ("My dog" , new String ("Ralph" )); %>

Si l'objet de session "Mon chien" est toujours là, cette valeur sera non nulle :<%= session.getAttribute ("My dog" ) %>

<%-- Voyez si "Mon chien" erre vers une autre forme --%>

< /FORM>

///:~

L'objet session est fourni par défaut, il est donc disponible sans aucun code supplémentaire. Les appels getID(), getCreationTime() et getMaxInactiveInterval() sont utilisés pour afficher des informations sur cet objet de session.

Lorsque vous obtenez cette session pour la première fois, vous verrez que MaxInactiveInterval est, par exemple, de 1 800 secondes (30 minutes). Cela dépend de la configuration de votre conteneur JSP/servlet. MaxInactiveInterval est réduit à 5 secondes pour rendre les choses plus intéressantes.

Si vous rechargez la page avant la fin des 5 secondes, vous verrez :

Valeur de session pour "Mon chien" = Ralph

Mais si vous attendez plus longtemps, alors "Ralph" deviendra nul.

Pour voir comment les informations de session sont transférées vers d'autres pages et pour voir l'effet de l'invalidation d'un objet de session par rapport au simple fait de le laisser expirer, deux nouvelles pages sont créées. Le premier (disponible en cliquant sur le bouton « invalider » dans SessionObject.jsp) lit les informations de session puis invalide explicitement la session :<%-- // : ! c15:jsp:SessionObject2.jsp%>

Les sessions ont été présentées dans la section précédente sur les servlets et sont également disponibles dans JSP. Les exemples suivants examinent les objets de session et vous permettent de manipuler la durée avant qu'une session ne devienne invalide.<%= session.getId () %>

L'objet de session est transféré --<%= session.getValue ("My dog" ) %>

<% session.invalidate (); %>

///:~

Valeur de la session pour "Mon chien"

Pour expérimenter cela, mettez à jour SessionObject.jsp, puis cliquez immédiatement sur le bouton "invalider" pour accéder à la page SessionObject2.jsp. À ce stade, vous verrez toujours "Ralph" et immédiatement après (avant que l'intervalle de 5 secondes ne s'écoule), mettez à jour SessionObject2.jsp pour voir que la session a été invalidée avec succès et que "Ralph" a disparu.

Si vous revenez à SessionObject.jsp, actualisez la page pour avoir à nouveau un intervalle de 5 secondes, puis cliquez sur le bouton "Conserver", vous serez redirigé vers la page SessionObject3.jsp suivante, qui n'invalide pas la session :<%-- // : ! c15:jsp:SessionObject3.jsp%>

Les sessions ont été présentées dans la section précédente sur les servlets et sont également disponibles dans JSP. Les exemples suivants examinent les objets de session et vous permettent de manipuler la durée avant qu'une session ne devienne invalide.<%= session.getId () %>

L'objet de session est transféré --<%= session.getValue ("My dog" ) %>

///:~

Retour

Puisque cette page n'invalide pas la session, "Ralph" restera lors de chaque actualisation de page jusqu'à ce que l'intervalle de 5 secondes entre les actualisations soit écoulé. Ce n'est pas très différent du jouet Tomagotchi : tant que vous jouez avec Ralph, il sera là, sinon il disparaîtra.

Les cookies ont été introduits dans la section précédente sur les servlets. Encore une fois, la brièveté de JSP rend la gestion des cookies plus facile que l'utilisation de servlets. L'exemple suivant montre cela en récupérant les cookies fournis dans la demande, en lisant et en modifiant l'âge maximum (date d'expiration) et en attachant le nouveau cookie à la demande de réponse :

// : ! c15:jsp:Cookies.jsp<%-- Ce programme se comporte différemment selon les navigateurs ! --%>

Les sessions ont été présentées dans la section précédente sur les servlets et sont également disponibles dans JSP. Les exemples suivants examinent les objets de session et vous permettent de manipuler la durée avant qu'une session ne devienne invalide.<%= session.getId () %>

<% Cookie cookies = request.getCookies (); for (int i = 0 ; i < cookies.length ; i ++) { %>Nom du cookie :<%= cookies [ i ]. getName () %>
valeur:<%= cookies [ i ]. getValue () %>
Ancien âge maximum en secondes :<%= cookies [ i ]. getMaxAge () %>
<% cookies [ i ]. setMaxAge (5 ); %>Nouvel âge maximum en secondes :<%= cookies [ i ]. getMaxAge () %>
<% } %> <% ! int count = 0 ; int dcount = 0 ; %> <% response.addCookie (new Cookie ("Bob" + count ++, "Dog" + dcount ++)); %>

///:~

Étant donné que chaque navigateur stocke les cookies différemment, vous pouvez constater un comportement différent selon les navigateurs (pas convaincu, mais il peut s'agir d'un bug qui pourrait être corrigé au moment où vous lirez ceci). Vous pouvez également obtenir des résultats différents si vous quittez votre navigateur et le lancez par rapport à si vous visitez une autre page puis revenez à Cookies.jsp. Notez que l'utilisation d'un objet de session semble plus appropriée que l'utilisation directe de cookies.

Après avoir affiché l'ID de session, chaque cookie du tableau de cookies fourni avec l'objet de requête est affiché sur la page avec son âge maximum. L'âge maximum est modifié et affiché à nouveau pour tester la nouvelle valeur, puis le nouveau cookie est ajouté à la réponse. Cependant, votre navigateur peut ignorer cet âge maximum ; Cela vaut la peine de jouer avec ce programme et de modifier la valeur d'âge maximum pour voir le comportement sous différents navigateurs.

Conclusion sur JSP

Cette section n'est qu'un bref aperçu de JSP, et même avec ce qui est couvert ici (avec ce que vous apprendrez sur Java dans le reste du livre et avec vos connaissances en HTML), vous pouvez commencer à écrire des pages Web complexes en utilisant JSP. La syntaxe JSP n'est pas censée être mystérieuse ou compliquée, donc si vous comprenez ce qui a été présenté dans cette section, vous êtes prêt à être productif avec JSP. Vous pouvez trouver plus d'informations dans la plupart des manuels sur les servlets disponibles ou sur java.sun.com.

Il est particulièrement pratique d'avoir accès à JSP même si votre objectif est uniquement de créer des servlets. Vous constaterez que si vous avez une question concernant le comportement d'une fonction de servlet, il est beaucoup plus facile et rapide d'écrire un programme de test en JSP pour obtenir la réponse que d'écrire un servlet. Une partie de la commodité réside dans le fait que vous devez écrire moins de code et que vous pouvez mélanger le HTML rendu avec du code Java, mais cet avantage devient particulièrement clair lorsque vous voyez que le conteneur JSP gère toute la recompilation et le rechargement du JSP pour vous à chaque fois que le code source est exécuté. changements.

Cependant, le problème avec JSP est que vous devez considérer que la création de JSP nécessite un niveau de compétence plus élevé que la simple programmation en Java ou la simple création de pages Web. De plus, déboguer un JSP défectueux n'est pas aussi simple qu'avec un programme Java, car (de nos jours) les messages d'erreur sont plus obscurs. Cela devrait changer à mesure que les systèmes de développement s'améliorent, mais nous pourrions également voir d'autres technologies basées sur Java et le Web mieux adaptées aux compétences des concepteurs de sites Web.

Exercices

1. Créez une page JSP qui imprime une chaîne de texte à l'aide de la balise

   .

2. Définissez la couleur de ce texte de manière aléatoire à l'aide du code intégré dans la page JSP. Si vous ne disposez pas d'un conteneur JSP existant, vous devez télécharger, installer et exécuter Tomcat depuis jakarta.apache.org
3. Modifiez la valeur d'âge maximum dans Cookies.jsp et observez le comportement dans différents navigateurs. Notez également la différence entre la visite à nouveau d'une page et le téléchargement/téléchargement par le navigateur. Si vous ne disposez pas d'un conteneur JSP existant, vous devrez télécharger, installer et exécuter Tomcat depuis jakarta.apache.org pour pouvoir exécuter JSP.

Créez une JSP avec un champ permettant à l'utilisateur de saisir l'heure d'expiration de la session et un deuxième champ contenant les données stockées dans la session. Le bouton Soumettre actualise la page et obtient l'heure d'expiration de la session actuelle et les données de la session, puis les place comme valeur par défaut dans les champs ci-dessus. Si vous ne disposez pas d'un conteneur JSP existant, vous devrez télécharger, installer et exécuter Tomcat depuis jakarta.apache.org pour pouvoir exécuter JSP.

La technologie JSP fait partie de la famille des technologies Java. Pages JSP : compilées en servlets et peuvent appeler des composants JavaBeans (beans) ou des composants Enterprise JavaBeans (beans entreprise) pour effectuer le traitement sur le serveur. Ainsi, la technologie JSP est un élément clé d’une architecture évolutive pour une application Web.

R : La technologie JavaServer Faces est un framework permettant de créer des interfaces utilisateur pour les applications Web. La technologie JavaServer Faces comprend :

Un ensemble d'API pour : présenter l'interface utilisateur des composants et gérer leur état, gérer les événements et valider les entrées, définir la navigation dans les pages et prendre en charge l'internationalisation et l'accessibilité.

Une bibliothèque de balises JavaServer Pages (JSP) personnalisée pour exprimer l'interface JavaServer Faces sur une page JSP.

JSP est une servlet spécialisée.

JSF est un ensemble de balises que vous pouvez utiliser avec JSP.

Du point de vue du navigateur/client

JSP et JSF se ressemblent car, selon les exigences de l'application, JSP est plus adapté aux applications basées sur des requêtes.

JSF est conçu pour les applications Web plus riches basées sur des événements. Je vois l'événement comme plus granuleux que la demande/réponse.

Du point de vue du serveur

La page JSP est convertie en servlet et a un comportement minimal.

La page JSF est convertie en une arborescence de composants (par un FacesServlet spécialisé) et elle suit le cycle de vie des composants défini par la spécification.

Servlets :

L'API Java Servlet permet aux développeurs Java d'écrire du code côté serveur pour fournir du contenu Web dynamique. Comme d'autres API de serveur Web propriétaires, l'API Java Servlet offre des performances améliorées par rapport à CGI ; cependant, il présente certains avantages supplémentaires clés. Étant donné que les servlets ont été codés en Java, ils offrent une approche orientée objet (OO) et, plus important encore, peuvent s'exécuter sur n'importe quelle plate-forme. Ainsi, le code était portable sur n’importe quel hôte prenant en charge Java. Les servlets ont grandement contribué à la popularité de Java, car il est devenu une technologie largement utilisée pour développer des applications Web côté serveur.

JSP est construit sur des servlets et fournit une solution plus simple, basée sur des pages, pour créer de grandes quantités de contenu HTML dynamique pour les interfaces utilisateur Web. JavaServer Pages permet aux développeurs et concepteurs Web d'éditer facilement des pages HTML avec des balises spéciales pour la partie Java dynamique. JavaServer Pages fonctionne grâce à un servlet spécial appelé conteneur JSP, qui est installé sur le serveur Web et gère toutes les demandes d'affichage de page JSP. Le conteneur JSP traduit le JSP demandé en code de servlet, qui est ensuite compilé et exécuté immédiatement. Les requêtes suivantes pour la même page appelleront simplement le servlet d'exécution de la page. Si une modification est apportée au JSP sur le serveur, une demande de visualisation déclenche une autre traduction, compilation et redémarrage du servlet d'exécution.

JavaServer Faces est un framework Java standard permettant de créer des interfaces utilisateur pour les applications Web. Plus important encore, cela simplifie le développement de l’interface utilisateur, qui constitue souvent l’une des parties les plus difficiles et les plus fastidieuses du développement d’applications Web.
Bien qu'il soit possible de créer des interfaces utilisateur à l'aide des technologies Web Java de base (telles que les servlets Java et les pages JavaServer) sans le cadre global conçu pour les sites Web de développement d'applications d'entreprise, ces technologies de base peuvent souvent entraîner des problèmes de développement et de maintenance. Plus important encore, lorsque les développeurs parviennent à une solution concernant la qualité de la production, le même ensemble de problèmes résolus par JSF sera résolu de manière non standard. JavaServer Faces est conçu pour simplifier le développement d'interfaces utilisateur pour les applications Web Java des manières suivantes :
Il fournit une approche basée sur les composants et indépendante du client pour créer des interfaces utilisateur Web qui améliorent la productivité des développeurs et la facilité d'utilisation.
Cela facilite l'accès et la gestion des données d'application à partir de l'interface utilisateur Web.
Il gère automatiquement l'état de l'interface utilisateur entre plusieurs requêtes et plusieurs clients de manière simple et discrète.
Il fournit un cadre de développement convivial pour un public diversifié de développeurs possédant des compétences différentes.
Il décrit un ensemble standard de modèles architecturaux pour les applications Web.

Il existe également des situations dans lesquelles vous souhaiterez peut-être prendre en charge JSP plutôt que JSF. La nature de l’application devrait être le facteur décisif dans le choix de la technologie.

Si vous disposez d'une interaction graphique riche et de nombreux scripts Java requis, vous pouvez utiliser JSF. Fondamentalement, si votre architecture GUI est basée sur des composants, orientée et même pilotée comme Swing, alors JSF est le meilleur.

Si l'application est une simple soumission de formulaire qui ne nécessite pas beaucoup d'interaction avec l'interface graphique, alors JSP peut bien fonctionner si l'apprentissage d'une nouvelle technologie représente une surcharge et qu'une structure complexe n'est pas nécessaire.

Pages du serveur Java (JSP) est une technologie Java qui permet aux développeurs et concepteurs Web de développer rapidement et de gérer facilement des pages Web dynamiques et riches en informations qui exploitent les systèmes d'entreprise existants. La technologie JSP dissocie l'interface utilisateur de la génération de contenu, permettant aux concepteurs de modifier la mise en page globale sans modifier le contenu dynamique sous-jacent.

Facettes est le premier langage de déclaration de page non-JSP conçu pour JSF (Visages du serveur Java), qui a fourni aux développeurs JSF un modèle de programmation plus simple et plus puissant par rapport à JSP. Il résout divers problèmes rencontrés dans JSP pour le développement d'applications Web.

Voici un tableau qui compare les caractéristiques des scripts et des visages :

Jsp dispose également d'un code de servlet natif qui ne nécessite aucune compilation externe qu'il peut exécuter directement. Les modifications prendront effet dans le jsp directement dans le navigateur.

Le servlet doit être compilé (c'est-à-dire qu'il aura une création de classe définie)

Jsf est un composant de vue MVC Framework

JSP est un composant View MVC (Model View Controller). Le contrôleur accepte la demande entrante et la transmet au modèle, qui peut être un bean permettant d'accéder à la base de données. Le JSP formate ensuite la sortie en utilisant HTML, CSS et JavaScript, puis le résultat est renvoyé au demandeur.

JSP : signifie HTML+Java Code :

JSP a son propre cycle de vie jsp_init() jsp_service() jsp_destroy

Après la première requête, le JSP est converti en fichier .java. Il existe trois types de balises que nous utilisons. 1.) sans script

Ici, le développeur peut déclarer toutes les choses qu'il souhaite emporter avec lui.

2.) Balise d'expression

Ici, le développeur peut utiliser certaines données liées à l'impression

Ici, le développeur peut déclarer certaines données associées à la méthode.

Servlette :

Une servle a son propre cycle de vie.

Init() service() détruire()

Après le premier conteneur de requête, les données seront lues à partir du fichier web.xml puis après le message d'accueil, le remplissage sera affiché.
Maintenant, après avoir exécuté l'action, il recherchera l'URL et après ce processus, il y recherchera le servlet spécifique. une opération de maintenance sera effectuée.

Comme nous l'avons vu dans l'article précédent, les servlets nous permettent de recevoir des requêtes d'un client, de faire du travail et d'afficher les résultats à l'écran. Jusqu'au moment où il faut afficher la sortie à l'écran, la servlet fonctionne bien. Vous pouvez y insérer une logique assez complexe, effectuer des appels à la base de données et bien plus encore, ce qui est nécessaire à l'application. Mais l'affichage à l'écran à l'intérieur du servlet lui-même est très gênant. Dans notre exemple, nous nous sommes limités à une solution extrêmement simple. Que devrez-vous faire si vous proposez des idées de conception complexes ? Il est peu probable qu'un concepteur Web soit capable de comprendre comment restituer la sortie dans notre servlet. Et lorsqu'il voudra mettre en œuvre ses idées de conception, il devra s'adresser au programmeur et lui demander de changer le code du servlet afin de modifier la conception. Celui-ci devra être recompilé, il faudra proposer des algorithmes intelligents pour afficher non seulement des images, mais aussi du JavaScript. Juste un cauchemar.
Il est clair pour tout développeur sensé qu’une solution différente doit être utilisée. Le plus évident est de trouver un mécanisme qui diviserait la tâche en deux parties : une partie traite la demande, modifie les données, collecte les données, les place dans un certain package et les transfère à la deuxième partie, qui le fait. une seule chose - affiche ces données.
C'est ainsi que nous arrivons au modèle que nous connaissons déjà : Model-View-Controller (MVC). Pour le cas des applications Web, le contrôleur devient un servlet, le paquet de données que nous avons généré devient un modèle. Mais JSP – Java Server Pages – est parfait pour le rôle de présentation (View).
Dans cet article, nous donnerons un aperçu général de cette technologie. Et nous continuerons « Département des ressources humaines » dans le prochain article, où nous pourrons immédiatement utiliser des technologies familières - servlets et JSP.
L'idée principale de JSP est très simple : la page elle-même est un modèle avec des balises HTML déjà préparées, entre lesquelles vous devez insérer les données nécessaires. Quelque chose comme ça (ce n'est qu'un diagramme)

<% String name = request.getParameter("name"); if (name == null || name.length() == 0) { %>Bonjour le monde!<% } else { %>Bonjour le monde! Je suis<%= name%> <% } %>

< html > < head > < title > Échantillon Bonjour tout le monde < / title > < / head > < body > < h1 > Nom de la chaîne = requête . getParameter("nom"); if (nom == null || nom . longueur () == 0 ) ( Bonjour le monde! <% } else { Bonjour le monde! Je suis<%= name %> < / h1 > < / body > < / html >

Comme vous pouvez le constater, notre fichier HTML est un mélange de balises HTML et de code Java. Essentiellement, JSP est converti en servlet lors du premier accès et fonctionne comme un servlet. C’est très important à comprendre. JSP N'EST PAS une page comme une page HTML - il est important qu'un nouveau programmeur comprenne clairement qu'il ne s'agit que d'un autre servlet - vous n'avez tout simplement pas besoin de programmer sa sortie.<%» и здесь вам можно написать любой код, который будет нужен.
Vous pouvez simplement le dessiner. Et insérez les données aux bons endroits. Mais parce que Si une page JSP ressemble d’une manière ou d’une autre à du HTML, ce sera évidemment plus facile pour le concepteur. Et je le dis encore une fois FORTEMENT aux débutants : JSP est un SERVLET. Sa préparation avec toutes les données s'effectue sur le serveur. C'est ici que toutes les données sont insérées. Et l'utilisateur reçoit une page HTML prête à l'emploi dans le navigateur, qui ne présente aucun signe de JAVA. Peut-être une sorte d'applet - mais c'est une technologie complètement différente. C'est tout simplement pratique d'utiliser JSP - vous effectuez la logique de réception des données dans un servlet (qui ne ressemble pas à JSP), puis transmettez les données à un autre servlet (cette fois sous forme de JSP), dont la tâche est de dessiner un Page HTML utilisant ces données. Vous n’avez tout simplement pas besoin de dessiner beaucoup. De plus, vous n'avez pas besoin de recompiler les classes JSP. Vous pouvez simplement remplacer le JSP par un autre plus moderne et il sera automatiquement compilé à nouveau. Ce qui est généralement assez pratique : vous venez de copier la page requise à la place de l'ancienne. Comme vous pouvez le voir, le code Java est placé entre crochets avec un signe de pourcentage "
Comme vous pouvez le voir, notre code vérifie la présence du paramètre name dans la requête (request.getParameter("name")) et, s'il existe, alors un message s'affiche. Sinon, nous verrons une version « raccourcie » de l’inscription.

demande
Un peu plus d'informations - JSP possède plusieurs objets prédéfinis. Ceux. ils doivent être perçus comme des objets prêts à l'emploi et utilisables. Il s'agit de la demande, de la réponse, de la sortie, de la session, de l'application, de la configuration, du pageContext et de la page. Je vais en donner un bref résumé ; il est possible que pour l'instant ce ne soit pas très intéressant, et ce ne soit pas clair. Mais juste au cas où.

réponse
Il s'agit d'un objet HttpServletResponse associé à une réponse à une requête client. Notez que comme le flux de sortie (voir ci-dessous) est mis en mémoire tampon, il est possible de modifier les codes d'état HTTP et les en-têtes de réponse même si cela ne serait pas autorisé dans un servlet normal, tant que certaines données de sortie ont déjà été envoyées au client. .

dehors
Il s'agit d'un objet PrintWriter utilisé pour envoyer la sortie au client. Cependant, pour rendre l'objet de réponse (voir section précédente) utile, vous devez utiliser une variante tamponnée de PrintWriter, JspWriter. N'oubliez pas que vous pouvez modifier la taille du tampon et même désactiver la mise en mémoire tampon en modifiant la valeur de l'attribut buffer de la directive page. Notez également que out est utilisé presque exclusivement par les scriptlets, puisque les expressions JSP sont automatiquement placées dans le flux de sortie, éliminant ainsi le besoin d'appeler explicitement out.

session
Il s'agit d'un objet HttpSession associé à la requête. Les sessions sont créées automatiquement et cette variable existe même s'il n'y a aucune référence aux sessions entrantes. La seule exception est lorsque vous désactivez l'utilisation des sessions à l'aide de l'attribut session de la directive page. Dans ce cas, les références à la variable de session entraînent des erreurs lors de la traduction de la page JSP vers le servlet.

application
Il s'agit d'un objet de type ServletContext obtenu grâce à l'utilisation de la méthode getServletConfig().getContext().

configuration
Il s'agit d'un objet ServletConfig pour la page actuelle.

pageContext
JSP introduit une nouvelle classe PageContext pour les fonctionnalités spécifiques au serveur de sandboxing, telles que des JspWriters plus efficaces. L'idée est que si vous y accédez via cette classe plutôt que directement, votre code peut s'exécuter sur des moteurs servlet/JSP "normaux".

page
Essentiellement un synonyme de cela, et non nécessaire lorsque vous travaillez avec Java. Cette variable a été créée en vue de l'avenir, lorsque d'autres langages de script autres que Java pourraient devenir disponibles.

Jetons un coup d'œil à notre création en action. Vous pouvez compiler notre servlet avec la commande

javac –cp .;servlet-api.jar étudiants\web\*.java

Après cela, plaçons notre classe HelloWorldServlet dans le répertoire \webapps\studentsApp\WEB-INF\students\web\. Et le fichier hello.jsp dans le répertoire racine de notre application est \webapps\studentsApp.
Maintenant, notre arborescence de répertoires est un peu plus simple (nous n'utilisons pas certaines classes)

Cours WEB-INF étudiants web -HelloWorldServlet.class -web.xml -hello.jsp

< strong >WEB-INF cours étudiants BonjourWorldServlet. classe Internet. XML Bonjour. jsp< / strong >

Le fichier web.xml déjà connu aura exactement le même aspect que dans la partie précédente

Bonjour Bonjour /Bonjour

< ! DOCTYPE web - app PUBLIC "-//Sun Microsystems, Inc.//DTD Application Web 2.3//FR" "http://java.sun.com/dtd/web-app_2_3.dtd"> < web - app > < servlet > < servlet - name >Bonjour< / servlet - name > < servlet - class >étudiants. la toile. BonjourMondeServlet< / servlet - class > < / servlet > < servlet - mapping > < servlet - name >Bonjour< / servlet - name > < url - pattern >/Bonjour< / url - pattern > < / servlet - mapping > < / web - app >

Lancez Tomcat puis essayez d'appeler notre application par URL
http://localhost:8080/studentsApp/bonjour

Si vous voulez voir mon nom, utilisez cette URL
http://localhost:8080/studentsApp/hello?name=Anton
Vous pourrez remplacer votre nom plus tard :)

Balise personnalisée

Nous pouvons maintenant approfondir un peu JSP. Comme vous l'avez probablement déjà remarqué, JSP est un mélange de code Java et de balises HTML. À mesure que la complexité de la logique de présentation augmente (et JSP est utilisé précisément comme présentation - mais même la présentation peut avoir une logique assez sophistiquée - couleurs, polices, etc.), la page passe du HTML plus ou moins compréhensible au « style naval ». pâtes". Et le designer ne pourra plus rien comprendre. Il est probablement impossible de se débarrasser complètement de la logique dans JSP, mais d'une manière ou d'une autre, "nettoyer" le code et utiliser des outils plus pratiques - une telle solution existe. Et cela s'appelle CustomTags. Il s’agit essentiellement d’une simplification des conceptions JSP que je souhaitais réaliser.

Examinons un exemple simple de la façon dont vous pouvez écrire et utiliser votre propre balise. Pour ce faire, nous avons besoin de trois étapes :

1. Écrivez un fichier TLD (Tag Library Definition) – un fichier de descripteur de bibliothèque de balises.
2. Écrivez une classe pour implémenter la balise elle-même
3. Corriger le fichier HTML

Donc. Le fichier TLD a une extension .tld et est généralement déployé dans le répertoire WEB-INF de votre répertoire d'application. Bien qu'il puisse être placé dans un autre. Si vous disposez de nombreux fichiers de ce type, vous pouvez leur fournir un répertoire distinct. Voici notre version de hello.tld.

1.0 1.2 Exemple de bibliothèque de balises /Bibliothèque SimpleTag Exemple de tag pour HelloWorld Bonjour étudiants.web.tag.HelloTag vide Exemple de balise Hello World nom FAUX vrai

< taglib xmlns = "http://java.sun.com/xml/ns/j2ee" xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance" xsi : schémaLocation = "http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd" version = "2.0" > < tlib - version > 1.0 < / tlib - version > < jsp - version > 1.2 < / jsp - version > < short - name >Exemple de bibliothèque de balises< / short - name > < uri >/Bibliothèque SimpleTag< / uri > < description > Exemple de tag pour HelloWorld < / description > < tag > < name >Bonjour< / name > < tag - class >étudiants. la toile. étiqueter. BonjourTag< / tag - class > < body - content >vide< / body - content > < description > Exemple de balise Hello World < / description > < attribute > < name >nom< / name > < required >FAUX< / required > < rtexprvalue >vrai< / rtexprvalue > < / attribute > < / tag > < / taglib >

Comme vous l'avez probablement remarqué dans la description, une balise est la classe HelloTag. C'est lui qui est chargé d'afficher les informations. Écrivons-le.

package étudiants.web.tag; importer java.io.IOException ; importer javax.servlet.jsp.JspException ; importer javax.servlet.jsp.JspTagException ; importer javax.servlet.jsp.tagext.TagSupport ; public final class HelloTag extends TagSupport ( private String name = null; public int doStartTag() throws JspException ( try ( if (name == null) ( pageContext.getOut().write("Bonjour tout le monde!"); ) else ( pageContext.getOut().write("Hello, world! I"m " + name); ) ) catch (IOException ioe) ( throw new JspTagException(ioe.getMessage()); ) return SKIP_BODY; ) public String getName() ( return name; ) public void setName(String name) ( this.name = name; ) public void release() ( super.release(); name = null; ) )

forfait étudiants. la toile. étiqueter ; importer Java. io. IOException ; importer javax. servlet. jsp. JspException ; importer javax. servlet. jsp. JspTagException ; importer javax. servlet. jsp. texte du tag. TagSupport ; la classe finale publique HelloTag étend TagSupport ( nom de chaîne privé = null ; public int doStartTag() lance JspException ( essayer ( si (nom == null ) ( contexte de page. sortir(). write("Bonjour tout le monde !"); ) autre ( contexte de page. sortir(). écrire ("Bonjour tout le monde ! Je" suis " + nom ) ; ) catch (IOException ioe) ( lancer une nouvelle JspTagException(ioe. getMessage()); retourner SKIP_BODY ; chaîne publique getName()( renvoyer le nom ; public void setName (nom de la chaîne) ( ce. nom = nom ; publication vide publique() ( super. libérer(); nom= nul; } }

Pour assembler notre servlet et notre nouvelle balise, nous avons besoin d'une ligne plus complexe

javac –cp .;servlet-api.jar;jsp-api.jar étudiants\web\*.java étudiants\web\tag\*.java

La nouvelle bibliothèque jsp-api.jar se trouve au même endroit que servlet_api.jar - dans \common\lib. Maintenant, pour connecter notre tag à l'application, nous devons enregistrer notre bibliothèque dans le fichier web.xml

Bienvenue au personnel des étudiants Bienvenue au personnel des étudiants Bonjour étudiants.web.HelloWorldServlet Bonjour /Bonjour http://www.someurl.ru /WEB-INF/bonjour.tld

XMLversion= "1.0" codage= "ISO-8859-1"?> < la toile- application> < afficher- nom> AccueilliràÉtudiantspersonnel< / afficher- nom>

JSP (pages du serveur Java) est une technologie qui vous permet d'intégrer du code Java ainsi que du langage EL (langage d'expression) dans le contenu d'une page statique) et permet aux développeurs Web de générer dynamiquement du HTML, du XML et d'autres pages Web. JSP fait partie intégrante de la technologie unifiée de création d'applications métiers J2EE.

JSP peut être exécuté sur presque n'importe quel serveur Web, puisque cette technologie est basée sur le langage de programmation Java, indépendant de la plate-forme. Les pages du serveur Java prennent en charge les balises HTML, les balises Javascript et son propre ensemble de balises.

JSP - vous permet de séparer la partie dynamique de la page de la partie statique. Cette technologie consiste à insérer du code Java dans une page. Nous n'envisagerons pas cette option pour l'utilisation de JSP car cette technologie est considérée comme obsolète et imparfaite. La raison est simple : les développeurs et les concepteurs qui développent l'apparence de la page ne sont pas toujours familiers avec Java, ce qui peut entraîner des difficultés supplémentaires lors de l'édition ou de la maintenance des applications Web.

Au lieu d'insérer du code Java, une bibliothèque de balises jstl est désormais utilisée, ou Javascript pour les plus avancées. Nous allons regarder un exemple avec des balises jstl. Il s'agit d'une bibliothèque très pratique qui possède presque toutes les fonctionnalités nécessaires à la création de pages dynamiques. Si vous avez besoin de quelque chose de spécifique, vous pouvez toujours écrire votre propre balise et insérer son contenu dans la page.

Nous connaissons déjà partiellement JSP depuis le début. La partie principale de la page JSP est HTML, dans laquelle sont insérées des balises au contenu dynamique.

Exemple de page JSP

Une connaissance très nécessaire que nous utiliserons est la directive JSP.

Une directive JSP est un message qu'une page peut envoyer au conteneur correspondant précisant quoi faire. Syntaxe des directives :<% @ атрибут = «значение» %>

Il existe trois principaux types de directives :

1. page (peut être utilisée pour importer des classes) ;
2. include (vous donne la possibilité d'insérer un fichier dans une classe de servlet lors de la traduction d'un fichier JSP en servlet) ;
3. taglib (permet de connecter une bibliothèque de tags).

Puisque nous n’insérerons pas de code dans la page, regardons les deux dernières directives.

Par exemple, nous avons des pages qui auront le même haut et le même bas. Un modèle très courant dans lequel le pied de page et l'en-tête sont les mêmes pour toutes les pages. Afin de ne pas écrire le code de ces pages dans chaque fichier JSP, vous pouvez mettre leur code dans des fichiers séparés puis le connecter à l'endroit dont nous avons besoin à l'aide de la directive include.

Emplacement des fichiers dans le projet :

Dans le code ci-dessus, vous pouvez voir l'utilisation de la directive taglib. Avec son aide, nous avons connecté la bibliothèque de balises jstl. En utilisant cette directive, vous pouvez connecter une bibliothèque de vos propres balises :<%@ taglib uri=»/WEB-INF/mylib.tld» prefix=»test» %>.

Notez qu'un attribut taglib important est préfixe. Il s'agit d'un attribut obligatoire. En utilisant le préfixe, vous pouvez appeler la bibliothèque en code. Vous pouvez choisir n’importe quel nom de préfixe. Au fait, voici l'utilisation réelle des balises jstl :

< c: forEach items= "$(comptes) " var = "compte" >

< tr align= "center" >

< td>$(compte.numéro)

< td>$(compte. solde)

< td>< c: if test= "${!account.isBlocked}" >$(statutActif)

< c: if test= "${account.isBlocked}" >$(statutBloqué)

< td>< c: if test= "${!account.isBlocked}" >

< a href= "?command=blockaccount&accountId=$(account.accountId)"> $( bloc )

< td>< a href= "?command=showinfo&accountId=$(account.accountId)"> $( showInfo )

Le code ci-dessus montre la sortie de tous les éléments de la liste. La manière dont nous l'avons transféré sur la page sera discutée dans les articles suivants. Sa syntaxe est :

$(article)

Il s'agit du code de la barre latérale inclus ci-dessus. Comme vous pouvez le constater, les branches sont utilisées ici pour afficher uniquement les informations disponibles pour un certain type d'utilisateur.

Syntaxe:
a est égal à b

Il est préférable de prendre en compte les balises jstl lors de l'écriture d'un projet réel, car je ne vois pas l'intérêt d'apprendre et de mémoriser toute la syntaxe de chaque action. Le code ci-dessus ne doit servir qu'à titre d'exemple de la façon dont il est utilisé. Il n’est pas nécessaire de mémoriser quoi que ce soit. Lorsque vous écrivez du code, référez-vous à cette syntaxe.

D'ailleurs, le code du projet dont ce code a été extrait se trouve ici : https://github.com/caligula95/payment-systemapp

J'ai posté le projet sur heroku : https://payment-systemapp.herokuapp.com/ - un compte gratuit est utilisé ici, donc pour la première demande, vous devez attendre quelques minutes pour que le projet démarre.