Java Server Pages (JSPs)

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

JSP (JavaServer Page) Referência: “

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>

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:

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.

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

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.

JSP – Ciclo de Vida

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

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" %>

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.

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.

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).

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 Permite a configuração de saída para o usuário. session Fornece métodos para a manipulação de sessões.

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> <% if ((session.getAttribute("statusBasicao") != null) && (session.getAttribute("statusBasicao").equals(“sim”)) out.println(session.getAttribute("statusBasicao")); else out.println("Basicao não executado"); %>

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.

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>" %>

JSP – Exemplo de diretivas
page contentType="text/html;charset=ISO " errorPage="paginaerro.jsp" %> taglib uri=" 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>

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.

JSP – Diretiva page Permite configurar propriedades de uma JSP;
Estas propriedades são fornecidas como atributos (XML) da tag page;

JSP – Diretiva page Alguns Atributos
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 errorPage URL relativo Configura a JSP de erro import Classes e interfaces a importar Permite importação de pacotes Java padrão

JSP – Diretiva page isErrorPage true/false
Atributo Valor Descrição Default isErrorPage true/false Indica se a página receberá exceções de outras páginas false isThreadSafe Determina se o servlet gerado implementa a interface SingleThreadModel true session Indica se a página atual precisa de informações de sessão

page contentType="text/html;charset=ISO " errorPage="erro.jsp" %> taglib uri=" 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>

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.

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;

page contentType="text/html;charset=ISO " errorPage="paginaerro.jsp" %> taglib uri=" 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>

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

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

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>

JSP – Ações Padrão Tags especiais disponíveis para uso em páginas JSP;

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” 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.

JSP – 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.

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"/>

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);

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;

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>);

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.

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)

JSTL – Classes de Tags Tipo URI Prefixo Exemplo Core
c <c:nomedatag /> XML x <x:nomedatag /> Internacionalização fmt <fmt:nomedatag /> Banco de Dados sql <sql:nomedatag /> Funções fn <fn:nomedatag />

JSTL – Exemplo taglib uri=" 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>

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.

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.

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.

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;

JSTL – Classes de Tags Tipo URI Prefixo Exemplo Core
c <c:nomedatag /> XML x <x:nomedatag /> Internacionalização fmt <fmt:nomedatag /> Banco de Dados sql <sql:nomedatag /> Funções fn <fn:nomedatag />

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/>)

JSTL - XML Ações Básicas Ações de Fluxo de Controle
<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.

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:

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 />

JSTL Internacionalização (I18N) Banco de Dados Funções
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;

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.

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 !!"); }

JSP – Extensão de Funções EL – TLD
<taglib xmlns=" xmlns:xsi=" xsi:schemaLocation=" 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> …

JSP – Extensão de Funções EL – “web.xml”
<web-app xmlns=" xmlns:xsi=" xsi:schemaLocation=" version="2.4"> ... <taglib> <taglib-uri>hello_url</taglib-uri> <taglib-location>/WEB-INF/hello.tld</taglib-location> </taglib> </web-app>

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>

Exercício 12 Implemente a extensão apresentada.

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!!!

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.

JSP – Extensão de Tags – “web.xml”
<web-app xmlns=" xmlns:xsi=" xsi:schemaLocation=" version="2.4"> ... <taglib> <taglib-uri>hello_url</taglib-uri> <taglib-location>/WEB-INF/hello.tld</taglib-location> </taglib> </web-app>

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.

JSP – Extensão de Tags – TLD
<taglib xmlns=" xmlns:xsi=" xsi:schemaLocation=" 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> JSP scriptless tagdependent

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:

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;

JSP – Extensão de Tags – Constantes
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.

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)

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.

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.

JSP – Extensão de Tags – JSP 2.0 – hello.tag
tag pageEncoding="ISO " body-content="empty" %> taglib uri=" prefix="c" %> attribute name="vezes" required="true" %> <c:forEach begin="1" end="${vezes}"> <c:out value="Alô você !!!"/> </c:forEach>

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>

Java Server Pages (JSPs)

Apresentações semelhantes

Apresentação em tema: "Java Server Pages (JSPs)"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback

Login

Autorizar-se através da rede social:

Java Server Pages (JSPs)

Apresentações semelhantes

Apresentação em tema: "Java Server Pages (JSPs)"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback