Meilleures pratiques pour les servlets et les pages JSP – Bien choisir son serveur d impression

La technologie Java Servlet et les pages JavaServer (pages JSP) sont des technologies côté serveur qui ont dominé le marché des technologies Java côté serveur; ils sont devenus le moyen standard de développer des applications Web commerciales. Les développeurs Java adorent ces technologies pour une multitude de raisons, notamment: les technologies sont assez faciles à apprendre et elles Écrivez une fois, exécutez partout paradigme aux applications Web. Plus important encore, s'ils sont utilisés efficacement en suivant les meilleures pratiques, les servlets et les pages JSP permettent de séparer la présentation du contenu. Les meilleures pratiques sont des approches éprouvées pour développer des applications Web basées sur des servlets et JSP de qualité, réutilisables et faciles à entretenir. Par exemple, du code Java intégré (scriptlets) dans des sections de documents HTML peut entraîner des applications complexes qui ne sont pas efficaces et difficiles à réutiliser, à améliorer et à maintenir. Les meilleures pratiques peuvent changer tout cela.

Dans cet article, je présenterai les meilleures pratiques importantes pour les servlets et les pages JSP; Je suppose que vous avez une connaissance pratique de base des deux technologies. Cet article:

• Présente un aperçu des servlets Java et des pages JavaServer (pages JSP)
• Fournit des conseils, des astuces et des directives pour l'utilisation des servlets et des pages JSP
• Fournit les meilleures pratiques pour les servlets et les pages JSP

Présentation des servlets et des pages JSP

Semblables aux scripts CGI (Common Gateway Interface), les servlets prennent en charge un modèle de programmation de demande et de réponse. Lorsqu'un client envoie une demande au serveur, le serveur envoie la demande au servlet. Le servlet construit ensuite une réponse que le serveur renvoie au client. Contrairement aux scripts CGI, cependant, les servlets s'exécutent dans le même processus que le serveur HTTP.

Lorsqu'une demande du client est faite, le un service est appelée et transmet un objet de demande et de réponse. Le servlet détermine d'abord si la demande est un AVOIR ou PUBLIER opération. Il appelle ensuite l'une des méthodes suivantes: doGet ou doPost. le doGet est appelée si la requête est AVOIR, et doPost est appelé si la demande est PUBLIER. Tous les deux doGet et doPost prendre la demande ( HttpServletRequest) et réponse ( HttpServletResponse).

En termes simples, les servlets sont des classes Java qui peuvent générer du contenu HTML dynamique en utilisant impression déclarations. Cependant, il est important de noter à propos des servlets qu'ils s'exécutent dans un conteneur et que les API fournissent une gestion du cycle de vie des sessions et des objets. Par conséquent, lorsque vous utilisez des servlets, vous bénéficiez de tous les avantages de la plate-forme Java, qui incluent le bac à sable (sécurité), l'API d'accès à la base de données via JDBC et la portabilité multiplateforme des servlets.

Pages JavaServer (JSP)

La technologie JSP – qui résume les servlets à un niveau supérieur – est une spécification ouverte et librement disponible développée par Sun Microsystems comme alternative à la technologie Active Server Pages (ASP) de Microsoft, et un composant clé de Java 2 Enterprise Edition (J2EE ) spécification. De nombreux serveurs d'applications disponibles dans le commerce (tels que BEA WebLogic, IBM WebSphere, Live JRun, Orion, etc.) prennent en charge la technologie JSP.

Comment fonctionnent les pages JSP?

Une page JSP est essentiellement une page Web avec du HTML traditionnel et des morceaux de code Java. L'extension de fichier d'une page JSP est .jsp plutôt que .html ou .htm, ce qui indique au serveur que cette page nécessite une gestion spéciale qui sera effectuée par une extension de serveur ou un plug-in.

Lorsqu'une page JSP est appelée, elle sera compilée (par le moteur JSP) dans un servlet Java. À ce stade, le servlet est géré par le moteur du servlet, comme tout autre servlet. Le moteur de servlet charge ensuite la classe de servlet (à l'aide d'un chargeur de classe) et l'exécute pour créer du HTML dynamique à envoyer au navigateur, comme illustré à la figure 1. Le servlet crée tout objet nécessaire et écrit tout objet sous forme de chaîne dans un flux de sortie vers le navigateur.

Figure 1: flux de demande / réponse appelant une page JSP

La prochaine fois que la page est demandée, le moteur JSP exécute le servlet déjà chargé, sauf si la page JSP a changé, auquel cas elle est automatiquement recompilée dans un servlet et exécutée.

Les meilleures pratiques

Dans cette section, je présente les meilleures pratiques pour les servlets et en particulier les pages JSP. L'accent mis sur les meilleures pratiques JSP est simplement dû au fait que les pages JSP semblent être plus largement utilisées (probablement parce que la technologie JSP favorise la séparation de la présentation du contenu). L'une des meilleures pratiques qui combine et intègre l'utilisation de servlets et de pages JSP est le modèle de conception Model View Controller (MVC), décrit plus loin dans cet article.

• Ne pas abuser du code Java dans les pages HTML: Mettre tout le code Java directement dans la page JSP est OK pour des applications très simples. Mais l'utilisation excessive de cette fonctionnalité conduit à du code spaghetti qui n'est pas facile à lire et à comprendre. Une façon de réduire le code Java dans les pages HTML consiste à écrire des classes Java distinctes qui effectuent les calculs. Une fois ces classes testées, des instances peuvent être créées.
• Choisissez le bon mécanisme d'inclusion: Les données statiques telles que les en-têtes, les pieds de page et le contenu de la barre de navigation sont mieux conservées dans des fichiers séparés et ne sont pas régénérées dynamiquement. Une fois que ce contenu est dans des fichiers séparés, il peut être inclus dans toutes les pages en utilisant l'un des mécanismes d'inclusion suivants:
  • Inclure la directive: <%@ include file="filename" %>
  • Inclure l'action:

Le premier mécanisme d'inclusion inclut le contenu du fichier spécifié pendant la conversion de la page JSP en servlet (phase de traduction), et le second inclut la réponse générée après l'exécution de la page spécifiée. Je recommanderais d'utiliser la directive include, qui est rapide en termes de performances, si le fichier ne change pas souvent; et utilisez l'action d'inclusion pour le contenu qui change souvent ou si la page à inclure ne peut pas être décidée tant que la page principale n'est pas exécutée.

Un autre mécanisme inclus est le balise d'action fournie par les pages JavaServer Standard Tag Library (JSTL). Vous pouvez utiliser cette balise pour importer ou importer du contenu provenant de sources locales et distantes. Voici quelques exemples:

• Ne mélangez pas la logique métier avec la présentation: Pour les applications avancées et lorsque davantage de code est impliqué, il est important de ne pas mélanger la logique métier avec la présentation frontale dans le même fichier. La séparation de la logique métier de la présentation permet des changements de part et d'autre sans affecter l'autre. Cependant, le code JSP de production devrait être limité à la présentation frontale. Alors, comment implémentez-vous la partie logique métier? C'est là que la technologie JavaBeans entre en jeu. Cette technologie est un modèle de composant portable indépendant de la plate-forme qui permet aux développeurs d'écrire des composants et de les réutiliser partout. Dans le contexte des pages JSP, les composants JavaBeans contiennent une logique métier qui renvoie des données à un script sur une page JSP, qui à son tour formate les données renvoyées par le composant JavaBeans pour affichage par le navigateur. Une page JSP utilise un composant JavaBeans en définissant et en obtenant les propriétés qu'il fournit. Les avantages de l'utilisation des composants JavaBeans pour augmenter les pages JSP sont les suivants:
  • Composants réutilisables: Différentes applications pourront réutiliser les composants.
  • Séparation de la logique métier et de la logique de présentation: vous pouvez modifier la façon dont les données sont affichées sans affecter la logique métier. En d'autres termes, les concepteurs de pages Web peuvent se concentrer sur la présentation et les développeurs Java peuvent se concentrer sur la logique métier.
  • Protège votre propriété intellectuelle en sécurisant le code source.

Si vous utilisez des composants Enterprise JavaBeans (EJB) avec votre application, la logique métier doit rester dans les composants EJB qui fournissent la gestion du cycle de vie, la prise en charge des transactions et l'accès multi-clients aux objets de domaine (Entity Beans).

• Utiliser des balises personnalisées: L'incorporation de bits de code Java (ou de scriptlets) dans des documents HTML peut ne pas convenir à tous les développeurs de contenu HTML, peut-être parce qu'ils ne connaissent pas le langage Java et ne se soucient pas d'apprendre sa syntaxe. Alors que les composants JavaBeans peuvent être utilisés pour encapsuler une grande partie du code Java, leur utilisation dans les pages JSP nécessite toujours que les développeurs de contenu aient une certaine connaissance de la syntaxe Java.

  La technologie JSP vous permet d'introduire de nouvelles balises personnalisées via la bibliothèque de balises. En tant que développeur Java, vous pouvez étendre les pages JSP en introduisant des balises personnalisées qui peuvent être déployées et utilisées dans une syntaxe de type HTML. Les balises personnalisées vous permettent également de fournir un meilleur packaging en améliorant la séparation entre la logique métier et la logique de présentation. De plus, ils fournissent un moyen de personnaliser la présentation lorsque cela ne peut pas être fait facilement avec JSTL.

  Certains des avantages des balises personnalisées sont les suivants:

  • Ils peuvent éliminer les scriptlets dans vos applications JSP. Tous les paramètres nécessaires à la balise peuvent être passés en tant qu'attributs ou contenu de corps, et donc aucun code Java n'est nécessaire pour initialiser ou définir les propriétés des composants.
  • Ils ont une syntaxe plus simple. Les scriptlets sont écrits en code Java, mais des balises personnalisées peuvent être utilisées dans une syntaxe de type HTML.
  • Ils peuvent améliorer la productivité des développeurs de contenu non programmeur, en leur permettant d'effectuer des tâches qui ne peuvent pas être effectuées avec HTML.
  • Ils sont réutilisables. Ils économisent du temps de développement et de test. Les scriptlets ne sont pas réutilisables, sauf si vous appelez le copier-coller "réutiliser".

  En bref, vous pouvez utiliser des balises personnalisées pour accomplir des tâches complexes de la même manière que vous utilisez HTML pour créer une présentation.

  Les directives de programmation suivantes sont pratiques lors de l'écriture de bibliothèques de balises personnalisées:

  • Restez simple: si une balise nécessite plusieurs attributs, essayez de la diviser en plusieurs balises.
  • Rendez-le utilisable: consultez les utilisateurs des balises (développeurs HTML) pour obtenir un haut degré de convivialité.
  • N'inventez pas de langage de programmation dans les pages JSP: ne développez pas de balises personnalisées qui permettent aux utilisateurs d'écrire des programmes explicites.
  • Essayez de ne pas réinventer la roue: plusieurs bibliothèques de balises JSP sont disponibles, comme le Jakarta Taglibs Project. Vérifiez si ce que vous voulez est déjà disponible.
• Ne réinventez pas la roue: Bien que les balises personnalisées fournissent un moyen de réutiliser des composants précieux, elles doivent toujours être créées, testées et déboguées. De plus, les développeurs doivent souvent réinventer la roue encore et encore et les solutions peuvent ne pas être les plus efficaces. C'est le problème résolu par la bibliothèque de balises standard JavaServer Pages (JSTL), en fournissant un ensemble de balises standard réutilisables. JSTL définit une bibliothèque de balises standard qui fonctionne de la même manière partout, vous n'avez donc plus à parcourir les collections à l'aide d'un scriptlet (ou des balises d'itération de nombreux fournisseurs). Le JSTL comprend des balises pour le bouclage, la lecture d'attributs sans syntaxe Java, l'itération sur diverses structures de données, l'évaluation conditionnelle des expressions, la définition concise des attributs et des variables de script et l'analyse des documents XML.
• Utiliser le langage d'expression JSTL: Les informations à transmettre aux pages JSP sont communiquées à l'aide d'attributs de portée JSP et de paramètres de demande. Un langage d'expression (EL), spécialement conçu pour les auteurs de pages, fait la promotion des attributs de portée JSP comme moyen standard de communiquer des informations de la logique métier aux pages JSP. Notez, cependant, que si l'EL est un aspect clé de la technologie JSP, ce n'est pas un langage de programmation à usage général. Il s'agit plutôt simplement d'un langage d'accès aux données, ce qui permet d'accéder facilement (et de manipuler) aux données d'application sans avoir à utiliser de scriptlets ou de valeurs d'expression au moment de la demande.

Dans JSP 1.x, un auteur de page doit utiliser une expression <%= aName %> pour accéder à la valeur d'un système, comme dans l'exemple suivant:

        

        

        

        <someTags: aTag attribute = "<%=
            pageContext.getAttribute("aName") %>">

ou la valeur d'un composant JavaBeans personnalisé:

<%= aCustomer.getAddress().getCountry() %>

Un langage d'expression permet à un auteur de page d'accéder à un objet à l'aide d'une syntaxe simplifiée. Par exemple, pour accéder à une simple variable, vous pouvez utiliser quelque chose comme:

Et pour accéder à une propriété JavaBeans imbriquée, vous utiliseriez quelque chose comme:

Si vous avez travaillé avec JavaScript, vous vous sentirez comme chez vous, car l'EL emprunte la syntaxe JavaScript pour accéder aux données structurées.

• Utilisez des filtres si nécessaire: Une des nouvelles fonctionnalités de la technologie JSP est les filtres. Si jamais vous rencontrez une situation où plusieurs servlets ou pages JSP doivent compresser leur contenu, vous pouvez écrire un seul filtre de compression et l'appliquer à toutes les ressources. Dans Java BluePrints, par exemple, des filtres sont utilisés pour fournir le SignOn.
• Utilisez un modèle de sécurité portable: La plupart des serveurs d'applications offrent des fonctionnalités de sécurité spécifiques au serveur ou au fournisseur qui verrouillent les développeurs sur un serveur particulier. Pour maximiser la portabilité de votre application d'entreprise, utilisez un modèle de sécurité d'application Web portable. En fin de compte, cependant, tout est une question de compromis. Par exemple, si vous disposez d'un ensemble prédéfini d'utilisateurs, vous pouvez les gérer à l'aide d'une connexion basée sur un formulaire ou d'une authentification de base. Mais si vous devez créer des utilisateurs de manière dynamique, vous devez utiliser des API spécifiques au conteneur pour créer et gérer des utilisateurs. Bien que les API spécifiques aux conteneurs ne soient pas portables, vous pouvez surmonter cela avec le modèle de conception de l'adaptateur.
• Utiliser une base de données pour des informations persistantes: Vous pouvez implémenter des sessions avec un HttpSession objet, qui fournit un mécanisme simple et pratique pour stocker des informations sur les utilisateurs, et utilise des cookies pour identifier les utilisateurs. Utilisez des sessions pour stocker des informations temporaires – donc même si elles se perdent, vous pourrez dormir la nuit. (Les données de session sont perdues lorsque la session expire ou lorsque le client change de navigateur.) Si vous souhaitez stocker des informations persistantes, utilisez une base de données, qui est beaucoup plus sûre et portable sur tous les navigateurs.
• Contenu du cache: Vous ne devez jamais régénérer dynamiquement du contenu qui ne change pas entre les demandes. Vous pouvez mettre en cache du contenu côté client, côté proxy ou côté serveur.
• Utiliser le pool de connexions: Je recommande d'utiliser le JSTL pour l'accès à la base de données. Mais si vous souhaitez écrire vos propres actions personnalisées pour l'accès à la base de données, je vous recommande d'utiliser un pool de connexions pour partager efficacement les connexions à la base de données entre toutes les demandes. Cependant, notez que les serveurs J2EE fournissent cela sous les couvertures.
• Mettre en cache les résultats des requêtes de base de données: Si vous souhaitez mettre en cache les résultats de la base de données, n'utilisez pas les JDBC ResultSet objet comme objet de cache. Ceci est étroitement lié à une connexion en conflit avec le pool de connexions. Copiez les données d'un ResultSet dans un bean spécifique à l'application tel que Vecteur, ou JDBC RowSets.
• Adoptez la nouvelle syntaxe XML JSP si nécessaire. Cela dépend vraiment de la conformité de XML à vos applications. Il y a cependant un compromis ici, car cela rend la JSP plus conviviale pour les outils, mais moins conviviale pour le développeur.
• Lisez et appliquez les BluePrints d'entreprise: Enterprise BluePrints de Sun fournit aux développeurs des directives, des modèles et des exemples d'applications, tels que Adventure Builder et Pet Store. Dans l'ensemble, les Blueprint J2EE fournissent les meilleures pratiques et un ensemble de modèles de conception, qui sont des solutions éprouvées aux problèmes récurrents de création d'applications Java d'entreprise portables, robustes et évolutives.

Intégration de servlets et de pages JSP

La spécification JSP présente deux approches pour la création d'applications Web à l'aide de pages JSP: les architectures JSP modèle 1 et modèle 2. Ces deux modèles diffèrent par l'emplacement où le traitement a lieu. Dans l'architecture du modèle 1, comme le montre la figure 2, la page JSP est responsable du traitement des demandes et du renvoi des réponses aux clients.

Figure 2: Architecture JSP modèle 1

L'architecture du modèle 2, comme le montre la figure 3, intègre l'utilisation des servlets et des pages JSP. Dans ce mode, les pages JSP sont utilisées pour la couche de présentation et les servlets pour les tâches de traitement. Le servlet agit comme un manette responsable du traitement des demandes et de la création des beans nécessaires à la page JSP. Le contrôleur est également responsable de décider à quelle page JSP transmettre la demande. La page JSP récupère les objets créés par la servlet et extrait le contenu dynamique pour l'insertion dans un modèle.

Figure 3: Architecture JSP modèle 2

Ce modèle favorise l'utilisation du modèle de conception de style architectural Model View Controller (MVC). Notez que plusieurs cadres existent déjà qui implémentent ce modèle de conception utile et qui séparent vraiment la présentation du contenu. Apache Struts est un framework formalisé pour MVC. Ce cadre est mieux utilisé pour les applications complexes où une seule demande ou soumission de formulaire peut entraîner des résultats sensiblement différents.

Conclusion

Les meilleures pratiques – qui sont des solutions éprouvées à des problèmes récurrents – conduisent à des applications de meilleure qualité. Cet article présente plusieurs directives et meilleures pratiques à suivre lors du développement d'applications Web basées sur des servlets et JSP.

Gardez un œil sur les servlets et les technologies JSP, car plusieurs choses passionnantes sont en préparation. JavaServer Faces (JFC), par exemple, un effort du processus de communauté Java qui vise à définir un cadre d'application Web standard, s'intégrera bien avec Apache Struts.

Pour plus d'informations

Remerciements

Un merci spécial à Gregory Murray de Sun Microsystems, dont les commentaires m'ont aidé à améliorer cet article.