com Simple Tags
Conheça uma nova forma, ao mesmo tempo simples e poderosa, de criar tags customizadas no JSP 2.0
Neste artigo são apresentados os Simple Tags, uma nova técnica de implementação de bibliotecas de tags (taglibs) introduzida no JSP 2.0. Com Simple Tags, podem ser criados todo tipo de tags, com mais facilidade: desde tags com corpo vazio, passando por tags que, dependendo de uma determinada condição, incluem ou não seu corpo, até tags que processam o corpo repetidas vezes.
Os Simple Tags serão apresentados através de exemplos passo a passo, de modo a facilitar, para aqueles que já conhecem as versões anteriores de JSP, a comparação com a implementação de "tags clássicos" (JSP 1.1/1.2). Para rodar os exemplos é necessário o Tomcat 5.x e o JSDK 1.4.x – veja como preparar o ambiente necessário no quadro "Primeiros Passos".
O novo JSP
O JSP 2.0 introduz uma série de facilidades, entre as quais se destaca a Expression Language (EL), que facilita o acesso a objetos e suas propriedades, através de uma sintaxe similar à de JavaScript. A EL foi apresentada nos artigos “Novidades do JSP
· Declaração – <%! Usuario usuario; %>
· Scriptlet – <% usuario = (Usuario) request.getAttribute(“usuario”); %>
· Expressão – <%= usuario.getNome() %>
Mas o que há de errado com scripts JSP? Na verdade, depende da forma que são usados. Páginas JSP devem ser utilizadas para formatar a apresentação para os clientes, e scripts JSP permitem incluir nas páginas qualquer código Java. O problema é que, dado o seu poder e sua praticidade, desenvolvedores muitas vezes sentem-se tentados a fazer uso excessivo de scripts, não apenas para fins de apresentação, mas também para codificar regras de negócio; estas deveriam ser centralizadas em uma camada separada de componentes, como em EJBs ou em classes Java comuns.
O uso exagerado de scripts leva a sistemas com regras de negócio duplicadas, trazendo dores de cabeça na hora da manutenção. Gerentes cansados de ver enormes blocos de código Java em páginas JSP apreciarão o novo elemento
O certo é que a Expression Language vem não apenas para facilitar a manipulação de objetos e suas propriedades, mas, junto com a JSTL, oferece funcionalidade suficiente para criar qualquer tipo de apresentação, livre de scripts JSP.
EL, JSTL e Tags Customizadas
Mas o que têm a ver a EL e a JSTL com as novas formas de criação de tags em JSP 2.0? Muito. A JSTL fornece uma biblioteca padrão suficiente para implementar a maioria dos controles necessários nas páginas JSP. Como sabemos, tags customizadas permitem estender a biblioteca de tags padrão com ações especificas às necessidades de nossos projetos. Esse recurso foi incluído no JSP 1.1 e aperfeiçoado no JSP 1.2, mas quem já criou tags usando essas versões conhece a dificuldade de entender o funcionamento dos diversos métodos e tipos de retorno definidos.
Foram muitos os pedidos para que o JSP fornecesse uma forma mais simples de desenvolvimento de tags customizadas – e o grupo que controla a nova especificação atendeu às solicitações. Baseando-se na EL, foram adicionadas duas novas técnicas para a criação de tags: Simple Tags e Tag Files. Neste artigo, são detalhados os Simple Tags.
Simple Tags são mais simples de implementar que os tags clássicos (do JSP 1.1 e 1.2), pois seu objetivo é trabalhar apenas com a EL, e não com scripts JSP – porém têm o mesmo poder funcional. Toda a lógica de processamento de um Simple Tag fica em um único método, doTag(), em uma classe que implementa a interface javax.servlet.jsp.tagext.SimpleTag.
Hello Simple Tags
Nosso primeiro exemplo implementa um Simple Tag que apresenta a tradicional saudação “Hello, world!” (veja a Figura 1). Ele é constituído de três arquivos: a página que usa o tag (Hello.jsp), o descritor da biblioteca de tags (simple-tag.tld) e a classe que implementa a lógica do tag (HelloTag.java). Os leitores que conhecem as técnicas de implementação de tags das versões anteriores de JSP podem pular os primeiros passos, passando diretamente para a criação da classe.
Vale lembrar que o web.xml de JSP 2.0/Servlet 2.4 – e todos os outros descritores do J2EE 1.4 (veja links) – são definidos através de XML Schema, e não mais por DTDs (uma das vantagens disso é que não é obrigatório manter a ordem dos elementos). A Listagem 1 apresenta o descritor usado para vários exemplos deste artigo.
A página Hello.jsp (Listagem 2) demonstra o uso do Simple Tag hello. A primeira coisa a fazer é declarar a biblioteca de tags utilizada na página com a diretiva taglib, especificando o prefixo "simpletag" e a URI "javamagazine_simple_tags". Após isto podemos usar "simpletag" para referenciar qualquer tag definido na biblioteca javamagazine_simple_tags, em particular o tag chamado hello, que irá imprimir a mensagem de saudação na página.
O arquivo simple-tag.tld (Listagem 3) define as propriedades da biblioteca de tags e deve estar dentro do diretório WEB-INF, preferencialmente em um subdiretório, por exemplo WEB-INF/tlds. Lembre-se que o container irá localizar e ler automaticamente todos os arquivos com extensão .tld, identificando as possíveis bibliotecas de tags usadas pela aplicação, antes de iniciá-la.
No exemplo, é definida a versão da biblioteca ("1.0") e seu nome ("javamagazine_simple_tags"), o mesmo usado na diretiva taglib da página. O elemento
Os passos até aqui são iguais aos realizados para tags clássicos. A diferença aparece na classe de implementação (Listagem 4). Os Simple Tags estendem a classe SimpleTagSupport (que implementa a interface SimpleTag), e implementam a lógica do tag em doTag(). A classe SimpleTagSupport fornece métodos para recuperar o corpo do tag e o contexto da página, entre outras funcionalidades.
O exemplo utiliza o método getJspContext() para recuperar o contexto da página – um objeto JspContext, novo no JSP 2.0, que define métodos para manipular atributos, tratar tags aninhados e recuperar o objeto implícito out (veja mais no quadro “Mudança de Contexto”). Por fim, obtém-se do contexto a variável implícita out, usada para inserir na página a mensagem de saudação.
Definição de Atributos
O tratamento de atributos em tags em JSP 2.0 é igual ao das versões anteriores. Para incluir um atributo, devem ser definidas suas propriedades no .tld e incluído um método setXXX() correspondente na classe de implementação.
Vamos adicionar um atributo – user – para que usuários sejam cumprimentados pelo nome (veja um exemplo na Figura 2). O JSP da Listagem 5 demonstra o uso da tag com o novo atributo. Note que, para o atributo foi especificado um valor fixo, mas numa aplicação real o valor seria obtido dinamicamente, de um objeto que identificasse o usuário, geralmente usando uma expressão EL, como:
No .tld, devemos adicionar a configuração do atributo (Listagem 6). Na propriedade attribute, definimos o nome do atributo e indicamos, com rtexprvalue, que ele pode receber valores dinamicamente (ou seja, por meio de expressões EL).
Na classe de implementação, para cada atributo declarado no .tld, devemos definir um método setXXX(), que será invocado pelo container antes da chamada de doTag(). Uma implementação típica desse método guarda o valor do atributo numa variável privada, para uso posterior no processamento.Veja a implementação na Listagem 7. Note a inclusão do método setUser() e da variável privada user; observe também que, como o atributo não é obrigatório, tivemos de tratar o caso em que seja omitido.
Tags que lêem o corpo
Nos exemplos anteriores, trabalhamos apenas com tags com o corpo vazio (
Os próximos exemplos são baseados em um sistema fictício. Imagine uma versão on-line da revista, exclusiva para assinantes. Analisando os requisitos da aplicação, logo se percebe que vários elementos visuais são comuns aos artigos e que a implementação de uma biblioteca de tags facilitaria muito a editoração.
Suponha que entre os vários tags solicitados, fomos incumbidos de desenvolver uma tag que apresenta os códigos das matérias em um quadro colorido com numeração e título, conforme a Figura 3. Suponha também que os requisitos especifiquem que o código do artigo on-line deva formar parte do corpo do tag, e que o título e a numeração do tag sejam usados como atributos, com o título sendo obrigatório e a numeração, se não fornecida, assumindo o valor "1".
A página ArtigoJavaMagazine.jsp (Listagem 8) mostra como foi usado o novo tag showCode. Observe que o código é incluído no corpo do tag e que foi omitido o atributo que define a numeração.
A configuração do novo tag é bastante similar à dos outros exemplos. É adicionado um elemento
A implementação da classe necessita ser capaz de obter o corpo do tag, incluí-lo na página JSP e circundá-lo com código HTML que dê a forma e a cor pretendidas para o quadro de código. A classe é mostrada na Listagem 10. Para recuperar o corpo do tag foi utilizado o método getJspBody() de SimpleTagSupport, que retorna o corpo num objeto JspFragment ("fragmento"). Um fragmento é um objeto que encapsula uma porção de código JSP.
Nota: Cuidado para não confundir fragmentos JSP em Simple Tags com os antigos "arquivos de fragmentos" (com extensão .jspf) que foram renomeados para "segmentos" em versões recentes da especificação JSP 2.0.
O método invoke() de JspFragment processa o código JSP do fragmento. Quando invoke() recebe null como parâmetro, ele direciona a saída para o JspWriter da página, fazendo com que o corpo do tag seja incluído na página JSP. O restante do código inclui métodos setXXX() para os atributos title e number, e usa o objeto out para circundar o corpo do tag com tags HTML.
Tags que Modificam o Corpo
Suponha agora, que, poucos dias após disponibilizar o novo tag para uso, foi recebida uma reclamação indicando que não estava funcionando corretamente. Uma captura de tela, enviada por e-mail, mostrava um artigo onde se podia constatar o problema (Figura 4). Por que o código do arquivo web.xml não aparece no quadro corretamente?
Analisando a página JSP (Listagem 11), nota-se que o código a ser mostrado no quadro contém tags que estão sendo enviadas ao navegador, e que são ignoradas por ele, por não serem reconhecidas como tags HTML - o navegador desconhece as tags como ...
