Java Server Pages (JSPs) Carlos Bazilio Depto de Ciência e Tecnologia Pólo Universitário de Rio das Ostras Universidade Federal Fluminense.

Java Server Pages (JSPs)Java Server Pages (JSPs)

Carlos Bazilio

Depto de Ciência e TecnologiaPólo Universitário de Rio das Ostras

Universidade Federal Fluminense

2

JSPs (JSPs (JavaServer PagesJavaServer Pages))

• São uma maneira mais confortável (comparado aos servlets) de se criar páginas web dinâmicas

• Aparentemente, podem ser encaradas como o oposto de servlets: servlets são classes Java gerando html, enquanto jsps são htmls com trechos de código Java

• Tecnicamente, são equivalentes: jsps são traduzidos pelo contêiner web em servlets equivalentes

3

JSP (JSP (JavaServer PageJavaServer Page))

• Referência: “http://java.sun.com/javaee/5/docs/api/javax/servlet/jsp/package-summary.html”

4

JSP - ExemploJSP - Exemplo

<html> <head> <title>JSP Básico</title> </head> <body> <h1>Um exemplo básico</h1> <% for (int i=1; i<7; i++) { out.println("<h" + i + ">Heading " + i + "</h" + i + ">"); } %> </body></html>

5

JSP – Exercício 6JSP – Exercício 6

• Copie o arquivo .jsp do exemplo para dentro do diretório de sua aplicação no Tomcat;

• Chame a página digitando a url correspondente no browser: http://localhost:8080/<diretorio_aplicacao>/<arquivo>.jsp

http://localhost:8080/%3Cdiretorio_aplicacao%3E/%3Carquivo%3E.jsp



6

JSP – Exercício 6JSP – Exercício 6

• De forma a simplificar a manutenção, supondo que os exercícios feitos até então compõe uma aplicação web, defina um servlet que receberá e tratará as requisições enviadas pelo cliente.

7

JSP – Ciclo de VidaJSP – Ciclo de Vida

• Podemos observar que, numa primeira chamada da página JSP, o browser demora um pouco para apresentar a resposta;

• Isto ocorre pois a página JSP precisa ser interpretada;

• Naturalmente, em chamadas sucessivas, o servlet não precisa ser gerado e o browser apresenta a resposta recebida mais rapidamente

8

JSP – Processo de JSP – Processo de CompilaçãoCompilação

• Solicitação para um JSP é recebida pelo contêiner

• Existem compilações de servlet com um registro de data/hora posterior ao JSP de origem?– Se não, o contêiner traduz o JSP para um servlet

Java equivalente, compila o arquivo e instancia o servlet;

• O contêiner invoca jsp_service() para executar o servlet;

• A resposta é enviada ao cliente.

9

JSP – Ciclo de VidaJSP – Ciclo de Vida

10

JSP – Servlet GeradoJSP – Servlet Gerado

• No Tomcat, o código do servlet gerado pode ser encontrado no diretório <tomcat>/work;

• Do código gerado, podemos observar que a classe <arquivo>_jsp não herda de HttpServlet, mas sim de uma especialização do fabricante;

• O método _jspService() equivale ao método service() visto anteriormente;

• Ele representa o conteúdo da JSP traduzido

11

JSP – Tipos de TagsJSP – Tipos de Tags

• Além das tags HTML, as seguintes tags podem ocorrer numa página JSP:

<% ... %> Tag de inserção de código Java <% int v = (int) (Math.random() * 10); %>

<%= ... %> Tag que gera o valor de uma expressão para ser exibido

<%= (Math.random() * 10) %>

<%! ... %> Tag de declaração. As declarações podem ser de variáveis instância ou métodos do servlet

<%! int v = (Math.random() * 10); %>

<%@ ... %> Tags para definição de diretivas: include, page e taglib

<%@ include file="formBasico.html" %>

12

JSP - ComentáriosJSP - Comentários

 Comentário copiado para a saída

<%! // ... %>

Comentários copiados para o código do servlet gerado

<%! /* ... */ %>

<%! /** ... */ %>

<% // ... %> e variantes acima

<%-- ... --%> Comentário JSP. Não é copiado nem para a saída, nem para o servlet.

13

JSP – Exercício 7JSP – Exercício 7• Crie uma página JSP para exibir a saída

abaixo. Para tal declare uma variável que irá conter uma lista de valores a serem copiados para a saída do usuário.

14

JSP – Variáveis Pré-JSP – Variáveis Pré-DefinidasDefinidas

• Auxiliam na criação de páginas JSP;• São usualmente chamadas de

objetos implícitos, pois podemos utilizá-las sem declará-las;

• Podemos encontrar estas declarações no início do método _jspService() (método do servlet gerado à partir de uma JSP).

15

JSP – Variáveis Pré-JSP – Variáveis Pré-DefinidasDefinidas

application Implementa a interface javax.servlet.ServletContext. Corresponde ao escopo de aplicação.

config É um objeto da classe ServletConfig. Ou seja, permite acessar parâmetros como os de inicialização do servlet.

out Envia dados de saída de volta para o usuário. É utilizado apenas dentro de scriptlets.

pageContext Oferece métodos para recuperação dos outros objetos implícitos.

request Permite a obtenção de informações sobre o request.

response Permite a configuração de saída para o usuário.

session Fornece métodos para a manipulação de sessões.

16

JSP – Exemplo com JSP – Exemplo com Variáveis Pré-definidasVariáveis Pré-definidas

<html><head><title>Basicão JSP</title></head> <body> <% String acessou = “sim”; session.setAttribute("statusBasicao", acessou); %> </body></html>…<html><head><title>Outro JSP</title></head> <body> <% if ((session.getAttribute("statusBasicao") != null) &&(session.getAttribute("statusBasicao").equals(“sim”))

out.println(session.getAttribute("statusBasicao")); else out.println("Basicao não executado"); %> </body></html>

17

Diretivas JSP – Diretivas JSP – Exercício 8Exercício 8

• Mostre, numa página JSP, o valor do contador criado num servlet anteriormente. Para tal, o contador deve ter sido criado como atributo.

18

JSP - DiretivasJSP - Diretivas

• São tags que fornecem ao contêiner informações sobre uma página JSP;

• Como citamos no slide Tipos de Tags, JSP possui 3 tipos de diretivas:– include– page– taglib

• As diretivas include têm a seguinte sintaxe:<%@ include file="<url_arquivo_incluido>" %>

19

JSP – Exemplo de JSP – Exemplo de diretivasdiretivas

<%@ page contentType="text/html;charset=ISO-8859-1" errorPage="paginaerro.jsp" %><%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %><html> <head> <title>Basicao JSP</title> </head> <body> <%@ include file=“saudacoes.html”%> <h1>Um exemplo basico</h1> <c:set var="indices" value="1, 2, 3, 4, 5" scope="page"/> <c:forEach items="${indices}" var="indice" varStatus="status"> <c:out value="<h${status.count}> Heading ${status.count} </h${status.count}>" /> </c:forEach> </body></html>

20

JSP – Diretiva includeJSP – Diretiva include

• Arquivos incluídos também podem ser páginas JSP;

• Esta construção tem o inconveniente de, no caso de alteração de um arquivo incluído, os arquivos que o incluem precisam ter suas datas/horas modificadas para que a alteração seja refletida;

• Esse inconveniente é resolvido pela ação <jsp:include /> (vista adiante) que resolve os elos de inclusão dinamicamente.

21

JSP – Diretiva pageJSP – Diretiva page

• Permite configurar propriedades de uma JSP;

• Estas propriedades são fornecidas como atributos (XML) da tag page;

22

JSP – Diretiva pageJSP – Diretiva pageAlguns AtributosAlguns Atributos

Atributo Valor Descrição Valor Default

autoFlush true/false Define o comportamento quando o buffer está cheio. Esvazia automaticamente ou gera uma exceção quando o buffer estoura

true

buffer none/n KB Configura o tamanho do buffer de saída

8 KB

contentType tipo MIME Configura o tipo MIME text/html;charset=ISO-

8859-1

errorPage URL relativo Configura a JSP de erro

import Classes e interfaces a importar

Permite importação de pacotes Java padrão

23


Atributo Valor Descrição Valor Default

isErrorPage true/false Indica se a página receberá exceções de outras páginas

false

isThreadSafe true/false Determina se o servlet gerado implementa a interface SingleThreadModel

true

session true/false Indica se a página atual precisa de informações de sessão

true

24


<%@ page contentType="text/html;charset=ISO-8859-1" errorPage="erro.jsp" %><%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %><html> <head> <title>Basicao JSP</title> </head> <body> <%@ include file=“saudacoes.html”%> <h1>Um exemplo basico</h1> <c:set var="indices" value="1, 2, 3, 4, 5" scope="page"/> <c:forEach items="${indices}" var="indice" varStatus="status"> <c:out value="<h${status.count}> Heading ${status.count} </h${status.count}>" /> </c:forEach> </body></html>

25


• A combinação das diretivas include e page permite, por exemplo, o compartilhamento de recursos (cabeçalhos, rodapés, etc) numa aplicação;

• Pacotes comuns podem ser importados numa única página JSP, e incluída por outras.

26

JSP – Diretiva taglibJSP – Diretiva taglib

• Mecanismo de extensão de tags;• Ou seja, permite a utilização de tags além das

pré-definidas (declaração, expressão, scriptlet e diretiva);

• Assim, podemos utilizar tags definidas por terceiros ou suas próprias tags personalizadas;

• JSTL é uma biblioteca de tags que implementa tarefas comuns e bem conhecidas, como iterações e condicionais; Visa minimizar o uso de código Java mesclado com código Html;

27


<%@ page contentType="text/html;charset=ISO-8859-1" errorPage="paginaerro.jsp" %><%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %><html> <head> <title>Basicao JSP</title> </head> <body> <%@ include file=“saudacoes.html”%> <h1>Um exemplo basico</h1> <c:set var="indices" value="1, 2, 3, 4, 5" scope="page"/> <c:forEach items="${indices}" var="indice" varStatus="status"> <c:out value="<h${status.count}> Heading ${status.count} </h${status.count}>" /> </c:forEach> </body></html>

28

Diretivas JSP – Diretivas JSP – Exercício 9Exercício 9

• Implemente o exemplo de uso de diretivas apresentado. Para tal, copie a biblioteca de JSTL (jstl.jar e standard.jar) para dentro de um dos diretórios abaixo:– <tomcat5>\commom\lib– <tomcat6>\lib– <app>\WEB-INF\lib

29

JSP – EL (Expression JSP – EL (Expression Language)Language)

• Outro recurso para especificação de páginas JSP; • Possui um conjunto de objetos implícitos próprio;• Contém conjunto abrangente de operadores;• Oferece acesso a coleções e propriedades aninhadas;• Sintaxe básica: ${ expressão em EL }• Pode ser utilizada tanto dentro de atributos de tags da

JSTL, quanto diretamente dentro de páginas;• Exemplos:

<p>1 é menor que 2: ${1<2}</p><p>6 é maior que 7: ${6 gt 7}</p><p>${cursos[‘petrobras’]}</p><p>${cursos.petrobras}</p><p>${applicationScope.statusBasicao}</p> // Idem para

sessionScope, requestScope, pageScope, param e paramValues

30

JSP - ELJSP - EL

• Especificação nova no JSP 2.0;• Ou seja, não compatíveis com versões de

contêineres que não suportam esta versão;• Mecanismo de extensão através de métodos

estáticos (visto à seguir);• Através do web.xml podemos desativá-la:

<jsp-property-group> <url-pattern>*.jsp</url-pattern> <el-ignored>true</el-ignored> </jsp-property-group>

31

JSP – Ações PadrãoJSP – Ações Padrão

• Tags especiais disponíveis para uso em páginas JSP;

32


<jsp:forward page=”URL” /> Permite o encaminhamento de uma solicitação para outro recurso dentro da mesma aplicação Web (diferente de redirecionamento). A página que encaminha não pode gerar nenhuma saída para o browser.

<jsp:include page=”URL” flush=”true/false” />

Permite a inclusão de recursos que são tratados dinamicamente (oposto da diretiva include). O atributo page indica a página a ser incluída, enquanto que o atributo flush indica se algum conteúdo no buffer antes da inclusão deve ser enviado ou não.

<jsp:useBean class=”CLASSE” id=”IDENT” scope=”ESCOPO” />

Permite o uso de JavaBeans dentro de uma JSP (classe Java comum, com construtor default e métodos get e set para atributos)

<jsp:getProperty name=”IDENT” property=”NOME_PROP”/>

É utilizado para acessar propriedades dentro de um Bean.

33


<jsp:setProperty name=”IDENT” property=”NOME_PROP” value=”VALOR” />

É utilizado para configurar propriedades de um Bean.

<jsp:plugin type=”applet” code=”.CLASS” width=”VALOR” height=”VALOR” />

Permite a execução de um plugin, com possibilidade de instalação caso o navegador não o possua.

<jsp:params /> Conjunto de parâmetros a ser passado para um plugin.

<jsp:param name=”NOME” value=”VALOR” />

Formato de um parâmetro. Pode ser passado para um forward, um include ou dentro da tag params.

<jsp:fallback /> Mensagem a ser exibida quando um navegador não entende o código HTML gerado para o plugin.

34

JSP – JavaBeansJSP – JavaBeans

<% CarroCompras carro = (CarroCompras)session.getAttribute("carrinho"); // Se o usuário não possui carro de compras if (carro == null) { carro = new CarroCompras(); session.setAttribute("carrinho", carro); }%>

<jsp:useBean id="carro" class=“pkg.CarroCompras" scope="session"/>

35


• Abordagem de desenvolvimento de componentes para JSP;

• Encapsulam a lógica do negócio;• Exemplos de uso:

– Acesso a dados de várias origens;– Validação de dados inseridos em formulários;

• Possui as vantagens do desenvolvimento baseado em componentes;

• Simplifica as páginas JSP através, por exemplo, da substituição de scriptlets de criação de objetos por tags de manipulação de beans (jsp:useBean, jsp:setProperty e jsp:getProperty);

36


• Aumento sensível de produção na utilização de formulários.

• Um bean é uma classe Java comum que respeita algumas convenções (em JSP):– Um construtor default (sem argumentos) deve

estar disponível;– Suas propriedades devem ser acessadas

através de métodos get e set;– Entretanto, é possível chamar os métodos de

um bean diretamente, dentro dos scriptlets;

37


• Observe que podemos ter uma propriedade sem termos um atributo de classe para ela; Basta oferecermos métodos get e/ou set;

• Formato dos métodos:– Para uma propriedade chamada prop,

poderemos ter os métodos <tipo_prop> getProp(); e void setProp(<tipo_prop>);

38

Exercício 10Exercício 10

• Defina uma classe como um JavaBean (construtor default e métodos get e set públicos para as propriedades) para armazenar objetos com propriedades nome e url.

• Crie um arquivo .html que conterá o formulário com campos para o cadastro de favoritos.

• Crie um arquivo .jsp que tratará estas requisições. Este deve utilizar as tags de manipulação de beans.

• Uma lista de favoritos deve ser criada (atributo de sessão, por exemplo) e, para cada nova requisição, um novo item é inserido na lista.

39

JSTL JSTL (JavaServer Pages (JavaServer Pages Standard Tag Library)Standard Tag Library)

• Uma biblioteca de tags visa minimizar o uso de código Java mesclado com código Html;

• JSTL prove tags para 5 grupos funcionais:– Tags Básicas (iteração, desvio de fluxo, saída, ..)– Tags para manipulação de documentos XML– Tags para internacionalização– Tags de acesso a banco de dados– Tags de funções (principalmente para manipulação

de strings)

40

JSTL – Classes de TagsJSTL – Classes de Tags

Tipo URI Prefixo Exemplo

Core http://java.sun.com/jsp/jstl/core c <c:nomedatag />

XML http://java.sun.com/jsp/jstl/xml x <x:nomedatag />

Internacionalização http://java.sun.com/jsp/jstl/fmt fmt <fmt:nomedatag />

Banco de Dados http://java.sun.com/jsp/jstl/sql sql <sql:nomedatag />

Funções http://java.sun.com/jsp/jstl/functions

fn <fn:nomedatag />

http://java.sun.com/jsp/jstl/core


http://java.sun.com/jsp/jstl/xml

http://java.sun.com/jsp/jstl/fmt


http://java.sun.com/jsp/jstl/sql


http://java.sun.com/jsp/jstl/functions


41

JSTLJSTL – Exemplo – Exemplo <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %><html> <head>Exemplo de Uso de tags JSP</head> <body> <h1>Lista de Codinomes</h1> <table border="1"> <c:set var="nomes" value="Bazílio, Instrutor, Carlos, Fulano"

scope="page"/> <tr><th>Codinome</th><th>Preferência</th></tr> <c:forEach var="codinome" items="${nomes}"

varStatus="status"> <tr><td><c:out value="${codinome}"/></td>

<td><c:out value="${status.count}"/></td></tr> </c:forEach> </table> </body></html>

42

JSTL - CoreJSTL - Core

• Ações Básicas Gerais– <c:out value=“expressão” />

• Semelhante a tag de expressão JSP;• O conteúdo pode ser estático ou dinâmico (composto de EL);

– <c:set var=“nome_da_variável” value=“expressão” [scope=“page | request | session | application”] />

• Define uma variável com o valor da expressão fornecida em algum escopo;

• O escopo default é o page;– <c:catch [var=“nome_da_exceção”] />

• Utilizada para capturar exceções geradas pelo código JSP englobado;

• Estas exceções não são tratadas pelo mecanismo de página de erros de JSP.

• var armazenará o conteúdo da exceção gerada.

43


• Ações Básicas Condicionais– <c:if test=“condição_de_teste” [var=“nome_da_variável”]

[scope=“page | request | session | application”] />• Corresponde ao if das linguagens de programação;• Esta ação pode ter o valor do seu teste armazenado na variável

var, do escopo fornecido;

– <c:choose />• Corresponde ao switch, para agrupamento de sentenças case;

– <c:when test=“condição_de_teste” />• Corresponde à uma sentença case;

– <c:otherwise />• Ação padrão a ser executada quando nenhuma ação when for

tomada.

44


• Ações Básicas de Iteração– <c:forEach items=“collection” [var=“nome_da_variável”]

[varStatus=“nome_da_variável_status”] [begin=“início”] [end=“fim”] [step=“passo”] />

• Corresponde ao for das linguagens de programação;• Itera sobre coleções em geral;• varStatus contém informações sobre o índice numa iteração;

– <c:forTokens items=“string_tokens” delims=“delimitadores” [var=“nome_da_variável”] [varStatus=“nome_da_variável_status”] [begin=“início”] [end=“fim”] [step=“passo”] />

• Análoga a classe StringTokenizer;• A string fornecida é subdividida em tokens de acordo com os

delimitadores fornecidos.

45


• Ações Básicas de Iteração– <c:import url=“recurso” [context=“contexto”] [var=“variável”]

[scope=“escopo”] [charEncoding=“codificação”] />• Análogo à ação padrão <jsp:include />;• Entretanto, permite a utilização de urls absolutas; ou seja, conteúdo

fora da própria aplicação;– <c:param name=“nome_parâmetro” value=“valor_parâmetro” />

• Utilizado para criação de parâmetros de solicitação para URLs pelas ações c:import, c:url e c:redirect;

– <c:redirect url=“recurso” [context=“contexto”]/>• Necessário quando se deseja abortar o processamento da JSP

corrente; Frequentemente utilizado em situações de erro;– <c:url />

• Útil na regravação de URL com ID de sessão do cliente;• Necessário quando cookies estão desabilitados;

46

JSTL – Classes de TagsJSTL – Classes de Tags

Tipo URI Prefixo Exemplo

Core http://java.sun.com/jsp/jstl/core c <c:nomedatag />

XML http://java.sun.com/jsp/jstl/xml x <x:nomedatag />

Internacionalização http://java.sun.com/jsp/jstl/fmt fmt <fmt:nomedatag />

Banco de Dados http://java.sun.com/jsp/jstl/sql sql <sql:nomedatag />

Funções http://java.sun.com/jsp/jstl/functions

fn <fn:nomedatag />



http://java.sun.com/jsp/jstl/xml







47

JSTL - XMLJSTL - XML

• Ações Básicas– Expressões de manipulação que utilizam a linguagem XPath;

• Exemplos:• $variable : procura por um atributo chamado variable no contexto

de página. Equivale a pageContext.findAttribute(“variable”)• $applicationScope$variable : procura por um atributo chamado

variable no contexto de aplicação (idem para sessionScope, pageScope, requestScope e param);

– <x:parse xml=“documento_XML” var=“nome_variável” [scope=“escopo”] />

• Percorre um documento XML;• Não faz validação frente a esquemas ou DTDs;• O atributo xml deverá conter uma variável, cujo conteúdo foi

importado através de uma url de um xml (<c:import/>)

48

JSTL - XMLJSTL - XML

• Ações Básicas– <x:out select=“expressão_xpath” [escapeXML=“{true | false}”] />

• Após a chamada da ação parse, está ação permite a extração de partes do documento XML à partir de expressões XPath;

– <x:set var=“nome_variável” select=“expressão_xpath” [scope=“escopo”] />

• Permite armazenar o resultado de uma consulta XPath para futura utilização;

• A variável utilizada pode ser definida em qualquer dos escopos vistos anteriormente;

• Ações de Fluxo de Controle– <x:if />, <x:choose /> <x:when /> <x:otherwise /> <x:forEach />– Similares às tags da biblioteca básica;– Atributo chamado select é utilizado sempre que referenciamos o

documento XML.

49

JSTL – Exercício 11JSTL – Exercício 11

• Escolha algum canal de informações XML (feed) de sua preferência e gera uma página similar à seguinte página:

50

JSTL – Exercício 11JSTL – Exercício 11

• Para tal geração, é necessário os seguintes passos:– Copiar a biblioteca Xalan (XML) para ser acessível

pela aplicação– Processar o XML da seguinte maneria:

• Escolha o canal RSS de sua preferência• Importe este link para a sua aplicação: <c:import />• Processe-o como um documento XML: <x:parse />• Percorra o documento para gerar a saída: <x:forEach />

51

JSTLJSTL

• Internacionalização (I18N)– Oferece funções de internacionalização (localidade) e

formatação de datas e números;• Banco de Dados

– Tags para consultas a banco de dados;– Naturalmente, só devem ser utilizadas em protótipos

ou aplicações simples;– Para aplicações corporativas, esses dados devem

estar encapsulados em componentes JavaBeans;• Funções

– Basicamente oferece funções para a manipulação de strings;

52

JSP – Mecanismo de JSP – Mecanismo de ExtensãoExtensão

• Incorporação de novas ações e funções que podem ser utilizadas em páginas JSP;

• Permite ampliar a separação entre os papéis do programador e do webdesigner:– O programador encapsula código Java em tags e funções EL;– O webdesigner só precisa compreender a semântica de tags e

funções e terá um tempo maior para implementar a apresentação;

• Tipos de extensão:– Novas funções para expressões EL;– Ações personalizadas;

• Ambos necessitam de 3 tarefas:– Implementação em Java da função/ação;– Criação do arquivo .tld (Tag Library Descriptor);– Atualização do descritor de implantação.

53

JSP – Extensão de JSP – Extensão de Funções ELFunções EL

• A implementação em Java é fornecida através de um método Java public static;

package helloPackage;

public class ELFunctions {public static String sayHello () {

return new String("Hello from EL !!");}

}

54

JSP – Extensão de JSP – Extensão de Funções EL – TLDFunções EL – TLD

<taglib xmlns="http://java.sun.com/xml/ns/j2ee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"

version="2.0">

<description>Hello library</description>

<display-name>Hello Tags</display-name>

<tlib-version>1.1</tlib-version>

<short-name>h</short-name>

<uri>hello_url</uri>

<function>

<name>SayHello</name>

<function-class>helloPackage.ELFunctions</function-class>

<function-signature>java.lang.String sayHello()</function-signature>

</function> …

55

JSP – Extensão de JSP – Extensão de Funções EL – “web.xml”Funções EL – “web.xml”

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"


xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"

version="2.4">

...

<taglib>

<taglib-uri>hello_url</taglib-uri>

<taglib-location>/WEB-INF/hello.tld</taglib-location>

</taglib>

</web-app>

56

JSP – Extensão de JSP – Extensão de Funções ELFunções EL

<%@ taglib uri="hello_url" prefix="h" %>

<html>

<head>Exemplo de Uso de tags JSP</head>

<body>

<p>${h:SayHello()}</p>

</body>

</html>

57


• Implemente a extensão apresentada.

58

JSP – Extensão de TagsJSP – Extensão de Tags

<%@ taglib uri="hello_url" prefix="h" %>

<html>

<head>Exemplo de Uso de tags JSP</head>

<body>

<p><h:tagqq quant=“5”></h:tagqq></p>

</body>

</html>

Alo mundo!!!Alo mundo!!!Alo mundo!!!Alo mundo!!!Alo mundo!!!

HTML

59


• Passos para geração do servlet:– Após o uso de uma tag <myprefix:mytag />,

busca-se, à partir de myprefix, a uri correspondente na página onde a mytag é usada (diretiva taglib);

– O descritor de implantação (“web.xml”) contém a associação entre a uri e o descritor da biblioteca (arquivo .tld);

– O arquivo .tld contém, para cada tag, a classe que implementa essa tag; Ou seja, conterá a classe que implementa mytag.

60

JSP – Extensão de Tags JSP – Extensão de Tags – “web.xml”– “web.xml”

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"


xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"

version="2.4">

...

<taglib>

<taglib-uri>hello_url</taglib-uri>

<taglib-location>/WEB-INF/hello.tld</taglib-location>

</taglib>

</web-app>

61


• Passos para geração do servlet:– Após o uso de uma tag <myprefix:mytag />,

busca-se, à partir de myprefix, a uri correspondente na página onde a mytag é usada (diretiva taglib);

– O descritor de implantação (“web.xml”) contém a associação entre a uri e o descritor da biblioteca (arquivo .tld);

– O arquivo .tld contém, para cada tag, a classe que implementa essa tag; Ou seja, conterá a classe que implementa mytag.

62

JSP – Extensão de Tags JSP – Extensão de Tags – TLD– TLD

<taglib xmlns="http://java.sun.com/xml/ns/j2ee"


xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd" version="2.0">

… <short-name>h</short-name>

<uri>hello_url</uri>

<tag>

<name>tagqq</name>

<tag-class>helloPackage.TagQQ</tag-class>

<body-content>empty</body-content>

<attribute>

<name>quant</name>

<rtexprvalue>true</rtexprvalue>

</attribute></tag></taglib>

JSPscriptless

tagdependent

63


• Para criação de tags personalizadas é preciso definir uma classe que implemente uma das interfaces, ou estenda uma das classes abaixo:

64

JSP – Extensão de Tags JSP – Extensão de Tags – Implementação– Implementação

package helloPackage;import java.io.IOException;import javax.servlet.jsp.tagext.TagSupport;import javax.servlet.jsp.JspException;

public class TagQQ extends TagSupport {public int doStartTag () throws JspException {

try {pageContext.getOut().print(“Alo mundo!!!");

}catch (IOException e) {

System.out.println("Erro em TagQQ");throw new JspException(e);

}return SKIP_BODY;

}}

65

JSP – Extensão de Tags JSP – Extensão de Tags – Constantes– Constantes

Constante Significado

EVAL_BODY_INCLUDE

Retornado pelo método doStartTag(), indica que o conteúdo do corpo da tag deve ser avaliado e colocado na saída.

EVAL_PAGE Retornado pelo método doEndTag(), indica que o restante da JSP deve ser processada.

SKIP_BODY Os métodos doStartTag() e doAfterBody() podem retornar esse valor para indicar que o corpo deve ser pulado.

SKIP_PAGE Valor que pode ser retornado pelo método doEndTag() para indicar que o restante da página deve ser pulado.

66


• Implemente uma biblioteca de tags que para atender aos seguintes usos numa página JSP:

<mybib:add nome=“nome_da_url” url=“url”/>• Adiciona o nome e a url a um objeto, com escopo de

aplicação, que guarda urls (alguma coleção, provavelmente criada por você para armazenar os pares).

<mybib:link pos=“posicao”/>• Retorna um link na forma <a href=“url”>nome</a>,

onde url e nome estão armazenados no objeto citado acima, na posição posicao.

• Para este exercício, inclua no projeto o .jar que contém a definição das extensões de tag: (<tomcat>\common\lib\jsp-api.jar)

67


• A aplicação deve implementar os tratadores de tag e criar telas para cadastro de favoritos e para a listagem destes favoritos.

68

JSP – Extensão de Tags – JSP – Extensão de Tags – Simple TagsSimple Tags - JSP 2.0 - JSP 2.0

• À partir da JSP 2.0, o desenvolvimento de tags personalizadas se tornou bem mais simples;

• Basicamente, precisamos fazer 3 tarefas:– Criar um diretório chamado tags, abaixo do diretório

WEB-INF (“WEB-INF/tags”), que conterá arquivos com extensão .tag para a definição das tags;

– Criar arquivos .tag para cada tag a ser utilizada; estes arquivos poderão utilizar tags como JSTL e JavaBeans, mas não poderão conter scriptlets;

– Uso das tags definidas, numa JSP, com a definição do parâmetro tagdir na diretiva taglib.

69

JSP – Extensão de Tags JSP – Extensão de Tags – JSP 2.0 – hello.tag– JSP 2.0 – hello.tag

<%@ tag pageEncoding="ISO-8859-1" body-content="empty" %><%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<%@ attribute name="vezes" required="true" %>

<c:forEach begin="1" end="${vezes}"> <c:out value="Alô você !!!"/></c:forEach>

70

JSP – Extensão de Tags JSP – Extensão de Tags – JSP 2.0 – basico.jsp– JSP 2.0 – basico.jsp

<%@ taglib tagdir="/WEB-INF/tags" prefix="tag2" %><html> <head> <title>Basicao JSP</title> </head> <body> <tag2:hello vezes="3"/> </body></html>

Java Server Pages (JSPs) Carlos Bazilio Depto de Ciência e Tecnologia Pólo Universitário de Rio das Ostras Universidade Federal Fluminense.

Documents