Java Server Pages (JSPs)
Carlos Bazilio
Depto de Ciência e Tecnologia
Pólo Universitário de Rio das Ostras
Universidade Federal Fluminense
JSPs (JavaServer 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
2
JSP (JavaServer Page)
• Referência:
“http://java.sun.com/javaee/5/docs/api/java
x/servlet/jsp/package-summary.html”
3
JSP - 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>
4
JSP – 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
5
JSP – 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.
6
JSP – 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
7
JSP – Processo de
Compilaçã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.
8
JSP – Ciclo de Vida
9
JSP – 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
10
JSP – 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" %>
11
JSP - 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.
12
JSP – 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.
13
JSP – Variáveis PréDefinidas
• 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).
14
JSP – Variáveis PréDefinidas
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
session
Permite a configuração de saída para o usuário.
Fornece métodos para a manipulação de sessões.
15
JSP – Exemplo com
Variá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>
16
Diretivas JSP –
Exercí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.
17
JSP - 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>" %>
18
JSP – Exemplo de
diretivas
<%@ 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>
19
JSP – 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.
20
JSP – Diretiva page
• Permite configurar propriedades de
uma JSP;
• Estas propriedades são fornecidas
como atributos (XML) da tag page;
21
JSP – Diretiva page
Alguns 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 8 KB
de saída
contentType tipo MIME
Configura o tipo MIME
errorPage
URL relativo
Configura a JSP de erro
import
Classes e
interfaces a
importar
Permite importação de
pacotes Java padrão
text/html;
charset=ISO8859-1
22
JSP – Diretiva page
Atributo
Valor
Descrição
Valor
Default
isErrorPage
true/false
Indica se a página
receberá exceções de
outras páginas
isThreadSafe
true/false
session
true/false
Determina se o servlet
true
gerado implementa a
interface
SingleThreadModel
Indica se a página atual
true
precisa de informações de
sessão
false
23
JSP – Exemplo de
diretivas
<%@ 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>
24
JSP – Diretiva page
• 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.
25
JSP – 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;
26
JSP – Exemplo de
diretivas
<%@ 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>
27
</body>
</html>
Diretivas JSP –
Exercí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
28
JSP – EL (Expression
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
29
JSP - 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>
30
JSP – Ações Padrão
• Tags especiais disponíveis para uso
em páginas JSP;
31
JSP – Ações Padrão
<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” Permite o uso de JavaBeans dentro de uma JSP
id=”IDENT”
(classe Java comum, com construtor default e
scope=”ESCOPO” />
métodos get e set para atributos)
<jsp:getProperty
name=”IDENT”
property=”NOME_PROP”/>
É utilizado para acessar propriedades dentro de um
Bean.
32
JSP – Ações Padrão
<jsp:setProperty
É utilizado para configurar propriedades de um Bean.
name=”IDENT”
property=”NOME_PROP”
value=”VALOR” />
<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. 33
JSP – 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"/>
34
JSP – JavaBeans
• 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);
35
JSP – JavaBeans
• 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;
36
JSP – JavaBeans
• 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>);
37
Exercí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.
38
JSTL (JavaServer Pages
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)
39
JSTL – 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 />
40
JSTL – 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>
41
</body>
</html>
JSTL - 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.
42
JSTL - Core
• 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.
43
JSTL - Core
• 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.
44
JSTL - Core
• 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;
45
JSTL – 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 />
46
JSTL - 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/>)
47
JSTL - 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.
48
JSTL – Exercício 11
• Escolha algum canal de informações XML
(feed) de sua preferência e gera uma
página similar à seguinte página:
49
JSTL – 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 />
50
JSTL
• 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;
51
JSP – Mecanismo de
Extensã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.
52
JSP – Extensão de
Funçõ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 !!");
}
}
53
JSP – Extensão de
Funçõ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>
54
JSP – Extensão de
Funções EL – “web.xml”
<web-app 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-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>
55
JSP – Extensão de
Funções EL
<%@ taglib uri="hello_url" prefix="h" %>
<html>
<head>Exemplo de Uso de tags JSP</head>
<body>
<p>${h:SayHello()}</p>
</body>
</html>
56
Exercício 12
• Implemente a extensão apresentada.
57
JSP – 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>
HTML
Alo mundo!!!
Alo mundo!!!
Alo mundo!!!
Alo mundo!!!
Alo mundo!!!
58
JSP – Extensão de Tags
• 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.
59
JSP – Extensão de Tags
– “web.xml”
<web-app 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-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>
60
JSP – Extensão de Tags
• 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.
61
JSP – Extensão de Tags
– 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">
… <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>
JSP
<name>quant</name>
scriptless
tagdependent
<rtexprvalue>true</rtexprvalue>
62
</attribute></tag></taglib>
JSP – Extensão de Tags
• Para criação de tags personalizadas é preciso
definir uma classe que implemente uma das
interfaces, ou estenda uma das classes abaixo:
63
JSP – Extensão de Tags
– 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;
}
}
64
JSP – Extensão de Tags
– Constantes
Constante
Significado
EVAL_BODY_INCL
UDE
Retornado pelo método doStartTag(), indica que
o conteúdo do corpo da tag deve ser avaliado e
colocado na saída.
Retornado pelo método doEndTag(), indica que
o restante da JSP deve ser processada.
EVAL_PAGE
SKIP_BODY
SKIP_PAGE
Os métodos doStartTag() e doAfterBody()
podem retornar esse valor para indicar que o
corpo deve ser pulado.
Valor que pode ser retornado pelo método
doEndTag() para indicar que o restante da 65
página deve ser pulado.
Exercício 13
• 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)
66
Exercício 13
• A aplicação deve implementar os
tratadores de tag e criar telas para
cadastro de favoritos e para a listagem
destes favoritos.
67
JSP – Extensão de Tags –
Simple Tags - 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.
68
JSP – Extensão de Tags
– JSP 2.0 – hello.tag
<%@ tag pageEncoding="ISO-8859-1" bodycontent="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>
69
JSP – Extensão de Tags
– 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>
70
Download
