jsp modificado: incluir implementación

Question

Una de las cosas que siempre me ha molestado acerca de <jsp:include..> es que no es posible pasar valores que no sean cadenas a la página incluida como entradas distintas a la página. Por ejemplo, me gustaría ser capaz de hacer lo siguiente:

<c:forEach var="item" items="${listOfItems}"> 
    <jsp:include page="mypage.jsp"> 
     <jsp:attribute name="item" value="${item}/> 
    </jsp:include> 
</c:forEach> 

La idea es que, al declarar el elemento que se pasa como un atributo dentro de la jsp: include nodo, el código está haciendo más clara cuál era el intento ... de suministrar ese parámetro a la página incluida.

El único mecanismo actualmente disponible para hacer esto es definir el atributo "globalmente" y luego dejar que la página incluida lo lea desde el espacio global. Desafortunadamente, esto pierde el mismo "intento" que el que proporciona < jsp: param >. Además, hace que el código sea más difícil de depurar, por la misma razón que lo hacen los globales en cualquier entorno de programación.

¿Alguien sabe de una implementación de un mecanismo de inclusión que realiza las funciones de jsp: incluir, pero permite pasar en valores que no sean cadenas? O, si no, estaría abierto a ideas alternativas que conserven el mismo objetivo de intento y facilidad de depuración.

Como nota al margen, me gustaría ver un mecanismo incorporado "captura" para cuando la página incluida genera un error:

<abc:include page="mypage"> 
    <abc:param name="something" value="some string value"/> 
    <abc:attribute name="somethingelse" value="${nonStringValue}"/> 
    <abc:catch var="ex"> 
     The page failed, so the content it generated will not be sent to the output 
     stream. Instead, we can collapse the part of the page that it's content 
     would be... possibly putting a comment in the page with 
     <!-- There was an exception generating this module: 
      <c:out value="${ex.getMessage}/> 
      --> 
    </abc:catch> 
</abc:include> 

Answer 1

Después de leer las respuestas aquí, además de hacer la investigación adicional sobre el tema, se me ha ocurrido con lo siguiente:

• Puede serializar los objetos a continuación, deserializar en la JSP incluido.No es un fanático de esto porque hace que el código sea más complejo (cada objeto que pasa debe ser serializable, etc.)
• Puede usar taglibs. No soy partidario de esto, ya que creo que cumplen una función diferente a JSP. Incluir archivos
• Puede definir las variables en el alcance de la solicitud, lo que las pondrá a disposición del JSP incluido. No es un gran admirador de esto ya que no muestra la intención del programador (al pasar los valores a la página incluida, ya que solo se usa).
• Realmente no hay (que pude encontrar) una implementación que logre lo que estoy buscando, pero es posible construir algo que se aproxime a través de etiquetas personalizadas.

Hice un poco de trabajo y armé el código para lograr lo que estaba buscando, y luego threw it up on sourceforge. Se le permite especificar las entradas en la forma en que estaba describiendo:

<inc:include page="normal.jsp"> 
    <inc:param name="param1" value="param1value" /> 
    <inc:param name="param2" value="param2value" /> 
    <inc:attrib name="attrib1" value="${attrib1value}" /> 
    <inc:attrib name="attrib2" value="${attrib2value}" /> 
    <inc:catch var="ex"> 
     This block was not rolled up because there wasn't an error. 
     Should never see this, but just in case, the exception was: ${ex.message} 
    </inc:catch> 
</inc:include> 

El único problema con él (en este momento) es que agrego los atributos para el ámbito de la petición antes de que se incluyó a la página, luego eliminarlos después (o reinícielos si ya existían). Lo que me gustaría hacer, en cambio, es ajustar el objeto de solicitud en su lugar y anular los métodos de atributo para incluir automáticamente los valores pasados ​​... Todavía estoy trabajando en eso.

Answer 2

allows for passing in non-String values?

Cuando usted está restringido a pasar las cadenas alrededor, una La solución común es serializar sus objetos.

Answer 3

De la especificación JSTL:

Nested scoped variables are only visible within the body of the action and are stored in "page" scope.

se puede pasar a través de referencias a objetos solicitud ámbito de aplicación.

standardInclude.jsp:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> 
<c:out value="${foo}" /> 

standardAction.jsp:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> 
<% 
    //evil scriptlet 
    request.setAttribute("mylist", java.util.Arrays.asList("bar", "baz")); 
%> 
<c:forEach items="${mylist}" var="foo"> 
    <c:set var="foo" scope="request" value="${foo}" /> 
    <jsp:include page="standardInclude.jsp" /> 
    <c:set var="foo" scope="request" value="${null}" /> 
</c:forEach> 

Usted puede utilizar la etiqueta catch capturar excepciones.

thrower.jsp:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> 
<c:out value="OK: ${foo}" /> 
<% 
    //evil scriptlet 
    if ("bar".equals(request.getAttribute("foo"))) 
    throw new java.io.IOException("oops"); 
%> 

catcher.jsp:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> 
<% 
    //evil scriptlet 
    request.setAttribute("mylist", java.util.Arrays.asList("bar", "baz")); 
%> 
<c:forEach items="${mylist}" var="foo"> 
    <br /> 
    <c:set var="foo" scope="request" value="${foo}" /> 
    <c:catch var="ex"> 
     <jsp:include page="thrower.jsp" /> 
    </c:catch> 
    <c:if test="${ex ne null}"> 
     <c:out value="Error for ${foo}" /> 
    </c:if> 
    <c:set var="foo" scope="request" value="${null}" /> 
</c:forEach> 

Esta emitirá:

Error for bar 
OK: baz 

Answer 4

Esto se puede achived con etiquetas JSP archivos en lugar de incluye. Vea mi respuesta a una pregunta similar en JSP Component Creation para más detalles.