A Technologia Java Server Pages
Revendo a Aplicação de Compras On-line
O que é uma Página JSP?
- Uma página JSP é uma página contendo HTML, WML, XML, ... com trechos de programas
Java (elementos JSP) embutidos
- Simplificam a geração de conteúdo dinâmico porque Web Designers pode manipular as
páginas com mais facilidade do que manipulando servlets
- A página JSP é automaticamente transformada em servlet e o servlet executa no servidor
para gerar a resposta

- Segue abaixo um exemplo de uma aplicação com uma única página JSP
- Execute a aplicação aqui: http://anjinho.dsc.ufpb.br:8000/data
- A aplicação mostra a data de acordo com várias locales
- Seu browser poderá pedir a instalação do alfabeto Cirílico (ISO-8859-5)

<%@ page import="java.util.*" %>
<%@ page import="MyLocales" %>
<%@ page contentType="text/html; charset=ISO-8859-5" %>
<html>
<head><title>Localized Dates</title></head>
<body bgcolor="white">
<jsp:useBean id="locales" scope="application" class="MyLocales"/>
<form name="localeForm" action="index.jsp" method="post">
<b>Locale:</b>
<select name=locale>
<%
Iterator i = locales.getLocaleNames().iterator();
String selectedLocale = request.getParameter("locale");
while (i.hasNext()) {
String locale = (String)i.next();
if (selectedLocale != null && selectedLocale.equals(locale) ) {
%>
<option selected><%=locale%></option>
<%
} else {
%>
<option><%=locale%></option>
<%
}
}
%>
</select>
<input type="submit" name="Submit" value="Get Date">
</form>
<p>
<jsp:include page="date.jsp" flush="true" />
</body>
</html>
- Alguns comentários:
- Diretivas (<%@ page ... %>) importam classes do
package java.util e a classe MyLocales class e estabeleçam o "content type"
returnado pela página
- O elemento jsp:useBean cria um objeto contendo uma
coleção de locales e inicializa uma variável que referencia este objeto
- Scriptlets (<% ... %>):
- Recuperam o valor do parâmetro "locale"
- Iteram na coleção de nomes de locales
- Inserem texto HTML condicional na saída
- Expressões (<%= ... %>) inserem o valor de uma
variável como string na resposta
- O elemento jsp:include envia um pedido para outra página
(date.jsp) inclui sua resposta na resposta da página que faz a chamada
- Segue o conteúdo de date.jsp
<%@ page import="java.util.*" %>
<%@ page import="MyDate,MyLocales" %>
<html>
<body bgcolor="white">
<jsp:useBean id="date" class="MyDate"/>
<jsp:useBean id="locales" scope="application" class="MyLocales"/>
<%
Locale locale = locales.getLocale(request.getParameter("locale"));
if (locale != null) {
%>
<jsp:setProperty name="date" property="locale" value="<%=locale%>"/>
The date in <b><%=locale.getDisplayName()%></b> is <b><%=date.getDate()%></b>
<% } %>
</body>
</html>
- Segue o código de MyLocales.java
import java.util.*;
import java.text.DateFormat;
public class MyLocales {
HashMap locales;
ArrayList localeNames;
DateFormat dateFormatter;
public MyLocales() {
locales = new HashMap();
localeNames = new ArrayList();
Locale list[] = DateFormat.getAvailableLocales();
for (int i = 0; i < list.length; i++) {
locales.put(list[i].getDisplayName(), list[i]);
localeNames.add(list[i].getDisplayName());
}
Collections.sort(localeNames);
}
public Collection getLocaleNames() {
return localeNames;
}
public Locale getLocale(String displayName) {
return (Locale)locales.get(displayName);
}
}
Composição da aplicação DataApp
C:\... >ant data
Buildfile: build.xml
init:
data:
[mkdir] Created dir: C:\...\build\data
[copy] Copying 3 files to C:\...\build\data
[javac] Compiling 2 source files to C:\...\build\data
BUILD SUCCESSFUL
Total time: 11 seconds
- Chame o deploytool e execute as seguintes ações
- Criar a aplicação chamada DataApp
- Selecione File->New->Application
- No file chooser, navegue até to src/data
- No campo "File Name", digite DataApp
- Clique em "New Application"
- Clique em "OK"
- Criar o WAR e adicionar o Web Component à aplicação DataApp
- Selecione File->New->Web Component
- Selecione "DataApp" no combo box "Create new WAR File in
Application"
- Digite DataWAR no campo "WAR Display Name"
- Clique em "Edit"
- Navegue até build/data. Selecione index.jsp, date.jsp, MyDate.class e MyLocales.class e
clique em "Add" e então em "Finish"
- Clique em "Next"
- Clique em "JSP" no radio button "Web Component" e clique em
"Next"
- Selecione index.jsp no combo box "JSP Filename" e clique em "Finish"
- Fornecer a raiz do contexto (context root)
- Selecione DataApp
- Selecione a orelha "Web Context"
- Digite "data"
- Salve
Deployment da aplicação DataApp
- Selecionar Tools/Deploy e faça o deployment da aplicação no servidor desejado
Execução da aplicação DataApp
Composição e Deployment da Aplicação de Compras On-line
- Os exemplos de páginas JSP que veremos são baseados na aplicação de compras
on-line
(Duke's Bookstore), refeita para usar páginas JSP
- As páginas usadas são mostradas na tabela abaixo
Funcionalidade |
Páginas JSP |
Entrar na livraria |
bookstore.jsp |
Criar o banner da livraria |
banner.jsp |
Examinar o catálogo |
catalog.jsp |
Adicionar um livro à cesta de compras |
catalog.jsp
bookdetails.jsp |
Receber informação detalhada sobre um livro |
bookdetails.jsp |
Mostrar a cesta de compras |
showcart.jsp |
Remover um ou mais livros da cesta de compras |
showcart.jsp |
Comprar os livros presentes na cesta de compras |
cashier.jsp |
Receber uma confirmação de pedido |
receipt.jsp |
- Continuamos usando o banco de dados jdbc/BookDB
- Porém database.BookDB foi reescrito para ser um JavaBean (não EJB)
- Desta forma, podemos usar melhor os recursos JSP (usebean)
- database.BookDB não acessa o banco de dados diretamente mas através de um Enterprise
Bean (EJB)
- Veremos como EJBs funcionam adiante
- Por enquanto, esqueça da parte de acesso ao BD
- Outra mudança é que a aplicação usa um applet para exibir um relógio digital
- Antes de ver o código, vamos fazer a aplicação rodar ...
Composição da Aplicação
C:\...>ant livrosjsp
Buildfile: build.xml
init:
web-ejb:
[mkdir] Created dir: C:\...\build\webejb
[javac] Compiling 6 source files to C:\...\build\webejb
livrosjsp:
[mkdir] Created dir: C:\...\build\livrosjsp
[copy] Copying 11 files to C:\...\build\livrosjsp
[javac] Compiling 8 source files to C:\...\build\livrosjsp
[war] Building war: C:\...\build\livrosjsp\livrosjsp.war
BUILD SUCCESSFUL
Total time: 11 seconds
- Inicie o servidor J2EE (j2ee -verbose)
- Inicie o banco de dados (cloudscape -start)
- Caso não tenha criado o banco de dados de livros, veja aqui
- Este é o mesmo banco de dados usado com servlets (BookDB)
- Inicie o deploytool
- Criar uma aplicação J2EE chamada LivrosJSPApp
- Selecione File->New->Application
- No file chooser, navigue até src/livrosjsp
- No campo "File Name", digite LivrosJSPApp
- Clique em "New Application"
- Clique em OK
- Adicione Livrosjsp.war à aplicação LivrosJSPApp
- Selecione File->Add to application->Web WAR
- No dialogo, navegue até build/livrosjsp. Selecione livrosjsp.war. Clique em "Add
Web WAR"
- Adicione o Enterprise Bean BookDBEJB à aplicação
- Selecione File->New Enterprise Bean ou o botão "New Enterprise Bean"
- Na combo box "Create New JAR File in Application", selecione LisvrosJSPApp
- No campo "JAR Display Name", digite BookDBJAR
- Clique em Edit para adicionar arquivos ao conteúdo
- Neste dialog box (Edit Contents), navegue até o diretório build/webejb e adicione os
packages database e exception. Clique em OK e clique em Next
- Escolha Session e Stateless como tipo de Bean
- Em Enterprise Bean Class, selecione database.BookDBEJBImpl
- Na caixa "Remote Interfaces", selecione database.BookDBEJBHome para
"Remote Home Interface" e database.BookDBEJB para "Remote Interface"
- No campo "Enterprise Bean Name", digite BookDBEJB
- Clique em Next e Clique em Finish
- Adicione a BookDBEJB uma referência de recurso para o banco de dados
- Selecione o enterprise bean BookDBEJB
- Selecione a orelha "Resource Refs"
- Clique em Add
- Selecione javax.sql.DataSource na coluna Type
- Digite jdbc/BookDB no campo "Coded Name"
- Digite jdbc/BookDB no campo "JNDI Name"
- Salve o BookDBJAR
- Selecione BookDBJAR
- Selecione "File-Save As"
- Navegue até o diretório build/webejb
- Digite bookDB.jar no campo "File name"
- Clique em "Save EJB JAR As"
- Adicione uma referência á Enterprise Bean BookDBEJB
- Selecione LivrosJSPWAR
- Selecione a orelha "EJB Refs"
- Clique em Add
- Digite ejb/BookDBEJB na coluna "Coded Name"
- Selecione Session na coluna Type
- Selecione Remote na coluna Interfaces
- Digite database.BookDBEJBHome na coluna "Home Interface"
- Digite database.BookDBEJB na coluna "Local/Remote Interface"
- Especifique nomes JNDI
- Selecione LivrosJSPApp
- Selecione a orelha "JNDI Names"
- Na tabela "Application", localize o componente EJB e digite BookDBEJB na
coluna "JNDI Name"
- Na tabela "References", localize "EJB Ref", e digite BookDBEJB na
coluna "JNDI Name"
- Na tabela "References", locate o componente "Resource" e
digite jdbc/BookDB na coluna "JNDI Name"
- Forneça o "context root"
- Selecione a orelha "Web Context"
- Enter ireallylovebooks
- Salve
- Faça deployment da aplicação
- Selecione Tools->Deploy
- Clique em Finish
- Abra a URL da livraria http://anjinho.dsc.ufpb.br:8000/ireallylovebooks/enter
- A primeira navegação numa página JSP é mais lenta pois o servlet está sendo criado
e compilado, antes da execução
O Ciclo de Vida de uma Página JSP
- Ao chamar uma página JSP, um servlet especial verifica se página é mais nova do que o
servlet que a representa
- Se for, o servlet é regerado a partir da JSP e recompilado
- Isso ocorre automaticamente
- Necessário para alterar aplicações sem desligar o servidor para aplicações de
missão crítica (24x7)
- Portanto, uma página JSP é, na realidade, um servlet e muito da discussão sobre
servlets se aplica aqui
Tradução e Compilação
- A tradução de uma página JSP para um servlet ocorre de acordo com as seguintes regras
básicas:
- Texto fora dos elementos JSp são impressos com out.println(...)
- Diretivas <%@ ... %> controlam como o Web Container
traduz e executa a página JSP
- "Executar a página" significa "executar o servlet gerado a partir da
página"
- Elementos de script são inseridos em Java no código fonte do servlet
- Elementos como <jsp:XXX ... /> são convertidos em
chamadas de métodos para componentes JavaBeans (não EJB) ou chamadas à API de servlet
- Depois da tradução, compilação da página e carga do servlet:
- O método jspInit() é chamado
- É comum fornecer código para este método para inicializar a página
- Vide adiante
- O método _jspService() é chamado
- Quando o servlet é removido, jspDestroy() é chamado
Execução
- As diretivas "page" podem controlar a execução da página
Bufferização
- Há bufferização automática
- O seguinte método pode alterar o parâmetros do buffer
<%@ page buffer="none|xxxkb" %>
Tratamento de erros
- Exceções podem ocorrer durante a execução da páginas JSP
- A diretiva seguinte diz o que deve ser feito quando ocorre um erro
<%@ page errorPage="file_name" %>
- Nossa aplicação usa a seguinte diretiva:
<%@ page errorPage="errorpage.jsp"%>
- No início de errorpage.jsp, há a diretiva seguinte que diz que a página está
tratando um erro
<%@ page isErrorPage="true" %>
- Esta diretiva disponibiliza o objeto de exceção (da classe
javax.servlet.jsp.JspException) para a página de erro para que você possa tratar a
exceção adequadamente
- A errorpage.jsp completa aparece abaixo
- A variável "exception" representa um objeto implícito disponibilizado pelo
container
<%--
Copyright 2001 Sun Microsystems, Inc. All Rights Reserved.
This software is the proprietary information of Sun Microsystems, Inc.
Use is subject to license terms.
--%>
<%@ page isErrorPage="true" %>
<%@ page import="java.util.*" %>
<%
ResourceBundle messages = (ResourceBundle)session.getAttribute("messages");
if (messages == null) {
Locale locale=null;
String language = request.getParameter("language");
if (language != null) {
if (language.equals("English")) {
locale=new Locale("en", "");
} else {
locale=new Locale("pt", "");
}
} else
locale=new Locale("en", "");
messages = ResourceBundle.getBundle("BookStoreMessages", locale);
session.setAttribute("messages", messages);
}
%>
<html>
<head>
<title><%=messages.getString("ServerError")%></title>
</head>
<body bgcolor="white">
<h3>
<%=messages.getString("ServerError")%>
</h3>
<p>
<%= exception.getMessage() %>
</body>
</html>
Inicialização e Finalização de uma Página JSP
- A inicialização é feita em jspInit() e a finalização em jspDestroy()
- Os servlets que precisam acessar o banco de dados (catalog.jsp, bookdetails,
showcart.jsp, bookstore.jsp) incluem uma página de inicialização
<%@ include file="initdestroy.jsp" %>
- Esta página define os métodos jspInit() e jspDestroy()
- jspInit obtém acesso a um EJB que acessa o banco de dados
- Detalhes sobre EJB serão vistos em outro capítulo
<%@ page import="database.*" %>
<%@ page errorPage="errorpage.jsp" %>
<%@ page import="javax.ejb.*, javax.naming.*,
javax.rmi.PortableRemoteObject, java.rmi.RemoteException,
database.BookDB, database.BookDBEJB, database.BookDBEJBHome"
%>
<%!
private BookDBEJB bookDBEJB;
public void jspInit() {
bookDBEJB =
(BookDBEJB)getServletContext().getAttribute("bookDBEJB");
if (bookDBEJB == null) {
try {
InitialContext ic = new InitialContext();
Object objRef = ic.lookup("java:comp/env/ejb/BookDBEJB");
BookDBEJBHome home = (BookDBEJBHome)PortableRemoteObject.narrow(objRef,
database.BookDBEJBHome.class);
bookDBEJB = home.create();
getServletContext().setAttribute("bookDBEJB", bookDBEJB);
} catch (RemoteException ex) {
System.out.println("Couldn't create database bean." + ex.getMessage());
} catch (CreateException ex) {
System.out.println("Couldn't create database bean." + ex.getMessage());
} catch (NamingException ex) {
System.out.println("Unable to lookup home: "+ "java:comp/env/ejb/BookDBEJB."+ ex.getMessage());
}
}
}
public void jspDestroy() {
bookDBEJB = null;
}
%>
- É também possível tratar a inicialização usando ContextListener como fizemos com
servlets
- Exercício para casa: altere a aplicação para usar um ContextListener
Criação de Conteúdo Estático
- Conteúdo estático (digamos HTML) é simplesmente escrito na página JSP
- O default é HTML, mas o atributo contentType pode ser mudado para informar o formato
adequado
- Por exemplo, para gerar WML:
<%@ page contentType="text/vnd.wap.wml"%>
Criação de Conteúdo Dinâmico
- Para gerar conteúdo dinâmico, acessam-se objetos Java usando elementos de script
Usando Objetos em Páginas JSP
- Vários objetos podem ser acessados a partir de uma página JSP
- Alguns desses objetos são automaticamente disponibilizados pelo container (objetos
implícitos)
- Outros objetos são específicos para sua aplicação
Objetos implícitos
- São criados pelo container
- Contêm informação relacionada com um pedido, uma página, uma sessão ou uma
aplicação inteira
- A tabela abaixo sumariza esses objetos
Variável |
Classe |
Descrição |
application |
javax.servlet.ServletContext |
O contexto do servlet da página JSP e de qualquer Web Component contidos
na mesma aplicação |
config |
javax.servlet.ServletConfig |
Informação de inicialização para o servlet da página JSP |
exception |
java.lang.Throwable |
Acessível apenas a partir de uma página de erro |
out |
javax.servlet.jsp.JspWriter |
O stream de saída |
page |
java.lang.Object |
A instância do servlet da página JSP processando o pedido atual.
Raramente usado por autores de páginas JSP |
pageContext |
javax.servlet.jsp.PageContext |
O contexto de uma página JSP. Provê uma API única para gerenciar
atributos com escopo. Esta API é muito usada ao implementar "tag handlers" (ver
em outro capítulo) |
request |
subtipo de javax.servlet.ServletRequest |
O pedido gatilhando a execução da página JSP |
response |
subtipo de javax.servlet.ServletResponse |
A resposta retornada ao cliente. Raramente usado por autores de páginas
JSP |
session |
javax.servlet.http.HttpSession |
O objeto de sessão com o cliente |
Objetos específicos de aplicação
- Não coloque business logic na página JSP!
- É melhor encapsular o business logic em objetos
- Melhor que sejam beans para facilitar a escrita de página JSP
- Isso permite que Page Designers se concentrem em questões de apresentação
- Há 4 formas de criar objetos numa página JSP
- A classe de servlet da página JSP pode ter, como qualquer classe, variáveis de
instância (atributos) e variáveis de classe (estáticas)
- Tais variáveis são declaradas em declarações (vide adiante) e acessadas em
scriptlets e expressões (vide adiante)
- Atributos de objetos de escopo (nos escopos ServletContext, HttpSession, ServletRequest
e PageContext) são criados e usados em scriptlets e expressões
- Componentes JavaBeans podem ser criados e acessados usando elementos JSP
Objetos compartilhados
- O container pode iniciar páginas JSPs em servlets multithreaded ou não
- Isso é indicado na sua página com a diretiva
<%@ page isThreadSafe="true|false" %>
- Com "true", o container poderá despachar pedidos de clientes diferentes para
essa página em threads diferentes
- O default é "true"
- Cuidado! Com "false", você não precisa se preocupar com o acesso simultâneo
a objetos com escopo de página mas deve continuar a tratar da concorrência em objetos em
escopos de sessão e aplicação
Elementos de Script JSP
- Elementos de scripts são usados para:
- Criar e acessar objetos
- Definir métodos
- Gerenciar o controle de fluxo
- Um dos objetivos da tecnologia JSP é de separar os dados estáticos de templates HTML e
o código necessário para gerar conteúdo dinâmico
- Portanto, evite programar na página JSP
- O uso de "custom tags", visto à frente, ajuda a minimizar a programação
- A linguagem de script é Java mas pode ser qualquer outra que possa chamar objetos Java
<%@ page language="linguagem de script" %>
- Se precisar importar classes ou pacotes:
<%@ page import="packagename.*, fully_qualified_classname" %>
- Por exemplo, na nossa aplicação, showcart.jsp faz o seguinte:
<%@ page import="java.util.*, cart.*" %>
Declarações
- Usadas para declarar variáveis e métodos
- A sintaxe é:
<%! declaração na linguagem de script %>
- Exemplo: aqui está (novamente) o arquivo initdestroy.jsp, incluído em várias páginas
JSP
<%--
Copyright 2001 Sun Microsystems, Inc. All Rights Reserved.
This software is the proprietary information of Sun Microsystems, Inc.
Use is subject to license terms.
--%>
<%@ page import="database.*" %>
<%@ page errorPage="errorpage.jsp" %>
<%@ page import="javax.ejb.*, javax.naming.*,
javax.rmi.PortableRemoteObject, java.rmi.RemoteException,
database.BookDB, database.BookDBEJB, database.BookDBEJBHome"
%>
<%!
private BookDBEJB bookDBEJB;
public void jspInit() {
bookDBEJB =
(BookDBEJB)getServletContext().getAttribute("bookDBEJB");
if (bookDBEJB == null) {
try {
InitialContext ic = new InitialContext();
Object objRef = ic.lookup("java:comp/env/ejb/BookDBEJB");
BookDBEJBHome home = (BookDBEJBHome)PortableRemoteObject.narrow(objRef,
database.BookDBEJBHome.class);
bookDBEJB = home.create();
getServletContext().setAttribute("bookDBEJB", bookDBEJB);
} catch (RemoteException ex) {
System.out.println("Couldn't create database bean." + ex.getMessage());
} catch (CreateException ex) {
System.out.println("Couldn't create database bean." + ex.getMessage());
} catch (NamingException ex) {
System.out.println("Unable to lookup home: "+ "java:comp/env/ejb/BookDBEJB."+ ex.getMessage());
}
}
}
public void jspDestroy() {
bookDBEJB = null;
}
%>
Scriptlets
- Um scriptlet contém um fragmento de código
<%
comandos na linguagem de script
%>
- Uma variável criada num scriptlet pode ser acessada em qualquer lugar da página JSP
- Exemplo: observe como showcart.jsp itera nos itens que estão na cesta de compras
(trecho em destaque)
<%@ include file="initdestroy.jsp" %>
<%@ page import="java.util.*, cart.*" %>
<%
ResourceBundle messages = (ResourceBundle)session.getAttribute("messages");
%>
<jsp:useBean id="bookDB" class="database.BookDB" scope="page" >
<jsp:setProperty name="bookDB" property="database" value="<%=bookDBEJB%>" />
</jsp:useBean>
<jsp:useBean id="cart" scope="session" class="cart.ShoppingCart"/>
<jsp:useBean id="currency" class="util.Currency" scope="session">
<jsp:setProperty name="currency" property="locale" value="<%=request.getLocale()%>"/>
</jsp:useBean>
<html>
<head><title><%=messages.getString("TitleShoppingCart")%></title></head>
<%@ include file="banner.jsp" %>
<%
String bookId = request.getParameter("Remove");
if (bookId != null) {
cart.remove(bookId);
bookDB.setBookId(bookId);
BookDetails book = bookDB.getBookDetails();
%>
<font color="red" size="+2"><%=messages.getString("CartRemoved")%><em><%=book.getTitle()%>
</em>
<br> <br>
</font>
<%
}
if (request.getParameter("Clear") != null) {
cart.clear();
%>
<font color="red" size="+2"><strong>
<%=messages.getString("CartCleared")%>
</strong><br> <br></font>
<%
}
// Print a summary of the shopping cart
int num = cart.getNumberOfItems();
if (num > 0) {
%>
<font size="+2"><%=messages.getString("CartContents")%><%=num%> <%=(num==1 ? messages.getString("CartItem") : messages.getString("CartItems"))%>
</font><br>
<table>
<tr>
<th align=left><%=messages.getString("ItemQuantity")%></TH>
<th align=left><%=messages.getString("ItemTitle")%></TH>
<th align=left><%=messages.getString("ItemPrice")%></TH>
</tr>
<%
Iterator i = cart.getItems().iterator();
while (i.hasNext()) {
ShoppingCartItem item = (ShoppingCartItem)i.next();
BookDetails book = (BookDetails)item.getItem();
%>
<tr>
<td align="right" bgcolor="#ffffff">
<%=item.getQuantity()%>
</td>
<td bgcolor="#ffffaa">
<strong><a href="<%=request.getContextPath()%>/bookdetails?bookId=<%=book.getBookId()%>">
<%=book.getTitle()%></a></strong>
</td>
<td bgcolor="#ffffaa" align="right">
<jsp:setProperty name="currency" property="amount" value="<%=book.getPrice()%>"/>
<jsp:getProperty name="currency" property="format"/> </td>
<td bgcolor="#ffffaa">
<strong>
<a href="<%=request.getContextPath()%>/showcart?Remove=<%=book.getBookId()%>"><%=messages.getString("RemoveItem")%></a></strong>
</td></tr>
<%
// End of while
}
%>
<tr><td colspan="5" bgcolor="#ffffff">
<br></td></tr>
<tr>
<td colspan="2" align="right" "bgcolor="#ffffff">
<%=messages.getString("Subtotal")%></td>
<td bgcolor="#ffffaa" align="right">
<jsp:setProperty name="currency" property="amount" value="<%=cart.getTotal()%>"/>
<jsp:getProperty name="currency" property="format"/>
</td>
</td><td><br></td></tr></table>
<p> <p>
<strong><a href="<%=request.getContextPath()%>/catalog"><%=messages.getString("ContinueShopping")%></a>
<a href="<%=request.getContextPath()%>/cashier"><%=messages.getString("Checkout")%></a>
<a href="<%=request.getContextPath()%>/showcart?Clear=clear"><%=messages.getString("ClearCart")%></a></strong>
<%
} else {
%>
<font size="+2"><%=messages.getString("CartEmpty")%></font>
<br> <br>
<center><a href="<%=request.getContextPath()%>/catalog"><%=messages.getString("Catalog")%></a> </center>
<%
// End of if
}
%>
</body>
</html>
Expressões
- Usadas parar inserir no stream de saída um string correspondendo a uma expressão
<%= expressão na linguagem de script %>
- Como exemplos, identifique o uso de expressões na página showcart.jsp, acima
Inclusão de Conteúdo numa Página JSP
- Há duas formas de incluir conteúdo numa página JSP
- Durante a tradução da página
- Durante a execução da página
- A inclusão durante a tradução é feita através de diretiva como já visto:
<%@ include file="initdestroy.jsp" %>
// ...
<%@ include file="banner.jsp" %>
- A inclusão durante a execução é feita com elemento JSP:
<jsp:include page="date.jsp"/>
- Este exemplo foi usado no exemplo "data", acima
- Quando usar a diretiva e quando usar o elemento JSP para incluir?
- Nos casos acima, qualquer um serve
- Usar o elemento JSP é um pouco mais lento
- A decisão tem a ver com a freqüência de atualização do recurso
incluído (a página)
- Se você vai alterar o conteúdo da página incluída com
frequência, é melhor usar o elemento JSP pois a última versão
sempre vai ser incluída
- Isso só aconteceria com a diretiva se houvesse recompilação da
página, o que não vai ocorrer automaticamente, porque a página
original (que faz a inclusão) não foi alterada
- Se a informação incluída mudar infrequentemente, pode usar a
diretiva
- Exemplo: se você tiver uma página mensagemDoDia.jsp, com uma
mensagem que muda todos os dias e que é incluída em várias outras
páginas JSP, pode ser mais conveniente usar o elemento JSP
Transferência de Controle para Outro Web Component
- Antes de retornar informação para o cliente, uma página JSP pode transferir o
controle para outra página:
<jsp:forward page="/main.jsp" />
Elemento Param
- Num elemento "include" ou "forward", parâmetros adicionais (al´pem
dos disponíveis no pedido original) podem ser passados:
<jsp:include page="..." >
<jsp:param name=”param1” value="value1"/>
</jsp:include>
- Nossa aplicação usa <jsp:param ...>, mas em outro contexto que não veremos aqui
(a inclusão de um applet)
Finalmente ...
- Não mostraremos todo o código fonte da aplicação aqui: as novidades já foram
tratadas
- É responsabilidade do aluno estudar o código completo da aplicação
livros programa