Etiquetas JSP con salida estática

Question

Estoy considerando crear algunas etiquetas JSP que siempre darán el mismo resultado. Por ejemplo:

<foo:bar>baz</foo:bar>

Siempre saldrá:

<div class="bar">baz</div>

¿Hay alguna forma de hacer que una etiqueta JSP se comporte como la salida estática en el servlet generado?

Por ejemplo:

out.write("<div class=\"bar\">");
...
out.write("</div>");

en lugar de

x.y.z.foo.BarTag _jspx_th_foo_bar_0 = new x.y.z.foo.BarTag();
_jspx_th_foo_bar_0.setPageContext(pageContext);
_jspx_th_foo_bar_0.setParent(null);
_jspxTagObjects.push(_jspx_th_foo_bar_0);
int _jspx_eval_foo_bar_0 = _jspx_th_foo_bar_0.doStartTag();
etc...
etc...
etc...

Fondo

Me preocupa el rendimiento. Todavía no lo he probado, pero parece que el servlet generado hace mucho por algo muy simple, y el rendimiento es muy importante.

Pero si el servlet se comporta como si la salida se escribiera directamente en el JSP, el costo de producción será cero.

Veo algunas ventajas al hacer esto. Puedo cambiar el HTML estático o incluso cambiar a algo más dinámico, sin editar cada portlet. En nuestra configuración, es fácil cambiar una etiqueta, pero lleva mucho tiempo cambiar cada JSP que usa un elemento específico.

Esto también significa que puedo obligar a los desarrolladores a no escribir algo como

<div class="bar" style="whatever">...</div>

Hay incluso más ventajas, pero si cuesta rendimiento en los servidores de producción, probablemente no valga la pena.

Answer 1

Hice una prueba de rendimiento. Hay muy poca diferencia en el rendimiento, por lo que no hay problema.

Cómo hice la prueba

Creé 500 etiquetas individuales (mediante programación) en una de nuestras bibliotecas de etiquetas. (Entonces está envuelto en un frasco, etc.) Todos se ven así, con el número como la única diferencia:

package XX.XX.XX.XX

import java.io.IOException;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.TagSupport;

public class Test0001Tag extends TagSupport {

    public Test0001Tag() {
    }

    public int doStartTag() throws JspException {

        try {
            pageContext.getOut().print("<div class=\"Test0001\">");
        } catch (IOException e) {
            throw new JspException(e);
        }
        return EVAL_BODY_INCLUDE;
    }

    public int doEndTag() throws JspException {
        try {
            pageContext.getOut().print("</div>");
        } catch (IOException e) {
            throw new JspException(e);
        }
        return EVAL_PAGE;
    }

    public void release() {
        super.release();
    }
}

Y luego 500 entradas en el TLD como esta:

<tag>
   <name>test0001</name>
   <tagclass>XX.XX.XX.XX.Test0001Tag</tagclass>
   <bodycontent>JSP</bodycontent> 
</tag>

Luego agarré un JSP con un pequeño código e hice dos copias: una con HTML estático y otra con etiquetas.

El que tiene HTML estático:

<!-- 
<%long start = System.currentTimeMillis();%>
<% for (int i = 0; i < 1000; i++) { %>
<div class="Test0001">X</div>
<div class="Test0002">X</div>
<div class="Test0003">X</div>
...
<div class="Test0498">X</div>
<div class="Test0499">X</div>
<div class="Test0500">X</div>
<% } %>
<%System.out.println(System.currentTimeMillis()-start);%>
 -->

El que tiene etiquetas:

<!-- 
<%long start = System.currentTimeMillis();%>
<% for (int i = 0; i < 1000; i++) { %>
<bddesign:test0001>X</bddesign:test0001>
<bddesign:test0002>X</bddesign:test0002>
<bddesign:test0003>X</bddesign:test0003>
...
<bddesign:test0498>X</bddesign:test0498>
<bddesign:test0499>X</bddesign:test0499>
<bddesign:test0500>X</bddesign:test0500>
<% } %>
<%System.out.println(System.currentTimeMillis()-start);%>
 -->

El bucle se introdujo porque ambos salieron con cero milisegundos. (Desafortunadamente ejecuto Windows en el trabajo, así que no obtengo mucha precisión aquí). El hecho de que 500 etiquetas no produjeran un retraso medible podría ser suficiente respuesta, pero quería más, incluso si la repetición puede permitir alguna optimización.

El resultado para 500 000 etiquetas:

• Etiquetas JSP: 15-19 segundos
• Etiquetas HTML: 12-16 segundos

Entonces, hay una diferencia, pero creo que es insignificante en comparación con todo lo demás que ocurre desde que el usuario hace clic hasta que la respuesta se muestra en la pantalla.

Otros pensamientos

Hasta donde yo sé, la granularidad en Windows es de aproximadamente 15-16 milisegundos. Entonces & Quot; 0 milisegundos & Quot; en realidad significa " < 16 milisegundos " ;. Un retraso de menos de 16/500 milisegundos pr. la etiqueta es bastante aceptable.

Intenté con 1000 etiquetas, pero el compilador JSP estaba muy descontento con eso. Reduje a 500 etiquetas porque la alternativa era cambiar la configuración que invalidaría mis resultados.

Hice que el HTML generado fuera un comentario HTML, porque el navegador está en la misma máquina física que el servidor de prueba, y temía que el navegador tomara demasiado procesamiento de tiempo de CPU, incluso con un núcleo dual UPC. La solución fácil fue comentar el HTML.

Answer 2

Estoy bastante seguro de que el impacto en el rendimiento será negligente teniendo en cuenta el código que acaba de mostrar.

Answer 3

Me preguntaba ... ¿por qué no usar solo una antigua inclusión ?