Java Server Pages JSPs Carlos Bazilio Depto de
Java Server Pages (JSPs) Carlos Bazilio Depto de Ciência e Tecnologia Pólo Universitário de Rio das Ostras Universidade Federal Fluminense
JSPs (Java. Server 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 (Java. Server 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> <h 1>Um exemplo básico</h 1> <% 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 Http. Servlet, mas sim de uma especialização do fabricante; • O método _jsp. Service() 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="form. Basico. 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 12 servlet.
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 _jsp. Service() (método do servlet gerado à partir de uma JSP). 14
JSP – Variáveis PréDefinidas application Implementa a interface javax. servlet. Servlet. Context. Corresponde ao escopo de aplicação. config É um objeto da classe Servlet. Config. 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. page. Context 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. set. Attribute("status. Basicao", acessou); %> </body> </html> … <html><head><title>Outro JSP</title></head> <body> <% if ((session. get. Attribute("status. Basicao") != null) && (session. get. Attribute("status. Basicao"). equals(“sim”)) out. println(session. get. Attribute("status. Basicao")); 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 content. Type="text/html; charset=ISO-8859 -1" error. Page="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”%> <h 1>Um exemplo basico</h 1> <c: set var="indices" value="1, 2, 3, 4, 5" scope="page"/> <c: for. Each items="${indices}" var="indice" var. Status="status"> <c: out value="<h${status. count}> Heading ${status. count} </h${status. count}>" /> </c: for. Each> </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 Atributo Valor Descrição Valor Default auto. Flush true/false Define o comportamento true quando o buffer está cheio. Esvazia automaticamente ou gera uma exceção quando o buffer estoura buffer none/n KB Configura o tamanho do buffer de saída 8 KB content. Typ tipo MIME e Configura o tipo MIME text/html; charset=ISO 8859 -1 error. Page URL relativo Configura a JSP de erro import Classes e interfaces a importar Permite importação de pacotes Java padrão 22
JSP – Diretiva page Atributo Valor Descrição Valor Default is. Error. Page true/false Indica se a página receberá exceções de outras páginas is. Thread. Safe true/false session true/false Determina se o servlet true gerado implementa a interface Single. Thread. Model Indica se a página atual true precisa de informações de sessão false 23
JSP – Exemplo de diretivas <%@ page content. Type="text/html; charset=ISO-8859 -1" error. Page="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”%> <h 1>Um exemplo basico</h 1> <c: set var="indices" value="1, 2, 3, 4, 5" scope="page"/> <c: for. Each items="${indices}" var="indice" var. Status="status"> <c: out value="<h${status. count}> Heading ${status. count} </h${status. count}>" /> </c: for. Each> </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 content. Type="text/html; charset=ISO-8859 -1" error. Page="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”%> <h 1>Um exemplo basico</h 1> <c: set var="indices" value="1, 2, 3, 4, 5" scope="page"/> <c: for. Each items="${indices}" var="indice" var. Status="status"> <c: out value="<h${status. count}> Heading ${status. count} </h${status. count}>" /> </c: for. Each> 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: – <tomcat 5>commomlib – <tomcat 6>lib – <app>WEB-INFlib 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>${application. Scope. status. Basicao}</p> // Idem para session. Scope, request. Scope, page. Scope, param e param. Values 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: use. Bean class=”CLASSE” Permite o uso de Java. Beans dentro de uma JSP id=”IDENT” (classe Java comum, com construtor default e scope=”ESCOPO” /> métodos get e set para atributos) <jsp: get. Property name=”IDENT” property=”NOME_PROP”/> É utilizado para acessar propriedades dentro de um Bean. 32
JSP – Ações Padrão <jsp: set. Property É 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 – Java. Beans <% Carro. Compras carro = (Carro. Compras)session. get. Attribute("carrinho"); // Se o usuário não possui carro de compras if (carro == null) { carro = new Carro. Compras(); session. set. Attribute("carrinho", carro); } %> <jsp: use. Bean id="carro" class=“pkg. Carro. Compras" scope="session"/> 34
JSP – Java. Beans • 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: use. Bean, jsp: set. Property e jsp: get. Property); 35
JSP – Java. Beans • 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 – Java. Beans • 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> get. Prop(); e void set. Prop(<tipo_prop>); 37
Exercício 10 • Defina uma classe como um Java. Bean (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 (Java. Server 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: nomedatag /> Banco de Dados http: //java. sun. com/jsp/jstl/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> <h 1>Lista de Codinomes</h 1> <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: for. Each var="codinome" items="${nomes}" var. Status="status"> <tr><td><c: out value="${codinome}"/></td> <td><c: out value="${status. count}"/></td></tr> </c: for. Each> </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: for. Each items=“collection” [var=“nome_da_variável”] [var. Status=“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; • var. Status contém informações sobre o índice numa iteração; – <c: for. Tokens items=“string_tokens” delims=“delimitadores” [var=“nome_da_variável”] [var. Status=“nome_da_variável_status”] [begin=“início”] [end=“fim”] [step=“passo”] /> • Análoga a classe String. Tokenizer; • 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”] [char. Encoding=“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: nomedatag /> Banco de Dados http: //java. sun. com/jsp/jstl/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 page. Context. find. Attribute(“variable”) • $application. Scope$variable : procura por um atributo chamado variable no contexto de aplicação (idem para session. Scope, page. Scope, request. Scope 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” [escape. XML=“{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: for. Each /> – 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: for. Each /> 50
JSTL • Internacionalização (I 18 N) – 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 Java. Beans; • 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 hello. Package; public class ELFunctions { public static String say. Hello () { return new String("Hello from EL !!"); } } 53
JSP – Extensão de Funções EL – TLD <taglib xmlns="http: //java. sun. com/xml/ns/j 2 ee" xmlns: xsi="http: //www. w 3. org/2001/XMLSchema-instance" xsi: schema. Location="http: //java. sun. com/xml/ns/j 2 ee/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>Say. Hello</name> <function-class>hello. Package. ELFunctions</function-class> <function-signature>java. lang. String say. Hello()</function-signature> 54
JSP – Extensão de Funções EL – “web. xml” <web-app xmlns="http: //java. sun. com/xml/ns/j 2 ee" xmlns: xsi="http: //www. w 3. org/2001/XMLSchema-instance" xsi: schema. Location="http: //java. sun. com/xml/ns/j 2 ee/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: Say. Hello()}</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!!! 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/j 2 ee" xmlns: xsi="http: //www. w 3. org/2001/XMLSchema-instance" xsi: schema. Location="http: //java. sun. com/xml/ns/j 2 ee/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/j 2 ee" xmlns: xsi="http: //www. w 3. org/2001/XMLSchema-instance" xsi: schema. Location="http: //java. sun. com/xml/ns/j 2 ee/web-jsptaglibrary_2_0. xsd" version="2. 0"> … <short-name>h</short-name> <uri>hello_url</uri> <tag> <name>tagqq</name> <tag-class>hello. Package. Tag. QQ</tag-class> <body-content>empty</body-content> <attribute> JSP <name>quant</name> scriptless tagdependent <rtexprvalue>true</rtexprvalue> 62 </attribute></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 hello. Package; import java. io. IOException; import javax. servlet. jsp. tagext. Tag. Support; import javax. servlet. jsp. Jsp. Exception; public class Tag. QQ extends Tag. Support { public int do. Start. Tag () throws Jsp. Exception { try { page. Context. get. Out(). print(“Alo mundo!!!"); } catch (IOException e) { System. out. println("Erro em Tag. QQ"); throw new Jsp. Exception(e); } return SKIP_BODY; } } 64
JSP – Extensão de Tags – Constantes Constante Significado EVAL_BODY_INC Retornado pelo método do. Start. Tag(), LUDE indica que o conteúdo do corpo da tag deve ser avaliado e colocado na saída. EVAL_PAGE Retornado pelo método do. End. Tag(), indica que o restante da JSP deve ser processada. SKIP_BODY Os métodos do. Start. Tag() e do. After. Body() podem retornar esse valor para indicar que o corpo deve ser pulado. SKIP_PAGE Valor que pode ser retornado pelo método do. End. Tag() para indicar que o restante da página deve ser pulado. 65
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>commonlibjsp-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 Java. Beans, 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 page. Encoding="ISO-8859 -1" bodycontent="empty" %> <%@ taglib uri="http: //java. sun. com/jsp/jstl/core" prefix="c" %> <%@ attribute name="vezes" required="true" %> <c: for. Each begin="1" end="${vezes}"> <c: out value="Alô você !!!"/> </c: for. Each> 69
JSP – Extensão de Tags – JSP 2. 0 – basico. jsp <%@ taglib tagdir="/WEB-INF/tags" prefix="tag 2" %> <html> <head> <title>Basicao JSP</title> </head> <body> <tag 2: hello vezes="3"/> </body> </html> 70
- Slides: 70