java - sintaxis - ¿Cuál es la diferencia entre incluir archivos con la directiva de inclusión JSP, incluir acciones de JSP y usar archivos de etiquetas JSP?




jsp y html (4)

Parece que hay dos métodos para crear plantillas con JSP. Incluyendo archivos con una de estas declaraciones

<%@ include file="foo.html" %>
<jsp:include page="foo.html" />

o usando archivos de etiquetas JSP

// Save this as mytag.tag
<%@ tag description="Description" pageEncoding="UTF-8"%>
<html>
<head>
</head>
<body>
    <jsp:doBody/>
</body>
</html>

Y en otra página JSP llámala con

<%@ taglib prefix="t" tagdir="/WEB-INF/tags" %>

<t:mytag>
    <h1>Hello World</h1>
</t:mytag>

Entonces, ¿qué método debo usar? ¿Se considera ahora que uno está obsoleto o ambos son válidos y cubren diferentes casos de uso?

Editar

¿No usar este archivo de etiqueta es lo mismo que usar un incluir?

// Save this as product.tag
<%@ tag description="Product templage" pageEncoding="UTF-8"%>
<%@ tag import="com.myapp.Product" %>
<%@ attribute name="product" required="true" type="com.myapp.Product"%>

Product name: ${product.name} <br/>
Quantity: ${product.quantity} <br/>

Y llámalo a otro JSP con

<%@ taglib prefix="t" tagdir="/WEB-INF/tags" %>

<t:product>
    <c:forEach items="${cart.products}" var="product">
        <t:product product="${product}"/>
    </c:forEach>
</t:product>

Eso me parece que es lo mismo que usar un parámetro de inclusión y pasarlo. Entonces, ¿los archivos de etiquetas son lo mismo que incluye?


Existen varios mecanismos para reutilizar contenido en un archivo JSP.

Los siguientes 4 mecanismos para incluir contenido en JSP se pueden categorizar como reutilización directa :
(para los primeros 3 mecanismos que citan de "Head First Servlets and JSP" )

1) La directiva de inclusión:

<%@ include file="header.html" %>

Estático : agrega el contenido del valor del atributo de archivo a la página actual en el momento de la traducción . La directiva se diseñó originalmente para plantillas de diseño estáticas, como encabezados HTML.

2) La acción estándar <jsp:include> :

<jsp:include page="header.jsp" />

Dinámico : agrega el contenido del valor del atributo de página a la página actual en el momento de la solicitud . Fue pensado más para contenido dinámico proveniente de JSPs.

3) La etiqueta <c:import> JSTL:

<c:import url=”http://www.example.com/foo/bar.html” />

Dinámico : agrega el contenido del valor del atributo URL a la página actual, en el momento de la solicitud . Funciona muy parecido a <jsp:include> , pero es más potente y flexible: a diferencia de los otros dos incluye, la URL <c:import> puede ser desde fuera del contenedor web .

4) Preludios y codas:

Estático : los preludios y las codas se pueden aplicar solo al principio y al final de las páginas .
Puede incluir implícitamente preludios (también llamados encabezados) y codas (también llamados pies de página) para un grupo de páginas JSP al agregar elementos <include-prelude> y <include-coda> respectivamente dentro de un elemento <jsp-property-group> en Descriptor de despliegue web.xml de aplicación web. Leer más aquí:
Configuración de las inclusiones implícitas al principio y al final de las JSP
Definición de inclusiones implícitas

Tag File es un método indirecto de reutilización de contenido, la forma de encapsular contenido reutilizable . Un archivo de etiqueta es un archivo fuente que contiene un fragmento de código JSP que se puede volver a usar como una etiqueta personalizada .

El PROPÓSITO de includes y Tag Files es diferente.

El archivo de etiquetas (un concepto introducido con JSP 2.0) es una de las opciones para crear etiquetas personalizadas . Es una forma más rápida y fácil de crear etiquetas personalizadas . Las etiquetas personalizadas , también conocidas como extensiones de etiquetas, son elementos JSP que permiten que la lógica personalizada y la salida proporcionada por otros componentes Java se inserten en las páginas JSP. La lógica proporcionada a través de una etiqueta personalizada se implementa mediante un objeto Java conocido como controlador de etiquetas .

Algunos ejemplos de tareas que pueden realizar las etiquetas personalizadas incluyen operar en objetos implícitos, procesar formularios, acceder a bases de datos y otros servicios empresariales, como correo electrónico y directorios, e implementar control de flujo.

En cuanto a tu Editar

Tal vez en su ejemplo (en su Edición ), no hay diferencia entre usar inclusión directa y un Archivo de etiqueta. Pero las etiquetas personalizadas tienen un amplio conjunto de características . Ellos pueden

  • Personalícese por medio de atributos pasados ​​desde la página de llamadas.

  • Pase las variables a la página de llamadas.

  • Acceda a todos los objetos disponibles para las páginas JSP.

  • Comunicarse entre sí. Puede crear e inicializar un componente JavaBeans, crear una variable EL pública que haga referencia a ese bean en una etiqueta, y luego usar el bean en otra etiqueta.

  • Estar anidado dentro de otro y comunicarse por medio de variables privadas.

Lea también esto en "Pro JSP 2": comprensión de las etiquetas personalizadas de JSP .

Lectura útil

Conclusión

Usa los instrumentos adecuados para la tarea concreta.

Use los archivos de etiquetas como una forma rápida y fácil de crear etiquetas personalizadas .

En cuanto al contenido incluido en JSP (cita de here ):

  • Use la directiva include si el archivo cambia raramente. Es el mecanismo más rápido. Si su contenedor no detecta automáticamente los cambios, puede forzar que los cambios surtan efecto eliminando el archivo de la clase de la página principal.

  • Utilice la acción de inclusión solo para el contenido que cambia con frecuencia, y si la página que desea incluir no se puede decidir hasta que se solicite la página principal.


La principal ventaja de <jsp:include /> sobre <%@ include > es:

<jsp:include /> permite pasar parámetros

<jsp:include page="inclusion.jsp">
    <jsp:param name="menu" value="objectValue"/>
</jsp:include>

lo cual no es posible en <%@include file="somefile.jsp" %>


Posible pregunta duplicada

<@include> - La etiqueta directiva ordena al compilador JSP fusionar los contenidos del archivo incluido en el JSP antes de crear el código del servlet generado. Es el equivalente a cortar y pegar el texto de su página de inclusión directamente en su JSP.

  • Solo se ejecuta un servlet en tiempo de ejecución.
  • Se puede acceder a las variables de Scriptlet declaradas en la página primaria en la página incluida (recuerde, son la misma página).
  • La página incluida no necesita ser compilada como una JSP independiente. Puede ser un fragmento de código o texto sin formato. La página incluida nunca se compilará como independiente. La página incluida también puede tener cualquier extensión, aunque .jspf se ha convertido en una extensión usada convencionalmente.
  • Una desventaja de los contenedores más antiguos es que los cambios en las páginas de inclusión pueden no tener efecto hasta que se actualice la página principal. Las versiones recientes de Tomcat verificarán las páginas de inclusión para las actualizaciones y forzarán una recompilación del padre si se actualizan.
  • Un inconveniente adicional es que, dado que el código está incrustado directamente en el método de servicio del servlet generado, el método puede crecer muy grande. Si supera 64 KB, es probable que su compilación JSP falle.

<jsp:include> - Por otro lado, la etiqueta de acción JSP ordena al contenedor detener la ejecución de esta página, ejecutar la página incluida y fusionar el resultado de esa página en el resultado de esta página.

  • Cada página incluida se ejecuta como un servlet separado en tiempo de ejecución.
  • Las páginas se pueden incluir condicionalmente en tiempo de ejecución. Esto a menudo es útil para plantillas de marcos que incluyen páginas compiladas. La página primaria puede determinar qué página, si corresponde, se debe incluir de acuerdo con alguna condición de tiempo de ejecución.
  • Los valores de las variables scriptlet deben pasarse explícitamente a la página de inclusión.
  • La página incluida debe poder ejecutarse por sí misma.
  • Es menos probable que se produzcan errores de compilación debido a que se excede el tamaño máximo del método en la clase de servlet generada.

Según sus necesidades, puede usar <@include> o <jsp:include>


Java revisitado

  1. El recurso incluido por la directiva include se carga durante el tiempo de traducción jsp, mientras que el recurso incluido por la acción include se carga durante el tiempo de solicitud.
  2. Cualquier cambio en el recurso incluido no será visible en caso de directiva de inclusión hasta que el archivo jsp vuelva a compilarse. Mientras que en caso de incluir acción, cualquier cambio en el recurso incluido será visible en la siguiente solicitud.
  3. Incluir directiva es importación estática, mientras que incluir acción es importación dinámica
  4. La directiva include usa el atributo de archivo para especificar el recurso que se incluirá, mientras que incluye el atributo de página de uso de acción para el mismo propósito.




tagfile