Java Server Pages JSP

Java Server Pages
JSP
Roneclei Campos dos Santos
[email protected]
Eduardo Manuel de Freitas Jorge
[email protected]
2008
Java Server Pages – JSP
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
2
Java Server Pages – JSP
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,
3
Java Server Pages – JSP
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.
4
Java Server Pages – JSP
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”
5
Java Server Pages – JSP
•
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
6
Java Server Pages – JSP
•
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
7
Java Server Pages – JSP
•
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")
8
Java Server Pages – JSP
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: 
<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
<%
.
.
9
Java Server Pages – JSP
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.
10
Java Server Pages – JSP
•
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">
11
Java Server Pages – JSP
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.
12
Java Server Pages – JSP
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 é criada
sem 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.
13
Java Server Pages – JSP
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:
14
Java Server Pages – JSP
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.
15
Java Server Pages – JSP
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:
16
Java Server Pages – JSP
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, reiniciar, 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
17
Java Server Pages – JSP
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.
18
Java Server Pages – JSP
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>
19
Java Server Pages – JSP
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.
20
Java Server Pages – JSP
*/
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
*
21
Java Server Pages – JSP
* 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");
}
}
22
Java Server Pages – JSP
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.*" %>
23
Java Server Pages – JSP
<%
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: 
<input type="text" name="login">
24
Java Server Pages – JSP
<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);
25
Java Server Pages – JSP
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.*" %>
<%
26
Java Server Pages – JSP
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: 
<input type="text" name="login">
27
Java Server Pages – JSP
<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>
28
Java Server Pages – JSP
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
29