¿Cómo puedo evitar el código Java en archivos JSP, usando JSP 2?

Soy nuevo en Java EE y sé que algo como las siguientes tres líneas

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

es una forma de codificación de la vieja escuela y en JSP versión 2 existe un método para evitar el código Java en archivos JSP. ¿Cuáles son las líneas alternativas JSP 2 y cómo se llama esta técnica?

preguntado el 05 de julio de 10 a las 04:07

@Koray Tugay, siempre que la variable de contador se declare en algún lugar antes de su uso, entonces ciertamente es válida ... -

@SheldonR. Esto es válido: <% = contador ++%> o esto: <%! int contador = 0; int x = contador ++; %> pero no: <%! int contador = 0; contador ++; %> -

@KorayTugay, lo que quise decir es que si el contador de variables se declaró en un bloque de script anterior, debería ser válido en un bloque posterior. Pero en última instancia, los programadores de J2EE en estos días deberían usar variables EL en lugar de scriptlets, de todos modos ...

30 Respuestas

El uso de guiones (aquellos <% %> cosas en JSP de hecho está muy desanimado desde el nacimiento de etiquetas (como el JSTL) y EL (Lenguaje de expresión, Aquellos ${} cosas) allá por 2001.

Las principales desventajas de guiones son:

  1. Reutilización: no puede reutilizar scriptlets.
  2. Reemplazabilidad: no se puede hacer que los scriptlets sean abstractos.
  3. Habilidad OO: no se puede hacer uso de herencia / composición.
  4. Capacidad de depuración: si scriptlet arroja una excepción a la mitad, todo lo que obtiene es una página en blanco.
  5. Testabilidad: Los scriptlets no son comprobables por unidades.
  6. Mantenibilidad: por saldo se necesita más tiempo para mantener la lógica del código mezclado / desordenado / duplicado.

Dom El propio Oracle también recomienda en el Convenciones de codificación JSP para evitar el uso de guiones siempre que la misma funcionalidad sea posible mediante clases (etiqueta). Aquí hay varias citas de relevancia:

De la especificación JSP 1.2, se recomienda encarecidamente que se utilice la biblioteca de etiquetas estándar JSP (JSTL) en su aplicación web para ayudar reducir la necesidad de scriptlets JSP en tus páginas. Las páginas que utilizan JSTL son, en general, más fáciles de leer y mantener.

...

Donde sea posible, evitar scriptlets JSP siempre que las bibliotecas de etiquetas proporcionen una funcionalidad equivalente. Esto hace que las páginas sean más fáciles de leer y mantener, ayuda a separar la lógica de negocios de la lógica de presentación y hará que sus páginas evolucionen más fácilmente a páginas de estilo JSP 2.0 (la especificación JSP 2.0 admite, pero resta importancia al uso de scriptlets).

...

Con el espíritu de adoptar el patrón de diseño modelo-vista-controlador (MVC) para reducir el acoplamiento entre el nivel de presentación y la lógica empresarial, No se deben utilizar scriptlets JSP para escribir lógica empresarial. Más bien, los scriptlets JSP se utilizan si es necesario para transformar los datos (también llamados "objetos de valor") devueltos al procesar las solicitudes del cliente en un formato adecuado listo para el cliente. Incluso entonces, esto se haría mejor con un servlet de controlador frontal o una etiqueta personalizada.


Cómo reemplazar guiones depende enteramente del único propósito del código / lógica. La mayoría de las veces, este código debe colocarse en una clase Java completa:

  • Si desea invocar el mismo Código Java activado cada solicitud, menos o más independientemente de la página solicitada, por ejemplo, verificar si un usuario está conectado, luego implementar un filtrar y escriba el código en consecuencia en doFilter() método. P.ej:

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

    Cuando se asigna en un <url-pattern> cubriendo las páginas JSP de interés, entonces no es necesario copiar y pegar la misma pieza de código en todas las páginas JSP.


  • Si desea invocar algún código Java para preprocesar una solicitud, por ejemplo, precargar alguna lista de una base de datos para mostrarla en alguna tabla, si es necesario en función de algunos parámetros de consulta, luego implementar un servlet y escriba el código en consecuencia en doGet() método. P.ej:

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

    De esta manera, es más fácil lidiar con las excepciones. No se accede a la base de datos en medio de la representación JSP, pero mucho antes de que se muestre la JSP. Todavía tiene la posibilidad de cambiar la respuesta siempre que el acceso a la base de datos arroje una excepción. En el ejemplo anterior, se mostrará la página de error 500 predeterminada que de todos modos puede personalizar mediante un <error-page> in web.xml.


  • Si desea invocar algún código Java para proceso después de una solicitud, por ejemplo, procesar el envío de un formulario, luego implementar un servlet y escriba el código en consecuencia en doPost() método. P.ej:

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

    De esta forma, tratar con diferentes destinos de página de resultados es más fácil: volver a mostrar el formulario con errores de validación en caso de error (en este ejemplo en particular, puede volver a mostrarlo usando ${message} in EL), o simplemente ir a la página de destino deseada en caso de éxito.


  • Si desea invocar algún código Java para control el plan de ejecución y / o el destino de la solicitud y la respuesta, luego implementar un servlet de acuerdo con la Patrón del controlador frontal de MVC. P.ej:

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

    O simplemente adopte un marco MVC como JSF, Primavera MVC, Postigo, etc. para que termine con solo una página JSP / Facelets y una clase JavaBean sin la necesidad de un servlet personalizado.


  • Si desea invocar algún código Java para controlar el flujo dentro de una página JSP, entonces necesita tomar un taglib de control de flujo (existente) como Núcleo JSTL. Por ejemplo, mostrar List<Product> en una mesa:

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

    Con etiquetas de estilo XML que encajan muy bien entre todo ese HTML, el código es mejor legible (y por lo tanto más fácil de mantener) que un montón de scriptlets con varias llaves de apertura y cierre ("¿A dónde diablos pertenece esta llave de cierre?"). Una ayuda sencilla es configurar su aplicación web para lanzar una excepción siempre que guiones todavía se utilizan agregando la siguiente pieza a web.xml:

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

    In Facetas, el sucesor de JSP, que es parte del marco MVC proporcionado por Java EE JSF, ya es no posible de usar guiones. De esta manera, automáticamente se ve obligado a hacer las cosas "de la manera correcta".


  • Si desea invocar algún código Java para acceder y visualizar datos de "backend" dentro de una página JSP, luego debe usar EL (lenguaje de expresión), esos ${} cosas. Por ejemplo, volver a mostrar los valores de entrada enviados:

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

    La ${param.foo} muestra el resultado de request.getParameter("foo").


  • Si desea invocar alguna utilidad Código Java directamente en la página JSP (normalmente public static métodos), entonces debe definirlos como funciones EL. Hay un estándar funciones taglib en JSTL, pero también puede crear funciones usted mismo fácilmente. A continuación, se muestra un ejemplo de cómo JSTL fn:escapeXml es útil para prevenir XSS ataques.

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

    Tenga en cuenta que la sensibilidad XSS no está específicamente relacionada con Java / JSP / JSTL / EL / lo que sea, este problema debe tenerse en cuenta en cada aplicación web que desarrolle. El problema de guiones es que no proporciona ninguna forma de prevención incorporada, al menos no utilizando la API estándar de Java. El sucesor de JSP, Facelets, ya tiene un escape HTML implícito, por lo que no necesita preocuparse por los agujeros XSS en Facelets.

Ver también:

Respondido el 07 de diciembre de 18 a las 13:12

+1 Gran respuesta. Pero no te vuelvas dogmático, en ocasiones usar scriptlets ESTÁ bien, pero esa debería ser la excepción que confirma la regla. - svachon

@svachon: Los scriptlets son útiles para la creación rápida de prototipos / pruebas. Hasta donde yo sé, solo hay un uso de producción "legítimo" de un scriptlet, a saber <% response.getWriter().flush(); %> entre las </head> y <body> para mejorar el rendimiento del análisis de páginas web en el navegador web. Pero este uso es a su vez completamente insignificante cuando el tamaño del búfer de salida en el lado del servidor es bajo (1 ~ 2KB). Ver también este artículo. - BalusC

@BalusC Algunas veces me he quedado atascado con clases de Java que no seguían el patrón getter / setter. En mi humilde opinión, ese es un caso en el que un scripltet hace el trabajo. - svachon

@svachon: envolvería esas clases con sus propias clases javabean y las usaría en su lugar. - BalusC

Fue una respuesta bastante buena, pero las partes doGet y doPost son engañosas. Esos métodos son para manejar métodos de solicitud específicos (HEAD, GET y POST) y no para solicitudes de "preprocesamiento" o "posprocesamiento". - MetroidFan2002

Como salvaguardia: deshabilite Scriptlets para siempre

As otra pregunta está discutiendo, puede y siempre debe deshabilitar scriptlets en su web.xml descriptor de la aplicación web.

Siempre haría eso para evitar que cualquier desarrollador agregue scriptlets, especialmente en empresas más grandes donde perderá la visión general tarde o temprano. La web.xml la configuración se ve así:

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

contestado el 23 de mayo de 17 a las 11:05

¿Esto también deshabilita los comentarios de scriptlet ?: <%-- comment that i don't want in the final HTML --%> . Me parece útil utilizar estos comentarios en lugar de HTML. - David lavanda

@MrSpoon buscó una respuesta para ti. Según esta respuesta + comentario, esto apaga los scriptlets <% %>, expresiones scriptlet <%! %>y declaraciones de scriptlet <%= %>. Eso significa directivas <%@ %> y comentarios <%-- --%> permanecer habilitado y utilizable, por lo que aún puede hacer comentarios e incluye. - Martin

La desactivación de las directivas scriptlet sería terrible: recortar los espacios en blanco es invaluable para interactuar con sistemas heredados que se vuelven locos con espacios en blanco adicionales. - Córcega

JSTL ofrece etiquetas para condicionales, bucles, conjuntos, get, etc. Por ejemplo:

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

JSTL funciona con atributos de solicitud; la mayoría de las veces, los establece un servlet en la solicitud, que hacia adelante a la JSP.

Respondido 22 Jul 16, 13:07

¿Por qué dice que JSTL funciona con atributos de solicitud? Pueden trabajar con atributos en cualquier ámbito, ¿no es así? - Koray Tugay

Puede utilizar etiquetas JSTL junto con expresiones EL para evitar mezclar código Java y 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>

Respondido 08 Oct 18, 16:10

También hay marcos basados ​​en componentes, como Postigo, que generan una gran cantidad de HTML.

Las etiquetas que terminan en el HTML son extremadamente básicas y prácticamente no hay lógica que se mezcle. El resultado son páginas HTML casi vacías con elementos HTML típicos. La desventaja es que hay muchos componentes en el Postigo API para aprender y algunas cosas pueden ser difíciles de lograr bajo esas restricciones.

Respondido 25 ago 20, 22:08

En el patrón arquitectónico MVC, las JSP representan la capa de vista. Incrustar código Java en JSP se considera una mala práctica.

Puedes usar el JSTL, marcador librey velocidad con JSP como "motor de plantillas".

El proveedor de datos de esas etiquetas depende de los marcos con lo que estás lidiando. puntales 2 y trabajo web como una implementación para el patrón MVC usa OGNL "técnica muy interesante para exponer las propiedades de los Beans a JSP".

Respondido 13 Feb 21, 10:02

La experiencia ha demostrado que las JSP tienen algunas deficiencias, una de las cuales es difícil de evitar mezclar el marcado con el código real.

Si puede, considere usar una tecnología especializada para lo que necesita hacer. En Java EE 6 hay JSF 2.0, que proporciona muchas características interesantes, como pegar los beans de Java junto con las páginas JSF a través del #{bean.method(argument)} enfoque.

Respondido 05 Jul 10, 09:07

Respuesta anterior, pero no puedo resistirme a decir que JSF es uno de los inventos más horrendos en el espacio de Java. Intente hacer un enlace único (como HTTP GET) y entenderá por qué. - Alex

@ Alex pero aún mejor. No dudes en recomendar algo aún mejor. - Thorbjorn Ravn Andersen

Si simplemente desea evitar los inconvenientes de la codificación Java en JSP, puede hacerlo incluso con scriplets. Simplemente siga un poco de disciplina para tener un mínimo de Java en JSP y casi ningún cálculo y lógica en la página 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 forwarding, 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>

Respondido 25 ago 20, 21:08

Aprenda a personalizar y escribir sus propias etiquetas usando JSTL

Tenga en cuenta que EL es Mal (excepciones en tiempo de ejecución y refactorización).

Wicket también puede ser malo (rendimiento y laborioso para aplicaciones pequeñas o nivel de vista simple).

Ejemplo de java2s

Esto debe agregarse al web.xml de la aplicación web.

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

Crea un archivo java2s.tld en la / 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>

Compile el siguiente código en 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;
    }
}

Inicie el servidor y cargue el archivo bodyContent.jsp en el navegador:

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

Respondido 25 ago 20, 22:08

aunque la reutilización de los componentes está bien, se dirige a algún campo - tomasb

Postigo también es una alternativa que separa completamente Java de HTML, por lo que un diseñador y un programador pueden trabajar juntos y en diferentes conjuntos de código con poca comprensión mutua.

Mira a Wicket.

Respondido 25 ago 20, 22:08

Hiciste una buena pregunta y, aunque obtuviste buenas respuestas, te sugiero que te deshagas de JSP. Es una tecnología obsoleta que eventualmente morirá. Utilice un enfoque moderno, como motores de plantillas. Tendrá una separación muy clara de las capas de presentación y negocios, y ciertamente no tendrá código Java en las plantillas, por lo que puede generar plantillas directamente desde el software de edición de presentaciones web, en la mayoría de los casos aprovechando WYSIWYG.

Y, por supuesto, manténgase alejado de los filtros y el procesamiento previo y posterior, de lo contrario, puede lidiar con dificultades de soporte / depuración, ya que siempre no sabe de dónde obtiene el valor la variable.

Respondido 20 Abr '14, 01:04

JSP es en sí mismo un motor de plantillas - zorro de guerra

No importa cuánto intente evitar, cuando trabaje con otros desarrolladores, algunos de ellos seguirán prefiriendo scriptlet y luego insertarán el código maligno en el proyecto. Por lo tanto, configurar el proyecto en el primer signo es muy importante si realmente desea reducir el código scriptlet. Hay varias técnicas para superar esto (incluidos varios marcos que otros mencionaron). Sin embargo, si prefiere el método JSP puro, utilice el archivo de etiquetas JSTL. Lo bueno de esto es que también puede configurar páginas maestras para su proyecto, por lo que las otras páginas pueden heredar las páginas maestras

Cree una página maestra llamada base.tag debajo de su WEB-INF / etiquetas con el siguiente contenido

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

En esta página principal, creé un fragmento llamado "título", para que en la página secundaria, pudiera insertar más códigos en este lugar de la página maestra. Además, la etiqueta <jsp:doBody/> será reemplazado por el contenido de la página secundaria

Cree una página secundaria (child.jsp) en su carpeta 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> se usa para especificar la página maestra que desea usar (que es base.tag en este momento). Todo el contenido dentro de la etiqueta. <jsp:body> aquí reemplazará el <jsp:doBody/> en su página maestra. Su página secundaria también puede incluir cualquier biblioteca de etiquetas y puede usarla normalmente como la otra mencionada. Sin embargo, si usa cualquier código scriptlet aquí (<%= request.getParameter("name") %> ...) e intente ejecutar esta página, obtendrá un JasperException because Scripting elements ( &lt;%!, &lt;jsp:declaration, &lt;%=, &lt;jsp:expression, &lt;%, &lt;jsp:scriptlet ) are disallowed here. Por lo tanto, no hay forma de que otras personas puedan incluir el código maligno en el archivo jsp

Llamar a esta página desde su controlador:

Puede llamar fácilmente al archivo child.jsp desde su controlador. Esto también funciona bien con el marco de struts.

Respondido el 26 de enero de 13 a las 18:01

"No importa cuánto intente evitar, cuando trabaje con otros desarrolladores, algunos de ellos seguirán prefiriendo scriptlet y luego insertarán el código maligno en el proyecto". Consulte la respuesta "Como salvaguardia: deshabilite Scriptlets para siempre". - Luis Martínez

Para evitar el código Java en archivos JSP, Java ahora proporciona bibliotecas de etiquetas, como JSTL.

Además, Java ha creado JSF en el que puede escribir todas las estructuras de programación en forma de etiquetas.

Respondido 25 ago 20, 22:08

Utilice bibliotecas de etiquetas JSTL en JSP. Eso funcionará perfectamente.

Respondido 25 ago 20, 22:08

Simplemente use la etiqueta JSTL y la expresión EL.

Respondido 11 Jul 11, 07:07

Si alguien está realmente en contra de la programación en más lenguajes de uno, Sugiero GWT. Teóricamente, puede evitar todos los elementos de JavaScript y HTML, porque Google Toolkit transforma todo el cliente y el código compartido a JavaScript. No tendrás problema con ellos, por lo que tienes un servicio web sin codificar en ningún otro idioma. Incluso puede usar algún CSS predeterminado de algún lugar, ya que lo proporcionan las extensiones (smartGWT o vaadin). No es necesario que aprenda docenas de anotaciones.

Por supuesto, si lo desea, puede infiltrarse en las profundidades del código e inyectar JavaScript y enriquecer su página HTML, pero realmente puede evitarlo si lo desea, y el resultado será bueno como se escribió en cualquier otro marco. . Digo que vale la pena intentarlo, y el GWT básico está bien documentado.

Y, por supuesto, muchos compañeros programadores describieron o recomendaron varias otras soluciones. GWT es para personas que realmente no quieren lidiar con el elemento web o minimizarlo.

Respondido 25 ago 20, 21:08

Realmente no responde a la pregunta del OP. - Evan Donovan

@EvanDonovan bueno, prácticamente da una respuesta. No necesita meterse con los códigos Java que se mezclan con otros lenguajes. Admito que usa Java para la codificación, pero se traducirá a JS sin llamadas a Java. Pero el alcance de la pregunta es cómo evitar el caos del JSP clásico. Y la tecnología GWT resuelve eso. Agregué esta respuesta ya que nadie la mencionó, pero relevante ya que es una alternativa a JSP. No quería responder todo el alcance de la pregunta, sino agregar una información valiosa para las personas que buscan alternativas. - CsBalazsHungría

Una buena idea del mundo de Python es Idiomas de atributos de plantilla; TAL fue introducido por Zope (por lo tanto, también conocido como "Plantillas de página de Zope", ZPT) y es un estándar, con implementaciones en PHP, XSLT y Java también (he usado las encarnaciones de Python / Zope y PHP). En esta clase de lenguajes de plantillas, uno de los ejemplos anteriores podría verse así:

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

El código parece HTML normal (o XHTML) más algunos atributos especiales en un espacio de nombres XML; se puede ver con un navegador y un diseñador puede modificarlo de forma segura.

Hay soporte para macros y para internacionalización y localización también:

<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 hay traducciones del contenido disponibles, se utilizan.

No se mucho sobre el Implementación de Java, Sin embargo.

Respondido 25 ago 20, 21:08

JSP ha sido reemplazado desde diciembre de 2009 por Facelets, que admite este material. Facelets también está basado en XML. Véase también, entre otros, el Capítulo de facelets en el tutorial de Java EE 6 y ui:xxx etiquetas en Facelts VDL. - BalusC

No conozco muy bien Facelets, pero IIRC se trata de escribir clases que implementan elementos XML personalizados. La forma TAL / ZPT es tener plantillas que contengan HTML verdadero (X) con atributos especiales que llenen o reemplacen los elementos originales; por lo tanto, puede ver la plantilla de trabajo y ver un prototipo con contenido ficticio agradable. No estoy seguro de que Facelets permita modificar los elementos HTML originales (sin un espacio de nombres adicional) usando atributos personalizados. - Tobías

Acabo de echar otro vistazo a este material de Facelets. Contiene todo tipo de instalaciones de validación, etc. y, por lo tanto, sigue una filosofía completamente diferente a la de TAL. La forma TAL es: "Mantenga la lógica fuera de la plantilla lo más limpiamente posible; haga que todas las cosas complicadas las haga el controlador que lo alimenta". Nunca le darás una plantilla de Facelets a un diseñador para que la modifique; simplemente no es posible. En cuanto al contenido generado, es como usar tal:replace="structure (expression)" atributos todo el tiempo. - Tobías

El uso de scriptlets en JSP no es una buena práctica.

En su lugar, puede utilizar:

  1. Etiquetas JSTL
  2. Expresiones EL
  3. Etiquetas personalizadas: puede definir sus propias etiquetas para usar.

Por favor refiérase a:

  1. http://docs.oracle.com/javaee/1.4/tutorial/doc/JSTL3.html
  2. EL

respondido 22 nov., 13:16

Claro, reemplace <%! counter++; %> mediante una arquitectura de productor-consumidor de eventos, donde la capa empresarial es notificada sobre la necesidad de incrementar el contador, reacciona en consecuencia y notifica a los presentadores para que actualicen las vistas. Se trata de una serie de transacciones de base de datos, ya que en el futuro necesitaremos conocer el valor nuevo y antiguo del contador, quién lo ha incrementado y con qué finalidad. Obviamente, la serialización está involucrada, ya que las capas están completamente desacopladas. Podrá incrementar su contador sobre RMI, IIOP, SOAP. Pero solo se requiere HTML, que no implementa, ya que es un caso tan mundano. Su nuevo objetivo es alcanzar 250 incrementos por segundo en su nuevo y brillante servidor E7, 64GB RAM.

Tengo más de 20 años en programación, la mayoría de los proyectos fallan antes del sexteto: Reutilización Reemplazabilidad OO-capacidad Depurabilidad Testabilidad Mantenibilidad incluso es necesaria. Otros proyectos, dirigidos por personas que solo se preocupaban por la funcionalidad, tuvieron un gran éxito. Además, la estructura rígida del objeto, implementada demasiado pronto en el proyecto, hace que el código no pueda adaptarse a los cambios drásticos en las especificaciones (también conocido como ágil).

Por lo tanto, considero una postergación la actividad de definir "capas" o estructuras de datos redundantes, ya sea al principio del proyecto o cuando no se requiera específicamente.  

respondido 22 nov., 17:12

Técnicamente, todos los JSP se convierten en Servlets durante el tiempo de ejecución..

JSP se creó inicialmente con el propósito de desacoplar la lógica de negocio y la lógica de diseño, siguiendo el patrón MVC. Entonces, JSP es técnicamente todo el código Java durante el tiempo de ejecución.

Pero para responder a la pregunta, bibliotecas de etiquetas se utilizan normalmente para aplicar lógica (eliminar código Java) a páginas JSP.

Respondido 25 ago 20, 21:08

Si usamos las siguientes cosas en una aplicación web Java, el código Java se puede eliminar del primer plano del archivo JSP.

  1. Use la arquitectura MVC para una aplicación web

  2. Usar etiquetas JSP

una. Etiquetas estándar

B. Etiquetas personalizadas

  1. Lenguaje de expresión

Respondido 25 ago 20, 21:08

¿Cómo puedo evitar el código Java en archivos JSP?

Puede usar etiquetas de biblioteca de pestañas como JSTL además del lenguaje de expresión (EL). Pero EL no funciona bien con JSP. Así que probablemente sea mejor eliminar JSP por completo y usar Facetas.

Facetas es el primer lenguaje de declaración de página no JSP diseñado para JSF (caras del servidor Java) que proporcionó un modelo de programación más simple y poderoso para los desarrolladores de JSF en comparación con JSP. Resuelve diferentes problemas que ocurren en JSP para el desarrollo de aplicaciones web.

Ingrese la descripción de la imagen aquí

Fuente

Respondido 25 ago 20, 21:08

Definitivamente apoyo esta respuesta. JSF con o sin Facelets. Pensé que el desarrollo en JSP había cesado en gran medida hace más de 10 años. ¡Escribí JSP por última vez en 2000! - caja

Usar Scriptlets es una forma muy antigua y no recomendado. Si desea generar algo directamente en sus páginas JSP, simplemente use Lenguaje de expresión (EL) para cada año fiscal junto con la JSTL.

También hay otras opciones, como usar un motor de plantillas como Velocity, Freemarker, Thymeleaf, etc. Pero usar JSP simple con EL y JSTL sirve para mi propósito la mayor parte del tiempo y también parece el más simple para un principiante.

Además, tenga en cuenta que no es una buena práctica hacer lógica empresarial en la capa de vista. Debe realizar su lógica empresarial en el excepcional capa y pasar el resultado de salida a sus vistas a través de una controlador.

Respondido 25 ago 20, 21:08

Utilice un marco de JavaScript similar a Backbone.js o AngularJS para el diseño de la interfaz de usuario y obtenga los datos mediante una API REST. Esto eliminará por completo la dependencia de Java de la interfaz de usuario.

Respondido 25 ago 20, 21:08

Ya no se usa nada de eso, amigo. Mi consejo es desacoplar la vista (CSS, HTML, JavaScript, etc.) del servidor.

En mi caso, hago que mis sistemas manejen la vista con Angular y todos los datos necesarios se obtienen del servidor mediante los servicios REST.

Créame, esto cambiará su forma de diseñar.

Respondido 25 ago 20, 21:08

JSP 2.0 tiene una función llamada "Etiquetar archivos", y puede escribir etiquetas sin código Java externo y tld. Necesitas crear un .tag archivar y poner en WEB-INF\tags. Incluso puede crear una estructura de directorio para empaquetar sus etiquetas.

Por ejemplo:

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

Úselo como

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

Además, puede leer el cuerpo de la etiqueta fácilmente:

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

Úselo:

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

Los ejemplos son muy simples, pero aquí puede realizar muchas tareas complicadas. Tenga en cuenta que puede utilizar otras etiquetas (por ejemplo: JSTL que tiene etiquetas de control como if/forEcah/chosen manipulación de texto como format/contains/uppercase o incluso etiquetas SQL select/update), pasar todos los parámetros de tipo, por ejemplo Hashmap, acceso session, request, ... en su archivo de etiquetas también.

Archivo de etiqueta son tan fáciles de desarrollar que no es necesario reiniciar el servidor al cambiarlos, como los archivos JSP. Esto los hace fáciles de desarrollar.

Incluso si usa un marco como Struts 2, que tiene muchas etiquetas buenas, puede encontrar que tener sus propias etiquetas puede reducir mucho su código. Puede pasar los parámetros de su etiqueta a struts y de esta manera personalizar su etiqueta de marco.

Puede usar etiquetas no solo para evitar Java, sino también para minimizar sus códigos HTML. Yo mismo trato de revisar el código HTML y crear muchas etiquetas tan pronto como veo que los códigos duplicados comienzan en mis páginas.

(Incluso si termina usando Java en su código JSP, lo cual espero que no, puede encapsular ese código en una etiqueta).

Respondido 25 ago 20, 21:08

  1. Haga sus valores y parámetros dentro de sus clases de servlet
  2. Obtenga esos valores y parámetros dentro de su JSP usando JSTL / Taglib

¡Lo bueno de este enfoque es que su código también es código HTML!

Respondido el 01 de diciembre de 18 a las 16:12

Como dicen muchas respuestas, use JSTL o cree sus propias etiquetas personalizadas. Aquí es una buena explicación sobre la creación de etiquetas personalizadas.

Respondido 25 ago 20, 21:08

Al usar etiquetas JSTL junto con expresiones EL, puede evitar esto. Pon lo siguiente en tu página 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" %>

Respondido 25 ago 20, 21:08

Muchas de las respuestas aquí van por la ruta de "usar un marco". No hay nada de malo en eso. Sin embargo, no creo que realmente responda a su pregunta, porque los marcos pueden o no usar JSP, ni están diseñados de ninguna manera con la eliminación del uso de Java en JSP como objetivo principal.

La única buena respuesta a su pregunta "cómo evito usar Java en una JSP" es: no puede.

Para eso están las JSP: usar Java para representar HTML con datos / lógica dinámicos. La pregunta de seguimiento podría ser, ¿cuánto Java debo usar en mis JSP?
Antes de responder a esa pregunta, también debería reflexionar: "¿Necesito usar JSP para crear contenido web con Java?" La respuesta a esa última es no. Existen muchas alternativas a las JSP para desarrollar aplicaciones orientadas a la web utilizando Java. Struts, por ejemplo, no te obliga a usar JSP; no me malinterpretes, puedes usarlos y muchas implementaciones lo hacen, pero no es necesario que lo hagas. Struts ni siquiera te obliga a usar HTML. Un JSP tampoco, pero seamos honestos, un JSP que no produce HTML es un poco extraño. Los servlets, como es sabido, le permiten servir cualquier tipo de contenido que desee a través de HTTP de forma dinámica. Ellos son el La tecnología principal detrás de casi todo Java Web: las JSP son solo plantillas HTML para servlets, en realidad.
Entonces, la respuesta a la cantidad de Java que debe poner en una JSP es "la menor cantidad posible". Por supuesto, tengo Java en mis JSP, pero consiste exclusivamente en definiciones de biblioteca de etiquetas, variables de sesión y de cliente, y beans que encapsulan los objetos del lado del servidor. Las etiquetas <%%> en mi HTML son casi exclusivamente llamadas de propiedad o expresiones variables. Las raras excepciones incluyen cálculos ultraespecíficos pertenecientes a una sola página y es poco probable que se vuelvan a utilizar; correcciones de errores que surgen de problemas específicos de la página que solo se aplican a una página; concatenaciones de última hora y aritmética derivadas de requisitos inusuales de alcance limitado a una sola página; y otros casos similares. En un conjunto de códigos de 1.5 millones de líneas, 3000 JSP y 5000 clases, tal vez haya 100 instancias de estos fragmentos únicos. Habría sido muy posible realizar estos cambios en las clases o en las definiciones de la biblioteca de etiquetas, pero habría sido excesivamente complejo debido a la especificidad de cada caso, habría tardado más en escribir y depurar y, como resultado, habría tardado más en llegar a mi usuarios. Es una decisión de criterio. Pero no se equivoque, no puede escribir JSP de ningún significado con "no java" ni le gustaría hacerlo. La capacidad está ahí por una razón.

Respondido 28 ago 20, 01:08

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.