Tag JSP con output statico

Question

Sto pensando di creare alcuni tag JSP che daranno sempre lo stesso output. Ad esempio:

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

Produrrà sempre:

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

Esiste un modo per far sì che un tag JSP si comporti esattamente come l'output statico nel servlet generato?

Ad esempio:

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

invece di

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

Sfondo

Sono preoccupato per le prestazioni. Non l'ho ancora provato, ma sembra che il servlet generato faccia molto per qualcosa di molto semplice e che le prestazioni siano molto importanti.

Ma se il servlet si comporta come se l'output fosse scritto direttamente nel JSP, il costo in produzione sarà zero.

Vedo alcuni vantaggi facendo questo. Posso modificare l'HTML statico o persino cambiare in qualcosa di più dinamico, senza modificare tutti i portlet. Nella nostra configurazione è facile cambiare un tag, ma richiede molto tempo per cambiare ogni JSP che utilizza un elemento specifico.

Questo significa anche che posso costringere gli sviluppatori a non scrivere qualcosa del genere

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

Ci sono ancora più vantaggi, ma se costa prestazioni sui server di produzione, probabilmente non ne vale la pena.

Answer 1

Ho effettuato un test delle prestazioni. C'è poca differenza nella performance, quindi non c'è problema.

Come ho effettuato il test

Ho creato 500 singoli tag (programmaticamente) in una delle nostre librerie di tag. (Quindi è avvolto in un barattolo ecc.) Sembrano tutti così, con il numero come unica differenza:

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

E quindi 500 voci nel TLD in questo modo:

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

Quindi ho preso un JSP con un po 'di codice e ho fatto due copie: una con HTML statico e una con tag.

Quello con HTML statico:

<!-- 
<%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);%>
 -->

Quello con i tag:

<!-- 
<%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);%>
 -->

Il loop è stato introdotto perché entrambi sono usciti con zero millisecondi. (Sfortunatamente eseguo Windows al lavoro, quindi non ho molta precisione qui.) Il fatto che 500 tag non abbiano ritardato la misura potrebbe essere una risposta sufficiente, ma volevo di più, anche se la ripetizione potrebbe consentire una certa ottimizzazione.

Il risultato per 500000 tag:

• Tag JSP: 15-19 secondi
• Tag HTML: 12-16 secondi

Quindi c'è una differenza, ma penso che sia insignificante rispetto a tutto ciò che accade dai clic dell'utente alla risposta viene visualizzato sullo schermo.

Altri pensieri

Per quanto ne so, la granularità di Windows è di circa 15-16 millisecondi. Quindi & Quot; 0 millisecondi & Quot; in realtà significa " < 16 millisecondi " ;. Un ritardo inferiore a 16/500 millisecondi pr. il tag è abbastanza accettabile.

Ho provato con 1000 tag, ma il compilatore JSP non era molto soddisfatto. Ho ridotto a 500 tag perché l'alternativa era modificare l'impostazione che avrebbe invalidato i miei risultati.

Ho reso l'HTML generato un commento HTML, perché il browser si trova sulla stessa macchina fisica del server di test e temevo che il browser avrebbe impiegato troppo tempo di rendering della CPU, anche con un dual-core PROCESSORE. La soluzione semplice era commentare l'HTML.

Answer 2

Sono abbastanza sicuro che il colpo di performance sarà trascurabile considerando il codice che hai appena mostrato.

Answer 3

Mi chiedevo ... perché non usare solo un semplice includi ?