Opiniões: JSTL x Tags do Framework

Eu achei “out”, “bean” e “loop” meio sem motivo, especialmente por causa de JSTL e EL.

Pra que elas existem?

mtw:out é para cuspir as coisas, em qualquer contexto.

mtw:bean pega um bean que está no output e coloca no contexto. Daí para cuspir seus atributos vc só precisa usar o mtw:out value=“username” por exemplo.

com JSTL ficaria assim:

c:out value="${action.output.user.username}"

A idéia é colocar o bean num contexto pois daí vc pode criar uma infinidade de tags para acessar esse contexto, como é o caso do user:avatarImg, no final do tutorial.

Já o loop é necessário para loopar um contexto de lista. A dúvida que surge é porque não fazer o próprio mtw:list loopar ? A resposta é porque vc quer usar tags como isEmpty entre a declaração do contexto e o loop.

Faz sentido?

Dá para usar JSTL com EL pra tudo, mas usando as tags do framework fica mais limpo e direto.

Achei o mesmo. Uma coisa, vendo as tags me lembrei um pouco do tempo que eu trabalhava com ColdFusion

<cfif x="a"> foo <cfelseif x="b"> xazam <cfelse> yada yada </cfif>

Quer dizer que ainda existem 2 contextos antes de se chegar a alguma coisa que o usuário tenha colocado por lá? Action e output?

Acho que isso tá meio complicado demais…

O melhor mesmo era que ele simplesmente fizesse ${usuario.nome} e desse um print no usuário.

Eu acho que taglibs só devem ser criadas quando for uma coisa absolutamente necessária, se já tem uma ótima forma de se fazer isso, pra que reinventar a roda? Pra que fazer o cara ter que entender ainda mais coisas do que EL e JSTL? Isso é realmente necessário? Vai facilitar ou atrapalhar o serviço dele?

E porque não usar o “forEach” pra fazer os loops? É exatamente pra isso que ele serve.

Maurício Linhares:

Quer dizer que ainda existem 2 contextos antes de se chegar a alguma coisa que o usuário tenha colocado por lá? Action e output?

Acho que isso tá meio complicado demais…

Não digo que fica complicado, porque é obvio que vc tem action.input, action.output e action.session, mas realmente fica mais verbose.

A solução seria criar um filtro (ou fazer isso para todas as action mesmo, independente de filtro) para pegar os elementos do output e jogar no request. Daí o cara acessa: c:out value=“user.username” ao invés de c:out value=“action.output.user.username”

As tags de JSTL são genéricas, isto é são pau pra toda obra, logo elas não são tão clean assim. Já as tags do framework, por serem integradas com o framework são mais consisas.

Por exemplo:

Como eu faço isso com JSTL, assumindo que eu tenho uma lista de usuários chamada users no request. (Primeiro problema sério: a interface List não tem getSize, só size que o EL não pega!)

[color=red]Alguem bom de JSTL poderia passar o código abaixo para JSTL para fazermos uma comparação de simplicidade e objetividade?[/color]

<mtw:list value="users">
<mtw:isEmpty>
Vc não tem nenhum amigo!
</mtw:isEmpty>
<mtw:isEmpty negate="true">
<table><tr><td>Nome</td><td>Email</td></tr>
</mtw:isEmpty>
<mtw:loop>
<tr>
<td><mtw:out value="username" /></td>
<td><mtw:out value="email" /></td>
</tr>
</mtw:loop>
<mtw:isEmpty negate="true">
</table>
</mtw:isEmpty>
</mtw:list>

Acho que menos verbose que isso impossível. Com JSTL deve ficar bem mais verbose. E espere até vc ver os tags de paginação.

O que eu estou defendendo é que embora vc consiga tudo com JSTL, eles são bastante verboses por serem genéricos. Acredito que com os tags do framework as coisas ficam mais limpas e claras.

Eu acho que complica Sérgio, se eu estudei um livrão de 800 páginas que me dizem que a sessão fica no map implícito do jsp chamado ${session}, quando eu usar o seu framework eu quero que ele esteja lá também, porque eu aprendi que a coisa funciona assim, já é natural buscar as coisas seguindo a especificação.

Eu voto no filtro pra cuidar disso.

Eu achei o “isEmpty” interessante, mas ainda assim não acho que isso é o tipo de processamento que deva ser feito na própria página, isso é coisa pra se fazer no action.

E não dá pra passar esse código pra JSTL não, exatamente por causa do “isEmpty”.

Maurício Linhares:

Eu acho que complica Sérgio, se eu estudei um livrão de 800 páginas que me dizem que a sessão fica no map implícito do jsp chamado ${session}, quando eu usar o seu framework eu quero que ele esteja lá também, porque eu aprendi que a coisa funciona assim, já é natural buscar as coisas seguindo a especificação.

Concordo! Deixa eu apenas tentar defender o meu ponto mais uma vez, pois acho que vc está sendo um pouco resistente. (Sem bronca porque tu ajuda demais Mauricio! Só tenho que te agradecer pelo seu feedback sempre com questões interessante!)

Aprender e se acostumar com um sistema de tags ridículo como esse é tranquilo. Não é nada que vai te tomar mais do que 15 minutos. São tags intuitivas, mais até que o JSTL. JSTL te obriga a declarar a todo momento a qual contexto vc se refere, já com as tags do framework esse contexto fica implícito, me entende.

Como vc faria isso na action ??? Meteria uma boolean no output só para dizer se está empty ou não ??? Hummm… Isso é realmente legal ? Pode ser, não tenho certeza… Toda action que meter uma lista no output, vai ter que meter esse boolean tb para dizer se está empty ou não ??? Meio esquisito na minha cabeça…

Então temos um problema. Se vc não está conseguindo imagina o Zé Mané que tá começando agora?

Se não for te dar muito trabalho, solucione a questão do isEmpty como vc desejar e passe esse código para JSTL, assim poderemos fazer uma comparação boa.

Imagine paginação, que é algo importante pra caramba. Eu tenho uns tags aqui que fazem isso de uma maneira limpa e transparente, pois toda a lógica está dentro do tag e se comunica com o framework.

Agora como é que vc faz paginação com JSTL ??? Fica uma zona incrível !!! Só se vc fizer isso na action, mas aí tu já começa a poluir a action, me entende. Esse tag de paginação é uma mão na roda!

saoj:

<mtw:list value="users">
<mtw:isEmpty>
Vc não tem nenhum amigo!
</mtw:isEmpty>
<mtw:isEmpty negate="true">
<table><tr><td>Nome</td><td>Email</td></tr>
</mtw:isEmpty>
<mtw:loop>
<tr>
<td><mtw:out value="username" /></td>
<td><mtw:out value="email" /></td>
</tr>
</mtw:loop>
<mtw:isEmpty negate="true">
</table>
</mtw:isEmpty>
</mtw:list>

Acho que menos verbose que isso impossível. Com JSTL deve ficar bem mais verbose. E espere até vc ver os tags de paginação.

Bom, vejamos como isso ficaria se vc estivesse usando Ruby On Rails, e dai vamos ver quem ganha no quesito expressividade, ok?

<% if @users.empty? %> Voce nao tem nenhum amigo! <% else %> <table><tr><td>Nome</td><td>Email</td></tr> <% @users.each |u| do %> <tr> <td>${u.username}</td> <td>${u.email}</td> </tr> <% end %> <% end %>

Opinioes?

Eu ia até responder… mas fiquei envergonhado :shock:

A proposito, vc nao precisa de isEmpty se o seu loop tiver um “else”. Em Python funciona assim, e o codigo fica com cheirinho de chiclé:

foo = [1,2,3] for f in foo: print "foo has " + f else: print "meh!"

Ruby on Rails:

<% if @users.empty? %>
 Voce nao tem nenhum amigo!
 <% else %>
 <table><tr><td>Nome</td><td>Email</td></tr>
 <% @users.each |u| do %>
 <tr>
 <td>${u.username}</td>
 <td>${u.email}</td>
 </tr>
 <% end %>
</table>
 <% end %>

Mentawai tags: (melhorado pois minha lógica estava tosca)

<mtw:list value="users">
 <mtw:isEmpty>
 Vc não tem nenhum amigo!
 </mtw:isEmpty>
 <mtw:isEmpty negate="true">
 <table><tr><td>Nome</td><td>Email</td></tr>
 <mtw:loop>
 <tr>
 <td><mtw:out value="username" /></td>
 <td><mtw:out value="email" /></td>
 </tr>
 </mtw:loop>
  </table>
 </mtw:isEmpty>
 </mtw:list>

Ruby é melhor!!!

Mas a questão aqui é comparar com JSTL. Voltando ao mundo Java…

Nops, a EL procura em todos os contextos, em sequencia:

page -> request -> session -> aplication

Se não encontrar em nenhum não imprime nada.

Na verdade eu meto um “null” e boto um <x:choose/> na página, se for null faz “blablabla” se não for roda o loop. Fica do mesmo jeito do seu, só que com mais palavrinhas (mas não dá nem pra comparar nenhum dos dois com RoR).

Só com JSTL é impossível, não dá pra chamar métodos usando EL, só propriedades. Tem que fazer alguma coisa no action, como eu faço, ou então criar uma tag como as suas pra fazer isso.

Isso é extremamente relativo, porque paginação é uma coisa que tem muitas variáveis, acho que um bom exemplo disso é o DisplayTags, que tem um monte de opções pra serem colocadas, como ordenação e tudo mais. Acho que nesse caso não tem uma solução “simples” não, cada caso termina sendo um caso diferente, só dá pra “generalizar” se você vai usar um “componente” (como o DisplayTag) ou então JSF.

Nops, a EL procura em todos os contextos, em sequencia:

page -> request -> session -> aplication

Se não encontrar em nenhum não imprime nada.

O contexto que eu estava me referindo é o nome da variável e não o escopo. (Me expressei mal!) No mentawai quando vc faz um <mtw:out value=“username”/> o user, que é o nome da variável em questão está impícito.

Concluindo: quer usar JSTL, use JSTL, pois o framework te dá essa opção. Quer brincar com as tags do framework então brinque.

Po, vou pegar um exemplo das tags de paginação e colocar aqui para vc ver. Acho que com elas dá até pra fazer uma frente melhor com o RoR. :lol: :lol: :lol:

Como isso é feito em JSTL/EL:

<c:choose>

     <c:when test="${users == null}">
          Você ainda não tem nenhum amigo.
     </c:when>

     <c:otherwise>

               <table>
                    <tr>
                         <td>Nome</td>
                         <td>Email</td>
                   </tr>

          <c:forEach items="${users}" var="user">
                   <tr>
                         <td><c:out value="${user.nome}" /></td>
                         <td><c:out value="${user.email}" /></td>
                   </tr>
          </c:forEach>

                </table>

     </c:otherwise>

</c:choose>

Ah, outra coisa Sérgio, como é que eu faço pra acessar propriedades aninhadas dos objetos?

Imagine que o usuário tem uma propriedade nome que tem mais duas propriedades, primeiroNome e segundoNome, como eu acesso isso?

Eu ainda prefiro assim…

#if ($users.isEmpty())
      Você ainda não tem nenhum amigo.
    #else
      <table>
        <tr>
          <td>Nome</td>
          <td>Email</td>
        </tr>
        #foreach ($user in $users)
        <tr>
          <td>$user.nome</td>
          <td>$user.email</td>
        </tr>
	#end
      </table>
    #end

Pessoal,

A grande vantagem da EL está em suprimir o tamanho da sintaxe?

Sem +!

Maurício Linhares:

Ah, outra coisa Sérgio, como é que eu faço pra acessar propriedades aninhadas dos objetos?

Imagine que o usuário tem uma propriedade nome que tem mais duas propriedades, primeiroNome e segundoNome, como eu acesso isso?

<mtw:bean value="user">
    <mtw:bean value="nome">
        <mtw:out value="firstName"/>
        <mtw:out value="lastName"/>
    </mtw:bean>
</mtw:bean>

Nesse caso JSTL é melhor mesmo !!! :?

O Struts tinha (ainda tem, mas ninguém mais usa) uma expression language que era só clocar “.” (pontos) pra acessar as propriedades, porque você não faz assim também Sérgio?

betonit:

Pessoal,

A grande vantagem da EL está em suprimir o tamanho da sintaxe?

Sem +!

Nops, a grande vantagem da EL é poder ser colocada diretamente dentro do HTML e não deixar você chamar métodos (e isso as vezes é uma desvantagem, quando lidamos com classes antigas ou que não seguem a especificação JavaBean), apenas acessar propriedades JavaBeans.

Maurício Linhares:

O Struts tinha (ainda tem, mas ninguém mais usa) uma expression language que era só clocar “.” (pontos) pra acessar as propriedades, porque você não faz assim também Sérgio?

Isso é o que o EL do JSP faz, não? Pode ser também. Melhor do que dois tags, um dentro do outro, né ? Se bem que dois tags criam dois contextos (um com o objeto user e outro com o objeto name por exemplo) e isso pode ser útil caso vc queira fazer mais coisas com esses contextos.

Mauricio:

Nops, a grande vantagem da EL é poder ser colocada diretamente dentro do HTML e não deixar você chamar métodos (e isso as vezes é uma desvantagem, quando lidamos com classes antigas ou que não seguem a especificação JavaBean), apenas acessar propriedades JavaBeans.

Só uma observacao, Mauricio. Isso não funciona com JSTL/EL:

<h4>${user.username}</h4>

Tem que ser assim:

<h4><c:out value="${user.username}" /></h4>

Ou seja, vc tem que usar EL dentro das tags de JSTL, certo?

Não, EL foi feita pra ser usada fora das tags :mrgreen:

Eu realmente não sei porque o pessoal usa <x:out/> pra fazer isso.

Pelo menos desde que eu aprendi a usar isso eu uso assim.

Ah, EL pode ser usada também pra fazer comparações que retornam um boolean.

saoj:

Ruby é melhor!!!

Mas a questão aqui é comparar com JSTL. Voltando ao mundo Java…

Nao entendi pq vc vai basear a sua performance em cima de um negocio que ja foi dito que eh ruim. Voce devia estar tentando bater o Rails, nao fazer uma JSTL que nao fede. :?

Maurício Linhares:

Não, EL foi feita pra ser usada fora das tags :mrgreen:

Eu realmente não sei porque o pessoal usa <x:out/> pra fazer isso.

Pelo menos desde que eu aprendi a usar isso eu uso assim.

[color=red][size=18]Mas não funciona !!! Eu testei aqui !!! Como faz isso funcionar, se é que vc não está enganado ???[/size][/color]

Rapaz, eu realmente não imagino porque não funciona aí, mas desde que eu comecei a trabalhar com JSPs eu faço assim (Servlet 2.4 e JSP 2.0).

Você tá usando um servlet container compatível com essas especificações? Tem algum SCWCD 1.4 por aqui?

Sim, to usando a ultima versao de tudo!

Putz, agora quero fazer isso funcionar aqui…

Vou perguntar ao Google…

Agora o Mentawai tem suporte a EL e a JSTL? Oba!

Não vou mais ter que usar uma versao alterada aqui… 8) 8) 8) 8)

Outra coisa, agora o menta também tem tags de condicao? que legal!

Um abraço!

Sempre teve, só que antes vc tinha que acessar o output da action assim:

<c:out value="${action.output.user.username}" />

e agora basta assim:

<c:out value="${user.username}" />

Vc pode escolher usar só JSTL com EL, usar JSTL junto com as tags do mentawai, ou usar só as tags do mentawai, quando possível.

Tem a <mtw:if>, que serve apenas para checar equivalência, mas nada te impede de usar a <c:if> do JSTL.

Agora vc pode criar suas próprias tags condicionais de maneira muita fácil extendendo a classe org.mentawai.tag.util.ConditionalTag.

Checklist para fazer EL funcionar em qualquer canto:

-Está usando um container com servlets 2.4 e JSP 2.0? (ex: tomcat 5)
-Está escrevendo uma aplicação web para versão 2.4 de servlets? (olhe o seu web.xml)

Aqui eu tenho java 1.5, tomcat 5.5 e meu web.xml começa assim:

Funciona perfeitamente.

sergio, por que eu não deveria usar um framework já bem estabelecido, como JSF, Tapertry ou Wicket, que permitem desenvolvimento componentisado e estremamente produtivo no lugar do seu?

louds,

Eu preciso desenvolver uma aplicacao web, e eu nunca usei nenhum desses frameworks que você citou. Só sei usar o WebWork, mas não sou muito fã de xmls…

Aí eu escolho o mentawai!

Framework mvc é uma questao de gosto (a não ser que o seu chefe te obrigue a usar algum, né…). Quanto mais opcoes melhor!

O saoj, por exemplo, parece ser um kra que não gosta de xmls de configuracao, entao fez o menta…

É assim que funciona

Vc pode usar o framework que vc quiser, pois isso é questão de gosto.

O Mentawai é uma alternativa com um objetivo bem claro:

:arrow: Ser o mais simples e fácil possível

:arrow: Não fazer uso de XML

:arrow: Ser flexível para ser facilmente estendido

:arrow: Implementar o MVC da maneira mais limpa possível

Se vc acha JSF ou Tapestry produtivos, isso é uma opinião que se aplica estritamente a vc, que já deve ter uma boa experiência com esses framework.

Na minha opinião esses frameworks não são simples e são abarrotados de XML pra todo lado. Eu particularmente não gosto, mas isso é o meu gosto pessoal.

Porque vc não dá uma olhada no mentawai e contribui com dicas e sugestões ??? Sei que vc não gostou muito do Lohis, mas agora com o Mentawai que é open-source (Apache License) bem que vc podia dar algumas sugestões e dicas ao invés de simplesmente desacreditar o projeto. Não é melhor ajuda?

O Mentawai não é meu. É da comunidade. É 100% nacional! Tem muita gente dando um feedback positivo e colaborando com dicas para melhorá-lo. Eu mesmo estou começando um projeto web sério usando ele como framework, e outros estão fazendo o mesmo.

Então: Já que vc acha JSF e Tapestry mais produtivos que o Mentawai, dê um exemplo ou me ajude a fazer o Mentawai tão produtivo quanto. Eu e a comunidade te agradecemos.

Vc participa ou é o autor de algum projeto open-source?

Por pior que seja, tem coisas que ficam piores escritas em java que em xml. page-flow, por exemplo.

E quanto ao web-work, o uso de xml é bem dosado no caso dele. E se quiser pode até usar arquivos properties