Comment éviter le code Java dans les fichiers JSP?

Je suis nouveau à 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 la version 2 de JSP il existe une méthode pour éviter le code Java dans les fichiers JSP. Est-ce que quelqu'un peut s'il vous plaît me dire l'alternative JSP 2 lignes, et ce que cette technique est appelé?

1543
demandé sur Francesco Menzani 2010-07-05 11:24:06
la source

29 ответов

l'utilisation de scriptlets (ces "choses 151980920") dans JSP est en effet fortement découragé depuis la naissance de taglibs (comme JSTL ) et EL ( Expression Language , those ${} things) way back in 2001.

les principaux inconvénients de scriptlets sont:

  1. réutilisable: vous ne pouvez pas réutiliser les scriptlets.
  2. Remplacement: vous ne pouvez pas faire les scriptlets abstrait.
  3. OO-capacité: vous ne pouvez pas faire usage de l'héritage et de composition.
  4. Débuggability: si scriptlet lance une exception à mi-chemin, tout ce que vous obtenez est une page blanche.
  5. Testabilité: les scriptlets ne sont pas de l'unité-testable.
  6. maintenabilité: par saldo plus de temps est nécessaire pour maintenir la logique de code mêlée/encombrée/dupliquée.

Sun Oracle lui-même recommande également dans le JSP conventions de codage d'éviter l'utilisation de scriptlets chaque fois que la même fonctionnalité est possible par (tag) des classes. Voici plusieurs cites pertinentes:

de la spécification JSP 1.2, il est fortement recommandé que la bibliothèque JSP Standard Tag Library (JSTL) soit utilisée 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 à tenir à jour.

...

dans la mesure du possible, éviter les scriptlets JSP chaque fois que les bibliothèques d'étiquettes offrent des fonctionnalités équivalentes. Cela rend les pages plus faciles à lire et à maintenir, aide à séparer la logique d'affaires de la logique de présentation, et rendra vos pages plus faciles à évoluer dans les pages de style JSP 2.0 (la spécification JSP 2.0 prend en charge, mais met l'accent sur l'utilisation des scriptlets).

...

dans l'esprit de l'adoption du modèle de contrôleur de vue de modèle (MVC) afin de réduire l'accouplement entre couche de présentation de la logique d'entreprise, JSP scriptlets ne doivent pas être utilisées pour l'écriture de la logique. Les scriptlets JSP sont plutôt utilisés si nécessaire pour transformer les données (aussi appelées "objets de valeur") retournées à partir du traitement des requêtes du client dans un format approprié prêt à recevoir le client. Même dans ce cas, il serait préférable d'utiliser un servlet de contrôleur front ou une étiquette personnalisée.


comment remplacer scriptlets dépend entièrement du seul but du code/logique. Plus que souvent ce code doit être placé dans une classe Java fullworthy:

  • si vous souhaitez invoquer le même code Java sur chaque requête, moins ou plus indépendamment de la page demandée, p.ex. vérification si un utilisateur est connecté, puis mettre en œuvre un filtre et inscrire le code en conséquence dans la méthode 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.
        }
    }
    

    lorsqu'il est cartographié sur un <url-pattern> approprié couvrant les pages de JSP d'intérêt, alors vous n'avez pas besoin de copier le même morceau de code sur toutes les pages de JSP.


  • si vous voulez invoquer un code Java pour préprocesseur une requête, p.ex. précharger une liste à partir d'une liste base de données pour afficher dans une certaine table, si nécessaire basée sur certains paramètres de requête, puis mettre en œuvre un servlet et écrire 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 traiter les exceptions est plus facile. La base de données N'est pas accessible au milieu du rendu JSP, mais bien avant que le JSP ne soit affiché. Vous avez toujours la possibilité de changer la réponse à chaque fois que L'accès DB exception. Dans l'exemple ci-dessus, l'erreur par défaut 500 page sera affichée que vous pouvez de toute façon personnaliser par un <error-page> dans web.xml .


  • si vous voulez invoquer un code Java pour postprocess une requête, p.ex. le traitement d'un formulaire soumettre, puis mettre en œuvre un servlet et écrire le code en conséquence dans doPost() méthode. E. g.:

    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.
        }
    }
    

    cette façon de traiter avec différentes destinations de la page de résultat est plus facile: rejouer le formulaire avec des erreurs de validation en cas d'une erreur (dans cet exemple particulier, vous pouvez rejouer en utilisant ${message} dans EL ), ou tout simplement prendre la page cible désirée en cas de succès.


  • si vous voulez invoquer du code Java pour le plan d'exécution et/ou la destination de la requête et de la réponse, puis mettre en œuvre un servlet selon le Mvc's front Controller Pattern . 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 tout simplement adopter un cadre MVC comme JSF , MVC printemps , Wicket , etc afin que vous finissiez avec juste une page JSP / Facelets et une classe Javabean sans la nécessité d'un servlet.


  • si vous voulez invoquer du code Java pour contrôler le flux à l'intérieur d'une page JSP, alors vous devez saisir un taglib (existant) de contrôle du flux comme JSTL core . E. g. l'affichage de List<Product> dans un tableau:

    <%@ 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'inscrivent bien dans tout ce HTML, le code est plus lisible (et donc mieux maintenable) qu'un tas de scriptlets avec divers accolades d'ouverture et de fermeture ( "où diable cette accolade de fermeture appartient-elle?" ). Une aide facile est de configurer votre application web pour lancer une exception chaque fois que scriptlets sont encore utilisés en ajoutant le morceau 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 de la Java EE fourni MVC framework JSF , il est déjà Non possible d'utiliser scriptlets . De cette façon, vous êtes automatiquement forcé de faire les choses "de la bonne façon".


  • si vous voulez invoquer un code Java pour accéder et afficher "sauvegarder" des données à l'intérieur d'une page JSP, alors vous devez utiliser EL (Expression Language), ceux ${} des choses. E. g. l'affichage des présenté des valeurs de saisie:

    <input type="text" name="foo" value="${param.foo}" />
    

    le ${param.foo} affiche le résultat de request.getParameter("foo") .


  • si vous voulez invoquer quelque utility code Java directement dans la page JSP (typiquement public static méthodes), alors vous devez les Définir comme des fonctions EL. Il y a un standard fonctions taglib dans JSTL, mais vous pouvez aussi facilement créer des fonctions vous-même . Voici un exemple comment JSTL fn:escapeXml est utile pour prévenir XSS attaques .

    <%@ 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/whatever, ce problème doit être pris en compte dans chaque webapplication que vous développez. Le problème de scriptlets est qu'il ne fournit aucun moyen de prévention de builtin, du moins pas en utilisant L'API Java standard. Le successeur de JSP, Facelets, a déjà une sortie HTML implicite, donc vous n'avez pas à vous soucier des trous XSS dans les Facelets.

voir aussi:

1864
répondu BalusC 2018-06-08 11:34:53
la source

comme garantie: désactiver les Scriptlets pour de bon

Comme une autre question est en train de discuter, vous pouvez toujours désactiver les scriptlets dans votre web.xml web descripteur de l'application.

je ferais toujours cela afin d'empêcher tout développeur d'ajouter des scriptlets, surtout dans les grandes entreprises où vous perdrez 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>
208
répondu Stefan Schubert-Peters 2017-05-23 13:31:37
la source

JSTL propose des tags pour conditionals, loops, sets, gets, etc. Par exemple:

<c:if test="${someAttribute == 'something'}">
   ...
</c:if>

JSTL fonctionne avec les attributs request - ils sont le plus souvent définis dans la requête par un Servlet, qui transmet au JSP.

103
répondu Bozho 2016-07-22 15:17:16
la source

Je ne suis pas sûr que ce soit correct.

vous devriez lire quelque chose à propos de MVC. Spring MVC & Struts 2 sont les deux plus courants.

56
répondu tzim 2010-07-05 11:59:55
la source

vous pouvez utiliser les balises JSTL avec les expressions EL pour éviter de mélanger le code Java et 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>
49
répondu Behrang 2018-10-08 18:36:41
la source

il y a aussi des cadres basés sur des composants comme Wicket qui génèrent beaucoup de HTML pour vous. Les balises qui se retrouvent dans le HTML sont extrêmement basiques et il n'y a pratiquement aucune logique qui se mélange. 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 à apprendre dans L'API Wicket et que certaines choses peuvent être difficiles à réaliser sous ces contraintes.

32
répondu tsand 2011-03-22 21:24:53
la source

dans le dessin Architectural MVC, les JSPs représentent la couche View. Intégrer du code java dans JSPs est considéré comme une mauvaise pratique. Vous pouvez utiliser JSTL , freeMarker , velocity avec JSP comme " modèle de moteur". Le fournisseur de données à ces étiquettes dépend des cadres que vous traitez. Struts 2 et webwork en tant que mise en œuvre pour les utilisations du modèle MVC OGNL "très technique intéressante pour exposer les Haricots Propriétés de JSP ".

29
répondu Sami Jmii 2016-10-06 21:13:19
la source

L'expérience a montré que les JSP ont quelques défauts, l'un d'eux étant difficile d'éviter de mélanger le markup avec le code réel.

si vous le pouvez, alors envisagez d'utiliser une technologie spécialisée pour ce que vous devez faire. En Java EE 6, Il y a JSF 2.0, qui fournit beaucoup de belles fonctionnalités, y compris le collage des fèves de Java avec les pages JSF à travers l'approche #{bean.method(argument)} .

25
répondu Thorbjørn Ravn Andersen 2010-07-05 12:30:06
la source

Wicket est également une alternative qui sépare complètement java du html, de sorte qu'un concepteur et un programmeur peuvent travailler ensemble et sur différents ensembles de code avec peu de compréhension de l'autre.

regardez Wicket.

23
répondu msj121 2011-05-21 00:42:34
la source

si vous voulez simplement éviter les inconvénients du codage Java dans JSP, vous pouvez le faire même avec les scripts. Il suffit de suivre une certaine discipline pour avoir un minimum de Java dans JSP et presque pas de calcul et de 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>
23
répondu dipu 2015-12-07 13:40:28
la source

apprendre à personnaliser et à écrire vos propres étiquettes en utilisant JSTL

notez que EL est EviL (runtime exceptions, refactoring)

Wicket peut être mauvais aussi (performance, toilette pour les petites applications ou simple vue niveau)



Exemple de java2s ,

ceci doit être ajouté au web de l'application web.XML

<taglib>
    <taglib-uri>/java2s</taglib-uri>
    <taglib-location>/WEB-INF/java2s.tld</taglib-location>
</taglib>

créer Fichier:java2s.tld in the / 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>

compiler 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émarrer le serveur et charger le contenu du corps.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>
23
répondu tomasb 2016-03-08 13:44:33
la source

vous avez posé une bonne question et bien que vous ayez eu de bonnes réponses, je vous suggérerais de vous débarrasser de JSP. C'est une technologie dépassée, qui finira par mourir. Utilisez une approche moderne, comme les moteurs de modèle. Vous aurez une séparation très claire des couches d'affaires et de présentation, et certainement pas de code Java dans les gabarits, de sorte que vous pouvez générer des gabarits directement à partir du logiciel d'édition de présentation web, dans la plupart des cas en utilisant WYSIWYG.

Et certainement rester à l'écart de filtres et pré-et post-traitement, sinon vous pouvez faire face à des difficultés de support/débogage car vous ne savez pas toujours où la variable obtient la valeur.

22
répondu Dmitriy R 2014-04-20 04:02:46
la source

afin d'éviter le code java dans les fichiers JSP, java fournit maintenant des bibliothèques de balises comme JSTL. java a aussi créé JSF dans laquelle u peut écrire toutes les structures de programmation sous forme de balises

20
répondu mahesh 2011-02-23 09:14:50
la source

, peu importe combien vous essayez d'éviter, lorsque vous travailler avec d'autres développeurs, certains d'entre eux préfèrent encore scriptlet puis insérez le mal de code dans le projet. Par conséquent, configurer le projet au premier signe est très important si vous voulez vraiment réduire le code du script. Il y a plusieurs techniques pour surmonter cela (y compris plusieurs cadres que d'autres ont mentionnés). Cependant, si vous préférez la méthode JSP pure, alors utilisez le fichier de balise JSTL. La bonne chose à ce sujet est que vous peut également mettre en place des pages de maître pour votre projet, de sorte que les autres pages peuvent hériter les pages de maître

créer une page principale appelée base.étiquette sous votre WEB-INF/tags 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 de mater, j'ai créé un fragment appelé" title", pour que dans la page enfant, je puisse insérer plus de codes dans cet endroit de la page principale. En outre ,l'étiquette <jsp:doBody/> sera remplacé par le contenu de la page enfant

créer une page enfant (enfant.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> est utilisé pour spécifier la page principale que vous voulez utiliser (qui est la base.tag en ce moment). Tout le contenu à l'intérieur de l'étiquette <jsp:body> ici remplacera le <jsp:doBody/> sur votre page principale. Votre page enfant peut également inclure n'importe quelle étiquette lib et vous pouvez l'utiliser normalement comme l'autre mentionné. Cependant, si vous utilisez un code scriptlet ici ( <%= request.getParameter("name") %> ...) et essayez d'exécuter cette page, vous obtiendrez un JasperException because Scripting elements ( &lt;%!, &lt;jsp:declaration, &lt;%=, &lt;jsp:expression, &lt;%, &lt;jsp:scriptlet ) are disallowed here . Par conséquent, il n'y a aucun moyen que d'autres personnes puissent inclure le code mal dans le fichier jsp

appelant cette page depuis votre contrôleur:

Vous pouvez facilement appeler l'enfant.fichier jsp de votre contrôleur. Cela fonctionne aussi bien avec le cadre des entretoises

20
répondu Thai Tran 2013-01-26 22:07:56
la source

utiliser JSTL Tag libraries dans JSP, qui fonctionnera parfaitement.

18
répondu Chandra Sekhar 2011-06-05 08:23:50
la source

utilisez simplement L'étiquette JSTL et l'expression EL.

17
répondu tanglei 2011-07-11 10:59:59
la source

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, parce que Google Toolkit transforme tous les clients et le code partagé à JS, vous n'aurez pas de problème avec eux, de sorte que vous avez un service Web sans codage dans d'autres langues. Même vous pouvez utiliser certains CSS par défaut de quelque part comme il est donné par les extensions (smartGWT ou Vaadin). Vous n'avez pas besoin d'apprendre des dizaines d' annotation.

bien sûr, si vous voulez, vous pouvez vous Hacker dans les profondeurs du code et injecter JS et enrichir votre page HTML, mais vraiment vous pouvez l'éviter si vous voulez, et le résultat sera bon comme il a été écrit dans d'autres cadres. Je dis qu'il vaut la peine d'essayer, et le GWT de base est bien documenté.

et bien sûr beaucoup d'autres programmeurs ont décrit ou recommandé par la présente plusieurs autres solutions. GWT est pour les gens qui ne veulent vraiment pas de deal avec la partie web ou pour la minimiser.

16
répondu CsBalazsHungary 2013-03-19 17:00:10
la source

a neat idea from the Python world are Template attribut languages ; TAL a été introduit par Zope (donc un.K. A. "Zope Page Templates", ZPT) et est un standard, avec des implémentations en PHP, XSLT et Java aussi (j'ai utilisé les incarnations Python/Zope et PHP). Dans cette classe de langues de templating, 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 à HTML ordinaire (ou XHTML) plus quelques attributs spéciaux dans un espace-nom XML, il peut être visualisé avec un navigateur et modifié en toute sécurité par un concepteur. Il y a un support pour les macros et pour i18n aussi bien:

<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 grand chose sur le Java implementation , cependant.

15
répondu Tobias 2012-06-13 12:42:53
la source

utiliser des scriptlets dans JSPs n'est pas une bonne pratique.

à la place, vous pouvez utiliser:

  1. balises JSTL
  2. EL expressions
  3. étiquettes personnalisées-vous pouvez définir vos propres étiquettes à utiliser.

prière de se référer à:

  1. http://docs.oracle.com/javaee/1.4/tutorial/doc/JSTL3.html
  2. EL
14
répondu kapil das 2013-11-22 20:02:02
la source

bien sûr, remplacer <%! counter++; %> par une architecture producteur d'événements-consommateur, où la couche affaires est informée de la nécessité d'augmenter le compteur, il 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 aurons besoin de connaître la valeur nouvelle et ancienne du compteur, qui l'a incrémenté et avec quel but à l'esprit. Évidemment la sérialisation est impliquée, puisque les couches sont entièrement découplé. Vous pourrez incrémenter votre compteur sur RMI, IIOP, SOAP. Mais seul le HTML est requis, ce que vous n'implémentez pas, car c'est un cas si banal. Votre nouvel objectif est d'atteindre 250 incréments par seconde sur votre nouveau serveur RAM brillant E7, 64 Go.

j'ai plus de 20 ans de programmation, la plupart des projets échouent avant le sextet: la réutilisation de la Remplaçabilité oo-capacité de Débuggabilité testabilité maintenabilité est même nécessaire. D'autres projets, dirigés par des personnes qui seulement soucié de la fonctionnalité, ont été extrêmement fructueux. En outre, la structure rigide de l'objet, mise en œuvre trop tôt dans le projet, rend le code incapable d'être adapté aux changements drastiques dans les spécifications (aka agile).

C'est pourquoi je considère comme une procrastination l'activité consistant à définir des" couches " ou des structures de données redondantes soit au début du projet, soit lorsqu'elles ne sont pas spécifiquement requises.  

12
répondu Razvan 2017-11-22 15:22:43
la source

techniquement, JSP sont tous convertis en Servlets pendant l'exécution . JSP a d'abord été créé dans le but de découpler la logique opérationnelle et la logique de conception, en suivant le modèle MVC. Donc JSP sont techniquement tous les codes java pendant l'exécution. Mais pour répondre à la question, les bibliothèques de balises sont généralement utilisées pour appliquer la logique (suppression des codes Java) aux pages JSP.

11
répondu mel3kings 2013-06-14 13:31:31
la source

si nous utilisons les éléments suivants dans une application Web java, le code java peut être éliminé de l'avant-plan du JSP.

  1. utiliser l'architecture MVC pour l'application web

  2. Utiliser les Balises JSP

    A. Étiquettes Standard

    B. Étiquettes Personnalisées

  3. Langage D'Expression

9
répondu Ajay Takur 2012-06-08 07:10:48
la source

Comment éviter le code Java dans les fichiers JSP?

vous pouvez utiliser des étiquettes de bibliothèque de tabulation comme JSTL en plus de la langue D'Expression ( EL ). Mais EL ne fonctionne pas bien avec JSP. Il est donc probablement préférable de laisser tomber JSP complètement et d'utiliser Facelets .

Facelets est la première déclaration de page non JSP langage conçu pour JSF (Java Server Faces) qui a fourni un modèle de programmation plus simple et plus puissant aux développeurs JSF par rapport à JSP. Il résout différents problèmes se produit dans JSP pour le développement d'applications web.

enter image description here

5
répondu Yster 2015-12-24 14:47:27
la source

L'utilisation de Scriptlets est une manière très ancienne et non recommandée. Si vous voulez produire directement quelque chose dans vos pages JSP il suffit d'utiliser Expression Language(EL) avec JSTL .

Il ya aussi d'autres options telles que l'utilisation d'un moteur de templating comme la vitesse, Freemarker, Thymeleaf etc Mais l'utilisation de JSP simple avec EL et JSTL sert mon but la plupart du temps et il semble également le plus simple pour un débutant.

aussi, prenez note que ce n'est pas une bonne pratique de faire de la logique d'affaires dans la couche view, vous devriez effectuer vos logiques d'affaires dans la couche Service, et passez le résultat de la sortie à vos vues à travers un contrôleur.

2
répondu adn.911 2017-11-30 18:59:33
la source

rien de ce qui est utilisé plus mon ami, mon conseil est de découpler la vue(css, html, javascript, etc) du serveur.

dans mon cas, je fais mes systèmes de manipulation de la vue avec angle et toutes les données nécessaires sont apportées à partir du serveur en utilisant des services de repos.

croyez-moi, cela va changer la façon dont vous concevez

2
répondu Eduardo 2017-12-12 22:45:33
la source

utiliser l'épine dorsale, angulaire comme le cadre javascript pour la conception D'UI et récupérez les données en utilisant l'api rest. Cela supprimera complètement la dépendance de java de L'interface utilisateur.

2
répondu Sumesh TG 2018-06-20 16:49:13
la source

JSP 2.0 a une fonctionnalité appelée " Tag Files " , vous pouvez écrire des tags sans code java externe et tld . Vous devez créer un fichier .tag et le mettre dans WEB-INF\tags vous pouvez même créer une structure de répertoire pour empaqueter vos tags.

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>

Utiliser comme

<%@ taglib prefix="h" tagdir="/WEB-INF/tags/html"%>
<h:label  name="customer name" />

vous pouvez aussi lire le corps de l'étiquette easly

/WEB-INF/tags/html/bold.tag
<%@tag description="Bold tag" pageEncoding="UTF-8"%>
<b>
  <jsp:doBody/>
</b>

Utiliser

<%@ taglib prefix="h" tagdir="/WEB-INF/tags/bold"%>
<h:bold>Make me bold</h:bold>

Les échantillons sont très simple, mais vous pouvez faire beaucoup de tâches compliquées ici. S'il vous plaît considérer que vous pouvez utiliser d'autres tags (par exemple: JSTL qui a des tags de contrôle comme if/forEcah/chosen manipulation de texte comme format/contains/uppercase ou même SQL tags select/update ), passer tous les paramètres de type, par exemple Hashmap , l'accès session , request , ... dans votre fichier de balise trop.

Fichier De Balises sont si faciles à développer que vous n'avez pas besoin de redémarrer le serveur lors de leur modification, comme les fichiers jsp. Cela le rend facile pour le développement.

même si vous utilisez un cadre comme struts 2, qui ont beaucoup de bonnes étiquettes, vous pouvez trouver qu'avoir vos propres étiquettes peut réduire votre code beaucoup. Vous pouvez passer vos paramètres de balise à struts et ainsi personnaliser votre balise framework.

vous pouvez utiliser tag non seulement pour éviter java, mais aussi de minimiser votre Les codes HTML. J'essaie moi-même de réviser les codes HTML et de construire des tags beaucoup dès que les doublons de code voir commencent dans mes pages.

(même si vous finissez par utiliser le code java dans votre JSP, ce que je ne souhaite pas, vous pouvez encapsuler ce code dans une étiquette)

1
répondu Alireza Fattahi 2016-04-12 17:55:51
la source

comme beaucoup de réponses le disent, utilisez JSTL ou créez vos propres étiquettes personnalisées. ici est une bonne explication sur la création d'étiquettes personnalisées

0
répondu Code_Mode 2017-07-07 23:24:49
la source

en utilisant les tags 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" %>
-1
répondu bhanwar rathore 2016-09-13 11:43:25
la source

Autres questions sur java jsp scriptlet