Upload
internet
View
102
Download
0
Embed Size (px)
Citation preview
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
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
JSP – Diretiva pageJSP – Diretiva page
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
JSP – Exemplo de JSP – Exemplo de diretivasdiretivas
<%@ 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
JSP – Diretiva pageJSP – 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.
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
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>
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 – Ações PadrãoJSP – 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” 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 – Ações PadrãoJSP – Ações Padrão
<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
JSP – JavaBeansJSP – 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);
36
JSP – JavaBeansJSP – 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;
37
JSP – JavaBeansJSP – 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>);
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 />
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
JSTL - CoreJSTL - 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.
44
JSTL - CoreJSTL - 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.
45
JSTL - CoreJSTL - 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;
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 />
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"
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>
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
Exercício 12Exercício 12
• 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
JSP – Extensão de TagsJSP – 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.
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"
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>
61
JSP – Extensão de TagsJSP – 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.
62
JSP – Extensão de Tags JSP – Extensão de Tags – TLD– 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>
<name>quant</name>
<rtexprvalue>true</rtexprvalue>
</attribute></tag></taglib>
JSPscriptless
tagdependent
63
JSP – Extensão de TagsJSP – 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:
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
Exercício 13Exercí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)
67
Exercício 13Exercício 13
• 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>