Simple Tags e Tag Files - Examples

Página 1

Ambiente de Deploy - Simple Tags e Tag Files

Esse projeto trata de Simple Tags e Tag Files. Abaixo vemos o diretório do projeto.

Sobre as imagens abaixo, é importante ter em mente o seguinte:

Arquivos de Tag são arquivos que contém código JSP ( são similares a páginas JSP, mas com extensão *.tag ou *.tagx ).

Diferentemente de Simple Tags, Tag Files podem conter elementos de script (declarações, scriptlets e expressões ).

Seus arquivos de tag devem estar localizados no diretório WEB-INF/tags ou algum subdiretório do mesmo.

Mas caso você coloque seus arquivos de tag dentro de um JAR, você necessitará escrever um descritor de biblioteca de tag ( arquivo *.tld ) para localizar esses arquivos.

Nesse caso, o arquivo *.tld deve estar localizado dentro do diretório META-INF ou algum subdiretório do mesmo e o arquivo *.tag deve estar localizado no diretório META-INF/tags

Deve-se colocar o arquivo *.tld de Simple Tags dentro do diretório WEB-INF/ ou em um subdiretório do mesmo, caso o arquivo não esteja dentro de um JAR. Caso o arquivo *.tld esteja dentro de um JAR, coloca-se esse arquivo dentro do diretório META-INF/ ou em algum subdiretório do mesmo. Em ambos os casos utiliza-se o elemento < uri > declarado no *.tld para utilizar as tags na página JSP e localizar o manipulador de tags da Simple Tag através do comando < %@ taglib %> e de seu atributo uri.

Página 2

Arquivo IterationTag.java

Todo manipulador de tag ( Tag Handler ) de Simple Tags deve implementar a interface SimpleTag.

A classe SimpleTagSupport é a classe padrão que implementa a interface SimpleTag, sobrescrevendo e fornecendo uma implementação padrão de todos os seus métodos e fornecendo os métodos:

getJspContext() - retorna um JspContext ( superclasse de PageContext ), utilizado para acessar variáveis implícitas e atributos de escopo.

getJspBody() - obtém um objeto JspFragment para processamento do corpo da tag.

findAncestorWithClass() - retorna a tag ancestral com a classe especificada.

O ciclo de vida de uma SimpleTag envolve a chamada via container dos seguintes métodos nessa ordem: setJspContext(), setParent(), setJspBody() e doTag().

No código abaixo, vemos um manipulador de tag chamado IterationTag utilizado para repetir um trecho de código no corpo da tag dependendo do valor armazenado no atributo estático repetitions.

Um atributo de tag deve constar no manipulador de tag como um atributo de classe private, constando métodos getters e setters públicos no padrão JavaBeans de modo que possa ser usado em páginas JSP.

Todo código referente ao processamento da tag é realizado no método doTag() em Simple Tags. Diferentemente do que ocorre em Classic Tags, cujo processamento da tag será dividida pelos métodos doStartTag(), doAfterBody() e doEndTag().

Atentar para o fato de que nenhum método de Simple Tag nos auxilia a acessar e manipular o conteúdo do corpo da tag como faríamos com Classic Tags. No caso de Simple Tags, apenas podemos processar o corpo da tag, não podemos alterá-lo!

O método getJspBody() retornará um objeto JspFragment e a chamada ao método invoke() requer como argumento um objeto JspWriter para informar para onde enviar a saída do processamento do código entre as tags. Como vemos no código abaixo, a chamada a getJspBody().invoke(null); irá redirecionar a saída ao objeto JspWriter do JSP corrente.

Página 3

Arquivo MathTag.java

No manipulador de tags de Simple Tag abaixo, a chamada a getJspContext().getOut() retorna um objeto JspWriter associado a página JSP que chama a Simple Tag MathTag.

O objeto JspWriter é utilizado para enviar caracteres de texto à saída JSP. No caso abaixo, a chamada irá enviar "A raiz quadrada de 289 eh ... " sendo executada a função Math.sqrt(x) cujo resultado também será impresso.

Página 4

Arquivo MathTagVersion2.java

O exemplo abaixo ilustra como obter e processar atributos dinâmicos no manipulador de tags. Para fazer isso, o manipulador de tags além de estender a classe padrão SimpleTagSupport, deve ainda implementar a interface DynamicAttributes e sobrescrever seu método setDynamicAttribute(String uri,String localName, Object value), que será chamado para cada atributo dinâmico encontrado ( atributos não mencionados no arquivo *.tld ). Após a chamada aos Setters de cada atributo estático e a chamada a setDynamicAttribute() para cada atributo dinâmico, o container chamará doTag().

Repare que para cada atributo dinâmico, o código em MathTagVersion2.java verifica se o localname ( nome do atributo ) é "min", "max" ou "pow" e respectivamente irá calcular e mostrar na tela o valor mínimo, o valor máximo ou a potência entre a variável estática num e o valor da variável dinâmica, dada por val.

Página 5

Arquivo MathTag.tld

O arquivo MathTag.tld abaixo é utilizado para associar nomes de tags e atributos de tag às classes java manipuladoras de tag.

Para um arquivo *.tld são tags obrigatórias:

< uri >: fornece uma String a ser chamada na página JSP através do atributo uri da diretiva < %@taglib % > para identificar a biblioteca de tags a ser utilizada. A tag < uri > deve ser única para cada arquivo *.tld.

< tlib-version > : versão da biblioteca de tags a ser utilizada.

< jsp-version > : versão do documento JSP a ser utilizado.

< tag >: todo arquivo *tld deve ter ao menos um elemento < tag >

O elemento < taglib > delimitando a biblioteca de tags.

Para o elemento < tag > são obrigatórios:

< name > : o nome da tag.

< tag-class >: o nome e caminho completo da classe manipuladora de tags dessa tag.

< body-content >: o conteúdo do corpo da tag. Pode receber os valores de empty, tagdependent, JSP, scriptless sendo que será inválido para o descritor de biblioteca de tags de uma Simple Tag especificar body-content como JSP ( uma SimpleTag não pode conter scripts – declarações, expressões ou scriptlets )

O elemento < attribute > define os atributos da tag como nome < name >, se o atributo é obrigatório < required >, e se aceita valores avaliados em tempo de requisição < rtexprvalue >.

O elemento < dynamic-attributes > especifica se a tag em questão aceita ou não atributos dinâmicos e em caso afirmativo, o manipulador de tag deve implementar a interface DynamicAttributes e sobrescrever seu método setDynamicAttribute(String URI, String localName, Object value)

Página 6

Arquivo example.tag

Exemplo simples de uma arquivo de tag chamado example.tag.

Repare que que é declarada uma variável através da diretiva < %@variable name-given="x" %>, cujo nome é x, e configurado seu valor para 'Hooray' através da tag JSTL da biblioteca core < c:set >.

É utilizada ainda a tag JSTL core c:forTokens de modo a imprimir a String configurada em items, quebrando-a pelo delimitador 'delims' de espaço em branco e armazenando cada parte na variável "fibNum" para posterior impressão de forma iterativa.

Página 7

Arquivo bodyAction.tag

A action JSP padrão jsp:doBody processa o conteúdo de dentro do corpo da tag.

Quando se recebe o conteúdo do corpo da tag através de jsp:doBody, pode-se armazenar esse conteúdo em uma variável com o atributo var ou armazenar o conteúdo do corpo da tag em um objeto Reader através do atributo varReader.

Assim, é declarada um atributo de tag file cujo nome é att, sendo obrigatório ao se usar < test: bodyAction att="algo" > através da diretiva < %@ attribute % >.

Caso att tenha o valor de "var", o corpo da tag será armazenado em uma variável String chamada "bodyvar", caso att tenha o valor de "reader", o conteúdo do corpo da tag será armazenada em um Reader chamado "bodyReader" e caso contrário o corpo da tag será impresso na página.

Página 8

Arquivo invoke.tag

No exemplo abaixo, o arquivo de tag especifica dois atributos obrigatórios de nomes "frag" e "proc".

Devido ao fato de que "frag" possui a propriedade fragment configurada para "true", tal variável armazenará automaticamente o conteúdo do corpo da tag em um objeto JspFragment.

Caso o valor do atributo proc seja "yes", será chamada a action padrão JSP < jsp:invoke >, que retornará o valor de JspFragment armazenado na variável frag como uma variável String à saída da página JSP.

Página 9

Arquivo showDynamics.tag

Aqui vemos um arquivo de tags utilizado para configurar atributos dinâmicos.

Repare que para fazer com que um arquivo de tag aceite atributos dinâmicos, devemos utilizar uma diretiva especial usada para tag files chamada < %@tag %> e configurar uma variável especial que receberá os valores dos atributos dinâmicos através da propriedade dynamic-attributes dessa diretiva.

No exemplo abaixo, isso é feito e a variável que receberá os atributos dinâmicos é configurada através do comando < %@ tag dynamic-attributes="attrib" % >

Após a página JSP declarar a tag correspondente juntamente com os atributos dinâmicos, eles serão impressos através da tag JSTL da biblioteca core < c:forEach items="${attrib}" var="att" >

Página 10

Arquivo state.tag

Aqui é informado um atributo com escopo de página chamado "x", obrigatório para utilizar a tag file. Isso é realizado através do comando

< %@attribute %>

Após o valor da variável 'x' ser configurada pela página JSP que chamar essa tag file, é realizado a comparação desse valor através da tag JSTL

< c:choose >

Caso o valor de x seja igual a "yes" será impresso na saída da JSP "Yippee!", caso contrário "Rats!" irá aparecer no browser.

Página 11

Arquivo invoke.jsp

Página invoke.jsp que executa o arquivo de tag invoke.tag.

Aqui é importante reparar que devemos informar via < %@ taglib % > o diretório padrão onde os arquivos de tags devem ser encontrados quando os mesmos não estão empacotados em um JAR, nesse caso tagdir apontará para "/WEB-INF/tags".

Aqui, é utilizada a tag desenvolvida com < inv:invoke >, configurado seu atributo obrigatório proc para o valor "yes" e configurado seu segundo atributo obrigatório de nome "frag" com auxílio de < jsp:attribute > como um corpo de tag.

Como o valor do atributo proc é "yes", o código em invoke.tag avalia e processa o corpo da tag armazenada no atributo de nome frag através comando < jsp:invoke fragment="frag" / >

Página 12

Saída de invoke.jsp

Aqui vemos a saída de invoke.jsp. Repare que o corpo da tag < inv:invoke > será processado e impresso na saída da JSP.

Página 13

Arquivo bodyAction.jsp

Aqui, configuramos um atributo de nome att e valor "var" através da tag < bodyAction >.

Conforme explicado no arquivo de tag bodyAction.tag, o corpo da tag será armazenado na variável bodyvar com escopo de aplicação. Após o retorno da tag, podemos na própria JSP imprimir o corpo da tag processado e armazenado na variável através de EL: ${bodyvar}

Página 14

Saída do arquivo bodyAction.jsp

O resultado da execução de < bod:bodyAction > é que o conteúdo do corpo da tag é armazenada na variável bodyvar. Além disso bodyAction.tag incluirá "Hello" antes do corpo armazenado na variável bodyvar.

Página 15

Arquivo dynamic.jsp

Aqui a página JSP chamará o arquivo de tag showDynamics.tag que efetuará a impressão dos valores das variáveis dinâmicas passadas. A saber, são passadas as variáveis dinâmicas de nomes first, second e third.

Página 16

Saída de dynamic.jsp

A saída de dynamic.jsp com as impressões dos valores de todas as variáveis dinâmicas passadas através da tag < dyn:showDynamics >

Página 17

Arquivo fiboTagFiles.jsp

Aqui, o arquivo de tag example.tag irá apresentar os 6 primeiros valores da sequência de Fibonacci seguida da expressão "Hooray!" na saída JSP.

Página 18

Saída de fiboTagFiles.jsp

Saída do arquivo fiboTagFiles.jsp

Página 19

Arquivo math.jsp

Esse arquivo JSP demonstra o uso da Simple Tag < math:functions > e < math:repetitions > conforme estabelecido manipulador de tag MathTag.java e MathTagVersion2.java e seus respectivos mapeamentos no TLD MathTag.tld.

Página 20

Saída de math.jsp

Aqui apresentamos a saída de math.jsp.

Página 21

Arquivo stateAttr.jsp

Aqui, utilizamos o arquivo de tag state.tag para imprimir "Yippee!" na tela caso seu atributo obrigatório x receba o valor "yes".

Caso o valor de x fosse diferente de "yes", seria mostrado "Rats!" na saída JSP.

Página 22

Saída de stateAttr.jsp

Apresentamos a saída de stateAttr.jsp.