java - beispiel - jstl




Wie vermeidet man Java-Code in JSP-Dateien? (19)

Die Erfahrung hat gezeigt, dass JSPs einige Mängel aufweisen, von denen einer schwer zu vermeiden ist, Markup mit tatsächlichem Code zu mischen.

Wenn Sie können, dann überlegen Sie sich, eine spezielle Technologie für das zu verwenden, was Sie tun müssen. In Java EE 6 gibt es JSF 2.0, das viele nette Funktionen bietet, darunter das Kleben von Java-Beans mit JSF-Seiten über die #{bean.method(argument)} .

Ich bin neu in Java EE und ich weiß, dass etwas wie die folgenden drei Zeilen

<%= x+1 %>
<%= request.getParameter("name") %>
<%! counter++; %>

ist eine altmodische Art zu schreiben und in JSP Version 2 gibt es eine Methode Java Code in JSP Dateien zu vermeiden. Kann mir bitte jemand die alternativen JSP 2-Linien nennen, und wie heißt diese Technik?


Die Verwendung von Scriptlets (diese <% %> %% <% %> things) in JSP wird tatsächlich seit der Geburt von Taglibs (wie JSTL ) und EL ( EL , diese ${} Dinge) vor mehr als einem Jahrzehnt stark abgeraten.

Die Hauptnachteile von Scriptlets sind:

  1. Wiederverwendbarkeit: Scriptlets können nicht wiederverwendet werden.
  2. Austauschbarkeit: Sie können Scriptlets nicht abstrakt machen.
  3. OO-Fähigkeit: Sie können keine Vererbung / Zusammensetzung verwenden.
  4. Debuggability: Wenn Scriptlet eine Ausnahme auf halbem Wege auslöst, erhalten Sie nur eine leere Seite.
  5. Testbarkeit: Skriptlets sind nicht testbar.
  6. Wartbarkeit: Pro Saldo wird mehr Zeit benötigt, um die Code Logik zu vermischen / überfüllt / dupliziert zu halten.

Sun Oracle selbst empfiehlt auch in den JSP-Codierungskonventionen , die Verwendung von Scriptlets zu vermeiden, wenn die gleiche Funktionalität durch (Tag-) Klassen möglich ist. Hier sind einige wichtige Beispiele:

Aus der JSP 1.2-Spezifikation wird dringend empfohlen, dass die JSP-Standard-Tag-Bibliothek (JSTL) in Ihrer Webanwendung verwendet wird, um die Notwendigkeit von JSP-Scriptlets in Ihren Seiten zu reduzieren . Seiten, die JSTL verwenden, sind im Allgemeinen einfacher zu lesen und zu pflegen.

...

Vermeiden Sie nach Möglichkeit JSP-Skriptlets, wenn Tag-Bibliotheken äquivalente Funktionen bereitstellen. Dies erleichtert das Lesen und Verwalten von Seiten, hilft bei der Trennung von Geschäftslogik und Präsentationslogik und erleichtert die Weiterentwicklung Ihrer Seiten zu Seiten im JSP 2.0-Stil (die JSP 2.0-Spezifikation unterstützt die Verwendung von Scriptlets, betont sie jedoch nicht mehr).

...

Im Sinne der Übernahme des MVC-Entwurfsmusters (Model-View-Controller) zur Reduzierung der Kopplung zwischen der Darstellungsebene und der Geschäftslogik sollten JSP-Skriptlets nicht zum Schreiben von Geschäftslogik verwendet werden. Stattdessen werden JSP-Scriptlets verwendet, um Daten (auch "Wertobjekte" genannt), die bei der Verarbeitung der Clientanforderungen zurückgegeben werden, in ein geeignetes clientfähiges Format zu transformieren. Selbst dann wäre dies besser mit einem Front-Controller-Servlet oder einem benutzerdefinierten Tag möglich.

Das Ersetzen von Skriptlets hängt ausschließlich vom Zweck des Codes / der Logik ab. Mehr als oft wird dieser Code in eine vollwertige Java-Klasse eingefügt:

  • Wenn Sie unabhängig von der angeforderten Seite denselben Java-Code für jede Anforderung aufrufen möchten, z. B. prüfen, ob ein Benutzer angemeldet ist, implementieren Sie einen filter und schreiben Sie entsprechend Code in die doFilter() Methode. Z.B:

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

    Wenn sie auf ein geeignetes <url-pattern> abgebildet werden, das die interessierenden JSP-Seiten abdeckt, müssen Sie nicht denselben Code über alle JSP-Seiten kopieren.

  • Wenn Sie einen Java-Code zur Vorverarbeitung einer Anfrage aufrufen möchten, z. B. eine Liste aus einer Datenbank doGet() , um sie ggf. in einigen Tabellen anzuzeigen, dann implementieren Sie ein servlet und schreiben Sie entsprechend Code in die Methode doGet() . Z.B:

    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);
        }
    }
    

    Auf diese Weise ist der Umgang mit Ausnahmen einfacher. Auf die Datenbank wird nicht mitten im JSP-Rendering zugegriffen, sondern weit bevor die JSP angezeigt wird. Sie haben immer noch die Möglichkeit, die Antwort zu ändern, wenn der DB-Zugriff eine Ausnahme auslöst. Im obigen Beispiel wird die Standardfehler-500-Seite angezeigt, die Sie ohnehin über eine <error-page> in web.xml anpassen können.

  • Wenn Sie einen Java-Code zum Nachbearbeiten einer Anfrage aufrufen möchten, z. B. das Verarbeiten einer Formularübergabe, implementieren Sie ein servlet und schreiben Sie entsprechend Code in die doPost() Methode. Z.B:

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

    Auf diese Weise ist es einfacher, mit verschiedenen Ergebnisseiten zu arbeiten: Das Formular wird im Fehlerfall mit Validierungsfehlern erneut angezeigt (in diesem Beispiel können Sie es mit ${message} in EL ) oder nur die gewünschte Zielseite übernehmen des Erfolgs.

  • Wenn Sie Java-Code zur Steuerung des Ausführungsplans und / oder des Ziels der Anforderung und der Antwort aufrufen möchten, implementieren Sie ein servlet gemäß dem Front-Controller-Muster der MVC . Z.B:

    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);
        }
    }
    

    Oder nehmen Sie einfach ein MVC-Framework wie JSF , Spring MVC , Wicket usw. an, sodass Sie nur eine JSP / Facelets-Seite und eine Javabean-Klasse erhalten, ohne dass Sie ein benutzerdefiniertes Servlet benötigen.

  • Wenn Sie Java-Code aufrufen möchten, um den Fluss in einer JSP-Seite zu steuern , müssen Sie eine (vorhandene) Taglib zur Flusskontrolle wie den JSTL-Core verwenden . ZB List<Product> in einer Tabelle anzeigen:

    <%@ 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>
    

    Mit XML-ähnlichen Tags, die gut zu allem HTML passen, ist der Code besser lesbar (und damit besser wartbar) als ein Stapel Scriptlets mit verschiedenen öffnenden und schließenden Klammern ( "Wo zum Teufel gehört diese schließende Klammer?" ). Eine einfache Hilfe besteht darin, Ihre Webanwendung so zu konfigurieren, dass immer dann, wenn Scriptlets noch verwendet werden, eine Ausnahme ausgelöst wird, indem das folgende Teil zu web.xml hinzugefügt wird:

    <jsp-config>
        <jsp-property-group>
            <url-pattern>*.jsp</url-pattern>
            <scripting-invalid>true</scripting-invalid>
        </jsp-property-group>
    </jsp-config>
    

    In Facelets , dem Nachfolger von JSP, der Teil des von Java EE bereitgestellten MVC-Framework JSF , ist es bereits nicht möglich, Scriptlets zu verwenden. Auf diese Weise werden Sie automatisch gezwungen, "den richtigen Weg" zu gehen.

  • Wenn Sie Java-Code für den Zugriff auf Backend-Daten in einer JSP-Seite aufrufen möchten, müssen Sie EL (Expression Language), diese ${} -Dinge verwenden. Beispiel: Gesendete Eingabewerte erneut anzeigen:

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

    Das ${param.foo} zeigt das Ergebnis von request.getParameter("foo") .

  • Wenn Sie Java-Quellcode direkt auf der JSP-Seite (in der Regel public static Methoden) aufrufen möchten, müssen Sie sie als EL-Funktionen definieren. In JSTL gibt es eine taglib mit Standardfunktionen, aber Sie können auch einfach selbst Funktionen erstellen . Hier ist ein Beispiel, wie JSTL fn:escapeXml nützlich ist, um XSS attacks zu verhindern.

    <%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
    ...
    <input type="text" name="foo" value="${fn:escapeXml(param.foo)}" />
    

    Beachten Sie, dass die XSS-Empfindlichkeit in keiner Weise speziell mit Java / JSP / JSTL / EL / was auch immer verwandt ist. Dieses Problem muss in jeder von Ihnen entwickelten Webapplikation berücksichtigt werden. Das Problem von Scriptlets besteht darin, dass es keine Möglichkeit für integrierte Präventivmaßnahmen bietet, zumindest nicht die Standard-Java-API. JSPs Nachfolger-Facelets hat bereits implizites HTML-Escaping, sodass Sie sich keine Sorgen über XSS-Lücken in Facelets machen müssen.

Siehe auch:


Egal, wie sehr Sie versuchen zu vermeiden, wenn Sie mit anderen Entwicklern arbeiten, werden einige von ihnen immer noch Scriptlet bevorzugen und dann den bösartigen Code in das Projekt einfügen. Daher ist das Einrichten des Projekts beim ersten Zeichen sehr wichtig, wenn Sie den Scriptlet-Code wirklich reduzieren möchten. Es gibt mehrere Techniken, um darüber hinwegzukommen (einschließlich einiger Frameworks, die andere erwähnt haben). Wenn Sie jedoch die reine JSP-Methode bevorzugen, verwenden Sie die JSTL-Tag-Datei. Das Schöne daran ist, dass Sie auch Masterseiten für Ihr Projekt einrichten können, sodass die anderen Seiten die Masterseiten erben können

Erstellen Sie eine Masterseite namens base.tag unter Ihren WEB-INF / -Tags mit folgendem Inhalt

<%@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>

Auf dieser Mater-Seite habe ich ein Fragment namens "title" erstellt, so dass ich auf der Child-Seite mehr Codes an dieser Stelle der Masterseite einfügen konnte. Außerdem wird das Tag <jsp:doBody/> durch den Inhalt der <jsp:doBody/> Seite ersetzt

Erstellen Sie untergeordnete Seite (child.jsp) in Ihrem WebContent-Ordner:

<%@ 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> wird verwendet, um die Masterseite anzugeben, die Sie verwenden möchten (in diesem Moment base.tag). Der gesamte Inhalt innerhalb des Tags <jsp:body> ersetzt das <jsp:doBody/> auf Ihrer Masterseite. Ihre Child-Seite kann auch eine beliebige Tag-Lib enthalten und Sie können sie normalerweise wie die anderen verwenden. Wenn Sie hier jedoch einen Scriptlet-Code verwenden ( <%= request.getParameter("name") %> ...) und versuchen, diese Seite auszuführen, erhalten Sie eine JasperException because Scripting elements ( &lt;%!, &lt;jsp:declaration, &lt;%=, &lt;jsp:expression, &lt;%, &lt;jsp:scriptlet ) are disallowed here . Daher können andere Leute den bösartigen Code nicht in die jsp-Datei aufnehmen

Aufruf dieser Seite von Ihrem Controller:

Sie können die Datei child.jsp einfach von Ihrem Controller aus aufrufen. Dies funktioniert auch gut mit dem Struts-Framework


Eine nette Idee aus der Python-Welt sind Template-Attribut-Sprachen ; TAL wurde von Zope eingeführt (daher auch bekannt als "Zope Page Templates", ZPT) und ist ein Standard mit Implementierungen in PHP, XSLT und Java (ich habe die Python- / Zope- und PHP-Inkarnationen verwendet). In dieser Klasse von Templating-Sprachen könnte ein Beispiel oben so aussehen:

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

Der Code sieht aus wie gewöhnliches HTML (oder XHTML) plus einige spezielle Attribute in einem XML-Namespace; Es kann mit einem Browser angezeigt und sicher von einem Designer optimiert werden. Es gibt Unterstützung für Makros und auch für i18n:

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

Wenn Übersetzungen des Inhalts verfügbar sind, werden sie verwendet.

Ich weiß jedoch nicht viel über die Java-Implementierung .


Ich bin mir nicht sicher, ob ich das richtig verstehe.

Sie sollten etwas über MVC lesen. Spring MVC & Struts 2 sind die zwei häufigsten Lösungen.


Im MVC Architectural-Muster repräsentieren JSPs die View-Ebene. Das Einbetten von Java-Code in JSPs wird als eine schlechte Vorgehensweise angesehen. Sie können JSTL , freeMarker , velocity mit JSP als "Template-Engine" verwenden. Der Datenanbieter für diese Tags hängt von den Frameworks ab , mit denen Sie arbeiten. Struts 2 und webwork als eine Implementierung für MVC Pattern verwendet OGNL "sehr interessante Technik, um die Eigenschaften von Beans gegenüber JSP freizulegen".


Sicher, ersetzen Sie <%! counter++; %> <%! counter++; %> <%! counter++; %> durch eine Ereignis-Producer-Consumer-Architektur, in der die Business-Schicht über die Notwendigkeit informiert wird, den Zähler zu erhöhen, reagiert sie entsprechend und benachrichtigt die Präsentatoren, damit sie die Ansichten aktualisieren. Es handelt sich um eine Anzahl von Datenbanktransaktionen, da wir in Zukunft den neuen und alten Wert des Zählers kennen müssen, der ihn zu welchem ​​Zweck inkrementiert hat. Offensichtlich ist eine Serialisierung beteiligt, da die Schichten vollständig entkoppelt sind. Sie können Ihren Zähler über RMI, IIOP, SOAP erhöhen. Aber nur HTML ist erforderlich, das Sie nicht implementieren, da es so ein banaler Fall ist. Ihr neues Ziel ist es, 250 Schritte pro Sekunde auf Ihrem neuen glänzenden E7, 64 GB RAM Server zu erreichen.

Ich habe mehr als 20 Jahre Programmiererfahrung, die meisten Projekte scheitern vor dem Sextett: Wiederverwendbarkeit Austauschbarkeit OO-Fähigkeit Debuggability Testability Wartbarkeit ist sogar erforderlich. Andere Projekte, die von Leuten geleitet wurden, denen nur die Funktionalität wichtig war, waren äußerst erfolgreich. Eine steife Objektstruktur, die zu früh im Projekt implementiert wird, macht den Code nicht in der Lage, an die drastischen Änderungen in den Spezifikationen (aka agil) angepasst zu werden.

Ich betrachte daher die Aufschiebung der "Schichten" oder redundanten Datenstrukturen entweder zu einem frühen Zeitpunkt im Projekt oder wenn sie nicht speziell benötigt werden.


Sie haben eine gute Frage gestellt und obwohl Sie gute Antworten bekommen haben, würde ich vorschlagen, dass Sie JSP loswerden. Es ist eine veraltete Technologie, die irgendwann sterben wird. Verwenden Sie einen modernen Ansatz wie Template-Engines. Sie werden eine klare Trennung zwischen Geschäfts- und Präsentationsebenen und ganz sicher keinen Java-Code in Vorlagen haben, sodass Sie Vorlagen direkt aus der Webpräsentationsbearbeitungssoftware erstellen können, wobei Sie in den meisten Fällen WYSIWYG nutzen.

Vermeiden Sie Filter und Pre- und Post-Processing, sonst können Sie Schwierigkeiten mit dem Support / Debugging haben, da Sie immer nicht wissen, wo die Variable den Wert bekommt.


Um JAVA-Code in JSP-Dateien zu vermeiden, bietet java jetzt auch Tag-Bibliotheken wie JSTL an. Java hat JSF entwickelt, in das man alle Programmierstrukturen in Form von Tags schreiben kann


Verwenden Sie JSTL Tag libraries in JSP, die perfekt funktionieren.


Wenn Sie die Nachteile der Java-Programmierung in JSP einfach vermeiden möchten, können Sie dies auch mit Skripts tun. Befolgen Sie ein wenig Disziplin, um minimales Java in JSP und fast keine Berechnung und Logik in der JSP-Seite zu haben.

<%@ 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>

Wenn wir die folgenden Dinge in einer Java-Webanwendung verwenden, kann Java-Code aus dem Vordergrund der JSP entfernt werden.

  1. Verwenden Sie die MVC-Architektur für die Webanwendung

  2. Verwenden Sie JSP-Tags

    ein. Standard-Tags

    b. Benutzerdefinierte Tags

  3. Ausdruckssprache


JSTL bietet Tags für Bedingungen, Schleifen, Sätze, Gets usw. an. Zum Beispiel:

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

JSTL arbeitet mit Anforderungsattributen - sie werden am häufigsten in der Anfrage von einem Servlet gesetzt, das an die JSP weiterleitet .


Wie vermeidet man Java-Code in JSP-Dateien?

Sie können Registerkarten-Tags wie JSTL zusätzlich zu Expression Language ( EL ) verwenden. Aber EL funktioniert nicht gut mit JSP. Daher ist es wahrscheinlich besser, JSP vollständig zu löschen und Facelets zu verwenden .

Facelets ist die erste Nicht-JSP-Seitenerklärungssprache, die für JSF (Java Server Faces) entwickelt wurde und JSF-Entwicklern im Vergleich zu JSP ein einfacheres und leistungsfähigeres Programmiermodell bot. Es behebt verschiedene Probleme in JSP für die Entwicklung von Webanwendungen.


Lernen Sie, wie Sie mit JSTL Ihre eigenen Tags anpassen und schreiben

Beachten Sie, dass EL EviL ist (Laufzeitausnahmen, Refactoring)
Wicket kann auch böse sein (Leistung, mühselig für kleine Apps oder einfache Ansichtsebene)

Beispiel von java2s ,

Dies muss der web.xml der Webanwendung hinzugefügt werden

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

Erstelle Datei: java2s.tld in der / 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>

kompilieren Sie den folgenden Code in 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;
    }
}

Starten Sie den Server und laden Sie bodyContent.jsp im Browser

<%@ 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>

Technisch gesehen werden JSP alle zur Laufzeit in Servlets konvertiert . JSP wurde ursprünglich zum Zweck der Entkopplung der Geschäftslogik und der Entwurfslogik gemäß dem MVC-Muster erstellt. Also JSP sind technisch alle Java-Codes zur Laufzeit. Aber um die Frage zu beantworten, werden Tag-Bibliotheken normalerweise verwendet, um Logik (Entfernen von Java-Codes) auf JSP-Seiten anzuwenden.


As many answers says, use JSTL or create your own custom tags. Here is good explanation about creating custom tags


Nothing of that is used anymore my friend, my advice is to decouple the view(css, html, javascript, etc) from the server.

In my case I do my systems handling the view with Angular and any data needed is brought from the server using rest services.

Believe me, this will change the way you design


Durch die Verwendung von JSTL-Tags zusammen mit dem EL-Ausdruck können Sie dies vermeiden. Fügen Sie die folgenden Dinge in Ihre JSP-Seite ein:

<%@ 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" %>




scriptlet