Tutorial JSP1

Prévia do material em texto

Java Server Pages 
JSP 
 
 
 
Roneclei Campos dos Santos 
roneclei.campos@gmail.com 
 
Eduardo Manuel de Freitas Jorge 
emjorge@reconcavotecnologia.org.br 
 
 
 
2008 
Java Server Pages – JSP 
 2 
Sumário: 
1 – Introdução...........................................................................................................3 
2 – Arquitetura JSP...................................................................................................4 
3 – Objetos Instanciados JSP...................................................................................5 
4 – Scripts.................................................................................................................5 
 4.1 – Declarações utilizadas..............................................................................5 
 4.2 – Diretivas utilizadas....................................................................................6 
5 – Sessão de Aplicação..........................................................................................6 
6 – Sessão de Usuário.............................................................................................8 
7 – Objeto Request...................................................................................................9 
8 – Conceitos básicos de formulários HTML..........................................................10 
 8.1 – HTML......................................................................................................10 
 8.2 – Formulários HTML..................................................................................10 
9 – Tabela...............................................................................................................12 
10 – Link.................................................................................................................14 
11 - Exemplo prático – Aplicação Login..................................................................14 
 11.1 – Configuração do Ambiente de Desenvolvimento JSP..........................15 
 11.1.1 – Recursos necessários........................................................................15 
 11.1.2 – instalação do JDK em ambiente Windows.........................................16 
 11.1.3 – Instalação do Tomcat.........................................................................16 
11.2 – Criando Estrutura de Diretórios...................................................................18 
 11.2.1 – Editando o arquivo web.xml..............................................................19 
11.3 – Implementando as Classes..........................................................................20 
11.4 – Implementando as páginas JSP..................................................................23 
12 - Conclusão........................................................................................................29 
13 - Referências.....................................................................................................29 
 
 
 
 
Java Server Pages – JSP 
 3 
1 – Introdução 
 
JSP – Java Server Pages – é uma tecnologia utilizada no desenvolvimento de 
aplicações Web, desenvolvida pela Sun microsystem, similar às tecnologias Active 
Server Pages (ASP) da Microsoft e PHP. Estas tecnologias estão fundamentadas 
na arquitetura SSI – Server Side Includes que são comandos extensivos à 
linguagem HTML, os quais podem conter conteúdo estático (HTML) e dinâmico 
(ASP, PHP, JSP, etc.). Esses comandos dinâmicos são processados pelo servidor 
Web antes da pagina HTML ser enviada. No lugar do comando é enviado apenas 
o resultado deste comando no formato HTML. 
 
Por ser baseada na linguagem de programação Java, tem a vantagem da 
portabilidade de plataforma, que permite a sua execução em diversos sistemas 
operacionais, como o Windows e o Linux. Esta tecnologia permite ao 
desenvolvedor web produzir aplicações que acessem o banco de dados, 
manipulem arquivos no formato texto, capturem informações a partir de 
formulários e captem informações sobre o visitante e sobre o servidor. 
Para desenvolver aplicações JSP é necessário um conhecimento prévio sobre a 
especificação J2EE que é um conjunto de padrões e especificações responsável 
por receber as requisições do cliente, entendê-las e direcioná-las aos 
responsáveis pelas respostas às ações solicitadas. Uma das especificações 
contidas em J2EE é a definição de um container Web. O container Web é o 
servidor de aplicação compatível com a especificação J2EE que dá suporte aos 
JSPs, e disponibiliza uma API com 9 objetos instanciados, que facilitam a 
implementação, isto possibilita ao programador focar o desenvolvimento na lógica 
da aplicação. 
 
Este Tutorial tem como objetivo apresentar conceitos básicos sobre a tecnologia 
Java Server Pages (JSP) desenvolvida pela Sun. Será abordado um exemplo 
prático de uma aplicação de Login, contendo conceitos de sessão de aplicação, 
sessão de usuário, requisições, configuração de ambiente de desenvolvimento, 
Java Server Pages – JSP 
 4 
além da instalação e configuração das ferramentas utilizadas. Será mostrado 
também conceitos básicos de HTML necessários para o desenvolvimento da 
aplicação de Login. 
 
 
2 – Arquitetura JSP 
 
 
 Figura 1 
• O Cliente faz uma requisição a uma página. O browser web efetua o pedido 
através da Internet. 
• O pedido JSP é enviado para o servidor web. 
• O servidor web reconhece o pedido especial (extensão .jsp) e entrega o 
arquivo JSP ao JSP Engine. 
 
 
 
 
 
Java Server Pages – JSP 
 5 
3 – Objetos Instanciados JSP 
 
• O “ambiente” de uma página JSP disponibiliza 9 objetos instanciados, para 
ser usado na implementação: 
– request – javax. servlet. ServletRequest 
– response – javax. servlet. ServletResponse 
– pageContext – javax. servlet. jsp. PageContext 
– session – javax. servlet. http. HttpSession 
– application – javax. servlet. servletContext 
– out – javax. servlet. jsp. JspWriter 
– config – javax. servlet. ServletConfig 
– page – java. lang. Object 
– exception – java. lang. Throwable 
 
 
 
4 – Scripts 
 
Os Scripts são trechos de código embutidos no código HTML do JSP. Não 
confundir com Java Scripts. Os scripts em uma página JSP são interpretados no 
servidor, enquanto que os Java Scripts são interpretados pelo browser (lado 
cliente). 
 
4.1 – Declarações utilizadas 
As declarações são usadas para definir variáveis e métodos específicos para uma 
página JSP. 
• Declaração de expressão 
<%= %> - o resultado é retornado como um String 
Exemplo: O seu endereço IP é: <%= request.getRemoteAddr() %> 
 <%= 2+2%> // Será retornado o String “4” 
 
Java Server Pages – JSP 
 6 
• Declaração de sintaxe: 
<% %> -.declaração livre. 
Exemplo: <% for( int i= 0; i< 10; i++){ out.println(“ numero: “+ i); }%> 
 
4.2 – Diretivas utilizadas 
 
• Diretiva page import : importa pacotes de classes. 
Exemplo: <%@page import="fib.*" %> 
 <%@ page import="java.util.List, java.awt.List" %> 
 
• Diretiva page language: informa a linguagem utilizada. 
Exemplo: <%@ page language="java" %> 
 
• Diretiva Forward: usada para redirecionar uma página 
Exemplo: pageContext.forward("index.jsp"); 
 
 
5 – Sessão de Aplicação 
A primeira vez que uma das páginas JSP da aplicação é chamada pode ser criada 
a referência ao objeto na sessão de aplicação. Através do objeto implícito 
pageContext é possível recuperar os atributos de qualquer escopo, utilizando o 
método getAttribute(String name, intScope) da classe PageContext a qual tem 
variáveis static final para cada escopo. 
Se eu desejar recuperar os atributos da sessão de aplicação: 
<%= pageContext.getAttribute(”gerenciaLogin”,PageContext.APPLICATION_SCOPE) %> 
Para setar o atributo na sessão é utilizado o método setAttribute 
 
 
Java Server Pages – JSP 
 7 
• pageContext.getAttribute(); 
public abstract java.lang.Object getAttribute(java.lang.String name, 
 int scope) 
Retorna o objeto associado com o nome no scopo especificado ou retorna 
null se o objeto não for encontrado. 
 
• pageContext.setAttribute(); 
public abstract void setAttribute(java.lang.String name, 
 java.lang.Object value, 
 int scope) 
Registra o nome e o valor especificado com o escopo definido. 
 
No exemplo abaixo, é possível acessar o objeto gl em qualquer página que 
contenha este código: 
GerenciaLogin gl = (GerenciaLogin) 
pageContext.getAttribute("gerenciaLogin",PageContext.APPLICATION_SCOPE); 
if (gl==null){ 
 gl = GerenciaLogin.getInstancia(); 
pageContext.setAttribute("gerenciaLogin",gl,PageContext.APPLICATION_SCOPE); 
} 
 
 
 Fonte: http://www.novatec.org/emjorge/pasi/modulo4_JSP.ppt 
 Figura 2 
Java Server Pages – JSP 
 8 
• Ao lado esquerdo tem-se uma página JSP fazendo referência à sessão de 
aplicação. Ao lado direito. Ao lado direito está descrito a Sessão de 
Aplicação provendo acesso a diversas páginas JSP. 
 
6 – Sessão de Usuário 
 
É o mecanismo utilizado para prover o controle de usuários dentro de uma 
aplicação web. Como o protocolo http não armazena informações de estado. é 
necessário tratar estes dados com sessão de usuário. Por exemplo: em uma 
aplicação web que necessite de autenticação, é desejável que o login seja 
solicitado em uma página de login, e os recursos das outras páginas do site 
devem estar disponíveis após a autenticação. Além disso, o usuário não poderá 
acessar diretamente certas páginas sem ter efetuado o login e somente o usuário 
autenticado com o mesmo browser é que poderá obter um referência para o objeto 
da sessão. Mais adiante, será mostrado um exemplo prático do uso de sessão de 
usuário. 
 
Para setar o atributo de um usuário: 
Session. SetAttribute 
public void setAttribute(java.lang.String name, 
 java.lang.Object value) 
 
Liga um objeto a essa sessão, usando o nome especificado. Se um objeto do 
mesmo nome é limitado já à sessão, o objeto é renomeado. 
 
Exemplo: session.setAttribute("login", l); 
 
Para recuperar o atributo de um usuário. 
Session. GetAttribute 
public java.lang.Object getAttribute(java.lang.String name) 
 
Retorna o objeto com o especifico nome na sessão corrente, ou nulo se nenhum 
objeto possuir o mesmo nome. 
 
Exemplo: session.getAttribute("login") 
 
 
Java Server Pages – JSP 
 9 
7 – Objeto request 
 
Solicitação que aciona o processamento da página e busca por valores de 
parâmetros ou cookies. 
 
- REQUEST.GETPARAMETER() ; javax. servlet. ServletRequest 
 
• Passando parâmetros 
 
Index.jsp 
<% 
. 
. 
<form name="form1" method="post" action="verifica.jsp"> 
 <p>Login:&nbsp; 
 <input type="text" name="login"> 
 <br><br> 
 Senha: 
 <input type="password" name="senha"> 
 <br><br> 
 <input type="submit" name="Submit" value="OK"> 
 </p> 
 </form> 
%> 
 
• Recebendo Parâmetros 
 
Verifica.jsp 
<% 
. 
. 
Java Server Pages – JSP 
 10 
String login_ = request.getParameter("login"); 
String senha_ = request.getParameter("senha"); 
 
out.println("<br>" + "login: " + login_); 
 
%> 
 
Obs.: OUT.PRINTLN(); javax. servlet. jsp. JspWriter 
Método utilzado para imprimir na tela do browser. Pode conter variáveis, 
constantes, números, arrays, Tags html, etc. 
 
Exemplo: out.println("<br>" + "login: " + login_); 
 
8 – Conceitos básicos de formulários HTML 
 
A seguir serão apresentados conceitos básicos de formulários HTML necessário à 
realização desde tutorial. 
 
8.1 – HTML 
 
“HTML (acrônimo para a expressão inglesa HyperText Markup Language, que 
significa Linguagem de Marcação de Hipertexto) é uma linguagem de marcação 
utilizada para produzir páginas Web estáticas. Documentos HTML podem ser 
interpretados por navegadores”. 
Fonte: http://pt.wikipedia.org/wiki/HTML 
 
8.2 – Formulários HTML 
 
Os formulários constituem-se numa matéria de extrema importância no HTML, 
uma vez que são responsáveis pela interação entre um usuário e o servidor, 
possibilitando a troca de dados ou informações. 
Java Server Pages – JSP 
 11 
• Principais Tags utilizadas em um Formulário 
 
<form> </form> : inicia e termina um formulário. 
Ex: <form name="form1" method="post" action="verifica.jsp"> 
O atributo method especifica a forma de envio dos dados do formulário. Os mais 
utilizados são GET e POST. No método GET os dados de entrada do script fazem 
parte do URL associado à consulta enviada para o servidor - por exemplo: 
mydoc.jsp?var1=valor1&var2=valor2... etc. Já no método POST, os dados de 
entrada do formulário são enviados pelo corpo da mensagem para o servidor, 
sendo invisível para o usuário, além de ser possível transferir grande quantidade 
de dados. 
 
O atributo action define o tipo de ação a realizar com o formulário. O formulário 
pode ser enviado para um programa ou script que processa seu conteúdo ou 
enviado a um endereço de e-mail. 
 
<input type=””> : text (linha única para texto), password, checkbox, radio, submit 
(button) e reset (button); 
 
Qualquer que seja o tipo de entrada de dados (Input, checkbox, radiobutton, 
ComboBox, etc). Cada um destes campos deve possuir um atributo name 
associado a um nome, de tal forma que o parâmetro action possa receber uma 
variável com o valor digitado pelo usuário. 
 
Exemplos: <input type="text" name="login"> 
 <input type="password" name="senha"> 
 <input type=" checkbox " name="senha"> 
 
 
 
 
Java Server Pages – JSP 
 12 
Parâmetros opcionais: 
 
value - atribui um valor inicial para o campoo; 
 
size - especifica o tamanho do campo;> 
 
maxlenght - especifica o número máxximo de caracteres aceitos pelo campo. 
Um botão do tipo reset pode ser usado para restaurar o valor padrão de todos os 
campos de um formulário: 
 
Exemplo: <input type="reset" value=”Limpar”> 
 
Um botão do tipo submit enviará as opções ou informações digitadas ao servidor: 
 
Exemplo: <input type="submit" value="Enviar"> 
 
São opcionais os parâmetros value que especifica o texto a ser exibido no botão e 
o parâmetro name que determinará a transmissão do valor contido em value, 
permitindo inserir de vários botões. 
 
9 – TABELA 
 
As tabelas são definidas pelas Tags <table> e </table>. Dentro dessas duas 
etiquetas são colocadas todas as outras etiquetas, textos e imagens que darão 
forma e conteúdo à tabela. 
 
As tabelas são descritas por linhas da esquerda para direita. Cada uma destas 
linhas é definida por outra tag e seu fechamento: <tr> e </tr>. 
Ainda assim, dentro de cada linha, haverá diferentes células. Cada uma dessas 
células será definida por outro par de etiquetas:<td> e </td>. Dentro desta etiqueta 
será colocado o conteúdo. 
Java Server Pages – JSP 
 13 
Exemplo de estrutura de tabela: 
<table> 
<tr> 
<td>Célula 1, linha 1</td> 
<td>Célula 2, linha 1</td> 
</tr> 
<tr> 
<td>Célula 1, linha 2</td> 
<td>Célula 2, linha 2</td> 
</tr> 
</table> 
 
O resultado será: 
 
Célula 1, linha 1 Célula 2, linha1 
Célula 1, linha 2 Célula 2, linha 2 
 
Parâmetros opcionais: 
 
align: Justifica o texto da célula da mesma forma que se fosse o de um parágrafo. 
border: especifica a espessura da borda da tabela. Se colocado 0 a tabela é criadasem borda. 
Valign: Podemos escolher se queremos que o texto apareça acima (top), no centro 
(middle) ou abaixo (bottom) da célula. 
bgcolor: Dá cor à célula ou escolha de linha. 
bordercolor: Define a cor da borda. 
Outros atributos que podem ser unicamente atribuídos a uma célula e não ao um 
conjunto de células de uma linha são: 
background: Permite-nos colocar um fundo para a célula a partir de um link a uma 
imagem. 
height: Define a altura da célula em pixels ou porcentagem. 
Java Server Pages – JSP 
 14 
width: Define a largura da célula em pixels ou porcentagem 
colspan: Expande um célula horizontalmente. 
rowspan: Expande um célula verticalmente. 
 
10 – LINK 
 
Para colocar um link, utilizaremos as etiquetas <a> e </a>. Dentro da etiqueta de 
abertura devemos especificar o destino do link. Este destino será introduzido sob a 
forma de atributo, no qual leva o nome href. 
 
A sintaxe geral de um link é portanto da seguinte forma: 
 
<a href="destino">conteúdo</a> 
 
Sendo o conteúdo um texto ou uma imagem. É a parte da página que se colocará 
ativa e onde deveremos clicar para acessar o link. 
 
E o destino por sua vez, será uma página, um correio eletrônico ou um arquivo. 
 
11 – Exemplo prático – Aplicação Login 
 
Como dito na introdução deste tutorial, para exemplificar os conceitos vistos acima 
será abordado um exemplo prático de uma aplicação de Login. O desenvolvimento 
da aplicação de login será feito através de um Passo-a-Passo, pois esta foi a 
forma mais simples encontrada para a implementação da aplicação. 
 
Segue abaixo a estrutura de funcionamento da aplicação mostrada na figura 3: 
 
 
 
 
Java Server Pages – JSP 
 15 
index.jsp verfica.jsp cadastrar.jsp 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 3 
 
11.1 – Configuração do Ambiente de Desenvolvimento JSP 
11.1.1 – Recursos necessários 
A seguir os recursos necessários para este tutorial e como conseguí-los: 
 Recursos URL Versão 
Kit JDK http://www.sun.com 6.0 
Tomcat http://tomcat.apache.org/download-55.cgi 5.5.16 
 
Para instalar o Tomcat é necessário possuir o kit de desenvolvimento Java JDK 
instalado em sua máquina. 
 
Java Server Pages – JSP 
 16 
11.1.2 – instalação do JDK em ambiente Windows 
 
O JDK pode ser baixado no site da Sun, http://www.sun.com , na guia Java - 
Download the lastest JDK. 
Para configurar o JDK, defina a variável de ambiente JAVA_HOME apontando 
para seu local de instalação (Ex: JAVA_HOME=C:\Arquivos de 
programas\Java\jdk1.6.0_05) . Esta variável de ambiente padrão é usada pelo 
Tomcat e vários outros sistemas baseados em Java, para determinar a JVM 
preferencial. Isto é muito importante se houver mais de uma instalação de J2SE 
no computador, mas a variável JAVA_HOME deve ser definida mesmo se houver 
apenas uma versão instalada. 
 
11.1.2 – Instalação do Tomcat 
 
Após instalar e configurar o JDK, baixe o Apache Tomcat do site 
http://tomcat.apache.org, Para instalar o Tomcat basta clicar em Next, Next,... , 
Finish e o Tomcat estará instalado. Caso o serviço não rode da primeira vez, 
execute o arquivo startup.bat localizado na pasta bin do Tomcat. 
Neste tutorial será utilizada a versão 5.0.16 do Tomcat. Para maiores informações 
sobre versões, acesse o site Apache Tomcat, na Apache Software Foundation. 
 
Para testar se o Tomcat está funcionando corretamente, abra o seu browser e 
digite http://localhost:8080. Deverá aparecera seguinte página: 
 
Java Server Pages – JSP 
 17 
 
 Figura 4 
Na home-page padrão do Tomcat, é possível acessar ferramentas de interface 
Web para administrar e gerenciar o servidor, sem a necessidade de editar 
arquivos de configuração. 
 
Para utilizar as ferramentas é solicitado o login de usuário (padrão é admin) e a 
senha, cadastrados durante a instalação do tomcat, para acesso a estes recursos. 
 
• Tomcat Manager - Permite gerenciar as aplicações — iniciar, parar, re-
iniciar, fazer deploy (distribuição) e undeploy — bem como monitorar o 
estado do servidor. 
 
• Tomcat Administration - Permite criar, excluir e configurar Serviços e seus 
elementos internos (Connector, Host, Alias, Context, Logger, Valve) do 
Java Server Pages – JSP 
 18 
Servidor Tomcat, bem como Recursos (Data Source etc.) e Autorizações 
(User, Group, Role). Estes itens correspondem aos elementos e atributos 
disponíveis no arquivo de configuração server.xml. 
 
11.2 – Criando Estrutura de Diretórios 
 
Para rodar os seus arquivos JSP é necessário montar uma estrutura de diretórios 
dentro da pasta onde o Tomcat foi instalado da seguinte forma: 
 
 Figura 5 
• loginWeb: local onde ficarão os arquivos *.html, *.jsp, e as imagens. 
• WEB-INF (respeitando maiúsculas): deve conter o arquivo web.xml. 
• classes: arquivos de classes (*.class) que serão utilizadas pelas páginas 
JSP. 
• fib: classes utilizadas na aplicação que estão no pacote fib. 
• lib: pacotes *.jar de bibliotecas utilizadas devem ficar armazenados aqui. 
Java Server Pages – JSP 
 19 
Esta estrutura de diretórios é universal, e é interpretada por qualquer servidor, 
sem a necessidade de alteração. Além disso, facilita a organização do conteúdo 
de desenvolvimento, bem como a segurança da aplicação, deixando visível 
apenas o conteúdo necessário. 
 
11.2.1 – Editando o arquivo web.xml 
 
Segundo a especificação Java Servlet/J2EE, o arquivo web.xml é o descritor do 
contexto de aplicação web, contém as configurações específicas da aplicação. 
 
web.xml: 
 
<?xml version="1.0" encoding="ISO-8859-1"?> 
<!DOCTYPE web-app 
 PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 
2.3//EN" 
 "http://java.sun.com/dtd/web-app_2_3.dtd"> 
 
<web-app> 
 <display-name>Aplicação Login</display-name> 
 <description> 
 LoginWeb 
 </description> 
 
 <welcome-file-list> 
 <welcome-file>index.jsp</welcome-file> 
 </welcome-file-list> 
 
 <error-page> 
 <error-code>404</error-code> 
 <location>/error.jsp</location> 
 </error-page> 
</web-app> 
Java Server Pages – JSP 
 20 
11.3 – Implementando as Classes 
 
• Classe Login: 
 
package fib; 
 
/** 
 * @author emjorge 
 * 
 * TODO To change the template for this generated type 
comment go to 
 * Window - Preferences - Java - Code Generation - Code and 
Comments 
 */ 
public class Login { 
 private String nome; 
 private String senha; 
 /** 
 * @return Returns the nome. 
 */ 
 public String getNome() { 
 return nome; 
 } 
 /** 
 * @param nome The nome to set. 
 */ 
 public void setNome(String nome) { 
 this.nome = nome; 
 } 
 /** 
 * @return Returns the senha. 
Java Server Pages – JSP 
 21 
 */ 
 public String getSenha() { 
 return senha; 
 } 
 /** 
 * @param senha The senha to set. 
 */ 
 public void setSenha(String senha) { 
 this.senha = senha; 
 } 
 public boolean equals(Object o){ 
 Login l = (Login)o; 
 if 
((this.nome.equals(l.getNome()))&&(this.senha.equals(l.getSen
ha()))){ 
 return true; 
 }else { 
 return false; 
 } 
 } 
} 
 
 
• Classe GerenciaLogin: 
 
package fib; 
 
import java.util.*; 
 
/** 
 * @author emjorge 
 * 
Java Server Pages – JSP 
 22 
 * TODO To change the template for this generated type 
comment go to 
 * Window - Preferences - Java - Code Generation - Code and 
Comments 
 */ 
public class GerenciaLogin { 
 private ArrayList listaLogin = new ArrayList(); 
 private static GerenciaLogin gl = new GerenciaLogin(); 
 
 private GerenciaLogin(){ 
 try{ 
 Login l = new Login(); 
 l.setNome("emjorge"); 
 l.setSenha("123"); 
 this.addLogin(l);}catch(Exception e){ 
 
 } 
 
 } 
 public static GerenciaLogin getInstancia(){ 
 return GerenciaLogin.gl; 
 } 
 public void addLogin(Login l) throws Exception{ 
 if (!(this.existeLogin(l))){ 
 this.listaLogin.add(l); 
 
 }else { 
 throw new Exception("Login duplicado"); 
 } 
 } 
 
Java Server Pages – JSP 
 23 
 public boolean existeLogin(Login l){ 
 Iterator it = this.listaLogin.iterator(); 
 while (it.hasNext()){ 
 Login l1 =(Login) it.next(); 
 if (l.equals(l1)){ 
 return true; 
 } 
 } 
 return false; 
 } 
 public ArrayList getListaLogin(){ 
 return this.listaLogin; 
 } 
 public static void main(String args[]){ 
 Login l = new Login(); 
 l.setNome("emjorge"); 
 l.setSenha("123"); 
 
 System.out.println(GerenciaLogin.getInstancia().existeLo
gin(l)); 
 } 
 
} 
 
11.4 – Implementando as páginas JSP 
 
• index.jsp 
 
<%@ page language="java" %> 
<%@page import="fib.*" %> 
<%@page import="java.util.*" %> 
 
Java Server Pages – JSP 
 24 
<% 
GerenciaLogin gl = (GerenciaLogin) 
pageContext.getAttribute("gerenciaLogin",PageContext.APPLICATION_S
COPE); 
if (gl==null){ 
 gl =GerenciaLogin.getInstancia(); 
 
pageContext.setAttribute("gerenciaLogin",gl,PageContext.APPLICATIO
N_SCOPE); 
} 
 
Login sl = (Login)session.getAttribute("login"); 
if (sl == null){ 
 request.setAttribute("msg", "Efetue o login"); 
 pageContext.forward("index.jsp"); 
} 
if (!(request.getParameter("cadastrar")==null)){ 
try{ 
 Login l = new Login(); 
 l.setNome(request.getParameter("login")); 
 l.setSenha(request.getParameter("senha")); 
 gl.addLogin(l); 
 }catch(Exception e){ 
 out.println("Atenção: Login já existe"); 
 } 
} 
%> 
<html> 
<head> 
<title>Login JSP</title> 
</head> 
<body bgcolor="#FFFFFF"> 
<form name="form1" method="post" action="cadastrar.jsp"> 
 <p>Login:&nbsp; 
 <input type="text" name="login"> 
Java Server Pages – JSP 
 25 
 <br><br> 
 Senha: 
 <input type="password" name="senha"> 
 <br><br> 
 <input type="submit" name="cadastrar" value="Cadastrar"> 
 </p> 
 </form> 
 
 <TABLE BORDER=2> 
 <TR><TD>Login</TD><TD>Senha</TD></TR> 
 
 <% 
 Iterator it = gl.getListaLogin().iterator(); 
 while (it.hasNext()){ 
 Login l = (Login) it.next(); 
 
 out.println("<TR><TD>"+l.getNome()+"</TD><TD>"+l.getSenha()+"
</TD></TR>"); 
 } 
 
 %> 
</TABLE> 
</body> 
</html> 
 
 
• verifica.jsp 
 
<%@ page language="java" %> 
<%@page import="fib.*" %> 
<% 
GerenciaLogin gl = (GerenciaLogin) 
pageContext.getAttribute("gerenciaLogin",PageContext.APPLICATION_S
COPE); 
Java Server Pages – JSP 
 26 
if (gl==null){ 
 gl =GerenciaLogin.getInstancia(); 
pageContext.setAttribute("gerenciaLogin",gl,PageContext.APPLICATIO
N_SCOPE); 
} 
Login l = new Login(); 
l.setNome(request.getParameter("login")); 
l.setSenha(request.getParameter("senha")); 
if (gl.existeLogin(l)){ 
 session.setMaxInactiveInterval(1800); 
 session.setAttribute("login", l); 
 out.println(" Login efetuado com sucesso"); 
}else{ 
 session.invalidate(); 
 request.setAttribute("msg","Login Inválido"); 
 pageContext.forward("index.jsp"); 
} 
%> 
<html> 
<head> 
<title>Login Verificado JSP</title> 
</head> 
<body bgcolor="#FFFFFF"> 
<p><a href="cadastrar.jsp">cadastrar Login</a></p> 
</body> 
</html> 
cadastrar.jsp 
 
<%@ page language="java" %> 
<%@page import="fib.*" %> 
<%@page import="java.util.*" %> 
 
<% 
Java Server Pages – JSP 
 27 
GerenciaLogin gl = (GerenciaLogin) 
pageContext.getAttribute("gerenciaLogin",PageContext.APPLICATION_S
COPE); 
if (gl==null){ 
 gl =GerenciaLogin.getInstancia(); 
pageContext.setAttribute("gerenciaLogin",gl,PageContext.APPLICATIO
N_SCOPE); 
} 
 
Login sl = (Login)session.getAttribute("login"); 
if (sl == null){ 
 request.setAttribute("msg", "Efetue o login"); 
 pageContext.forward("index.jsp"); 
} 
if (!(request.getParameter("cadastrar")==null) && sl != null){ 
try{ 
 Login l = new Login(); 
 l.setNome(request.getParameter("login")); 
 l.setSenha(request.getParameter("senha")); 
 gl.addLogin(l); 
 }catch(Exception e){ 
 out.println("Atenção: Login já existe"); 
 } 
} 
 
%> 
 
<html> 
<head> 
<title>Login JSP</title> 
</head> 
<body bgcolor="#FFFFFF"> 
<form name="form1" method="get" action="cadastrar.jsp"> 
 <p>Login:&nbsp; 
 <input type="text" name="login"> 
Java Server Pages – JSP 
 28 
 <br><br> 
 Senha: 
 <input type="password" name="senha"> 
 <br><br> 
 <input type="submit" name="cadastrar" value="Cadastrar"> 
 </p> 
 </form> 
 
 <TABLE BORDER=2> 
 <TR><TD>Login</TD><TD>Senha</TD></TR> 
 
 <% 
 Iterator it = gl.getListaLogin().iterator(); 
 while (it.hasNext()){ 
 Login l = (Login) it.next(); 
 
 out.println("<TR><TD>"+l.getNome()+"</TD><TD>"+l.getSenha()+"
</TD></TR>"); 
 } 
 
 %> 
 
</TABLE> 
</body> 
</html> 
 
 
 
 
 
 
 
Java Server Pages – JSP 
 29 
12 – Conclusão 
 
JSP permite o desenvolvimento de aplicações do lado do servidor e é baseado 
em Java, uma linguagem OO, podendo ser aplicados todos os conceitos de 
reutilização de componentes, desacoplamento e encapsulamento. JSP possibilita 
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. Além disso, outra vantagem das aplicações Java é a segurança e a 
portabilidade. Uma desvantagem que pode ser apontada do JSP é que, quando 
comparada com outras ferramentas de desenvolvimento web, como ASP, por 
exemplo, JSP é considerada mais difícil de se aprender porque é orientada a 
objetos e a maneira de escrever os programas é mais rígida. 
 
13 – Referências: 
 
• JAVA PARA A WEB COM SERVLETS, JSP E EJB 
o Autor: Budi Kurniawan 
o Editora: Ciência Moderna 
 
• Sun 
o http://java.sun.com/products/jsp/docs.html 
 
• Tutorial Tomcat - Instalação e Configuração Básica 
o http://www.mhvila.com.br/topicos/java/tomcat.html 
 
• NovaTec – Eduardo Jorge 
o http://www.novatec.org/emjorge/pasi/modulo4_JSP.ppt 
 
• CriarWeb 
o http://www.criarweb.com/artigos/93.php 
o http://www.criarweb.com/artigos/88.php