JSP-tags avec sortie statique

Question

J'envisage de créer des balises JSP qui donneront toujours le même résultat. Par exemple:

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

Toujours afficher:

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

Existe-t-il un moyen de faire en sorte qu'une balise JSP se comporte comme une sortie statique dans la servlet générée?

Par exemple:

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

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

Arrière-plan

Je suis inquiet pour la performance. Je n'ai pas encore testé cela, mais il semble que la servlet générée fasse beaucoup pour quelque chose de très simple et que les performances soient très importantes.

Mais si le servlet se comporte comme si la sortie avait été écrite directement dans le JSP, le coût de production serait de zéro.

Je vois quelques avantages à cela. Je peux changer le code HTML statique ou même passer à quelque chose de plus dynamique, sans éditer chaque portlet. Dans notre configuration, il est facile de changer une balise, mais cela prend beaucoup de temps de changer chaque JSP qui utilise un élément spécifique.

Cela signifie également que je peux forcer les développeurs à ne pas écrire quelque chose comme

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

Il y a encore plus d'avantages, mais si cela coûte des performances sur les serveurs de production, cela n'en vaut probablement pas la peine.

Answer 1

J'ai fait un test de performance. Il y a très peu de différence dans les performances, donc ce n'est pas un problème.

Comment j'ai fait le test

J'ai créé 500 balises individuelles (par programme) dans l'une de nos bibliothèques de balises. (Donc, il est emballé dans un pot, etc.) Ils ressemblent tous à ceci, avec le nombre comme seule différence:

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

Et puis 500 entrées dans le TLD comme ceci:

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

Ensuite, j'ai saisi un fichier JSP contenant un petit code et en ai fait deux copies: une avec HTML statique et une avec balises.

Celui avec HTML statique:

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

Celui avec les tags:

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

La boucle a été introduite car les deux sont sortis avec zéro milliseconde. (Malheureusement, je travaille sous Windows au travail, donc je n’ai pas beaucoup de précision ici.) Le fait que 500 balises ne génèrent pas un délai mesurable pourrait suffire, mais je voulais plus, même si la répétition permettait une optimisation.

Résultat pour 500 000 tags:

• tags JSP: 15-19 secondes
• balises HTML: 12 à 16 secondes

Donc, il y a une différence, mais je pense que c'est insignifiant comparé à tout ce qui se passe depuis les clics de l'utilisateur jusqu'à ce que la réponse soit affichée à l'écran.

Autres pensées

Pour autant que je sache, la granularité dans Windows est d'environ 15 à 16 millisecondes. Donc, & "0 millisecondes &"; signifie en réalité & "; & 16" millisecondes & ";. Un délai inférieur à 16/500 millisecondes par pr. La balise est tout à fait acceptable.

J'ai essayé avec 1000 balises, mais le compilateur JSP était très mécontent de cela. J'ai réduit le nombre de balises à 500 car l’alternative consistait à modifier la configuration, ce qui invaliderait mes résultats.

J'ai fait du HTML généré un commentaire HTML, car le navigateur est sur la même machine physique que le serveur de test et j'avais peur qu'il prenne trop de temps de calcul, même avec un processeur double cœur. CPU. La solution facile était de commenter le code HTML.

Answer 2

Je suis tout à fait certain que les performances seront négligeables compte tenu du code que vous venez de montrer.

Answer 3

Je me demandais ... pourquoi ne pas utiliser un simple include ?