Simple Tags

Página 1

Agenda

Discutiremos nessa apresentação:

O ciclo de vida de uma Simple Tag.

Discutiremos a semântica do modelo de eventos de Simple Tags, onde o método de evento doTag() é executado.

Escreveremos um programa que demonstra o uso de Simple Tags: SimpleTagHandler.

Escrever um manipulador de tags e explicar as restrições no conteúdo JSP dentro da tag.

Página 2

Manipuladores de Tag - Tag Handlers

Um "Tag Handler" é uma classe Java que trabalha como uma "Tag".

Um classe manipuladora de tag ou "tag handler" tem acesso a atributos de tag, ao corpo da tag e ao objeto pageContext.

Um "Tag Handler" pode ser de dois tipos:

Simple

Classic

Os manipuladores de tag 'Simple' foram adicionados na tecnologia JSP 2.0.

Página 3

Simple Tag API

Aqui vemos a API das tags Simple Tag.

A classe SimpleTagSupport implementa a interface SimpleTag, que por sua vez implementa a interface JspTag.

Página 4

Simple Tag API (2)

Uma Simple Tag necessita implementar a interface SimpleTag.

A classe SimpleTagSupport implementa a interface SimpleTag.

Para criar Simple Tags, nós normalmente estendemos a classe SimpleTagSupport.

A classe SimpleTagSupport possui os métodos:

doTag(), que deve ser sobrescrito.

getJspBody()

setJspBody(JspFragment) além de outros métodos.

Página 5

O ciclo de vida de uma SimpleTag

Veremos aqui o ciclo de vida de uma Simple Tag:

Uma vez que uma Simple Tag é chamada no código da página JSP, a classe manipuladora de tags ou "Tag Handler" é instanciada pela chamad a um construtor sem argumentos.

O container chamará o método setJspContext(JspContext) - a subclasse da classe JspContext é PageContext.

Caso a Simple Tag esteja dentro de outra Tag, o container chamará o método getParent(JspTag).

Caso a Simple Tag tenha atributos, os métodos 'Setters' de cada um dos atributos serão chamados usando-se os padrões de nome JavaBeans ( JavaBean naming Standards ).

Caso a Simple Tag tenha um corpo, setJspBody(JspFragment) será chamado e o corpo da tag não será declarado vazio:< body-content >empty < / body-content >

O método doTag() será chamado.

Simple Tags NÃO são reutilizadas pelo container.

Página 6

Simple Tag Handler

Para que se possa criar um manipulador de Simple Tag deve-se:

Escrever uma classe que estenda a classe 'SimpleTagSupport'.

Implementar o método doTag().

Escrever o arquivo TLD.

Colocar o TLD dentro de WEB-INF ou dentro de alguma subclasse de WEB-INF e colocar a classe manipuladora de tags dentro de WEB-INF/classes exatamente como um arquivo de classe Java normal.

Escreva um arquivo *.JSP que chame a tag criada.

Página 7

TagHandler1.java

Aqui escrevemos uma classe manipuladora de tags que estende a classe SimpleTagSupport e sobrescreve o método doTag() da classe estendida exatamente como descrevemos.

O método doTag() manipulará o corpo do documento JSP imprimindo a mensagem "Hello World".

Página 8

new_taglibrary.tld

Aqui vemos o arquivo *.tld

Página 9

simpletag_example.jsp

Aqui vemos a página simpletag_example.jsp que declara a variável de acesso à tag TagHandler1 através de < %@taglib % > e a utiliza na página JSP, chamando a tag TagHandler1.

Página 10

Saída do nosso exemplo de Simple Tag

Finalmente, aqui vemos a saída do nosso exemplo de Simple Tag:

Página 11

Simple Tag com um corpo - body tag

Caso a Simple Tag necessite ter um corpo, então a classe manipuladora de tag será definida com 'getJspBody().invoke()'

Exemplo, uma chamada a 'getJspBody().invoke(null)' fará com que o corpo da tag seja processado e a saída seja impressa pelo response.

Para que isso aconteça, o arquivo *.tld deve ser definido com < body-content > NÃO tendo valor 'empty' - NÃO pode ser vazio!

Página 12

Simple Tag com um corpo - body tag

Para que tenhamos acesso ao corpo da Simple tag e possamos processá-lo, não podemos ter < body-content > empty < / body-content >

< body-content >scriptless < / body-content > seria viável!

A página JSP deverá chamar a Simple tag dessa maneira:

Página 13

Simple Tag com atributos

Imagine que o corpo da tag necessite de uma expressão como valor para um atributo.

Deve-se primeiro declarar o atributo no arquivo *.TLD.

O método setter no padrão JavaBeans terá que ser fornecido na classe manipuladora de tags.

Cada vez que a tag for chamada pela página JSP, o método setter para o atributo correspondente será chamado.

O atributo não existe até que a tag seja chamada e somente pode ser configurado através do método setter pela classe manipuladora de tags.

Página 14

Simple Tag com atributos (2)

Nós podemos configurar o valor do atributo através da chamada ao método 'getJspContext()':

Nós também podemos acessar as variáveis implícitas JSP através do método 'getJspContext()'.

Simple Tags sempre obtém uma referência ao objeto JspContext.

Página 15

JspFragment

Um JspFragment é uma classe abstrata.

Um JspFragment é uma porção de código Java que não contém scriptlets.

É frequentemente utilizado para enviar o corpo da Simple Tag para o objeto response que imprimirá o resultado na saída da página.

Página 16

SkipPageException

Caso uma excessão "SkipPageException" seja gerada, o processamento da página será interrompido.

Isso é feito especificando 'throw new SkipPageException()' no código do manipulador de tag.

O resto da tag e o restante da página não serão executados uma vez que a exceção SkipPageException for lançada.

Somente a porção da tag e a página antes do lançamento da exceção irão aparecer na página gerada.

Página 17

PageContext API

Pelo fato de manipuladores de tag não terem acesso direto à objetos implícitos, eles os obtém através da referência a PageContext.

Devemos lembrar que Simple Tags obtém uma referência a JspContext e Classic Tags obtém uma referência a PageContext.

Página 18

Conclusão

Discutimos Simple Tags e mostramos como eles podem ser criados com e sem atributos.

Vimos o ciclo de vida de uma Simple Tag.

Escrevemos um Simple Tag Handler