Professional Documents
Culture Documents
JSP e Servlets
I
JSP e Servlets
Sumário
1. Introdução .................................................................................................................1-1
Objetivos................................................................................................................................... 1-2
O que é necessário para começar ?.................................................................................... 1-3
A tecnologia servlet ................................................................................................................ 1-4
A tecnologia JSP..................................................................................................................... 1-6
Servlets e JSP na arquitetura J2EE .................................................................................... 1-8
Tipos de aplicações na WEB .............................................................................................. 1-10
Arquitetura MVC para a Web.............................................................................................. 1-11
Vantagens da arquitetura MVC .......................................................................................... 1-13
Exercícios............................................................................................................................... 1-14
2. Servlets......................................................................................................................2-1
Objetivos................................................................................................................................... 2-2
Introdução ................................................................................................................................ 2-3
Características dos servlets .................................................................................................. 2-4
Comunicação com os clientes .............................................................................................. 2-7
A API Servlet ........................................................................................................................... 2-8
Exemplo de um Servlet........................................................................................................ 2-10
Ciclo de vida do Servlet ....................................................................................................... 2-12
O método init()....................................................................................................................... 2-14
O método service() ............................................................................................................... 2-16
O método destroy()............................................................................................................... 2-17
Destruição de um Servlet .................................................................................................... 2-18
Um Servlet com os métodos do Ciclo de Vida................................................................. 2-19
Diferenças entre as requisições GET e POST ................................................................ 2-20
Concorrência ......................................................................................................................... 2-23
Obtendo Informações sobre a Requisição ....................................................................... 2-25
Controlando o fluxo............................................................................................................... 2-27
Arquivo web.xml.................................................................................................................... 2-29
Parâmetros de Inicialização ................................................................................................ 2-31
Carregando um servlet......................................................................................................... 2-33
Exercícios............................................................................................................................... 2-34
3. Sessões .....................................................................................................................3-2
Objetivos................................................................................................................................... 3-3
Utilizando Sessões ................................................................................................................. 3-4
Exercícios................................................................................................................................. 3-8
4. Formulários...............................................................................................................4-1
Objetivos................................................................................................................................... 4-2
Lidando com Formulário ........................................................................................................ 4-3
Formulários .............................................................................................................................. 4-5
Campos de texto ..................................................................................................................... 4-6
Campos de texto escondidos................................................................................................ 4-7
Campos de senha................................................................................................................... 4-8
Botões de radio ....................................................................................................................... 4-9
Campos de escolha.............................................................................................................. 4-10
II
JSP e Servlets
Listas....................................................................................................................................... 4-11
Áreas de texto ....................................................................................................................... 4-12
Botão reset............................................................................................................................. 4-13
Botão de envio....................................................................................................................... 4-14
Seleção de arquivos ............................................................................................................. 4-15
Sobre os formulários... ......................................................................................................... 4-16
Exercícios............................................................................................................................... 4-20
5. JavaServer Pages...................................................................................................5-25
Objetivos................................................................................................................................. 5-26
JSP – Como Funciona ?...................................................................................................... 5-27
Escopo de Objetos ............................................................................................................... 5-29
Diretivas.................................................................................................................................. 5-31
Diretiva include...................................................................................................................... 5-36
Simbologia – JSP Tags........................................................................................................ 5-37
Declarações ........................................................................................................................... 5-38
Expressões ............................................................................................................................ 5-39
Scriptlets................................................................................................................................. 5-40
Comentários........................................................................................................................... 5-41
Ações ...................................................................................................................................... 5-42
<jsp:include>.......................................................................................................................... 5-43
<jsp:forward> ......................................................................................................................... 5-44
Exercícios............................................................................................................................... 5-45
6. JavaBeans.................................................................................................................6-1
Objetivos................................................................................................................................... 6-2
JavaBeans ............................................................................................................................... 6-3
Regras para Escrever Beans................................................................................................ 6-4
Propriedades de um Bean..................................................................................................... 6-7
Ações ........................................................................................................................................ 6-8
<jsp:useBean>......................................................................................................................... 6-9
<jsp:setProperty>.................................................................................................................. 6-10
<jsp:getProperty>.................................................................................................................. 6-12
O Uso de JavaBeans ........................................................................................................... 6-13
Como as ferramentas lêem os Beans ?............................................................................ 6-16
JavaBeans x Enterprise JavaBeans .................................................................................. 6-17
Exercícios............................................................................................................................... 6-18
8. Cookies......................................................................................................................... 2
Objetivos...................................................................................................................................... 3
Lidando com Cookies................................................................................................................ 4
Gerenciando Cookies................................................................................................................ 7
A classe Cookie.......................................................................................................................... 8
Definindo um cookie ................................................................................................................ 10
Recuperando um Cookie ........................................................................................................ 12
Considerações finais sobre cookies ..................................................................................... 14
Exercícios.................................................................................................................................. 15
9. Finalizando a aplicação............................................................................................. 18
Exercícios.................................................................................................................................. 19
IV
JSP e Servlets
V
JSP e Servlets
1. Introdução
1-1
Introdução
Objetivos
• Entender Servlets
• Como iniciar o conhecimento
• Entender JSP
• Distinções das tecnologias para aplicação WEB
1-2
Introdução
1-3
Introdução
A tecnologia servlet
1-4
Introdução
1 Os tipos Mime representam os tipos de arquivos que são apresentados a seu browser para que ele saiba o que
está sendo baixado e apresentar o arquivo de forma apropriada. Por exemplo, um arquivo HTML que é baixado pelo
browser é indicado pelo servidor web com o tipo Mime "text/html". Já arquivos GIF recebem o tipo "image/gif". A função
Mime Type (tipo Mime) do painel de controle de sua conta permite atribuir tipos Mime a arquivos de seu site para que os
browsers de seus visitantes possam tratar esses arquivos de forma apropriada.
1-5
Introdução
A tecnologia JSP
Quem conhece servlets verá que o JSP não oferece nada que você não
possa conseguir com os servlets puros. O JSP, entretanto, oferece a vantagem de
ser facilmente codificado, facilitando assim a elaboração e manutenção de uma
aplicação. Além disso, essa tecnologia permite separar a programação lógica
(parte dinâmica) da programação visual (parte estática), facilitando o
desenvolvimento de aplicações mais robustas, onde programador e designer
podem trabalhar no mesmo projeto, mas de forma independente. Outra
característica do JSP é produzir conteúdos dinâmicos que possam ser reutilizados.
1-6
Introdução
Por definição, JSP usa Java como sua linguagem de scripts. Por esse motivo,
O JSP é mais flexível e mais robusto do que outras plataformas baseadas
simplesmente em JavaScripts e VBScripts.
1-7
Introdução
1-9
Introdução
1-10
Introdução
1-11
Introdução
1-12
Introdução
1-13
Introdução
Exercícios
1-14
Introdução
1-15
JSP e Servlets
2. Servlets
2-1
Servlets
Objetivos
• O que são Servlets
• Como usar Servlets
• Diferença de Get e Post
• Entender Concorrência
• Criar uma Servlet
2-2
Servlets
Introdução
Pelo fato dos servlets serem escritos em Java, eles se aproveitam de todos
os benefícios da plataforma Java básica: um modelo de programação orientado
a objetos, gerenciamento automático de memória, portabilidade compatível
com várias plataformas e acessam todas a APIs de Java.
2-3
Servlets
Portabilidade
Pelo fato dos servlets serem escritos em Java e de acordo com uma API
bem definida e amplamente aceita, eles são altamente portáveis em sistemas
operacionais e execuções em servidores Web. Um servlet pode ser desenvolvido
por uma máquina Windows NT executando o Java Web Service e depois portado
facilmente em um servidor Unix executando o servidor Apache.
Força
Eficácia e Resistência
2-4
Servlets
Segurança
Elegância do código
Integração
2-5
Servlets
2-6
Servlets
2-7
Servlets
A API Servlet
2-8
Servlets
Note que a classe HttpServlet é uma classe abstrata. Para criar um Servlet
que atenda requisições HTTP o programador deve criar uma classe derivada da
HttpServlet e sobrescrever pelo menos um dos métodos descritos na tabela 2-1
que segue abaixo.
Método Descrição
doGet ( ... ) Trata as requisições HTTP GET.
doPost ( ... ) Trata as requisições HTTP POST.
doPut ( ... ) Trata as requisições HTTP PUT.
doDelete ( ... ) Trata as requisições HTTP DELETE.
service ( ... ) Trata as requisições HTTP SERVICE.
Tabela 2-1: Métodos da classe HttpServlet que devem ser sobrescritos para tratar requisições HTTP.
Todos esses métodos são invocados pelo servidor por meio do método
service(). O método doGet() trata as requisições GET. Este tipo de requisição
pode ser enviada várias vezes, permitindo que seja colocada em um bookmark.
O método doPost() trata as requisições POST que permitem que o cliente envie
dados de tamanho ilimitado para o servidor Web uma única vez, sendo útil para
enviar informações tais como o número do cartão de crédito. O método doPut()
trata as requisições PUT. Este tipo de requisição permite que o cliente envie um
arquivo para o servidor à semelhança de como é feito via FTP. O método
doDelete() trata as requisições DELETE, permitindo que o cliente remova um
documento ou uma página do servidor. O método service(), que recebe todas
as requisições, em geral não é sobrescrito, sendo sua tarefa direcionar a
requisição para o método adequado.
2-9
Servlets
Exemplo de um Servlet
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
2-11
Servlets
Método Descrição
2-12
Servlets
2-13
Servlets
O método init()
2-14
Servlets
2-15
Servlets
O método service()
2-16
Servlets
O método destroy()
2-17
Servlets
Destruição de um Servlet
2-18
Servlets
O código 2-6 abaixo executa um Servlet simples que retorna uma página
HTML estática para um browser. Este exemplo executa completamente a
interface do Servlet.
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
response.setContentType( "text/html" );
PrintWriter out = response.getWriter();
out.println( "<html>" );
out.println( "<head>" );
out.println( "<title>Exemplo de Servlet</title>" );
out.println( "</head>" );
out.println( "<body>" );
out.println( "<h1> Servlet com os métodos do ciclo de vida </h1>" );
out.println( "</body>" );
out.println( "</html>" );
out.close();
}
}
Código 2-6: Código de exemplo do uso da Interface Servlet.
2-19
Servlets
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
2-20
Servlets
}
}
Código 2-7: Código de exemplo do uso do método doGet para tratar requisições GET.
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
}
Código 2-8: Código de exemplo do uso do método doPost para tratar requisições POST
2-21
Servlets
2-22
Servlets
Concorrência
Uma vez carregado o servlet não é mais descarregado, a não ser que o
servidor Web tenha sua execução interrompida. De modo geral, cada requisição
que deve ser direcionada a determinada instância de servlet é tratada por um
thread sobre a instância de servlet. Isto significa que se existirem duas requisições
simultâneas que devem ser direcionadas para um mesmo objeto o container
criará dois threads sobre o mesmo objeto Servlet para tratar as requisições. A
figura 2-5 ilustra esta situação.
2-23
Servlets
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
synchronized(this) {
contador++;
out.println("<h1>Contador: "+contador+"</h1>");
try{
Thread.sleep(1000);
}
catch(InterruptedException ex) {}
out.println("<h1>Contador: "+contador+"</h1>");
}
out.close();
}
}
Código 2-10 : Servlet resolvendo o problema de concorrência.
2-24
Servlets
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
Enumeration e = request.getHeaderNames();
while (e.hasMoreElements()) {
String name = (String)e.nextElement();
String value = request.getHeader(name);
out.println(name + " = "+ value+"<br>");
}
out.println("</body></html>");
}
}
Código 2-11 : Servlet que retorna as informações sobre a requisição.
2-25
Servlets
Figura 2-6 : Saída da execução do Servlet que exibe as informações sobre a requisição.
2-26
Servlets
Controlando o fluxo
disp = request.getRequestDispatcher(“/inicial.jsp”);
...
2-27
Servlets
disp = request.getRequestDispatcher(“/rodape.jsp”);
disp.include(request, response);
...
2-28
Servlets
Arquivo web.xml
Arquivo descritor de módulos web. Módulos web contêm um ou mais
componentes web (tais como JSP, servlet, ou arquivos HTML). O descritor de
distribuição fica em /META-INF/web.xml e tem a função principal de definir as
configurações dos componentes web. Geralmente são armazenados em
arquivos WAR.
A lista a seguir apresenta alguns dos elementos legais que são permitidos
dentro do elemento web-app, na ordem padronizada:
2-29
Servlets
2-30
Servlets
Parâmetros de Inicialização
<web-app>
<servlet>
<servlet-name>NomeServlet</servlet-name>
<servlet-class>com.targettrust.ClasseServlet</servlet-class>
<init-param>
<param-name>param_1</param-name>
<param-value>value_1</param-value>
</init-param>
<init-param>
<param-name>param_2</param-name>
<param-value>value_2</param-value>
</init-param>
...
</servlet>
...
</web-app>
Código 2-17: Exemplo de arquivo web.xml utilizando parâmetros de inicialização
2-31
Servlets
<context-param>
<param-name>webmaster-email</param-name>
<param-value>webmaster@empresa.com.br</param-value>
</context-param>
2-32
Servlets
Carregando um servlet
<servlet>
<servlet-name> ... </servlet-name>
<servlet-class> ... </servlet-class>
<load-on-startup> ... </load-on-startup>
</servlet>
<servlet>
<servlet-name>Pesquisa</servlet-name>
<servlet-class>com.targettrust.PesquisaServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet>
<servlet-name>Cadastro</servlet-name>
<servlet-class>com.targettrust.CadastroServlet</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>
2-33
Servlets
Exercícios
Exercício 2: Todo servlet tem um ciclo de vida. Alguns métodos são chamados
pelo container web durante o ciclo de vida de um servlet. Descreva o método
init(), service() e destroy()
Exercício 3: Neste exercício você irá criar um servlet que possa receber várias
requisições e seja capaz de identificar cada uma pelo seu endereço IP. Este
servlet deve contar e armazenar quantos acessos/request cada cliente fez a
ele. Siga os passos abaixo para isto:
2-34
Servlets
2-35
Servlets
2-36
JSP e Servlets
2-1
Sessões
3. Sessões
3-2
Sessões
Objetivos
• O que são Sessões
• Como usar e manipular Sessões
3-3
Sessões
Utilizando Sessões
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
out.println("<html><head>");
out.println("<title>Teste de Sessão</title>");
out.println("</head>");
out.println("<body>");
out.println("<h3>Teste de Sessão</h3>");
out.println("<P>");
out.println("Dados da Sessão:" + "<br>");
Enumeration valueNames = session.getAttributeNames();
while (valueNames.hasMoreElements()) {
String name = (String) valueNames.nextElement();
String value = (String) session.getAttribute(name);
out.println(name + " = " + value+"<br>");
}
out.println("<P>");
out.println("<form action=/contexto/testeSessao method=POST>");
out.println("<h3>Nome: <input type=text size=20 name=nomedado></h3>");
out.println("<h3>Valor: <input type=text size=20 name=valordado></h3>");
out.println("<input type=submit value=Enviar>");
out.println("</form>");
out.println("</body></html>");
}
}
Código 3-1: Servlet para lidar com Sessões.
3-5
Sessões
Figura 3-1: Saída resultante da execução do Servlet que lida com Sessões.
3-6
Sessões
if ( usr != null ) {
// achou o bean na sessão
}else {
// não achou o bean na sessão
}
Código 3-3: Exemplo de busca de dados na sessão.
3-7
Sessões
Exercícios
Exercício 2: Neste exercício você irá criar um servlet e mostrar dados da sessão,
como visto no decorrer do estudo do capítulo. Siga os passosa abaixo para isto.
Exercício 3: Neste exercício você irá criar uma página HTML para chamar três
servlets, um que adiciona um java bean à sessão, outro que possa ler este java
bean e um terceiro que possa invalidar a sessão.
Passo 1: Crie uma página HTML na região onde podem ser armazenadas as
páginas HTML do seu projeto. Esta página deve conter três links, um para cada
servlet a ser chamado. Utilize o seguinte código para fazer o link entre os servlets:
...
out.println("<br>");
out.println("<a href=/contexto/gravarSessao> Gravar Bean</a>");
out.println("<br>");
out.println("<a href=/contexto/lerSessao>Ler Bean</a>");
out.println("<br>");
out.println("<a href=/contexto/invalidaSessao>Invalidar Sessão</a>");
...
Passo 2: Crie uma classe para representar um Curso e nesta classe declare
dois atributos privados para armazenar o nome do curso e a carga horária. Gere
para esta classe os métodos de leitura e gravação dos atributos bem como um
construtor que possa receber os o nome e a carga horária e já inicializar os
mesmos.
3-9
Sessões
3-10
JSP e Servlets
4. Formulários
4-1
Formulários
Objetivos
• O que são Formulários
• Como criar um Formulário
• Como lidar e tratar os Formulários
4-2
Formulários
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
response.setContentType("text/html");
out.println("<html>");
out.println("<head><title>Trata formulário</title></head>");
out.println("<body bgcolor=\"white\">");
out.println("<h3>Trata formulário</h3>");
4-3
Formulários
4-4
Formulários
Formulários
<html>
<body>
...
</body>
</html>
Código 4-2: Formato de formulário.
4-5
Formulários
Campos de texto
4-6
Formulários
Este código não irá gerar componente visual para ser exibido na página.
4-7
Formulários
Campos de senha
Estes campos representam caixas de texto que podem receber senhas. Elas
não exibem a senha digitada. Isto não significa que a senha estará sendo
enviada de forma criptografada e protegida para o servidor. Nunca utilize estes
campos em formulários que enviar os dados via o método get do protocolo http.
4-8
Formulários
Botões de radio
4-9
Formulários
Campos de escolha
Estes campos são semelhanes aos de radio, porém o objetido dos mesmos
é permitir a seleção de mais de uma opção. Neste caso os nomes dos campos
não pode ser o mesmo.
4-10
Formulários
Listas
4-11
Formulários
Áreas de texto
4-12
Formulários
Botão reset
4-13
Formulários
Botão de envio
Este é um componente muito importante pois ;e com ele que os dados são
enviados para o servidor. Este botão quando for clicado irá chamar o método
submit do formulário provocando o envio dos dados para o servidor através do
request.
4-14
Formulários
Seleção de arquivos
4-15
Formulários
Sobre os formulários...
<html>
<body>
<div align=center>
<h1> <%= request.getParameter("param") %> </h1>
</div>
</body>
</html>
4-16
Formulários
<html>
<body>
<h3>Qual o mês do seu aniversário?</h3>
</body>
</html>
Código 4-6: Arquivo enviaMes.jsp.
if (mes == 1) {
msg = "Falta apenas "+ mes +" mês para o seu aniversário.";
} else if (mes == -1) {
msg = "Seu aniversário foi no mês passado";
} else if (mes > 1) {
msg = "Faltam "+ mes +" meses para o seu aniversário.";
} else if (mes == 0) {
msg = "Oba... estamos no mês do seu aniversário.";
}else {
if (mes < 1) {
mes *= -1;
msg = "Seu aniversário foi a "+ mes +" meses atrás.";
}
}
%>
<html>
<body>
<h3> <%= msg %> </h3>
</body>
</html>
Código 4-7: Arquivo recebeMes.jsp
• Nas primeiras linhas utilizamos as tags "page import" para indicar quais
classes iremos utilizar em nossa página:
4-18
Formulários
• Cinco testes são efetuados dentro de um script (<% e %>). Eles são usados
para definir o valor que a variável "msg" terá, ou seja, a partir dos testes,
será decidida qual mensagem será exibida na tela.
• Uma expressão (<%= %>) é usada para exibir o valor da variável "msg":
4-19
Formulários
Exercícios
Exercício 1: Neste exercício você irá criar uma página de login para o usuário
fornecer seu login e senha de acesso ao sistema. Para isto crie uma página
HTML e nesta página declare um formulário sem nome e sem ação deixando
estes atributos ainda sem valor. Utilize para este formulário o método POST.
Passo 1: Crie uma página JSP com o nome login.jsp dento do seu projeto
Login:
<input type="text" name="login" size="20" maxlength="20">
Senha:
<input type="password" name="senha" size="8" maxlength="8">
Botão Acessar:
<input type="submit" value="Acessar">
4-20
Formulários
Código do curso:
<input type="text" name="codigo" size="8" maxlength="8">
Nome:
<input type="text" name="nome" size="50" maxlength="200">
Unidade de treinamento:
<select name="unidadeTreinamento">
<option value=""> Selecione uma unidade </option>
</select>
</textarea>
Preço:
<input type="text" name="preco" size="7" maxlength="7">
Carga Horária:
<input type="text" name="cargaHoraria" size="3" maxlength="3">
Em sala de aula?
<select name="salaAula">
<option value="S" selected>Sim</option>
<option value="N">Não</option>
</select>
In Company?
<select name="inCompany">
<option value="S">Sim</option>
<option value="N" selected>Não</option>
</select>
Botão Cadastrar:
<input type="submit" value="Cadastrar">
Botão Limpar:
4-21
Formulários
Curso:
<select name="curso">
<option value=""> Selecione um curso </option>
</select>
Instrutor:
4-22
Formulários
<select name="instrutor">
<option value=""> Selecione um instrutor </option>
</select>
Percentual de Royalty:
<input type="text" name="royalty" size="2" value="">
Botão Salvar:
<input type="submit" value="Salvar" >
Botão Limpar:
<input type="reset" value="Limpar">
4-23
Formulários
4-24
JavaServer Pages
5. JavaServer Pages
5-25
JavaServer Pages
Objetivos
• Funcionalidades do JSP
• Entendimento da estrutura funcional
• Como escrever códigos
• Entender o modo de execução das JSP’s
• Identificar como ocorre a criação de uma página JSP
5-26
JavaServer Pages
Servlets é uma boa idéia, mas dá para imaginar montar uma página
complexa usando println() ? Muitas vezes o desenvolvimento de um site é uma
tarefa complexa que envolve vários profissionais. A tarefa de projeto do layout
da página fica a cargo do Web Designer, incluindo a diagramação dos textos e
imagens, aplicação de cores, tratamento das imagens, definição da estrutura da
informação apresentada no site e dos links para navegação pela mesma. Já o
Desenvolvedor Web é responsável pela criação das aplicações que vão
executar em um site. O trabalho destes dois profissionais é somado na criação de
um único produto, mas durante o desenvolvimento a interferência mutua deve
ser a mínima possível. Ou seja, um profissional não deve precisar alterar o que é
foi feito pelo outro profissional para cumprir sua tarefa. A tecnologia Servlet não
nos permite atingir esse ideal. Por exemplo, suponha que um Web Designer
terminou o desenvolvimento de uma página e a entregou para o Desenvolvedor
Web codificar em um Servlet. Se após a codificação o Web Designer desejar
realizar uma alteração na página será necessário que ele altere o código do
Servlet (do qual ele nada entende) ou entregar uma nova página para o
Desenvolvedor Web para que ele a codifique totalmente mais uma vez.
Quaisquer umas dessas alternativas são indesejáveis e foi devido a esse problema
a Sun desenvolveu uma tecnologia baseada em Servlets chamada de JSP.
Java Server Pages são páginas HTML que incluem código Java e outros
tags especiais. Desta forma as partes estáticas da página não precisam ser
geradas por println(). Elas são fixadas na própria página. A parte dinâmica é
gerada pelo código JSP. Assim a parte estática da página pode ser projetada
por um Web Designer que nada sabe de Java.
A primeira vez que uma página JSP é carregada pelo container JSP o
código Java é compilado gerando um Servlet que é executado, gerando uma
página HTML que é enviada para o navegador. As chamadas subseqüentes são
enviadas diretamente ao Servlet gerado na primeira requisição, não ocorrendo
mais às etapas de geração e compilação do Servlet.
5-27
JavaServer Pages
5-28
JavaServer Pages
Escopo de Objetos
5-29
JavaServer Pages
5-30
JavaServer Pages
Diretivas
Diretiva Page
Atributo contentType
Este atributo indicará qual o tipo de conteúdo que a página JSP estará
gerando e enviando para o browser.
O valor deste atributo pode variar, text/html indica que o conteúdo a ser
enviado para o browser será HTML. Se trocarmos por text/plain indicará que o
conteúdo é texto puro e o browser não deverá interpretar o mesmo.
5-31
JavaServer Pages
Atributo import
Permite que seja especificado qual o pacote a ser importado. Por exemplo,
veja o código 5-4.
Atributo isThreadSafe
isThreadSafe = "true|false"
5-32
JavaServer Pages
Atributo session
session = "true|false"
O valor de true (default) indica que a variável predefinida session (do tipo
HttpSession) deve estar ligada a sessão existente, caso não exista uma sessão,
uma nova sessão deve ser criada para ligá-la. O valor false indica que sessões
não devem ser usadas.
Atributo buffer
buffer = "sizekb|none"
Atributo autoFlush
autoFlush = "true|false"
5-33
JavaServer Pages
Atributo extends
extends = "package.class"
Atributo info
info = "message"
Define uma String que pode ser recuperada pelo método getServletInfo().
Com esse atributo o autor pode adicionar uma cadeia de documentação à
página que sumariza sua funcionalidade. O valor padrão para o atributo info é a
cadeia vazia.
Atributo errorPage
errorPage = "url"
Especifica que a página JSP deve processar algum Throwables, mas não
carregá-lo na página corrente.
5-34
JavaServer Pages
Atributo isErrorPage
isErrorPage = "true|false"
Define se uma página pode atuar como uma página de erro para uma
outra página JSP. O default é false.
Atributo language
language = "java"
Especifica a linguagem que está sendo usada. Por enquanto o JSP suporta
somente Java.
5-35
JavaServer Pages
Diretiva include
<html><body>
<%@include file="navegadorInclude_2.html" %>
<!-- Parte específica da página -->
</body></html>
Código 5-15: Exemplo de um arquivo jsp de nome “include_2.jsp”.
<html><body>
<font face="verdana" size="1" color="#ffffcc">
<a href="home.jsp">HOME</a> -
<a href="secao_01.jsp">SEÇÃO 01</a> -
<a href="secao_02.jsp">SEÇÃO 02</a> -
<a href="secao_03.jsp">SEÇÃO 03</a>
</font>
<!-Parte específica da página ... -->
</body></html>
Código 5-17: Exemplo do código do arquivo “include_2.jsp” interpretado pelo browser.
5-36
JavaServer Pages
5-37
JavaServer Pages
Declarações
Alguns exemplos:
5-38
JavaServer Pages
Expressões
Para construir uma expressão em JSP você pode colocar entre as tags
qualquer expressão definida na Especificação da Linguagem Java. Ao contrário
dos scriptlets (que veremos a seguir), uma expressão não aceita ponto e vírgula e
define somente uma expressão da Linguagem.
5-39
JavaServer Pages
Scriptlets
Veja o exemplo:
<html><body>
<%
String option;
int numberOption = Integer.parseInt(request.getParameter("option"));
if (numberOption == 1) {
option = "Compra";
} else if (numberOption == 2) {
option = "Venda";
} else {
option = "Aluguel";
}
%>
5-40
JavaServer Pages
Comentários
Existem dois tipos principais de comentários que podem ser usados em uma
página JSP. Comentário de Conteúdo: esses comentários são transmitidos de
volta para o navegador como parte da resposta de JSP e são visíveis na
visualização do código da página. O comentário de conteúdo tem a seguinte
sintaxe: <!-- comentário --> .
Comentários JSP não são enviados para o cliente e são visíveis apenas nos
arquivos fontes JSP originais. O corpo do comentário é ignorado pelo container
JSP. Os comentários JSP podem assumir duas sintaxes:
5-41
JavaServer Pages
Ações
5-42
JavaServer Pages
<jsp:include>
A tag possui dois atributos page e flush. O atributo page informa a URL para
onde irá ocorrer a chamada. O atributo flush serve para informar a página JSP
principal que o seu buffer de conteúdo de saída será descarregado antes de se
passar o controle para a página referenciada na tag, permitindo que a página
incluída possa adicionar seu conteúdo de saída corretamente. Por esse motivo
ele deve sempre ser utilizado com o valor true.
5-43
JavaServer Pages
<jsp:forward>
5-44
JavaServer Pages
Exercícios
Exercício 1: JSP define quatro escopo para objetos, nestes escopos podem
portanto ser armazenados objetos que posteriormente possam ser recuperados.
Descreva, brevemente, cada um destes escopos.
Exercício 2: Neste exercício você irá criar duas páginas home, uma para o
administrador e outra para o instrutor.
Passo 1: Crie uma página JSP com o nome admHome.jsp dentro de seu
projeto. Nesta página crie três links como mostrado no código abaixo:
5-45
JavaServer Pages
Passo 2: Crie uma página JSP com o nome instHome.jsp dentro de seu
projeto. Nesta página crie dois links como mostrado no código abaixo:
Exercício 3: Agora vamos iniciar a construção de um servlet que irá atuar como
controller no nosso sistema. Este servlet terá papel de redireciondor e avaliador
de algumas questões ligadas ao sistema. Para isto siga os passos abaixo:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
}
}
5-46
JavaServer Pages
// Constantes
private final String URL_USO_INCORRETO = "/contexto/projeto/usoIncorreto.html";
private final String URL_ADM_HOME = "/projeto/admHome.jsp";
private final String URL_INST_HOME = "/projeto/instHome.jsp";
private final String URL_FORM_CURSO = "/projeto/cadastraCurso.jsp";
private final String URL_FORM_RESPONSAVEL = "projeto/defineResponsavel.jsp";
private final String URL_FORM_UPLOAD = "/projeto/uploadMaterial.jsp";
private final String URL_FORM_DOWNLOAD = "/projeto/downloadMaterial.jsp";
// Atributos
private String usuarioInit, senhaInit;
private ServletContext contexto;
Passo 4: Dentro do método init agora você irá capturar dois parâmetros de
inicialização que serão passados para o controller através do arquivo web.xml.
Defina então o seguinte código dentro do método init(), bem como configure
estes parâmetros no arquivo web.xml. Caso não lembre-se de como fazer isto
chame seu instrutor.
usrInit = config.getInitParameter("usuario");
pwdInit = config.getInitParameter("senha");
contexto = config.getServletContext();
if ( action == null ) {
response.sendRedirect( URL_USO_INCORRETO );
return;
}
if ( action.equalsIgnoreCase("logar") ) {
// Verificar se é administrador
5-47
JavaServer Pages
} else if ( action.equalsIgnoreCase("formCurso") ) {
contexto.getRequestDispatcher( URL_FORM_CURSO ).forward(request,
response);
return;
} else if ( action.equalsIgnoreCase("formResponsavel") ) {
contexto.getRequestDispatcher( URL_FORM_RESPONSAVEL ).forward( request,
response);
return;
} else if ( action.equalsIgnoreCase("formUpload") ) {
contexto.getRequestDispatcher( URL_FORM_UPLOAD ).forward(request,
response);
return;
} else if ( action.equalsIgnoreCase("formDownload") ) {
contexto.getRequestDispatcher( URL_FORM_DOWNLOAD ).forward(request,
response);
return;
}
5-48
JavaServer Pages
5-49
JSP e Servlets
6. JavaBeans
6-1
JavaBeans
Objetivos
• Conhecer o que são JavaBeans
• Criar JavaBeans
• Saber usar e manipular um JavaBean
• Uso do JavaBean com JSP e Servlets
6-2
JavaBeans
JavaBeans
6-3
JavaBeans
Para que esses componentes possam ser reconhecidos de forma geral, sua
implementação deve seguir um conjunto de regras que serão usadas pelas
ferramentas para introspecção da classe, ou seja, o processo de descobrir quais
as funcionalidades do Bean e disponibilizá-la para o usuário. Cabe ao usuário
fazer a interface entre o componente e o restante da aplicação, criando assim
um novo tipo de programador, o programador de componentes.
import java.io.Serializable;
public MyBean() { }
Esta classe é um exemplo do que devemos seguir para tornar uma classe
um bean, ou seja, o conjunto de regras que devemos obedecer para tornar o
componente reconhecível e usável por ferramentas.
6-4
JavaBeans
Métodos de Leitura:
Métodos de escrita:
6-5
JavaBeans
Você pode não definir métodos de escrita para uma determinada variável,
fazendo com que o usuário não seja capaz de modificar o conteúdo da
propriedade.
Outra regra que um Bean deve seguir é a implementação da interface
Serializable. A implementação desta interface fornece ao bean a propriedade
chamada de persistência. O conceito de persistência é permitir que o usuário
faça uso do componente em um determinado momento e possa salvar o seu
estado para o uso posterior partindo do mesmo ponto. A tecnologia que
possibilita essa propriedade é a Serialização de Objetos. Esta tecnologia permite
salvarmos o objeto em um fluxo para posterior recuperação. Quando houver a
recuperação, o objeto deve se comportar como se fosse exatamente o mesmo
de quando foi salvo, se olharmos o objeto como uma máquina de estado, então
podemos dizer que o objeto é recuperado no mesmo estado de quando foi
salvo.
6-6
JavaBeans
Propriedades de um Bean
6-7
JavaBeans
Ações
Existem três tags definidas pela especificação JSP para o uso dos Beans:
• <jsp:useBean>
• <jsp:setProperty>
• <jsp:getProperty>
6-8
JavaBeans
<jsp:useBean>
OU
O código acima indica que será gerada uma instância do bean definida
na classe package.myBeanClass e o nome dela será myBeanInstance na página.
Esta instância existirá durante o ciclo de vida de uma única solicitação HTTP para
a página.
6-9
JavaBeans
<jsp:setProperty>
property = “nomePropriedade”
Usando este formato a propriedade especificada será setada com o valor
que será passado como parâmetro no pedido HTTP(request).
property = “*”
Usando esta forma cada parâmetro enviado no pedido HTTP request será
avaliado a fim de se encontrar um método correspondente combinando com
seu nome, caso isto aconteça o método set é invocado com o valor do
parâmetro recebido no pedido HTTP.
6-10
JavaBeans
<jsp:setProperty property=”nomePropriedade”
value = “String|<%= ... %>” />
6-11
JavaBeans
<jsp:getProperty>
6-12
JavaBeans
O Uso de JavaBeans
A medida que o código Java dentro do HTML torna-se cada vez mais
complexo o desenvolvedor pode-se perguntar: Java em HTML não é o problema
invertido do HTML em Servlet? O resultado não será tão complexo quanto
produzir uma página usando println()? Em outras palavras, está novamente
misturando conteúdo com forma?
6-13
JavaBeans
<%@page contentType="text/html"
import = "cap06.*"%>
<HTML>
<HEAD>
<TITLE>Uso de JavaBeans</TITLE>
</HEAD>
<BODY>
<jsp:useBean id="teste" class="cap06.BeanSimples" />
<jsp:setProperty name="teste" property="mensagem" value="Olá mundo!" />
<H1> Mensagem: <I><jsp:getProperty name="teste" property="mensagem" /> </I></H1>
</BODY>
</HTML>
Código 6-15: Exemplo de javaBean. Arquivo jspBean.jsp.
import java.io.*;
6-15
JavaBeans
6-16
JavaBeans
6-17
JavaBeans
Exercícios
Exercício 1: Neste exercício você irá criar um java bean para representar um
instrutor. Este java bean será posteriormente utilizado nas suas páginas JSP.
Passo 1: Crie uma classe chamada InstrutorBean e para esta classe defina
as seguintes propriedades/atributos:
Código:
<input type="text" name="codigo" size="8" maxlength="8">
Nome:
<input type="text" name="nome" size="50" maxlength="100">
Email:
<input type="text" name="email" size="50" maxlength="150">
Senha:
<input type="password" name="senha" size="10" maxlength="10">
Botão Cadastrar:
<input type="submit" value="Cadastrar">
Botão Limpar:
<input type="reset" value="Limpar">
6-18
JavaBeans
Exercício 3: Crie agora uma pequena aplicação usando JSP para cadastrar
um instrutor no banco de dados. Utilize a classe InstrutorDB para fazer a
inserção do instrutor no banco. Observe que na classe InstrutorDB há
operações para isto. Nesta página JSP você terá um código que faz uso do
java bem criado anteriormente para representar um instrutor. Este java bean
será populado automaticamente com os valores enviados pelo formulário
acima criado. A página JSP fará uso do método :
6-19
JavaBeans
6-20
JavaBeans
6-21
JSP e Servlets
7. Objetos Implícitos
7-1
Objetos Implícitos
Objetivos
• O que são os objetos implícitos
• Como usar os objetos implícitos
• Quais são as funcionalidades dos objetos implícitos
7-2
Objetos Implícitos
Objetos Implícitos
Assim como todo objeto em Java, cada objeto implícito é uma instância
de uma classe ou interface e segue uma API correspondente. Abaixo segue um
resumo dos objetos implícitos disponíveis em JSP, suas respectivas
classes/interfaces e uma pequena descrição do objeto.
7-3
Objetos Implícitos
7-4
Objetos Implícitos
• page
• config
7-5
Objetos Implícitos
Objeto page
7-6
Objetos Implícitos
Objeto config
Métodos Descrição
Enumeration getInitParameterNames() Recupera os nomes de todos os
parâmetros de inicialização.
String getInitParameter(String name) Recupera o valor do parâmetro de
inicialização a partir de um nome.
Tabela 7-2: Descrição resumida dos objetos implícitos.
7-7
Objetos Implícitos
• request
• response
• out
7-8
Objetos Implícitos
Objeto request
7-9
Objetos Implícitos
7-11
Objetos Implícitos
Objeto response
7-12
Objetos Implícitos
Reescrita da URL:
Método Descrição
String encodeRedirectURL(String url) Codifica um URL para uso com o método
sendRedirect() para incluir informações
de sessão.
String encodeURL(String url) Codifica um URL usado em um link para
incluir informações de sessão.
Tabela 7-10: Descrição resumida dos objetos implícitos.
O código 7-3 ilustra uma das utilidades desse objeto. Vários cabeçalhos são
definidos para evitar que a página seja armazenada em cache por um
navegador.
<%
response.setHeader("Expires", 0);
response.setHeader("Pragme”, "no-cache");
if(request.getProtocol().equals("HTTP/1.1")){
response.setHeader("Cache-Control", "no-cache");
}
%>
Este script primeiro define o cabeçalho Expires para uma data no passado.
Isto significa que o conteúdo da página já expirou, como uma dica que seu
conteúdo não deve ser armazenado em cache.
7-13
Objetos Implícitos
7-14
Objetos Implícitos
Objeto out
Por exemplo, o objeto out pode ser usado dentro de um script para
adicionar conteúdo à página gerada. Veja o código 7-4 abaixo.
<%
int i = (int)(Math.random()*10);
if(i%2==0){
out.print("O Número escolhido "+ i +" é par!");
} else {
out.print("O Número escolhido "+ i +" é impar!");
}
%>
<%
if(i == 1){
out.print("<h6><font face='verdana'>Guga viaja nesta sexta para a Suíça
para jogar</font></h6>”);
}
%>
7-15
Objetos Implícitos
7-16
Objetos Implícitos
Objetos Contextuais
• request;
• session;
• application;
• pageContext.
Método Descrição
void setAttribute(String key, Object value) Associa um valor de atributo com um
nome.
Enumeration getAttributeNames() Recupera os nomes de todos os
atributos associados
com o objeto.
Object getAttribute(String key) Recupera o valor de atributo
associado com a chave.
void removeAttribute(String key) Remove o valor de atributo
associado com a chave.
Tabela 7-11: Os métodos comuns a esses quatro objetos e que são usados para armazenar e
recuperar valores dos atributos.
7-17
Objetos Implícitos
Objeto session
<%
Usuario u = new Usuario(nome, senha);
session.setAttribute("usuario", u);
%>
<%
Usuario u = (Usuario)session.getAttribute("usuario");
%>
A tabela 7-12 traz os principais métodos utilizados por esse objeto, além
daqueles descritos anteriormente na tabela 7-11.
7-18
Objetos Implícitos
Método Descrição
Object getAttibute(String nome) Recupera o objeto identificado por
"nome".
String getId() Retorna o Id da sessão.
long getCreationTime() Retorna a hora na qual a sessão foi
criada.
long getLastAccessedTime() Retorna a última vez que uma
solicitação associada com a sessão foi
recebida.
int getMaxInactiveInterval() Retorna o tempo máximo (em
segundos) entre solicitações pelo qual
a sessão será mantida.
void setMaxInactiveInterval(int time) Define o tempo máximo (em segundos)
entre solicitações pelo qual a sessão
será mantida.
boolean isNew() Retorna se o navegador do usuário
ainda não tiver confirmado o ID de
sessão.
boolean invalidate() Descarta a sessão, liberando quaisquer
objetos armazenados como atributos.
Tabela 7-12: Métodos do objeto HttpSession.
7-19
Objetos Implícitos
Objeto application
7-20
Objetos Implícitos
7-21
Objetos Implícitos
Objeto pageContext
7-22
Objetos Implícitos
Método Descrição
PAGE_SCOPE Escopo para atributos armazenados no objeto
pageContext.
REQUEST_SCOPE Escopo para atributos armazenados no objeto
request.
SESSION_SCOPE Escopo para atributos armazenados no objeto
session.
7-23
Objetos Implícitos
<%
//Recupera o object "usuario" do escopo pageContext
User uPag=(User)pageContext.getAttibute("user",pageContext.PAGE_SCOPE)
7-24
Objetos Implícitos
Tratamento de Erros
Objeto Exception
Método Descrição
String getMessage() Retorna a mensagem de erro descritiva
associada com a exceção quando ela foi
lançada.
void printStackTrace(PrintWriter out) Imprime a pilha de execução em
funcionamento quando a exceção foi
lançada para o fluxo de saída
especificado pelo parâmetro out.
String toString() Retorna uma cadeia combinando o
nome da classe da exceção com sua
mensagem de erro, se houver alguma.
Tabela 7-21: Principais métodos da classe Throwable.
7-25
Objetos Implícitos
7-26
Objetos Implícitos
É possível definir funções na própria página JSP através das tags <%! e %>.
Veja o exemplo abaixo:
<%!
String jogueMoeda(){
String retorno = "";
int i = (int)(Math.random()*10); //um número entre 0 e 10
i = i%2; //resto da divisão de i por 2
if(i==0){
retorno = "cara";
} else {
retorno = "coroa";
}
return retorno;
}
%>
<html>
<body>
<h1>Deu <%= jogueMoeda() %>!</h1>
</body>
</html>
<html>
<body>
<h1>Deu <%= jogueMoeda() %>,
<%= jogueMoeda() %>
<%= jogueMoeda() %>!</h1>
</body>
</html>
7-27
Objetos Implícitos
<%!
void jogueMoeda(int numeroJogadas, JspWriter o){
try{
for(int k=1; k <= numeroJogadas; k++){
//número entre 0 e 10
int i = (int)(Math.random()*10); i = i%2;
if(i==0){
o.print("cara");
} else {
o.print("coroa");
}
if (k==numeroJogadas){
o.print("!");
} else {
o.print(", ");
}
}
} catch(Exception e){}
}
%>
<html>
<body>
<h1>Deu <% jogueMoeda(10,out); %></h1>
</body>
</html>
7-28
Objetos Implícitos
<%!
void jogueMoeda(int numeroJogadas){
for(int k=1; k <= numerovezes; k++){
int i = Math.random();
i = i*10;
i = i%2;
if(i==0){
out.print("cara");
} else {
out.print("coroa");
}
if(k==numeroJogadas){
out.print("!");
} else {
out.print(", ");
}
}
}
%>
<html>
<body>
<h1>Deu <% jogueMoeda(50) %></h1>
</body>
</html>
7-29
Objetos Implícitos
Exercícios
Exercício 2: Neste exercício você irá utilizar o objeto implícito session. Iremos
utilizar este objeto para validar se o usuário esta logado e então permitir que as
páginas possam ser acessadas por ele. Siga abaixo os passos para isto.
<%
String idPagina = session.getId();
UsuarioLogado usr = (UsuarioLogado)session.getAttribute("usuario_logado");
if ( usr == null ) {
response.sendRedirect(url);
return;
}
if ( ! usr.getId().equals(idPagina) ) {
response.sendRedirect(url);
return;
}
%>
Exercício 3: Agora você irá contruir uma página para exibir os erros de exception
que podem ser gerados nas páginas JSP do seu sistema. Para isto construa uma
página JSP que possa ter acesso ao objeto implícito exception e através do uso
deste mostre a mensagem de erro de forma a informar o usuário o problema que
7-30
Objetos Implícitos
7-31
Objetos Implícitos
7-32
JSP e Servlets
1
Cookies
8. Cookies
2
Cookies
Objetivos
• O que são Cookies
• Como usar os Cookies
• Quais os objetivos de se usar Cookies
• Criar um Cookie
3
Cookies
Todas essas necessidades não podem ser atendidas com o uso básico do
protocolo HTTP, uma vez que ele não é orientado à sessão ou conexão. Com os
cookies é possível contornar essa deficiência, uma vez que as informações que
são neles armazenadas podem ser usadas para identificar os clientes. Existem
outras formas de contornar a deficiência do protocolo de HTTP, como a
codificação de URL e o uso de campos escondidos nas páginas HTML, mas o uso
4
Cookies
<html>
<head><title>Teste de Cookies </title></head>
<body>
<h3>Teste de Cookies</h3>
<%
Cookie[] cookies = request.getCookies();
if (cookies.length > 0) {
for (int i = 0; i < cookies.length; i++) {
Cookie cookie = cookies[i];
cookie.setPath("/");
%>Cookie Nome: <%=cookie.getName()%> <br>
Cookie Valor : <%=cookie.getValue()%> <br><br>
<%}
}
String cName = request.getParameter("cookienome");
String cValor = request.getParameter("cookievalor");
if (cName != null && cValor != null) {
Cookie cookie = new Cookie(cName ,cValor);
cookie.setPath("/");
response.addCookie(cookie);
}
%>
<form action="cookieTeste.jsp" method=POST>
Nome : <input type=text length=20 name=cookienome><br>
Valor : <input type=text length=20 name=cookievalor><br>
<input type=submit value=Enviar></form>
</body>
</html>
Código 8-1: JSP para lidar com Cookies. Arquivo cookieTeste.jsp.
5
Cookies
...
Cookie cookie = new Cookie(cName ,cValor);
cookie.setDomain(“*.com.br”); // todos os domínios como targettrust.com.br mas
não *.instrutor.targettrust.com.br
cookie.setMaxAge (3600); // uma hora de tempo de vida
...
6
Cookies
Gerenciando Cookies
7
Cookies
A classe Cookie
Método Descrição
String getName() retorna o nome do cookie.
String getValue() retorna o valor armazenado no cookie.
String getDomain() retorna o servidor ou domínio do qual o
cookie pode ser acessado.
String getPath() retorna o caminho de URL do qual o
cookie pode ser acessado.
boolean getSecure() indica se o cookie acompanha
solicitações HTTP ou HTTPS.
void setValue(String newValue) atribui um novo valor para o cookie.
void setDomain(String pattern) define o servidor ou domínio do qual o
cookie pode ser acessado.
void setPath(String url) define o caminho de URL do qual o
cookie pode ser acessado.
void setMaxAge(int expiry) define o tempo restante (em segundos)
antes que o cookie expire.
void setSecure(Boolean flag) retorna o valor de um único cabeçalho
de solicitação como um número
inteiro.
Tabela 8-2: Métodos pertencentes a classe Cookie.
9
Cookies
Definindo um cookie
<%
String email = request.getParameter("email");
String cookieName = "cookie";
Cookie cookieJSP = new Cookie(cookieName, email);
//indica que o cookie deve ser transferido pelo protocolo HTTP padrão
cookieJSP.setSecure(false);
<html>
<head>
<title>Grava Cookie</title>
</head>
<body>
<h1>Grava Cookie</h1>
Esta página grava um cookie na sua máquina.<br>
<a href='readCookie.jsp'>Lê conteúdo do cookie</a>
</body></html>
Código 8-4: Código do arquivo addCookie.jsp.
Vamos criar uma página html com um formulário que irá fornecer um e-
mail que será gravado pela página "addCookie.jsp":
10
Cookies
<html>
<body>
<form action="addCookie.jsp">
<input type="text" name="email">
<input type="submit" value="ok">
</body>
</html>
11
Cookies
Recuperando um Cookie
<%
String cookieName = "cookie";
Cookie listaPossiveisCookies[] = request.getCookies();
Cookie cookieJSP = null;
<html>
<body>
<h1>Lê Cookie</h1>
<% if (cookieJSP != null) { %>
A pagina "addcookie" gravou o seguinte email: <%= cookieJSP.getValue() %>
<% } else { %>
O cookie não gravou ou o prazo do cookie expirou.
<% } %>
</body>
</html>
12
Cookies
13
Cookies
14
Cookies
Exercícios
// Criar cookies
String lembrar = request.getParameter("lembrar");
if (lembrar != null && lembrar.equalsIgnoreCase("S") ) {
cLogin.setPath("/");
cSenha.setPath("/");
response.addCookie( cLogin );
response.addCookie( cSenha );
}
<%
String login = ""; // string para armazenar o valor do cookie login
String senha = ""; // string para armazenar o valor do cookie senha
15
Cookies
16
Cookies
17
Finalizando a aplicação
9. Finalizando a aplicação
18
Finalizando a aplicação
Exercícios
<select name="unidadeTreinamento">
<% Vector unidades = UnidadeTreinamentoDB.getUnidades();
for (int i = 0; i < unidades.size(); i++) {
UnidadeTreinamentoBean un = (UnidadeTreinamentoBean)unidades.get(i);
%>
<option value="<%= un.getNumero() %>"><%=un.getDescricao() %></option>
<% } %>
</select>
19
Finalizando a aplicação
Exercício 2: Agora faremos a página JSP que pode gravar o responsável pelo
material didático. Esta página não fará uso de java beans. Siga os passoa abaixo
para isto:
...
<select name="curso">
<% Vector cursos = CursoDB.getCursos();
for (int i = 0; i < cursos.size(); i++) {
CursoBean curso = (CursoBean)cursos.get(i);
%>
<option value="<%= curso.getCodigo() %>"><%=curso.getNome() %></option>
<% } %>
</select>
...
<select name="instrutor">
<% Vector instrutores = InstrutorDB.getInstrutores();
for (int i = 0; i < instrutores.size(); i++) {
InstrutorBean inst = (InstrutorBean)instrutores.get(i);
%>
<option value="<%= inst.getCodigo() %>"><%=inst.getNome() %></option>
<% } %>
</select>
...
Veja abaixo o código exemplo para isto que você deverá ter em uma
página JSP:
<%
...
String msg = "";
msg = MaterialDidaticoDB.definirResponsavel(curso, instrutor, date, royalty);
...
20
Finalizando a aplicação
%>
Exercício 3: Neste exercício você irá fazer o upload e download do material para
dentro do banco de dados. O seu instrutor irá fornecer dois arquivos com as
páginas JSP e seus formulários para que este processo possa ser feito. Os arquivos
são uploadMaterial.jsp e downloadMaterial.jsp. Abaixo as figuras que mostram
como estes arquivos serão exibidos no browser. Siga abaixo os passos para
realizar este exercício:
21
Finalizando a aplicação
Exercício 4: Neste exercício você irá validar o usuário para saber se ele é um
instrutor ou não. Até o momento não foi feita esta validação. Agora vamos
realizar modificações no controller para podermos então diferenciar entre um
administrador, um instrutor e um usuário inválido. Para isto altere o seu controller
fazendo uso do método localizado na classe InstrutorDB com a seguinte
assinatura:
Observe que este método retorna um objeto da classe InstrutorBean, aquel bean
que você criou. Este objeto contém informações sobre o instrutor, como, por
exemplo, o seu nome. Você deve utilizar estas informações para o objeto a ser
adicionado na sessão e que identifica o usuário logado. O código abaixo pode
ser utilizado como modelo:
22
Finalizando a aplicação
// Verificar se é instrutor
InstrutorBean inst = InstrutorDB.validaUsuario(login, senha);
if ( inst != null ) {
UsuarioLogado usr = null;
usr = new UsuarioLogado(inst.getNome(), "Bem vindo instrutor",
session.getId() );
session.setAttribute("usuario", u);
contexto.getRequestDispatcher(URL_INST_HOME).forward(request, response);
return;
} else {
// Usuário inválido. Não é administrador nem instrutor.
response.sendRedirect( URL_LOGIN );
return;
}
23
Finalizando a aplicação
24
JSP e Servlets
1
Apêndice 1 - Tomcat
Instalar JDK
• Download : http://java.sun.com/j2se/1.4/download.html
• Home-page : http://java.sun.com/j2se/
Instalar Tomcat
• Download : http://jakarta.apache.org/site/binindex.cgi
• Home-Page : http://jakarta.apache.org/tomcat/
As versões estáveis eram Tomcat 5.0.19 (APIs Servlet 2.4 e JSP 2.0, do J2EE
1.4) e Tomcat 4.1.30 (APIs Servlet 2.3 e JSP 1.2, integrantes do J2EE 1.3). O
download do instalador para Windows pode ser acessado no site primário em
2
Apêndice 1 - Tomcat
3
Apêndice 1 - Tomcat
Testar Tomcat
http://localhost:8080/
Na home-page padrão do Tomcat, o link "Tomcat Documentation" dá
acesso a toda a documentação necessária, instalada localmente, inclusive a API
Servlet/JSP da Sun, inclusa com o Tomcat.
4
Apêndice 1 - Tomcat
Tomcat Administration
Tomcat Manager
5
Apêndice 1 - Tomcat
Estrutura de diretórios
• dirdev\
o WEB-INF\ (diretório obrigatório)
src\ (os .java de servlets podem ficar aqui)
classes\ (os .class gerados devem ser direcionados para aqui)
lib\ (pacotes jar de bibliotecas utilizadas devem ficar aqui)
web.xml (arquivo XML de configuração do contexto)
6
Apêndice 1 - Tomcat
CATALINA_HOME\conf\Catalina\localhost\dev.xml
CATALINA_HOME\conf\server.xml
...
<Host name="localhost" ...>...
<Context path="/dev" docBase="C:\dir\dev"
debug="0" reloadable="true" crossContext="true">
<Logger className="org.apache.catalina.logger.FileLogger"
prefix="localhost_dev_log." suffix=".txt" timestamp="true" />
</Context>
...
</Host>
...
Código 4: Código para o arquivo server.xml
8
Apêndice 1 - Tomcat
Tomcat 5:
<web-app>
<display-name>Desenvolvimento</display-name>
<description>
Descritor do contexto de desenvolvimento.
</description>
<servlet>
<servlet-name>invoker</servlet-name>
<servlet-class>
org.apache.catalina.servlets.InvokerServlet
</servlet-class>
<init-param>
<param-name>debug</param-name>
<param-value>0</param-value>
</init-param>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>invoker</servlet-name>
<url-pattern>/servlet/*</url-pattern>
</servlet-mapping>
</web-app>
Tomcat 4:
9
Apêndice 1 - Tomcat
<web-app>
<display-name>Desenvolvimento</display-name>
<description>
Descritor do contexto de desenvolvimento.
</description>
<servlet-mapping>
<servlet-name>invoker</servlet-name>
<url-pattern>/servlet/*</url-pattern>
</servlet-mapping>
</web-app>
Ativar contexto
Testar contexto
http://localhost:8080/dev/
Bibliotecas Servlet
10
Apêndice 1 - Tomcat
Tomcat 5:
CATALINA_HOME\common\lib\servlet-api.jar
CATALINA_HOME\common\lib\jsp-api.jar
Tomcat 4:
CATALINA_HOME\common\lib\servlet.jar
Além disso, se o código Java de uma classe servlet sua importar pacotes ou
classes de uma biblioteca de terceiros (que não seja parte das APIs J2SE e
Servlet/JSP), o JAR com as classes compiladas desta biblioteca deve estar no
diretório WEB-INF\lib\ para que o Tomcat encontre.
11
Apêndice 1 - Tomcat
http://localhost:8080/dev/servlet/AloMundo
http://localhost:8080/dev/alomundo.jsp
Logs
Para ver logs de acesso, erro e depuração, leia os txt's gerados em:
CATALINA_HOME\logs\
Variáveis de Ambiente
JAVA_HOME
CATALINA_HOME
13
Apêndice 1 - Tomcat
CLASSPATH
PATH
set JAVA_HOME=C:\j2sdk1.4.2_04
set CATALINA_HOME=C:\Arquiv~1\Apache~1\Tomcat 5.0
set CLASSPATH=%CATALINA_HOME%\common\lib\servlet-api.jar;.;%CLASSPATH%
set CLASSPATH=%CATALINA_HOME%\common\lib\jsp-api.jar;%CLASSPATH%
set PATH=%JAVA_HOME%\bin;%PATH%
JAVA_HOME=/usr/j2sdk1.4.2_04
CATALINA_HOME=/usr/tomcat
CLASSPATH=$CATALINA_HOME%/common/lib/servlet-api.jar:.:%CLASSPATH%
CLASSPATH=$CATALINA_HOME%/common/lib/jsp-api.jar:%CLASSPATH%
PATH=$JAVA_HOME/bin:$PATH
Material de referência
14
Apêndice 1 - Tomcat
Tomcat 4:
o Servlet Examples : http://localhost:8080/examples/servlets/
o JSP Examples : http://localhost:8080/examples/jsp/
Tomcat 5:
o JSP Examples : http://localhost:8080/jsp-examples/
o Servlet Examples : http://localhost:8080/servlets-examples/
15
JSP e Servlets
1
Apêndice 2 – Sintaxe JSP
Declarações
Declaração de variáveis e
métodos válidos no script <%! declaração; [declaração;]+ ... %>
daquela página.
Expressões
Contém uma expressão
válida no script daquela <%= expressão %>
página.
Scriptlet
Contém um fragmento de
<% fragmento de um código com uma ou mais linhas
código válido no script
%>
daquela página.
Comentário HTML
Cria um comentário que é
enviado para o cliente
<!-- comentário [<%= expressão %>] -->
viabilizar no código da
página.
Comentário JSP
É visto apenas no fonte do JSP
mas não é enviado para o <%-- comentário --%> ou <% /* comentário */ %>
cliente.
Diretiva "Include"
Inclue um arquivo estático,
analisando os elementos JSP <%@ include file="URL relativa" %>
daquela página.
Diretiva "Page"
2
Apêndice 2 – Sintaxe JSP
Atributos e Valores:
- language = "java"
- extends = "package.class"
- import = "{package.class" | package.* }, ..."]
- session = "true | false"
Define atributos que serão
- buffer = "none | 8kb | sizekb"
aplicados a uma página JSP.
- autoFlush = "true | false"
- isThreadSafe = "true | false"
- info = "text"
- errorPage = "relativeURL"
- contentType = "{mimeType [; charset = characterSet]
text/html; charset = isso-8858-1}"
- isErrorPage = "true | false"
<jsp:useBean>
<jsp:useBean id=”meuBean” class=”package.meuBean”
Define a utilização de um
scope=”page” />
JavaBean
<jsp:plugin>
<jsp:plugin
Executa um applet ou bean e, type = “bean|applet”
se necessário realiza um code = “classFileName”
download de um Java-plug-in codebase = “classFileDirectoryName”
para executar …
</jsp:plugin>
<jsp:foward>
Redireciona uma requisição
para um arquivo HTML, JSP ou <jsp:forward page="{relativeURL | <%= expressão %>}"
Servlet para processar.
<jsp:include>
Redireciona o pedido para
qualquer recurso estático ou
dinâmico a partir de uma
<jsp:include page =”includeURL” flush=”true” />
página JSP principal, ao
término da ação retorna o
controle.
Tabela 1: Resumo das tags JSP.
3
Apêndice 2 – Sintaxe JSP
4
JSP e Servlets
1
Apêndice 3 - MVC
Colocar todo HTML dentro de uma Servlet realmente não parece a melhor
idéia. O que acontece quando se precisa mudar o design da página?
O seu designer não vai ter tempo de editar sua Servlet, recompila-la e
coloca-la no servidor.
Uma idéia mais interessante é usar o que é bom de cada um dos dois.
O JSP foi feito apenas para apresentar o resultado, e ele não deveria fazer
acessos a bancos e outros. Isso deveria estar na Servlet.
O ideal então é que a Servlet faça o trabalho sujo e árduo, e o JSP apenas
apresente esses resultados. A Servlet possui a lógica de negócios (ou regras de
negócio)e o JSP tem a lógica de apresentação. Podemos usar o recurso de
dispatch das servlets para que o JSP só seja chamado depois de que suas regras
foram executadas.
2
Apêndice 3 - MVC
processo
Melhorando o Processo
Seria melhor colocar cada regra de negócio (como inserir aluno, remover
aluno, fazer relatório de um aluno, etc...) em uma classe separada. Cada ação
(regra de negócio) em nossa aplicação estaria em uma classe. Essa classe
implementaria uma interface com algum método que será chamado no
momento que for decidido
Alguém precisa controlar então que ação será executada para cada
requisição, e que JSP será utilizado. Podemos usar uma servlet para isso, e então
3
Apêndice 3 - MVC
Repare na figura 4 a seguir que, apesar dos JSPs não estarem acessando a
parte da sua modelagem, isto é, as classes que direta ou indiretamente mexem
no banco de dados, ele tem uma referência a um Usuário, para poder colocar
suas informações na página resultante. Chamamos isso de “push” das
informações.
4
Apêndice 3 - MVC