Comment éviter le code Java dans les fichiers JSP?
Je suis nouveau dans Java EE et je sais que quelque chose comme les trois lignes suivantes
<%= x+1 %>
<%= request.getParameter("name") %>
<%! counter++; %>
est une ancienne méthode de codage et dans JSP version 2, il existe une méthode pour éviter le code Java dans les fichiers JSP. Quelqu'un peut-il me dire s'il vous plaît l'alternative JSP 2 lignes, et comment cette technique s'appelle?
L’utilisation de scriptlets (ces <% %> choses) dans JSP est en effet extrêmement découragée depuis la naissance de taglibs (comme JSTL ) et EL ( Expression Language , ces ${} choses) remonte à 2001.
Les principaux inconvénients de scriptlets sont les suivants:
- Réutilisation: vous ne pouvez pas réutiliser les scriptlets.
- Remplaçabilité: vous ne pouvez pas rendre les scriptlets abstraits.
- OO-aptitude: vous ne pouvez pas utiliser l'héritage/la composition.
- Débogage: si le scriptlet lève une exception à mi-chemin, tout ce que vous obtenez est une page vierge.
- Testabilité: les scriptlets ne sont pas testables par unité.
- Maintenabilité: par session, il faut plus de temps pour maintenir la logique du code mélangé/encombré/dupliqué.
Soleil Oracle lui-même recommande également dans le Conventions de codage JSP == d'éviter l'utilisation de scriptlets chaque fois que la même fonctionnalité est possible avec les classes (tag). Voici plusieurs villes pertinentes:
Dans la spécification JSP 1.2, il est vivement recommandé d'utiliser la bibliothèque de balises standard JSP (JSTL) dans votre application Web pour aider à réduire le besoin de scriptlets JSP dans vos pages. Les pages qui utilisent JSTL sont, en général, plus faciles à lire et à gérer.
...
Si possible, évitez les scriptlets JSP lorsque les bibliothèques de balises offrent des fonctionnalités équivalentes. Cela facilite la lecture et la maintenance des pages, permet de séparer la logique métier de la logique de présentation et facilitera l'évolution de vos pages en pages de style JSP 2.0 (la spécification JSP 2.0 prend en charge mais minimise l'utilisation de scriptlets).
...
Dans l’esprit d’adopter le modèle de conception model-view-controller (MVC) pour réduire le couplage entre le niveau de présentation et la logique métier, les scriptlets JSP ne doivent pas être utilisés pour l’écriture de la logique applicative. Au lieu de cela, les scriptlets JSP sont utilisés si nécessaire pour transformer les données (également appelées "objets de valeur") renvoyées du traitement des demandes du client dans un format approprié prêt pour le client. Même dans ce cas, cela serait mieux fait avec une servlet de contrôleur frontal ou une balise personnalisée.
Comment remplacer des scriptlets dépend entièrement du seul but du code/de la logique. Plus que souvent, ce code doit être placé dans une classe Java digne de ce nom:
Si vous souhaitez invoquer le même Java code sur chaque demande , quelle que soit la demande, quelle que soit la page demandée, par exemple Pour vérifier si un utilisateur est connecté, implémentez une méthode filter et écrivez le code en conséquence dans
doFilter(). Par exemple.:public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException { if (((HttpServletRequest) request).getSession().getAttribute("user") == null) { ((HttpServletResponse) response).sendRedirect("login"); // Not logged in, redirect to login page. } else { chain.doFilter(request, response); // Logged in, just continue request. } }Une fois mappé sur un
<url-pattern>approprié couvrant les pages JSP présentant un intérêt, vous n'avez pas besoin de copier le même morceau de code dans l'ensemble des pages JSP.Si vous souhaitez appeler du code Java pour pré-traiter une requête, par exemple. préchargez une liste d'une base de données à afficher dans une table, en fonction de certains paramètres de requête, puis implémentez un servlet et écrivez le code en conséquence dans
doGet()méthode. Par exemple.:protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { try { List<Product> products = productService.list(); // Obtain all products. request.setAttribute("products", products); // Store products in request scope. request.getRequestDispatcher("/WEB-INF/products.jsp").forward(request, response); // Forward to JSP page to display them in a HTML table. } catch (SQLException e) { throw new ServletException("Retrieving products failed!", e); } }Cette façon de faire avec les exceptions est plus facile. L'accès à la base de données n'est pas en cours de rendu JSP, mais bien avant qu'il ne soit affiché. Vous avez toujours la possibilité de modifier la réponse chaque fois que l'accès à la base de données lève une exception. Dans l'exemple ci-dessus, la page d'erreur 500 par défaut s'affiche. Vous pouvez néanmoins la personnaliser à l'aide d'un
<error-page>dansweb.xml.Si vous souhaitez appeler du code Java pour post-traiter une requête, par ex. traiter un formulaire, puis implémenter une servlet et écrire le code en conséquence dans
doPost(). Par exemple.:protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { String username = request.getParameter("username"); String password = request.getParameter("password"); User user = userService.find(username, password); if (user != null) { request.getSession().setAttribute("user", user); // Login user. response.sendRedirect("home"); // Redirect to home page. } else { request.setAttribute("message", "Unknown username/password. Please retry."); // Store error message in request scope. request.getRequestDispatcher("/WEB-INF/login.jsp").forward(request, response); // Forward to JSP page to redisplay login form with error. } }Il est ainsi plus facile de gérer différentes destinations de pages de résultats: réafficher le formulaire avec des erreurs de validation en cas d’erreur (dans cet exemple particulier, vous pouvez le réafficher à l’aide de
${message}in EL ), ou simplement aller à la page cible souhaitée en cas de succès.Si vous souhaitez appeler du code Java pour contrôler le plan d'exécution et/ou la destination de la demande et de la réponse, implémentez un servlet selon le Pattern du contrôleur frontal de MVC . Par exemple.:
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { try { Action action = ActionFactory.getAction(request); String view = action.execute(request, response); if (view.equals(request.getPathInfo().substring(1)) { request.getRequestDispatcher("/WEB-INF/" + view + ".jsp").forward(request, response); } else { response.sendRedirect(view); } } catch (Exception e) { throw new ServletException("Executing action failed.", e); } }Ou simplement adopter un framework MVC comme JSF , Spring MVC , Wicket , etc pour que vous ne disposiez que d'une page JSP/Facelets et d'une classe JavaBean sans avoir besoin d'un servlet personnalisé.
Si vous souhaitez appeler du code Java pour contrôler le flux dans une page JSP, vous devez récupérer une balise de contrôle de flux (existante) telle que ). JSTL core . Par exemple. afficher
List<Product>dans une table:<%@ taglib uri="http://Java.Sun.com/jsp/jstl/core" prefix="c" %> ... <table> <c:forEach items="${products}" var="product"> <tr> <td>${product.name}</td> <td>${product.description}</td> <td>${product.price}</td> </tr> </c:forEach> </table>Avec des balises de style XML qui s'intègrent parfaitement dans tout ce code HTML, le code est mieux lisible (et donc mieux maintenable) qu'un groupe de scriptlets avec différentes accolades ouvrantes et fermantes ( " accolade appartiennent à? "). Une aide facile consiste à configurer votre application Web pour générer une exception chaque fois que des scriptlets sont toujours utilisés en ajoutant l'élément suivant à
web.xml:<jsp-config> <jsp-property-group> <url-pattern>*.jsp</url-pattern> <scripting-invalid>true</scripting-invalid> </jsp-property-group> </jsp-config>Dans Facelets , le successeur de JSP, qui fait partie du framework MVC Java fourni par EE JSF , il est déjà pas possible d'utiliser des scriptlets . De cette façon, vous êtes automatiquement obligé de faire les choses "dans le bon sens".
Si vous souhaitez appeler du code Java pour accéder et afficher des données "backend" dans une page JSP, vous devez utiliser EL (Expression Language), ces
${}des choses. Par exemple. réaffichage des valeurs d'entrée soumises:<input type="text" name="foo" value="${param.foo}" />${param.foo}affiche le résultat derequest.getParameter("foo").Si vous souhaitez appeler du code utilitaire Java directement dans la page JSP (généralement les méthodes
public static), vous devez les définir en tant que fonctions EL. Il y a un standard fonctions taglib dans JSTL, mais vous pouvez également créer facilement des fonctions vous-même . Voici un exemple de l'utilité de JSTLfn:escapeXmlpour empêcher XSSattaques .<%@ taglib uri="http://Java.Sun.com/jsp/jstl/functions" prefix="fn" %> ... <input type="text" name="foo" value="${fn:escapeXml(param.foo)}" />Notez que la sensibilité XSS n'est en aucun cas spécifiquement liée à Java/JSP/JSTL/EL/peu importe, ce problème doit être pris en compte dans toutes les applications Web que vous développez. Le problème de scriptlets est qu’il ne fournit aucun moyen de prévention intégrée, du moins qu’il n’utilise pas l’API Java standard. Le successeur de JSP, Facelets, a déjà implémenté l'échappement HTML, vous n'avez donc pas à vous soucier des trous XSS dans Facelets.
Voir également:
En tant que sauvegarde: Désactivez les scriptlets pour de bon
Comme ne autre question est en discussion, vous pouvez et devez toujours désactiver les scriptlets dans votre descripteur d'application Web web.xml.
Je le ferais toujours afin d'empêcher tout développeur d'ajouter des scriptlets, en particulier dans les grandes entreprises où vous perdriez la vue d'ensemble tôt ou tard. Les paramètres web.xml ressemblent à ceci:
<jsp-config>
<jsp-property-group>
<url-pattern>*.jsp</url-pattern>
<scripting-invalid>true</scripting-invalid>
</jsp-property-group>
</jsp-config>
JSTL propose des balises pour les conditions, les boucles, les ensembles, les gets, etc. Par exemple:
<c:if test="${someAttribute == 'something'}">
...
</c:if>
JSTL fonctionne avec les attributs de requête - ils sont le plus souvent définis dans la requête par un servlet qui transmet au JSP.
Je ne sais pas si je comprends bien.
Vous devriez lire quelque chose sur MVC. Spring MVC & Struts 2 sont les deux solutions les plus courantes.
Vous pouvez utiliser des balises JSTL avec des expressions EL pour éviter de mélanger Java et le code HTML:
<%@ page contentType="text/html;charset=UTF-8" language="Java" %>
<%@ taglib uri="http://Java.Sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://Java.Sun.com/jsp/jstl/fmt" prefix="fmt" %>
<html>
<head>
</head>
<body>
<c:out value="${x + 1}" />
<c:out value="${param.name}" />
// and so on
</body>
</html>
Il existe également des frameworks basés sur des composants, tels que Wicket, qui génèrent une grande partie du code HTML pour vous. Les balises qui se retrouvent dans le code HTML sont extrêmement basiques et il n’ya pratiquement aucune logique qui soit mélangée. Le résultat est presque vide, comme des pages HTML avec des éléments HTML typiques. L'inconvénient est qu'il y a beaucoup de composants dans l'API Wicket à apprendre et certaines choses peuvent être difficiles à réaliser avec ces contraintes.
Dans le modèle MVC Architectural, les JSP représentent la couche de vue. L’incorporation de code Java dans des fichiers JSP est considérée comme une mauvaise pratique. Vous pouvez utiliser JSTL , freeMarker , vélocité avec JSP comme "moteur de gabarit". Le fournisseur de données pour ces balises dépend des cadres avec lesquels vous traitez. Struts 2 et webwork en tant qu'implémentation pour MVC Pattern utilise OGNL "technique très intéressante pour exposer les propriétés de Beans à JSP".
L'expérience a montré que les JSP présentaient certaines lacunes, l'une d'entre elles étant difficile d'éviter de mélanger du balisage avec du code réel.
Si vous le pouvez, envisagez d'utiliser une technologie spécialisée pour ce que vous devez faire. Dans Java EE 6, il existe JSF 2.0, qui fournit de nombreuses fonctionnalités de Nice, notamment le collage de beans Java avec des pages JSF via la méthode #{bean.method(argument)}.
si vous voulez simplement éviter les inconvénients du codage Java dans JSP, vous pouvez le faire même avec des scriplets. Il suffit de suivre une certaine discipline pour avoir un minimum Java dans JSP et pratiquement aucun calcul ni logique dans la page JSP.
<%@ page contentType="text/html;charset=UTF-8" language="Java" %>
<%//instantiate a JSP controller
MyController clr = new MyController(request, response);
//process action if any
clr.process(request);
//process page forwaring if necessary
//do all variable assignment here
String showMe = clr.getShowMe();%>
<html>
<head>
</head>
<body>
<form name="frm1">
<p><%= showMe %>
<p><% for(String str : clr.listOfStrings()) { %>
<p><%= str %><% } %>
// and so on
</form>
</body>
</html>
Apprenez à personnaliser et à écrire vos propres tags en utilisant JSTL
Notez que EL est EviL (exceptions d'exécution, refactoring)
Le guichet peut également être diabolique (performances, laborieux pour les petites applications ou simple niveau de vue)
Exemple tiré de Java2s ,
Ceci doit être ajouté au web.xml de l'application web
<taglib>
<taglib-uri>/Java2s</taglib-uri>
<taglib-location>/WEB-INF/Java2s.tld</taglib-location>
</taglib>
créer un fichier: Java2s.tld dans le répertoire/WEB-INF /
<!DOCTYPE taglib
PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
"http://Java.Sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<!-- a tab library descriptor -->
<taglib xmlns="http://Java.Sun.com/JSP/TagLibraryDescriptor">
<tlib-version>1.0</tlib-version>
<jsp-version>1.2</jsp-version>
<short-name>Java2s Simple Tags</short-name>
<!-- this tag manipulates its body content by converting it to upper case
-->
<tag>
<name>bodyContentTag</name>
<tag-class>com.Java2s.BodyContentTag</tag-class>
<body-content>JSP</body-content>
<attribute>
<name>howMany</name>
</attribute>
</tag>
</taglib>
compilez le code suivant dans WEB-INF\classes\com\Java2s
package com.Java2s;
import Java.io.IOException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.BodyContent;
import javax.servlet.jsp.tagext.BodyTagSupport;
public class BodyContentTag extends BodyTagSupport{
private int iterations, howMany;
public void setHowMany(int i){
this.howMany = i;
}
public void setBodyContent(BodyContent bc){
super.setBodyContent(bc);
System.out.println("BodyContent = '" + bc.getString() + "'");
}
public int doAfterBody(){
try{
BodyContent bodyContent = super.getBodyContent();
String bodyString = bodyContent.getString();
JspWriter out = bodyContent.getEnclosingWriter();
if ( iterations % 2 == 0 )
out.print(bodyString.toLowerCase());
else
out.print(bodyString.toUpperCase());
iterations++;
bodyContent.clear(); // empty buffer for next evaluation
}
catch (IOException e) {
System.out.println("Error in BodyContentTag.doAfterBody()" + e.getMessage());
e.printStackTrace();
} // end of catch
int retValue = SKIP_BODY;
if ( iterations < howMany )
retValue = EVAL_BODY_AGAIN;
return retValue;
}
}
Démarrez le serveur et chargez le fichier bodyContent.jsp dans le navigateur.
<%@ taglib uri="/Java2s" prefix="Java2s" %>
<html>
<head>
<title>A custom tag: body content</title>
</head>
<body>
This page uses a custom tag manipulates its body content.Here is its output:
<ol>
<Java2s:bodyContentTag howMany="3">
<li>Java2s.com</li>
</Java2s:bodyContentTag>
</ol>
</body>
</html>
Le guichet est également une alternative qui sépare complètement Java du code HTML, afin qu'un concepteur et un programmeur puissent travailler ensemble et sur différents ensembles de code avec une compréhension réduite de l'autre.
Regarde Wicket.
Vous avez soulevé une bonne question et bien que vous ayez de bonnes réponses, je vous suggérerais de vous débarrasser de JSP. C'est une technologie obsolète qui finira par mourir. Utilisez une approche moderne, comme les moteurs de gabarit. Vous aurez une séparation très claire des couches métier et présentation, et certainement pas de code Java dans les modèles. Vous pouvez ainsi générer des modèles directement à partir du logiciel d'édition de présentation Web, en utilisant le plus souvent WYSIWYG.
Et évitez bien sûr les filtres et les pré et post-traitements, sinon vous pourriez avoir des problèmes de support/débogage car vous ne savez toujours pas où la variable obtient la valeur.
afin d'éviter Java le code dans les fichiers JSP, Java fournit désormais des bibliothèques de balises telles que JSTL, et Java a mis au point JSF dans lequel vous pouvez écrire toutes les structures de programmation. la forme des tags
Peu importe ce que vous essayez d'éviter, lorsque vous travaillez avec d'autres développeurs, certains préfèrent quand même préférer Scriptlet, puis insérer le code malveillant dans le projet. Par conséquent, la configuration du projet au premier signe est très importante si vous souhaitez vraiment réduire le code de scriptlet. Il existe plusieurs techniques pour surmonter ce problème (y compris plusieurs cadres mentionnés par d’autres). Toutefois, si vous préférez la méthode JSP pure, utilisez le fichier de balise JSTL. La bonne chose à ce sujet est que vous pouvez également configurer des pages maîtres pour votre projet, de sorte que les autres pages puissent hériter des pages maîtres.
Créez une page principale appelée base.tag sous vos balises WEB-INF/avec le contenu suivant
<%@tag description="Overall Page template" pageEncoding="UTF-8"%> <%@attribute name="title" fragment="true" %> <html> <head> <title> <jsp:invoke fragment="title"></jsp:invoke> </title> </head> <body> <div id="page-header"> .... </div> <div id="page-body"> <jsp:doBody/> </div> <div id="page-footer"> ..... </div> </body> </html>
Sur cette page, j'ai créé un fragment appelé "titre", de sorte que dans la page enfant, je puisse insérer plus de codes à cet endroit de la page maître. De plus, la balise <jsp:doBody/> sera remplacée par le contenu de la page enfant.
Créer une page enfant (child.jsp) dans votre dossier WebContent:
<%@ taglib prefix="t" tagdir="/WEB-INF/tags" %> <t:base> <jsp:attribute name="title"> <bean:message key="hello.world" /> </jsp:attribute> <jsp:body> [Put your content of the child here] </jsp:body> </t:base>
<t:base> permet de spécifier le gabarit que vous souhaitez utiliser (c'est-à-dire base.tag pour le moment). Tout le contenu de la balise <jsp:body> remplace ici le <jsp:doBody/> de votre page maître. Votre page enfant peut également inclure n’importe quel tag lib et vous pouvez l’utiliser normalement comme l’autre. Cependant, si vous utilisez un code de scriptlet ici (<%= request.getParameter("name") %> ...) et essayez d’exécuter cette page, vous obtiendrez un JasperException because Scripting elements ( <%!, <jsp:declaration, <%=, <jsp:expression, <%, <jsp:scriptlet ) are disallowed here. Par conséquent, il est impossible pour d’autres personnes d’inclure le code malveillant dans le fichier jsp.
en appelant cette page depuis votre contrôleur:
Vous pouvez facilement appeler le fichier child.jsp à partir de votre contrôleur. Cela fonctionne également bien avec le cadre struts
Utilisez JSTL Tag libraries dans JSP, cela fonctionnera parfaitement.
Utilisez simplement la balise JSTL et l'expression EL.
Si quelqu'un est vraiment contre la programmation dans plus d'une langue, je suggère GWT, théoriquement, vous pouvez éviter tous les éléments JS et HTML, car Google Toolkit transforme tout le code client et le code partagé en JS, vous avez gagné ' Vous n’avez pas de problème avec eux, vous avez donc un service Web sans coder dans une autre langue. Même vous pouvez utiliser des CSS par défaut quelque part, comme cela est donné par des extensions (smartGWT ou Vaadin). Vous n'avez pas besoin d'apprendre des dizaines d'annotations.
Bien sûr, si vous le souhaitez, vous pouvez vous plonger dans les profondeurs du code et injecter JS et enrichir votre page HTML, mais vous pouvez réellement l'éviter si vous le souhaitez, et le résultat sera bon, car il a été écrit dans d'autres frameworks. Je dis qu'il vaut la peine d'essayer, et le GWT de base est bien documenté.
Et bien sûr, de nombreux autres programmeurs ont décrit ou recommandé plusieurs autres solutions. GWT est destiné aux personnes qui ne souhaitent vraiment pas utiliser la WebPart ou la minimiser.
Une bonne idée tirée du monde Python est: Langage d'attribut de modèle ; TAL a été introduit par Zope (donc "Zope Page Templates", ZPT) et est un standard, avec des implémentations en PHP, XSLT et Java également (j'ai utilisé Python/Zope et PHP incarnations). Dans cette classe de langages de templates, un exemple ci-dessus pourrait ressembler à ceci:
<table>
<tr tal:repeat="product products">
<td tal:content="product/name">Example product</td>
<td tal:content="product/description">A Nice description</td>
<td tal:content="product/price">1.23</td>
</tr>
</table>
Le code ressemble à du HTML ordinaire (ou XHTML) plus quelques attributs spéciaux dans un espace de noms XML; il peut être visualisé avec un navigateur et peut être modifié en toute sécurité par un concepteur. Il existe un support pour les macros et pour i18n également:
<h1 i18n:translate="">Our special offers</h1>
<table>
<tr tal:repeat="product products">
<td tal:content="product/name"
i18n:translate="">Example product</td>
<td tal:content="product/description"
i18n:translate="">A Nice description</td>
<td tal:content="product/price">1.23</td>
</tr>
</table>
Si des traductions du contenu sont disponibles, elles sont utilisées.
Je ne sais pas beaucoup sur le implémentation Java , cependant.
L'utilisation de scriptlets dans les fichiers JSP n'est pas une bonne pratique.
Au lieu de cela, vous pouvez utiliser:
- Balises JSTL
- Expressions EL
- Balises personnalisées: vous pouvez définir vos propres balises à utiliser.
Prière de se référer à:
Bien sûr, remplacez <%! counter++; %> par une architecture producteur/consommateur d'événements, où la couche de gestion est informée de la nécessité d'incrémenter le compteur, réagit en conséquence et informe les présentateurs afin qu'ils mettent à jour les vues. Un certain nombre de transactions de base de données sont impliquées, car à l'avenir, nous devrons connaître la valeur nouvelle et ancienne du compteur, qui l'a incrémentée et dans quel but. Il est évident que la sérialisation est impliquée, car les couches sont entièrement découplées. Vous pourrez incrémenter votre compteur sur RMI, IIOP, SOAP. Mais seul le code HTML est requis, ce que vous n'implémentez pas, car il s'agit d'un cas banal. Votre nouvel objectif est d’atteindre 250 incréments par seconde sur votre nouveau serveur brillant E7, 64 Go RAM.
J'ai plus de 20 ans d'expérience en programmation, la plupart des projets échouent avant le sextet: Réutilisabilité Remplaçabilité OO-capacité Debuggabilité Testabilité La maintenabilité est même nécessaire. D'autres projets, dirigés par des personnes qui ne s'intéressaient qu'à la fonctionnalité, ont rencontré un vif succès. En outre, la structure d'objet rigide, mise en œuvre trop tôt dans le projet, empêche le code de s'adapter aux modifications drastiques des spécifications (également appelé agile).
Je considère donc comme une procrastination le fait de définir des "couches" ou des structures de données redondantes, soit au début du projet, soit lorsque cela n’est pas spécifiquement requis.
Techniquement, les fichiers JSP sont tous convertis en servlets lors de l'exécution. JSP a été créé à l'origine pour découpler la logique métier et la logique de conception, en suivant le modèle MVC. Donc, JSP est techniquement tous les codes Java lors de l'exécution. Mais pour répondre à la question, les bibliothèques de balises sont généralement utilisées pour appliquer une logique (suppression des codes Java) aux pages JSP.
Si nous utilisons les éléments suivants dans une application Web Java, le code Java peut être éliminé du premier plan du JSP.
Utiliser l'architecture MVC pour une application Web
Utiliser les tags JSP
une. Tags standard
b. Tags personnalisés
Langage d'expression
Comment éviter le code Java dans les fichiers JSP?
Vous pouvez utiliser des balises de bibliothèque d'onglets comme JSTL en plus du langage d'expression (EL). Mais EL ne fonctionne pas bien avec JSP. Il est donc probablement préférable de supprimer complètement JSP et d’utiliser Facelets .
Facelets est le premier langage de déclaration de page autre que JSP conçu pour JSF (Java Server Faces) qui fournit aux développeurs JSF un modèle de programmation plus simple et plus puissant que le JSP. Il résout différents problèmes dans JSP pour le développement d'applications Web.
L'utilisation de scriptlets est une méthode très ancienne et non recommandée. Si vous voulez générer directement quelque chose dans vos pages JSP, utilisez simplement Expression Language (EL) avec JSTL.
Il existe également d’autres options, telles que l’utilisation d’un moteur de création de modèles, telles que Velocity, Freemarker, Thymeleaf, etc. Mais l’utilisation de JSP standard avec EL et JSTL me sert la plupart du temps et semble aussi la plus simple pour un débutant.
En outre, notez qu'il n'est pas recommandé de créer de la logique métier dans la couche de vue. Vous devez effectuer votre logique d'entreprise dans la couche Service et transmettre le résultat de la sortie à vos vues via un contrôleur.
Rien de tout cela n'est plus utilisé, mon ami, mon conseil est de découpler la vue (css, html, javascript, etc.) du serveur.
Dans mon cas, mes systèmes traitent la vue avec Angular et toutes les données nécessaires sont transférées du serveur à l'aide de services de repos.
Croyez-moi, cela va changer votre façon de concevoir
Utilisez backbone, angular, comme le framework javascript pour la conception d'interface utilisateur, et récupérez les données à l'aide de rest api. Cela supprimera complètement la dépendance Java de l'interface utilisateur.
JSP 2.0 a une fonctionnalité appelée "Tag Files", vous pouvez écrire des tags sans code Java externe et tld externe. Vous devez créer un fichier .tag et le placer dans WEB-INF\tags. Vous pouvez même créer une structure de répertoires pour conditionner vos balises.
Par exemple:
/WEB-INF/tags/html/label.tag
<%@tag description="Rensders a label with required css class" pageEncoding="UTF-8"%>
<%@attribute name="name" required="true" description="The label"%>
<label class="control-label control-default" id="${name}Label">${name}</label>
Utilisez-le comme
<%@ taglib prefix="h" tagdir="/WEB-INF/tags/html"%>
<h:label name="customer name" />
En outre, vous pouvez lire facilement le corps de la balise
/WEB-INF/tags/html/bold.tag
<%@tag description="Bold tag" pageEncoding="UTF-8"%>
<b>
<jsp:doBody/>
</b>
Utilise le
<%@ taglib prefix="h" tagdir="/WEB-INF/tags/bold"%>
<h:bold>Make me bold</h:bold>
Les exemples sont très simples, mais vous pouvez effectuer de nombreuses tâches compliquées ici. Veuillez considérer que vous pouvez utiliser d’autres balises (par exemple: JSTL qui possède des balises de contrôle telles que if/forEcah/chosen une manipulation de texte telle que format/contains/uppercase ou même des balises SQL select/update), transmettez tous les paramètres exemple Hashmap, accédez à session, request, ... dans votre fichier de balise également.
Tag File sont si faciles à développer que vous n’aviez pas besoin de redémarrer le serveur pour les modifier, comme les fichiers JSP. Cela les rend faciles pour le développement.
Même si vous utilisez un framework tel que Struts 2, qui contient beaucoup de bonnes balises, vous constaterez peut-être qu'avoir vos propres balises peut considérablement réduire votre code. Vous pouvez transmettre vos paramètres de balise à struts et ainsi personnaliser votre balise de structure.
Vous pouvez utiliser tag non seulement pour éviter Java, mais également pour réduire vos codes HTML. J'essaie moi-même de réviser les codes HTML et de construire des balises dès que les doublons de code commencent dans mes pages.
(Même si vous finissez par utiliser le Java dans votre code JSP, ce que j'espère, vous pouvez l'encapsuler dans une balise)
- Définissez vos valeurs et paramètres dans vos classes de servlet
- Récupérez ces valeurs et paramètres dans votre JSP à l'aide de JSTL/Taglib
La bonne chose à propos de cette approche est que votre code est aussi du code HTML!
Comme beaucoup de réponses le disent, utilisez JSTL ou créez vos propres balises personnalisées. Ici est une bonne explication sur la création de balises personnalisées
En utilisant les balises JSTL avec l'expression EL, vous pouvez éviter cela. Mettez les choses suivantes dans votre page jsp:
<%@ page contentType="text/html;charset=UTF-8" language="Java" %>
<%@ taglib uri="http://Java.Sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://Java.Sun.com/jsp/jstl/fmt" prefix="fmt" %>