Você está na página 1de 46

Módulo JSP

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP


webmaster@dbsystems.com.br
Índice Analítico

1. O QUE É JSP..............................................................................................................................................................1

2. INSTALANDO UM SERVIDOR JSP ......................................................................................................................2

3. SIMBOLOGIA - PARTE 1 .......................................................................................................................................4

4. SIMBOLOGIA - PARTE 2 .......................................................................................................................................7

5. COMANDOS LOOPS..............................................................................................................................................10

6. COMANDOS CONDICIONAIS.............................................................................................................................13

7. TRATANDO FORMULÁRIOS..............................................................................................................................16

8. OBJETOS IMPLÍCITOS - INTRODUÇÃO .........................................................................................................22

9. OBJETOS RELACIONADOS AO SERVLET .....................................................................................................23

10. OBJETOS RELACIONADOS A OUTPUT/INPUT DA PÁGINA......................................................................24

11. OBJETOS CONTEXTUAIS ...................................................................................................................................28

12. TRATAMENTO DE ERROS..................................................................................................................................33

13. JAVABEANS............................................................................................................................................................34

14. AÇÃO JSP:USEBEAN ............................................................................................................................................38

15. EXEMPLO – MINI APLICAÇÃO USANDO JAVABEANS ..............................................................................40

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP


webmaster@dbsystems.com.br
1. O que é JSP

JSP (Java Server Pages) é uma tecnologia para desenvolvimento de aplicações


WEB semelhante ao Microsoft Active Server Pages (ASP), porém tem a
vantagem da portabilidade de plataforma podendo ser executado em outros
Sistemas Operacionais além dos da Microsoft. Ela permite que ao desenvolvedor
de sites produzir aplicações que permitam o acesso a banco de dados, o acesso
a arquivos-texto, a captação de informações a partir de formulários, a captação
de informações sobre o visitante e sobre o servidor, o uso de variáveis e loops
entre outras coisas.
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.
Quando uma página JSP é requisitada pelo cliente através de um Browser, esta
página é executada pelo servidor, e a partir daí será gerada uma página HTML
que será enviada de volta ao browser do cliente. A figura abaixo ilustra esse
funcionamento:

Quando o cliente faz a solicitação de um arquivo JSP, é enviado um object


request para a JSP engine. A JSP engine envia a solicitação de qualquer
componente (podendo ser um JavaBeans component, servlet ou enterprise
Bean) especificado no arquivo. O componente controla a requisição

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 1


webmaster@dbsystems.com.br
possibilitando a recuperação de arquivos em banco de dados ou outro dado
armazenado, em seguida, passa o objeto response de volta para a JSP engine.
A JSP engine e o WEB server enviam a página JSP revisada de volta para o
cliente, onde o usuário pode visualizar os resultados através do WEB browser. O
protocolo de comunicação usado entre o cliente e o servidor pode ser HTTP ou
outro protocolo.
Por definição, JSP usa Java como sua linguagem de scripts. Por esse motivo, O
JSP é apresenta mais flexível e mais robusto do que outras plataformas
baseadas simplesmente em JavaScripts e VBScripts.
Requisitos para entender JSP? Para tirar um bom proveito do JSP é preciso
entender a linguagem Java. Isso porque, a parte lógica do JSP envolve Java
Beans, Objetos JDBC, Enterprise Java Beans (EJB) entre outros componentes
que interagem com a plataforma Java. Portanto, alertamos aqueles que
pretendem desenvolver uma aplicação mais sofisticada que entedam um pouco
de programação em Java.
O ideal é que se conheça um pouco de HTML, pouco mesmo. É comum em
grandes aplicações que o Programador JSP e o Designer sejam pessoas
diferentes. Portanto, nesse curso, usamos pouquíssimas tags HTML, nossa
preocupação está voltada para a parte lógica das aplicações e não para a parte
visual.
Nos próximos módulos você aprenderá como instalar um servidor JSP. Num
módulo posterior, você iniciará a programação em JSP e aprenderá a simbologia
dessa linguagem.

2. Instalando um servidor JSP

Para conseguir ver os resultados das páginas que iremos construir nos próximos
módulos desse curso, é preciso instalar na sua máquina um servidor JSP. Por se
tratar de uma extensão ao modelo de programação Java, o JSP pode ser
executado em qualquer plataforma. Existem diversos servidores JSP espalhados
na WEB, alguns deles, dispõe de versões para plataforma Windows e Linux. Dois
dos mais famosos são o Tomcat, do projeto Jakarta
(http://jakarta.apache.org/tomcat) e o Resin da Empresa Caucho
(www.caucho.com).
Nesse módulo, iremos mostrar a instalação do "Tomcat" para a plataforma
Windows NT ou 98/95, é bastante fácil de ser instalado e configurado. Se você
nunca instalou um servidor na sua máquina, não se preocupe!!! Mostraremos
passo a passo como fazer. Contudo, se você já é um cobra nessa área, um
rápida lida na seção abaixo já será suficiente para preparar sua máquina para
rodar páginas com scripts JSP.
• Passo 1: Instalação da Máquina Virtual.
Você necessitará, antes de tudo, ter a máquina virtual Java instalada (JDK -
Java Development Kit). Se você não tiver ainda o JDK instalado, faça o
download através do site da Empresa Sun. (http://java.sun.com).

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 2


webmaster@dbsystems.com.br
• Passo 2: Download do Servidor JSP.
Você poderá fazer o download do servidor Tomcat no site da empresa "Jakarta"
(http://jakarta.apache.org/builds/jakarta-tomcat-4.0/release/v4.1.18/bin/jakarta-tomcat-4.1.18-LE-jdk14.exe).
• Passo 3: Executar o arquivo de instalação.
Você pode usar a instalação padrão, no final da instalação você de informar uma
senha para o administrador do servidor. Após a instalação concluída, será
gerado alguns atalhos dentre eles “Start Tomcat” e “Stop Tomcat”, copie estes
dois atalhos para o seu desktop, para iniciar o servidor use o atalho “Start
Tomcat”, para parar use o atalho “Stop Tomcat”.
• Passo 4: Configurações default Tomcat.
De acordo com a configuração original do Tomcat, os arquivos deverão estar
nos seguintes diretórios:
- arquivos *.jsp (páginas com scripts JSP): " C:\Arquivos de programas\Apache
Group\Tomcat 4.1\webapps \sistema"
- arquivos *class e *.java (classes utilizadas em beans): " C:\Arquivos de
programas\Apache Group\Tomcat 4.1\webapps\sistema\WEB-
INF\classes\pacotes ".

• Passo 5: Testando o Tomcat.


Agora você deve testar o Tomcat. Abra o seu navegador e digite a url
"http://localhost:8080". Se a página de apresentação da empresa Jakarta
aparecer no seu navegador então a instalação do software ocorreu com sucesso.
Sua máquina estará pronta para rodar páginas JSP. É necessário digitar a porta
"8080" pois essa porta fica reservada para esse servidor.

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 3


webmaster@dbsystems.com.br
3. Simbologia - Parte 1

A maior parte do código de uma página JSP consiste em template text. O


template text é similar ao HTML, obedecendo às mesmas regras de sintaxe e é
simplesmente passado ao cliente por um servlet criado especialmente para
manusear a página. Para construir uma aplicação usando JSP você geralmente
escreve o texto HTML e inclue códigos JSP entre tags JSP. As tags normalmente
começam com "<%" e terminam com "%>". Vamos mostrar o clássico exemplo
do "Olá Mundo".

<html>
<body>
<h1><%= request.getParameter("text") %></h1>
</body>
</html>

Salve esse artigo com o nome "exemplo01.jsp". Para executar esse código
basta digitar em seu browser a URL:

..exemplo01.jsp?text=Ola+Mundo.

Perceba que foi possível passar o valor do objeto "text" como parâmetro na
própria URL e o servidor de JSP montou o código.
Se você verificar o código da página que apareceu no seu browser, verá o
seguinte:

<html>
<body>
<h1>Ola Mundo</h1>
</body>
</html>

O que aconteceu foi que o servidor JSP executou os comandos entre as tags
especiais "<%" e "%>", gerou e enviou para o browser um código HTML puro.
JSP fornece cinco categorias de tags: diretivas, declarações, expressões,
scriptlets e comentários.
As diretivas serão tratadas na parte 2 desse módulo do curso. Vamos nos
concentrar aqui no estudo das declarações, expressões, scriptlets e
comentários. Os três primeiras têm sintaxes e usos similares, mas têm
diferenças importantes. Vamos explicar, com alguns exemplos, as semelhanças
e diferenças entre elas.
Declarações (entre <%! and %>):
As declarações são usadas para definir variáveis e métodos específicos para
uma página JSP. Os métodos e variáveis declaradas podem então ser

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 4


webmaster@dbsystems.com.br
referenciados por outros elementos de criação de scriptlets na mesma página. A
cada declaração deve ser finalizada ou separada por "ponto-e-vírgula" e pode
assumir a seguinte sintaxe:

<%! declaration %>

Veja alguns exemplos:

<%! int i = 0; %>


<%! int a, b; double c; %>
<%! Circle a = new Circle(2.0); %>

Você deve declarar uma variável ou um método antes de usá-lo. O escopo de


uma declaração é geralmente o arquivo JSP, mas se for incluído outros arquivos
com a diretiva include, o escopo se expande para o cover do arquivo incluído.
Expressões (entre <%= e %>)
Podem conter alguma expressão válida da linguagem de script usada nessa
página (o padrão é que a Linguagem seja Java), mas sem ponto-e-vírgula.
A sintaxe para este elemento de criação de scripts é a seguinte:

<%= expression %>

Veja alguns exemplos:

<%= Math.sqrt(2) %>


<%= items[i] %>
<%= a + b + c %>
<%= new java.util.Date() %>

A expressão Java é avaliada (da esquesda para a direita), convertida em String


e depois inserida na página. Essa avaliação é feita em tempo de execução
(quando a página é solicitada) permitindo fácil e rápido acesso a informação que
foi requisitada. Por exemplo, uma exibição de data e hora em que a página é
acessada.
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.
Veja um exemplo:
Seu hostname: <%= request.getRemoteHost() %>
Para simplificar as expressões, existem um número de variáveis predefinidas
que você pode usar e que veremos a seguir.
Scriptlets (entre <% e %>)
Permitem você escrever trechos de código da Linguagem usada na página. Veja
o exemplo abaixo:
Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 5
webmaster@dbsystems.com.br
<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"; }
%>

<font face="verdana, arial" size=5>Opção Escolhida: <%= option %> </font>


.
.
.
</body>
</html>

Lembre-se que em um script você deve finalizar as expressões através do uso


de ponto-e-vírgula. Quando você escreve um script, você pode usar algum dos
objetos implícitos do JSP ou das classes importadas através da diretiva page,
variáveis ou métodos (declarados entre as tags <%! e %> ou objetos
nomeados através da tag <jsp:useBean>. Para testar a página acima basta
salvá-la com o nome de "classificados.jsp" e digitar a url
".../classificados.jsp?option=2".
• 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:

<!-- comment -->

Aqueles familiarizados com HTML percebem que é a mesma sintaxe de


comentário para essa linguagem de marcação. Tais comentários não produzem
qualquer output visível, mas podem ser visualizados pelo usuário final através
do item "view source" do navegador.

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 6


webmaster@dbsystems.com.br
Comentários JSP: não são enviados para o cliente e são visíveis apenas nos
arquivos fonte JSP originais. O corpo do comentário é ignorado pelo container
JSP. Os comentários JSP podem assumir duas sintaxes:

<%-- comment --%>


e
<% /* comment */ %>

Esse segundo comentário é introduzido dentro da página através de um


scriptlets, usando a sintaxe de comentário nativa da linguagem de criação de
scripts, no caso JAVA.

4. Simbologia - parte 2

As diretivas são usadas para fornecer informações especiais ao container JSP


sobre a página JSP quando esta é compilada para servlet. As diretivas JSP
afetam a estrutura global da classe servlet.
Existem dois tipos principais de diretivas:
- page: permite situações como importação de classes, customização de super
classes servlet entre outras;
- include: permite que seja inserido o conteúdo de um arquivo no servlet no
momento em que o arquivo JSP é traduzido para servlet.
01. Diretiva page
A diretiva page tem a seguinte sintaxe:

<%@ page attribute1=valor1 attribute2=valor2 attribute3=... %>

Abaixo relacionamos os atributos mais utilizados nas diretivas page:


• Atributo import
import="package.class" ou
import="package.class1,...,package.classN".
permite que seja especificado qual o pacote a ser importado. Por exemplo:
<%@ page import="java.util.*" %>
O atributo import attribute é o único que pode aparecer várias vezes.

• Atributo isThreadSafe
isThreadSafe="true|false".
O valor de true (default) indica o processamento normal do servlet quando
múltiplas requisições podem ser acessadas simultaneamente na mesma
instância de servlet. O valor false indica que o servlet deve implementar
SingleThreadModel, como requisição para cada requisição sinalizada ou com
requisições simultâneas sendo uma em cada instância.

• Atributo session

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 7


webmaster@dbsystems.com.br
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. Aqui está a implementação do contexto.

• Atributo buffer
buffer="sizekb|none"
Especifica o tamanho do buffer para o JspWriter out. O buffer padrão é definido
pelo servidor.

• Atributo autoFlush
autoflush="true|false"
O valor de true (default) indica se o buffer deve ser esvaziado quando estive
cheio. O valor false, indica que uma exceção deve ser mostrada quando ocorrer
overflows.

• Atributo extends
extends="package.class"
Define se a super classe do servlet deve ser gerada.

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

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

02. Diretiva include

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 8


webmaster@dbsystems.com.br
A diretiva include permite que sejam incluídos arquivos na hora em que a
página JSP é traduzida no servlet. Uma directive include é algo como:

<%@ include file="relative url" %>

Essa diretiva pode ser implementada de acordo com o seguinte exemplo:


muitos sites têm uma barra de navegação em cada página. Devido a problemas
com frames HTML isto é normalmente implementado com um tabela repetindo o
código HTML em cada página do site. Esta directive supre essa necessidade de
minimizar os esforços de manutenção conforme o código abaixo:

<html>
<%@ include file="navbar.html" %>
<!-Parte específica da página ... -->
</body>
</html>

Arquivo exemplo_02.jsp

<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_02.jsp">SEÇÃO 02</a>
</font>

Arquivo navbar.html

<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_02.jsp">SEÇÃO 02</a>
</font>
<!-Parte específica da página ... -->
</body>
</html>

Código do arquivo "exemplo_02.jsp" visto pelo browser

Apresentamos a seguir um resumo da sintaxe do JSP:

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 9


webmaster@dbsystems.com.br
Declara variáveis e métodos válidos no <%! declaração; [declaração;]+ ... %>
Declarações
script daquela página.
Contém uma expressão válida no script <%= expressão %>
Expressões
daquela página.
Contém um fragmento de código válido <% fragmento de um código com uma ou
Scriptlet
no script daquela página. mais linhas %>
Cria um comentário que é enviado para <!-- comentário [<%= expressão %>] -->
Comentário HTML
o cliente viabilizar no código da página.
É visto apenas no fonte do JSP mas não <%-- comentário --%> ou
Comentário JSP
é enviado para o cliente. <% /* comentário */ %>
Inclue um arquivo estático, analisando <%@ include file="URL relativa" %>
Diretiva "Include"
os elementos JSP daquela página.
<%@ page [ atributo = valor(es) ] %>
atributos e valores:
- language="java"
- extends = "package.class"
- import = "{package.class" | package.* },
..." ]
- session = "true | false"
- buffer = "none | 8kb | sizekb"
Define atributos que serão aplicados a
Diretiva "Page" - autoFlush = "true | false"
uma página JSP.
- isThreadSafe = "true | false"
- info = "text"
- errorPage"relativeURL"
- contentType = "{mimeType [; charset =
characterSet ] text/html; charset = isso-
8859-1}"
- isErrorPage = "true | false"

Define uma biblioteca tag e um prefixo <%@ taglib uri="URIToTagLibrary"


Diretiva Taglib para uma tag padrão usada na página prefix="tagPrefix" %>
JSP.
<tagPrefix:name attribute="value" + ... >
Acessa um padrão de funcionalidade de other tags and data
<tagPrefix:name>
uma tag. </tagPrefix:name>

Redireciona uma requisição para um <jsp:forward page="{relativeURL | <%=


<jsp:foward> arquivo HTML, JSP ou servlet para expressão %>}"
processar.

5. Comandos Loops

Essa lição trata as rotinas loop do Java que poderão ser usadas em páginas JSP.
Três comandos serão tratados a seguir:

• for;
• while;
• do .. while;

• Loop For

O loop for, repete uma instrução ou um bloco de instruções algum número de


vezes até que a condição seja satisfeita. Loops for são freqüentemente usados
para simples iterações na qual você repete um bloco de instruções um certo
número de vezes e então pára; mas você pode usar loops for para qualquer
espécie de loop. O código abaixo mostra um simples exemplo da utilização do
laço foor:

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 10


webmaster@dbsystems.com.br
Exemplo 01:

<html>
<body>

<% for (int i = 2; i < 8 ; i++) { %>


<font size=<%= i %>>Bom Dia!!! - Fonte: <%= i %></font>
<% } %>

</body>
</html>

• Loop While

O loop while é usado para repetir uma instrução ou bloco de instruções até que
uma condição particular seja verdadeira.
Veja o código abaixo:

Exemplo 2:

<html>
<body>

<%
int i = 0;
while (i < 8) { %>
<font size=<%= i %>>Bom Dia!!! - Fonte: <%= i %></font><br>
<%
i++;
} %>

</body>
</html>

Observe que se a condição é inicialmente falsa na primeira vez que é testada o


corpo do loop while nunca será executado. Se você precisa executar o corpo,
pelo menos uma vez, você pode usar o código do..while que será visto a seguir.

• Loop Do...While

O loop é exatamente como o loop while, exceto pelo fato de o loop do executar
uma dada instrução ou bloco até que uma condição seja falsa. A diferença
principal entre os dois é que os loops while testam a condição antes de iniciar o
loop, tornando possível que o corpo do loop nunca seja executado caso a
Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 11
webmaster@dbsystems.com.br
condição seja inicialmente falsa. Os loops do...while executam pelo menos uma
vez antes de testar a condição.
Veja o exemplo abaixo:

Exemplo 3:

<html>
<body>

<%
int i = 0;
do { %>
<font size=<%= i %>>Bom Dia!!! - Fonte: <%= i %></font><br>
<%
i++;
}
while (i < 8); %>

</body>
</html>

• Interrupção de Loops

Em todos os loops (for, while e do), o loop termina quando a condição que você
está testando é atingida. Porém, em alguma situação, você desejará sair do
loop antes do seu término normal. Para isso, você pode usar as palavras chaves
break e continue. A palavra chave break pára imediatamente a execução do
loop corrente. Se você tiver loops aninhados dentro de loop mais externo; caso
contrário, o programa simplesmente continua a execução da próxima instrução
após o loop.

<html>
<body>

<% int j;
for (int i = 1; i < 8 ; i++) {
j = i%5;
if (j == 0){ break; }
%>
<font size=<%= i %>>Bom Dia!!! - Fonte: <%= i %></font><br>
<% } %>

</body>
</html>

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 12


webmaster@dbsystems.com.br
No exemplo acima, o código dentro do loop é executado até que a variável i
assuma um valor que seja divisível por 5. Quando isso ocorre, o loop é
finalizado e o programa continua a ser executado após o final do código do loop.
Nesse caso o resultado obtido foi uma a geração de quatro linhas de código
html (ao invés de 7). Após gerar a página, o servidor JSP enviará para o
navegador o seguinte código:

<html>
<body>

<font size=1>Bom Dia!!! - Fonte: 1</font><br>

<font size=2>Bom Dia!!! - Fonte: 2</font><br>

<font size=3>Bom Dia!!! - Fonte: 3</font><br>

<font size=4>Bom Dia!!! - Fonte: 4</font><br>

</body>
</html>

6. Comandos Condicionais

Embora já possamos escrever algumas aplicações em JSP com o que já


aprendemos até agora, elas serão ainda fracas. Um dos grandes potenciais de
qualquer linguagem de programação, é a utilização de controles de fluxo
(condicionais e loops) para executar diferentes partes de um programa baseado
em testes. Nas próximas duas seções, aprenderemos os seguintes tópicos:

• comandos condicionais;
• comandos de loops.

Como foi dito em lições anteriores, o JSP nos permite construir páginas unindo
HTML e comandos Java. Mostraremos nessa lição como utilizar as conhecidas
rotinas condicionais do Java em páginas JSP. Três comandos serão tratadas a
seguir: if.. else, operador condicional, switch.

• Comando IF
Condicionais if contém a palavra-chave if, seguida de um teste booleano, e de
uma instrução (na maioria das vezes um bloco de instruções) para ser
executada se o teste for verdadeiro.

Exemplo 01:

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 13


webmaster@dbsystems.com.br
<html>
<body>

<%-- AS DUAS PROXIMAS LINHAS CRIA UMA VARIÁVEL


QUE RECEBE O VALOR DA DATA ATUAL DO SERVIDOR --%>

<%
java.util.Date dateNow = new java.util.Date();
int hourNow = dateNow.getHours();
%>

<%-- AS PROXIMAS LINHAS MISTURA HTML E JAVA


E PRODUZ COMO RESULTADO UMA SAUDAÇÃO QUE DEPENDE DA HORA --%>

<% if ((hourNow >= 5) && (hourNow < 13)) { %>


<font face="verdana">Bom Dia!!!</font>

<% } else if ((hourNow >= 13) && (hourNow < 19)) { %>
< font face="verdana">Bom Tarde!!!</font>

<% } else if ((hourNow >= 19) && (hourNow < 24)) { %>
<font face="verdana">Bom Noite!!!</font>

<% } else { %>


<font face="verdana">Boa Madrugada!!!</font>
<% } %>

</body>
</html>

• Operador Condicional

Uma alternativa para o uso das palavras-chaves if e else em uma instrução


condicional é usar o operador condicional, algumas chamado de operador
ternário.
O operador ternário é uma expressão, significando que ele devolve um valor
(diferentemente do if mais geral, o qual pode resultar em qualquer instrução ou
bloco sendo executado). O operador ternário é muito útil para condicionais
muito curtos ou simples, e tem a seguinte formato:
test ? trueResult : falseResul

O teste é uma expressão que devolve true e false (semelhante ao teste da


instrução if). Se o teste for verdadeiro retorna o valor de trueResult, caso
contrário, devolve o valor de falseResult.
Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 14
webmaster@dbsystems.com.br
Vamos como podemos usar o operador condicional para obter o mesmo efeito
do código anterior:

Exemplo 2:

<html>
<body>

<%-- AS DUAS PROXIMAS LINHAS CRIA UMA VARIÁVEL


QUE RECEBE O VALOR DA DATA ATUAL DO SERVIDOR --%>

<%
java.util.Date dateNow = new java.util.Date();
int hourNow = dateNow.getHours();
%>

<%
String mensagem;
mensagem = ((hourNow < 12)? "Onde você vai almoçar hoje?" : "Onde você
almoçou hoje?");
%>
<font face="verdana">Olá, Tudo bem? <%= mensagem %></font>

</body>
</html>

Apesar deste código parecer, a uma primeira vista, um pouco menos fácil de
entender que o anterior, ele é menor e portanto mais prático.

• Condicionais Switch

Na instrução switch, o teste (um tipo primitivo de byte, char, short ou int) é
comparado com cada valor em questão. Se um valor coincidente é achado, a
instrução (ou instruções) depois do teste é executada. Se nenhum valor for
encontrado, a instrução default é executada. Vamos analisar o exemplo abaixo:

Exemplo 3:

<html>
<body>

<%-- AS DUAS PROXIMAS LINHAS CRIA UMA VARIÁVEL


QUE RECEBE O VALOR DA DATA ATUAL DO SERVIDOR --%>
Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 15
webmaster@dbsystems.com.br
<%
java.util.Date dateNow = new java.util.Date();
int monthNow = (dateNow.getMonth()+1);
%>

<%
String mes;

switch(monthNow){
case 1: mes="Janeiro"; break;
case 2: mes="Fevereiro"; break;
case 3: mes="Março"; break;
case 4: mes="Abril"; break;
case 5: mes="Maio"; break;
case 6: mes="Junho"; break;
case 7: mes="Julho"; break;
case 8: mes="Agosto"; break;
case 9: mes="Setembro"; break;
case 10: mes="Outubro"; break;
case 11: mes="Novembro"; break;
default: mes="Dezembro"; break;
}
%>

<font face="verdana"> Nós estamos em <%= mes %></font>

</body>
</html>

Esse código atribui a variável monthNow o valor do mês atual. Note que na
instrução nós incrementamos o mês em uma unidade porque o método
"getMonth()" retorna 0 para o mês de janeiro, 1 para fevereiro e assim por
diante.
Observe que a limitação significativa no Java é que os testes e valores podem
ser somente de tipos primitivos. Você não pode usar tipos primitivos maiores
(long, float) ou objetos dentro de um switch, nem pode testar para nenhuma
outra relação senão a igualdade. Isso limita a utilidade do switch para todos os
casos exceto os mais simples, if´s aninhados podem funcionar para qualquer
espécie de teste em qualquer tipo.

7. Tratando Formulários

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 16


webmaster@dbsystems.com.br
Os formulários são ferramentas úteis e muito usada em diversas aplicações:
cadastro registros em um banco de dados, validação de um login/senha, envio
de email, envio de dados de um pesquisa, etc. Hoje é difícil desenvolver uma
aplicação para Web que não exija o uso de formulários. Pois bem, na lição de
hoje vamos aprender manipular formulários em aplicações JSP.
Apresentamos abaixo um código para mostrar o formato de um formulário HTML
e de seus objetos.

<html>
<body>

<!-- cabeçalho do formulário -->


<form name="nomedoformulario" action="paginajsp.jsp" method="get">

<!-- caixa de texto -->


<input type="text" name="variavel1" size=40 maxlength=40>

<!-- caixa de texto para senha -->


<input type="password" name="variavel2" size=40 maxlength=40>

<!-objeto do tipo radio -->


<input type="radio" name="variavel2" value="valordavariavel">Texto da
Varivavel 2

<!-objeto do tipo checkbox -->


<input type="checkbox" name="variavel3" value="xxxxx"> Texto da Varivavel
3

<!-objeto do tipo select -->


<select name="variavel4">
<option value="valor1">Valor 1
<option value="valor2">Valor 2
<option value="valor3">Valor 3
</select>

<!- area de texto -->


<textarea name="variavel5" cols=40 rows=2>
Texto da Variavel 5
</textarea>

<!- objeto hidden, para enviar dados que o usuário não vê no formulário -->
<input type="hidden" name="asd" value="asd">

<!- botão -->


<input type="button" value="textodobotao">
Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 17
webmaster@dbsystems.com.br
<!- botao de limpar informações do formulário -->
<input type="submit" value="limpar">

<!- botao de enviar formulário -->


<input type="submit" value="ok">

<!- imagem colocada para funcionar com botao de envio de formulário -->
<input type="image" src="pathdaimage/image.gif">

<!- objeto para anexar arquivo -->

<input type="file" name="asdas" accept="asd">

</form>

</body>
</html>

É importante fazermos algumas observações a cerca do código acima:


- no cabeçalho do formulário, indicamos através de
action="pathdoarquivo/paginajsp.jsp" o arquivo JSP que receberá os seus
dados.
- cada objeto do formulário recebe um nome. Deve-se tomar bastante cuidado
ao nomear tais objetos, isto porque, como sabemos, as variáveis Java são
sensíveis maiúscula/minúscula. Portanto, os objetos:

<input name="variavel1" type="text" value="">


<input name="Variavel1" type="text" value="">

São objetos diferentes porque receberam nomes diferentes (variavel1 e


Variavel1).

Mostraremos mais um exemplo (bastante simples) de como enviar dados a


partir de um formulário a uma página JSP.

<%-- Arquivo teste.jsp --%>


<html>
<body>

<center><h1> <%= request.getParameter("teste") %> </h1></center>

<form action="teste.jsp" method=get>


<input type="text" name="teste" size=40 maxlength=40><br>
<input type="submit" value="enviar">
Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 18
webmaster@dbsystems.com.br
</form>

</body>
</html>

A página jsp acima, chamada "teste.jsp", contém um formulário que envia para
ela mesma. O valor digitado em uma caixa de texto será mostrado como título
da página. Observe como fizemos isso:
- a página para qual nós enviaremos os dados do formulário é designada no
cabeçalho do formulário:

<form action="teste.jsp" method=get>

- o nome do objeto caixa de texto caixa de texto ("teste") é usado na expressão


request.getParameter("teste"). Note que se usássemos
request.getParameter("Teste") (com T maiúsculo), a página não iria retornar o
valor digitado na caixa de texto.
O próximo exemplo é formado por dois arquivos. O primeiro pode contém
apenas códigos HTML e o segundo contém códigos HTML e JSP.
Arquivo "envia_mês.htm":

<html>
<body>

<h3>Qual o mês do seu aniversário?</h3>


<form action="recebe_mes.jsp" method=get>
<select name="mesNasceu">
<option value="1">Janeiro
<option value="2">Fevereiro
<option value="3">Março
<option value="4">Abril
<option value="5">Maio
<option value="6">Junho
<option value="7">Julho
<option value="8">Setembro
<option value="9">Agosto
<option value="10">Outubro
<option value="11">Novembro
<option value="12">Dezembro
</select>

<input type="submit" value="enviar">


</form>

</body>
Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 19
webmaster@dbsystems.com.br
</html>

Arquivo "recebe_mês.jsp":

<%@ page import=java.util.Date %>


<%@ page import=java.lang.String %>
<%
String msg = "";
String mesString = request.getParameter("mesNasceu");
int mes = Integer.parseInt(mesString);
Date dateNow = new Date();
int monthNow = dateNow.getMonth() + 1;

mes -= monthNow;

if (mes == 1)
msg = "Falta apenas "+ mes +" mês para o seu aniversário.";

if (mes == -1)
msg = "Seu aniversário foi no mês passado";

if (mes > 1)
msg = "Faltam "+ mes +" meses para o seu aniversário.";

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>
<center>
<h3><%= msg %></h3>
<br><br><br>
<a href="Javascript:history.back(-1)">voltar</a>
</center>

</body>
</html>
Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 20
webmaster@dbsystems.com.br
O exemplo acima é um pouco menos simples que o primeiro. O arquivo
"envia_mes-jsp" contém um formulário com um objeto select que envia o mês
que a pessoa nasceu. Após escolher o mês e clicar no botâo "ok", o formulário
chama a página "recebe_mês.jsp" e envia seus dados para ela. Esta segunda
página é um pouco menos simples que a primeira. Vamos analisar o que ela
faz:
- nas primeira linhas utilizamos as tags "page import" para indicar quais classes
iremos utilizar em nossa página:

<%@ page import=java.util.Date %>


<%@ page import=java.lang.String %>

- cinco objetos são criados e inicializados.


- Usamos o método "request.getParameter(´nomedoparametro´)" com a
finalidade de pegar o valor passado para a página através de algum formulário
ou passando diretamente em sua URL. O segundo objeto foi inicializado
utilizando esse método para pegar o valor passado pelo formulário:

String mesString = request.getParameter("mesNasceu");

- O valor passado através de um formulário ou através da URL da página é


sempre do tipo String. Ao inicilizarmos o terceiro objeto, o método
"Integer.parseInt(variavelString)" transformou o valor contido na variável
mesString em Inteiro.

int mes = Integer.parseInt(mesString);

- O penúltimo objeto criado é do tipo Date (daí a importância de termos


importado a classe java.util.Date na primeira linha de nossa página). Ele é
inicializado com a hora local do servidor.

Date dateNow = new Date();

- Na inicialização do último objeto utilizamos o método "dateNow.getMonth()"


que retorna um inteiro indicando o valor da variável. Somamos 1 ao valor
retornado a partir desse método porque ele retorna 0 para janeiro, 1 para
fevereiro e assim por diante.

int monthNow = dateNow.getMonth() + 1;

- Cinco teste 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,
decidiremos qual mensagem será exibida na tela.
- Após efetuar os testes, o texto HTML é inserido na página.
Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 21
webmaster@dbsystems.com.br
- Uma expressão (<%= %>) é usada para exibir o valor da variável "msg":

<%= msg %>

8. Objetos Implícitos - Introdução

Como já vimos anteriormente, podemos criar, dentro de scriptlets na página


JSP, instâncias de uma classe Java e manipulá-las a fim de produzir conteúdo
dinâmico. Por exemplo, podemos criar um objeto de uma classe que acessa
uma base de dados e então usar métodos desse objeto para exibir na página
uma consulta ou transação com a base de dados. Ou seja, através da
manipulação desse objeto, quer seja acessando seus métodos e suas variáveis,
podemos gerar conteúdo dinâmico para a página JSP.
Além de objetos como esses, que estão completamente sobre o controle do
programador, o container JSP se encarrega de instanciar automaticamente,
durante a execução de uma página JSP, alguns objetos. Tais objetos podem ser
usados dentro da página JSP e são conhecidos como "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.

Objetos implícitos de JSP e suas APIS para aplicações de HTTP.

Objeto Classe ou Interface Descrição


Page javax.servlet.jsp.HttpJspPage Instância de servlet da página
Config javax.servlet.ServletConfig Dados de configuração de servlet
Request javax.servlet.http.HttpServletRequest Dados de solicitação, incluindo parâmetros
Response javax.servlet.http.HttpServletResponse Dados de resposta
Out javax.servlet.jsp.JspWriter Fluxo de saída para conteúdo da página
Session javax.servlet.http.HttpSession Dados de sessão específicos de usuário
Application javax.servlet.ServletContext Dados compartilhados por todas as páginas de
aplicação
PageContext javax.servlet.jsp.PageContext Dados de contexto para execução da página
Exception javax.lang.Throwable Erros não capturados ou exceção

Os nove objetos implícitos fornecidos por JSP podem ser classificados da


seguinte forma:

• Objetos relacionados ao servlet da página (page, config):


Os dois objetos implícitos de JSP nesta categoria se baseiam na implementação
da página JSP como um servlet.

• Objetos relacionados ao output e input da página (request, response,


out):
Os objetos classificados nessa categoria se concentram na entrada e saída
(input/output) de uma página JSP.

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 22


webmaster@dbsystems.com.br
• Objetos contextuais (application, session, request, pageContext):
Os objetos implícitos dessa categoria fornece à página JSP acesso ao contexto
dentro do qual ela está respondendo.

• Objetos resultantes de erros (exception):


Esta última categoria dos objetos implícitos fornece apenas um objeto que é
usado no tratamento de erros dentro de uma página JSP.

Esse módulo do curso sobre Objetos Implícitos foi dividido em seis partes. Nas
quatro primeiras serão abordadas as categorias de objetos implícitos listadas
acima. As duas últimas trazem exemplos práticos do uso dos objetos implícitos:
Parte 1 - Objetos Relacionados a Servlets
Parte 2 - Objetos Relacionados a Input/Output da página
Parte 3 - Objetos Contextuais
Parte 4 - Objetos de Tratamento de Erro
Parte 5 - Criando funções que manipulam objetos implícitos
Parte 6 - Exemplos do uso de Objetos Implícitos

9. Objetos Relacionados ao Servlet

Os objetos implícitos nesta categoria se baseiam na implementação da página


JSP como um servlet. Os dois objetos classificados nessa categoria são:

page
config

• Objeto page

O objeto page representa a própria página JSP ou, mais especificamente, uma
instância da classe de servlet na qual a página foi traduzida. O objeto page
implementa as interfaces javax.servlet.jsp.HttpJspPage e
javax.servlet.jsp.JspPage. Abaixo estão os links para a API que define essas
interfaces:
HttpJspPage
JspPage

Exemplo utilizando o objeto implícito page:

<%@ page info="Página de Teste" %>


.....
<%= ((javax.servlet.jsp.HttpJspPage)page).getServletInfo() %>

• Objeto config

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 23


webmaster@dbsystems.com.br
O objeto config armazena dados de configuração de servlet - na forma de
parâmetros de inicialização - para o servlet na qual uma página JSP é
compilada. Pelo fato das páginas JSP raramente serem escritas para interagir
com parâmetros de inicialização, este objeto implícito raramente é usado na
prática. O objeto config é uma intância da interface javax.servlet.ServletConfig.
Os métodos fornecidos por esta interface para recuperar parâmetros de
inicialização de servlet estão listados abaixo:

Métodos Descrição
Recupera os nomes de todos os parâmetros de
Enumeration getInitParameterNames()
inicialização.
Recupera o valor do parâmetro de inicilização a partir
String getInitParameter(String name)
de um nome.

Abaixo estão os links para a API que define a interface


javax.servlet.ServletConfig:
ServletConfig

10. Objetos Relacionados a OutPut/InPut da página

Os objetos classificados nessa categoria se concentram no input (entrada de


dados) e output (saída de informação) de uma página JSP. Os três objetos
classificados nessa categoria são:

• request
• response
• out

• Objeto request
O objeto request representa a solicitação que requisitou a página. O objeto
request implementa a interface javax.servlet.http.HttpServletRequest
(subinterface de javax.servlet.ServletRequest). Esse objeto, que também é
classificado como um objeto contextual, é um dos mais complexos e mais
utilizados na construção de páginas JSP. Podemos dividir os métodos desse
objeto em quatro funcionalidades:

Armazenar e Recuperar valores de atributos:


Método Descrição
Void setAttribute(String key, Object value) Associa um valor de atributo com um nome.
Recupera os nomes de todos os atributos associados com o
Enumeration getAttributeNames()
objeto.
Object getAttribute(String key) Recupera o valor de atributo associado com a chave.
Remove o valor de atributo associado com a chave.
void removeAttribute(String key)

Recuperar parâmetros de solicitação e cabeçalho de HTTP:

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 24


webmaster@dbsystems.com.br
Métodos Descrição
Retorna os nomes de todos os parâmetros de
Enumeration getParameterNames()
solicitação.
Retorna os primeiro valor (principal) de um único
String getParameter(String name)
parâmetro de solicitação.
Recupera todos os valores para um único parâmetro
String[] getParameterValues(String name)
de solictação.

Recuperar cabeçalhos de solicitação e cabeçalhos de HTTP:


Métodos Descrição
Recupera os nomes de todos os cabeçalhos
Enumeration getHeaderNames()
associados com a solicitação.
Retorna o valor de um único cabeçalho de solicitação,
String getHeader(String name)
como uma cadeia.
Retorna todos os valores para um único cabeçalho de
Enumeration getHeaders(String name)
solicitação.
Retorna o valor de um único cabeçalho de solicitação,
Int getIntHeader(String name)
com um número inteiro.
Retorna o valor de um único cabeçalho de solicitação,
Long getDateHeader(String name)
como uma data.
Recupera todos os cookies associados com a
Cookies[] getCookies()
solicitação.

Diversos métodos da interface que javax.servlet.hhtp.HttpServletRequest:


Métodos Descrição
String getMethod() Retorna o método de HTTP (e.g, POST, GET, etc) para a solicitação.
String getRequestURI() Retorna o URL de solicitação (não inclui a cadeia de consulta).
Retorna a cadeia de consulta que segue o URL de solicitação, se
String getQueryString()
houver algum.
Recupera os dados da sessão para a solicitação (i.e, o objeto
HttpSession getSession()
implícito session).
Recupera os dados da sessão para a solicitação (i.e, o objeto
HttpSession getSession(boolean flag)
implícito session), opcionalmente criando-o se ele ainda não existir.
RequestDispatcher Cria um dispatcher de solicitação para o URL local indicado.
getRequestDispatcher(String path)
Retorna o nome totalmente qualificado do host que enviu a
String getRemoteHost()
solicitação.
String getRemoteAddr() Retorna o endereço de rede (IP) do host que enviou a solicitação.
String getRemoteUser() Retorna o nome do usuário que enviou a solicitação, se conhecido.

Abaixo estão os links para a API que define essas interfaces:


ServletRequest
HttpServletRequest

Exemplo utilizando o objeto implícito request:


.....
Seu IP é :<%= request.getRemoteAddr() %><br>
Seu Host é :<%= request.getRemoteHost() %><br>
.....

• Objeto response
O objeto response representa a resposta que será enviada de volta para o
usuário como resultado do processamento da página JSP. Este objeto

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 25


webmaster@dbsystems.com.br
implementa a interface javax.servlet.http.HttpServletResponse que é uma
subinterface de javax.servlet.ServletResponse.

Podemos dividir os métodos desse objeto em quatro funcionalidades:

Especificar o tipo de conteúdo e codificação da resposta:


Métodos Descrição
Define o tipo MIME e, opcionalmente, a codificação de caracteres do
Void setContentType(String type)
conteúdo da resposta.
Retorna o conjunto de estilos de codificação de caracteres para o
String getCharacterEncoding()
conteúdo da resposta.

Definir cabeçalhos da resposta:


Métodos Descrição
Void addCookies(Cookie cookie) Adiciona o cookie especificado.
Boolean containsHeader(String name) Verifica se a resposta inclui o cabeçalho.
Atribui o valor definido pela variável "value" ao cabeçalho
Void setHeader(String name, String value)
especificado por "name"
Atribui o valor de número inteiro especificado por "value" ao
Void setIntHeader(String name, int value)
cabeçalho especificado por "name"
Atribui o valor de data especificado por "value" ao cabeçalho
Void setDateHeader(String name, long date)
especificado por "name"
Adiciona o valor definido por "value" ao cabeçalho especificado
Void addHeader(String name, String value)
por "name"
Adiociona o valor de número inteiro especificado por "value"
Void addIntHeader(String name, int value)
ao cabeçalho especificado por "name"
Void addDateHeader(String name, long Adiciona o valor de data especificado por "value" ao cabeçalho
date) especificado por "name"

Definir códigos de resposta:


Métodos Descrição
Define o código de status para a resposta (para cisrcuntâncias sem
Void setStatus(int code)
erro)
Void sendError(int status, String Define o código de status e mensagem de erro para a resposta.
msg)
Envia uma resposta para o navegador indicando que ele deveria
Void sendRedirect(String url)
solicitar um URL alternativo (absoluto)

Reescrita da URL:
Métodos Descrição
Codifica um URL para uso com o método
String encodeRedirectURL(String url)
sendRedirect() para incluir informações de sessão.
Codifica um URL usado em um link para incluir
String encodeURL(String url)
informações de sessão.

Abaixo estão os links para a API que define essas interfaces:


ServletResponse
HttpServletResponse

O exemplo abaixo 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.

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 26


webmaster@dbsystems.com.br
<%
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.

• Objeto out
Este objeto implícito representa o fluxo de saída para a página, cujo conteúdo
será enviado para o navegador com o corpo de sua resposta. O objeto out é
uma intância da classe javax.servlet.jsp.JspWriter.
Esse objeto implementa todos os métodos print() e println() definidos por
java.io.Writer.
Por exemplo, o objeto out pode ser usado dentro de um script para adicionar
conteúdo à página gerada. Veja o exemplo 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!");
}
%>

Esse objeto é muito utilizado para para gerar conteúdo dentro do corpo de um
script, sem ter que fechá-lo temporariamente para inserir conteúdo de página
estático. Contudo, deve-se evitar usar os métodos print() ou println() para
inserir cadeias de caracteres muito grandes. No próximo caso, é mais
aconselhável fechar o script e inserir o conteúdo estático. Veja o exemplo
abaixo:
Não Aconselhável:
<%
if(i == 1){
out.print("<h6>"+
"<font face='verdana'>"+
"Guga viaja nesta sexta"+
Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 27
webmaster@dbsystems.com.br
"para a Suíça para"+
"jogar"+
"</font>"+
"</h6>");
}
%>

Aconselhável:
<% if(i == 1) {%>
<h6>
<font face='verdana'>
Guga viaja nesta sexta
para a Suíça para
jogar
</font>
</h6>
<% } %>

O links abaixo refere-se a API que define a interfaces que o objeto out
implementa:
JspWriter

11. Objetos Contextuais

Os objetos implícitos dessa categoria fornece à página JSP acesso ao contexto


dentro do qual ela está respondendo. Os quatro objetos implícitos contextuais
são:

• request;
• session;
• application;
• pageContext.

Todos eles têm a capacidade de armazenar e recuperar valores de atributos


arbitrários. Os atributos de página, armazenados no objeto pageContext,
duram apenas enquanto o processamento de uma única página ocorre. Os
atributos de solicitação, armazenados no objeto request, também tem pouca
duração, mas podem ser transferidos entre páginas quando for transferido o
controle. Os atributos de sessão, armazenados no objeto session, duram
enquanto o usuário continuar a interagir com o servidor da web. Os atributos de
aplicação, armazenados no objeto application, são mantidos enquanto o
container JSP mantiver uma ou mais páginas de uma aplicação carregada na
memória - enquanto o container JSP estiver rodando. A tabela a seguir traz os

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 28


webmaster@dbsystems.com.br
métodos comuns aos quatro objetos e que são usados para armazenar e
recuperar valores de atributos:

Tabela 1: Os métodos comuns a esses quatro objetos e que são usados para
armazenar e recuperar valores de atributos:
Métodos Descrição
void setAttribute(String key, Object value) Associa um valor de atributo com um nome.
Recupera os nomes de todos os atributos associados com o
Enumeration getAttributeNames()
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.

• Objeto session
Este objeto representa a sessão atual de um usuário individual. Todas as
solicitações feitas por um usuário são consideradas parte de uma sessão. Desde
que novas solicitações por aqueles usuários continuem a ser recebidas pelo
servidor, a sessão persiste. Se, no entanto, um certo período de tempo passar
sem que qualquer nova solicitação do usuário seja recebida, a sessão expira.

O objeto session armazena informações a respeito da sessão. Um dos


principais usos para o objeto session é armazenar e recuperar valores de
atributos, a fim de transmitir as informações específicas de usuários entre as
páginas. Abaixo segue um exemplo que armazena dados na sessão, na forma
de um objeto que é instância de uma classe hipotética "Usuario":

<%
Usuario u = new Usuario(nome, senha);
session.setAttribute("usuario", u);
%>

Uma vez que um objeto tenha sido armazenado através do método


setAttibute(), ele pode ser recuperado - na mesma página ou em outra
acessada pelo usuário. O código abaixo ilustra a recuperação do objeto
armazenado no código anterior:

<%
Usuario u = (Usuario)session.getAttribute("usuario");
.....
%>

Perceba que o método getAttribute() retorna um objeto da classe Object,


portanto, é necessário fazermos um cast para converter o objeto retornado em
uma instância da classe desejada.

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 29


webmaster@dbsystems.com.br
O objeto session implementa a interface javax.servlet.http.HttpSession. A
tabela abaixo traz os principais métodos utilizados por esse objeto, além
daqueles descritos anteriormente na tabela 1:
Métodos 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.
Retorna a última vez que uma solicitação associada
long getLastAccessedTime()
com a sessão foi recebida.
Retorna o tempo máximo (em segundos) entre
int getMaxInactiveInterval()
solicitações pelo qual a sessão será mantida.
Define o tempo máximo (em segundos) entre
void setMaxInactiveInterval(int time)
solicitações pelo qual a sessão será mantida.
Retorna se o navegador do usuário ainda não tiver
boolean isNew()
confirmado o ID de sessão.
Descarta a sessão, liberando quaisquer objetos
boolean invalidate()
armazenados como atributos.

O link abaixo exibe a API completa da interface que implementa o objeto


session:
HttpSession

• Objeto application
Este objeto representa a aplicação à qual a página JSP pertence. Ele é uma
instância da interface javax.servlet.ServletContext. Os containers JSP
tipicamente tratam do primeiro nome de diretório em um URL como uma
aplicação. Exemplo:

• http://server/dbsystems/index.jsp
• http://server/dbsystems/principal.jsp
• http://server/dbsystems/forum/forum.jsp
• http://server/dbsystems/apostila/apostila.jsp

São todos considerados parte da mesma aplicação dbsystems.

Além dos métodos descritos na tabela 1, os métodos do objeto application


podem ser divididos em quatro funcionalidades:

Recuperar informações de versão do container servlet:


Método Descrição
String getServerInfo() Retorna o nome e versão do container servlet.
int getMajorVersion() Retorna a versão principal da API do servlet para o container servlet.
int getMinorVersion() Retorna a versão secundária da API do servlet para o container servlet.

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 30


webmaster@dbsystems.com.br
Interagir com arquivos e caminhos no servidor:
Método Descrição
Retorna o tipo MIME para o arquivo indicado, se conhecido
String getMimeType(String filename)
pelo servidor.
Traduz uma cadeia especificando um URL em um objeto
URL getResource(String path)
que acessa os conteúdos dos URLs, localmente ou na rede.
Traduz uma cadeia especificando um URL em um fluxo de
InputStream getResourceAsStream(String path)
entrada para ler seu conteúdo.
Traduz um URL local em um nome de caminho no sistema
String getRealPath(String path)
de arquivo local.
Retorna o contexto de aplicação para o URL local
ServletContext getContext(String path)
especificado.
RequestDispatcher getRequestDispatcher(String Cria um dispacher de solicitação para o URL local indicado.
path)

Suporte para log de mensagens:


Método Descrição
Void log(String message) Grava a mensagem o arquivo de log.
Grava a mensagem no aqrquivo de log, junto com a trilha de pilha
Void log(String message, Exception e)
para a exceção especificada.

Acessar parâmetros de inicialização:


Método Descrição
Recupera os nomes de todos os parâmetros de
Enumerations getInitParameterNames()
inicialização.
Recupera o valor do parâmetro de inicilização como o
String getInitParameter(String name)
nome dado.

O link abaixo exibe a API completa da interface que implementa o objeto


application: ServletContext

• Objeto pageContext
O objeto pageContext fornece várias facilidades como gerenciamento de
sessões, atributos, páginas de erro, inclusões e encaminhamento de requisições
de fluxo de resposta.
O objeto pageContext é uma instância da classe
javax.servlet.jsp.PageContext. Além dos métodos descritos na tabela 1, os
principais métodos desse objeto podem ser divididos em três categorias:

Acessar outros objetos implícitos de JSP:


Método Descrição
Retorna a instância de servlet para a página atual (objeto implícito
Object getPage()
page).
Retorna a solicitação que iniciou o processamento da página (objeto
ServletRequest getRequest()
implícito request).
ServletResponse Retorna a resposta para a página (objeto implícito response).
JspWriter getOut Retorna o fluxo de saída atual para a página (objeto implícito out).
Retorna a sessão associada com a solicitação da página atual, se
HttpSession getSession()
houver alguma (objeto implícito session).
ServletConfig getServletConfig() Retorna o objeto de configuração de servlet (objeto implícito config).
Retorna o contexto no qual o servlet da página roda (objeto implícito
ServletContext getServletContext()
application).
Para páginas de erro, retorna a exceção passada para a página
Exception getException()
(objeto implícito exception).

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 31


webmaster@dbsystems.com.br
Envio de solicitações de uma página JSP para outra:
Método Descrição
void forward(String path) Encaminha o processamento para um outro URL local dado pela String path.
void include(String path) Inclui o output do processamento de um outro URL local.

Acessar atributos através de múltiplos escopos:


Método Descrição
Associa o valor do atributo "obj" com a chave "key"
void setAttribute(String key, Object obj, int scope)
no escopo "scope".
Recupera os nomes de todos os atributos associado
Enumeration getAttributeNamesInScope(int scope)
com "key" no escopo "scope".
Recupera o valor de tributo associado com "name" no
Object getAttribute(String name, int scope)
escopo "scope"
Remove o valor de atributo associado com "name" no
removeAttribute(String name, int scope)
escope "scope"
Procura em todos os escopos pelo atributo associado
Object findAttribute(String name)
com "name".
Retorna o escopo no qual o atributo associado com
int getAttributesScope(String name)
"name" está armazenado.

Os últimos dois métodos listados na tabela anterior permitem a procura, através


de todos os escopos definidos, por um atributo associado com uma String
passada como parâmetro. Nos dois casos, o objeto pageContext irá realizar
uma busca através dos escopos na seguinte ordem: pageContext, request,
session e application.
A tabela anterior traz métodos que recebe parâmetros para especificar o
escopo. A classe javax.servlet.jsp.PageContext fornece variáveis estáticas para
representar estes quatro escopos diferentes. A tabela a seguir resume estas
variáveis:

Variável 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.
APPLICATION_SCOPE Escopo para atributos armazenados no objeto application.

O exemplo abaixo ilustra o uso do método "getAttribute" e das variáveis


estáticas descritas na tabela anterior:

<%
User uPag=(User)pageContext.getAttibute("user",pageContext.PAGE_SCOPE)
//Recupera o object "usuario" do escopo pageContext

User
uReq=(User)pageContext.getAttibute("user",pageContext.REQUEST_SCOPE)
//Recupera o object "usuario" do escopo request

User
uSes=(User)pageContext.getAttibute("user",pageContext.SESSION_SCOPE)

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 32


webmaster@dbsystems.com.br
//Recupera o object "usuario" do escopo session

User
uApp=(User)pageContext.getAttibute("user",pageContext.APPLICATION_SCOPE
)
//Recupera o object "usuario" do escopo application
%>

O link abaixo exibe a API completa da interface que implementa o objeto


pageContext:
PageContext

12. Tratamento de Erros

Esta última categoria dos objetos implícitos tem apenas um membro, o objeto
exception. Este objeto implícito é fornecido com o propósito de tratamento de
erros dentro de uma página JSP.

• Objeto Exception
O objeto exception não está automaticamente disponível em todas as páginas
JSP. Este objeto está disponível apenas nas páginas que tenham sido
designadas como páginas de erro, usando o atributo isErrorPage configurado
com true na diretiva page. O objeto exception é uma instância da classe
java.lang.Throwable correspondente ao erro não capturado que fez com que o
controle fosse transferido para a página de erro. Os principais métodos da
classe java.lang.Throwable que são utilizados dentro das páginas JSP são
listados na tabela abaixo:
Método Descrição
Retorna a mensagem de erro descritiva associada
String getMessage()
com a exceção quando ela foi lançada.
Imprime a pilha de execução em funcionamento
void printStackTrace(PrintWriter out) quando a exceção foi lançada para o fluxo de saída
especificado pelo parâmetro out.
Retorna uma cadeia combinando o nome da classe da
String toString() exceção com sua mensagem de erro, se houver
alguma.

O trecho abaixo ilustra o uso do objeto exception em uma página de erro JSP:

<@ page isErrorPage=true %>


<h1>Erro Encontrado</h1>
O seguinte erro foi eoncontrado:<br>
<b><%= exception %></b><br>
<% exception.printStackTrace(out); %>

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 33


webmaster@dbsystems.com.br
13. JavaBeans

JavaBeans são componentes de software que são projetados para serem


unidades reutilizáveis, que uma vez criados podem ser reusados sem
modificação de código, e em qualquer propósito de aplicação, seja um applet,
um servlet ou qualquer outra.

Um modelo de componente é definido como um conjunto de classes e interfaces


na forma de pacotes Java que deve ser usado em uma forma particular para
isolar e encapsular um conjunto de funcionalidades.

Os componentes JavaBeans são também conhecidos como Beans. Passaremos a


usar esta nomenclatura no restante deste curso.

Neste curso não falaremos sobre todos os conceitos de JavaBeans, daremos


atenção àqueles conceitos que mais são utilizados nas páginas JSP.

Regras para Escrever Beans

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

import java.io.Serializable;

01 public class MyBean implements Serializable {


02
03 private int property1;
04 private boolean property2;
05
06 public MyBean() {
07
08 }
09
10 public void setProperty1(int property1) {
11 this.property1 = property1;
12 }
13
14 public void setProperty2(boolean property2) {
15 this.property2 = property2;
16 }

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 34


webmaster@dbsystems.com.br
17
18 public int getProperty1() {
19 return property1;
20 }
21
22 public boolean isProperty2() {
23 return property2;
24 }
25 }

Esta classe é um exemplo do que devemos seguir para tornar uma classe um
bean, ou seja, o conjunto de regras que devemos obdecer para tornar o
compoenente reconhecível por ferramentas e usável.

Um bean, como modelo de componente, usa a idéia de encapsulamento.


Portanto, as suas variáveis devem ser acessadas somente através de métodos.
As variáveis de um Bean são suas propriedades.

A primeira regra que devemos respeitar é o construtor. O construtor de um


bean deve ser sem parametros.

Outra regra que devemos seguir diz respeito ao nome dos métodos que darão
acesso as propriedades do bean. Os métodos podem ser divididos em duas
categorias:

• Métodos de Leitura:
Os métodos de leitura de propriedades devem seguir a seguinte convenção:

public TipoDaPropriedade getNomeDaPropriedade()

Como mostrado no código acima a propriedade chamada property1 tem o


método de acesso getProperty1 . Note que a primeira letra da propriedade deve
ser minuscula enquanto a primeira letra depois do get deve ser em maiscula. A
palavra TipoDaPropriedade deve ser substituida por o tipo da propriedade. Para
variáveis booleanas vale o mesmo conceito, mas, ao invés do get usamos a
palavra is. No exemplo temos o acesso a propriedade property2 que é booleana
como:
public boolean isProperty2()

Observação: Você pode não definir um método de leitura para a variável. Se


isto for feito você não permitirá o acesso a ela.

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 35


webmaster@dbsystems.com.br
• Métodos de escrita:
Os métodos de escrita permitem ao usuário do componente modificar o
conteúdo da propriedade. Ele segue a seguinte terminologia:
public void setNomeDaPropriedade(TipoDaPropriedade varName)

Nos métodos de escrita não há caso especial para variáveis booleanas que
também podem ser modificadas através de métodos set.

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.

A tecnologia de serialização de objetos é muito importante em Java pois permite


a linguagem atividades complexas como computação distribuída e além de
muitas outras funcionalidades interessantes.

Para sermos capazes de serializar objetos basta fazer a classe implementar a


interface Serializable e nada mais.

• Propriedades de um Bean

Os beans possuem diversos tipos de propriedades, que são:


• Simples: Propriedades simples alteram a aparência ou comportamento do
bean e são acessadas através dos métodos de escrita e leitura mostrados.
• Ligadas: As propriedades deste tipo quando alteradas provocam uma
notificação para algum evento.
• Reprimidas: As propriedades podem ter sua mudança vetada pelo próprio
bean ou por objetos externos.
• Indexadas: Propriedades indexadas representam coleções de valores
acessados por indices, como arrays. A seguinte regra deve ser seguida por
propriedades indexadas.

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 36


webmaster@dbsystems.com.br
Para as propriedades indexadas temos:

• Métodos de leitura do array inteiro:

public TipoDaPropriedade[] getNomeDaPropriedade();


public void setNomeDaPropriedade(TipoDaPropriedade[] value);

• Métodos de leitura de elementos individuais:

public TipoDaPropriedade getNomeDaPropriedade(int index);


public void setNomeDaPropriedade(int index, TipoDaPropriedade value);

• Como as ferramentas lêem os Beans ?

JavaBeans são desenvolvidos param serem usados por terceiros (ou não). As
ferramentas de desenvolvimento em Java são capazes de ler beans e prover a
funcionalidade do componente para o usuário. Mas como as ferramentas são
capazes de descobrir a funcionalidade de um Bean já que ele não é uma classe
conhecida, ou seja, pode ser qualquer componente?

Para a realização desta tarefa, que chamamos introspecção, é usada uma API
disponível no Ambiente Runtime da plataforma Java, a Java Reflection API .
Usando a funcionalidade desta API a ferramenta procura os métodos públicos do
bean e faz a ligação dos métodos com as propriedades. Após a ferramenta ter
obtido todas as informações que ela necessita sobre a classe então as
propriedades e os métodos são disponibilizados para uso.

A introspecção é realizada pela classe java.beans.Introspector que usa a


Reflection API para descobrir as funcionalidades do bean por casamento de
padrão. No entanto, alternativamente você pode definir as informações sobre o
Bean em separado, em uma classe que implementa a interface BeanInfo,
porém não entraremos em detalhes sobre isso.

É importante saber que um bean também pode implementar outros métodos


que não aqueles que lêem ou gravam as propriedades. Esses métodos não
diferem em nada de outros métodos de qualquer outra classe em Java.

• JavaBeans x Enterprise JavaBeans

Já conhecemos o que é um JavaBean, então agora podemos compará-los com o


Enterprise JavaBeans (EJB). Quais as diferenças?

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 37


webmaster@dbsystems.com.br
Os JavaBeans assim como o EJB são modelos de componente, porém apesar
dos dois compartilharem o termo JavaBeans os modelos não são relacionados.
Uma parte da literatura tem referenciado EJB como uma extensão dos
JavaBeans, mas isto é uma interpretação errada. As duas APIs servem para
propósitos bem diferentes.

O JavaBean tem a intenção de ser usado em propósitos do mesmo processo


(intraprocesso) enquanto EJB é projetado para ser usado como componentes
interprocessos. Em outras palavras, os JavaBeans não têm a intenção de ser
usado como componente distribuído assim como o EJB.

O EJB é uma tecnologia que está em grande ascenção e será abordado em


futuros materias da DBSystems.

14. Ação jsp:useBean

Ações possibilitam a realização de tarefas complexas como instanciação de


objetos, comunicação com recursos do lado do servidor como páginas JSP e
servlets sem a necessidade de código Java. Embora o mesmo possa ser feito
com o uso de código Java dentro de scriptlets, o uso das tags de ações
promovem reusabilidade de seus componentes e aumenta a capacidade de
manutenção da página.

• Usando componentes JavaBeans

A tecnologia de componentes para JSP é baseada em componentes JavaBeans.


Antes de acessar um bean dentro de uma página JSP, é necessário identificar o
bean e obter uma referência dele. A tag jsp:useBean tenta obter uma referência
de um bean que já esteja criado, dependendo do escopo em que ele foi
definido. Caso não haja o componente definido haverá a criação de um novo
objeto.

Por exemplo a tag:

<jsp:useBean id="contador" class="dbsystems.Contador" scope="session"/>

Neste exemplo, a tag useBean instanciará um objeto que será identificado por
contador, a partir da classe dbsystems.Contador. A definição do escopo depende
muito do projeto em questão. No exemplo acima, este objeto criado será
compartilhado por toda sessão que será mantida com o usuário. Caso encontre-
se uma nova tag de criação de um objeto da classe dbsystems.Contador, o
objeto já instanciado será usado não havendo a necessidade de criação de
outro.

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 38


webmaster@dbsystems.com.br
Passos para criação do objeto:

Tentativa de localizar o objeto baseado nas informações (id, scope). Esta


inspeção é feita sincronizada apropriadamente por escopo para evitar
comportamentos não-determinísticos.

Definir a variável de script identificado por id.

Se o objeto for encontrado, a variável é inicializada com a referência localizada


e então é realizado um casting para o tipo específico. Se o cast falhar então
uma exceção do tipo java.lang.ClassCastException irá ocorrer e o
processamento da tag acaba.

Se o objeto não for encontrado no escopo e a classe não poder ser localizada
então uma exceção do tipo java.lang.InstantiationException ocorrerá e o
processamento da tag acabará.

Se o objeto não foi encontrado no escopo dado e a classe for encontrada com
um construtor padrão (sem argumentos) o objeto é instanciado e relacionado
com a variável de scriplet identificada por id.
Se um contrutor sem argumentos não for encontrado então uma exceção do
tipo java.lang.InstantiationException ocorrerá e o processamento da tag
acabará.

O processamento do corpo da tag é então executado. Um corpo de uma tag


<jsp:useBean> é executado para realizar algumas inicializações desejadas,
como no exemplo abaixo:

<jsp:useBean id="clientes" class="Clientes" scope="page">


<jsp:setProperty name="clientes" property="nome" value="Rafael dos Santos">
<jsp:setProperty name="clientes" property="telefone" value="648-2343"/>
</jsp:useBean>

O exemplo acima inicializa o objeto instanciado clientes com as propriedades


nome e telefone.

Entendendo os Escopos:

Os escopos definem o ciclo de vida de um objeto, eles podem ser definidos


como:

• page: Objetos definidos com o escopo page são vistos apenas pela página
onde ele foi criado. As referências para objetos no contexto page são
armazenados no objeto pageContext.

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 39


webmaster@dbsystems.com.br
• request: Objetos definidos no escopo request são vistos nas páginas usadas
para responder a requisição do usuário. Se uma página é redirecionada para
outra, os objetos de escopo request são preservados uma vez que fazem
parte da mesma requisição. As referências a objetos do contexto request são
armazenados no objeto implícito request.

• session: Objetos definidos no escopo sessão são acessíveis por páginas que
fazem parte da mesma sessão. As referências as esses objetos são
armazenadas no objeto session.
• application: Objetos definidos no escopo application são acessíveis por toda
aplicação JSP em questão e são armazenadas no objeto implícito application.

A tag <jsp:useBean> tem a seguinte sintáxe básica:

<jsp:useBean id="nome" scope="page|request|session|application"


class="nome_completo_da_classe"/>

15. Exemplo – Mini Aplicação usando JavaBeans

• Listagem - LoginBean.java

package curso;

import java.sql.*;
import java.io.Serializable;

public class LoginBean implements Serializable{

private ResultSet rs;


private String senha;
private String usuario;

/**
* Definição dos Metodos Get e Set da senha
*/
public String getSenha() {
return senha;
}

public void setSenha(String senha) {


this.senha = senha;
}

/**
* Definição dos Metodos Get e Set do Usuário
*/
public String getUsuario() {
return usuario;
}

public void setUsuario(String usuario) {


this.usuario = usuario;
}

/**

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 40


webmaster@dbsystems.com.br
* Verifica o Usuario e senha
*/
public boolean selectUsuario(String usuario, String senha){
String strSql ="select * from usuarios where usuario = '" + usuario +
"' and senha = '" + senha + "'";
try {
Connection con = getConnect();
PreparedStatement pstmt = con.prepareStatement(strSql);
rs = pstmt.executeQuery();
while(rs.next()){
return true;
}
} catch(SQLException sqlex){

System.err.println("Sem conexão...");
sqlex.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}
return false;
}

/**
* Obtem uma Conexão com o Banco de Dados
*/
private Connection getConnect() {
Connection conectar = null;
String driver = "org.gjt.mm.mysql.Driver";
String url = "jdbc:mysql://53.248.185.200:3306/curso";
String user = "root";
String password = "";
try {
Class.forName(driver);
conectar = DriverManager.getConnection(url,user,password);
} catch(ClassNotFoundException cnfex){
System.err.println("Erro ao conectar na base...");
cnfex.printStackTrace();
System.exit(1);
} catch(Exception ex){
ex.printStackTrace();
} finally {
return conectar;
}
}

• Listagem – login.jsp

<jsp:useBean id="log" class="curso.LoginBean" scope="request"/>


<jsp:setProperty name="log" property="*" />

<%!
private boolean blnUsuario = false;
%>

<%
if(request.getParameter("acao") != null ) {
if(request.getParameter("acao").equals("login")){
blnUsuario = log.selectUsuario(
(String)request.getParameter("usuario"),
(String)request.getParameter("senha")
);
if(blnUsuario){

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 41


webmaster@dbsystems.com.br
session.setAttribute("nomeUsuario",request.getParameter("
usuario"));
%>
<jsp:forward page="aplicacao.jsp" />
<%
} else {
%>
<jsp:forward page="error.jsp" />
<%
}
}
}
%>

<HTML>
<HEAD>
<TITLE>login.jsp</TITLE>
</HEAD>
<BODY>
<FORM METHOD="POST" ACTION="/" NAME="LOGIN">
<CENTER>
<TABLE>
<TBODY>
<TR>
<TD colspan="2" align="center">
<FONT color="#000099" size="5" face="Verdana">
Acesso a Aplicação
</FONT>
</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
</TR>
<TR>
<TD align="right">Usuário:</TD>
<TD><INPUT size="20" type="text" maxlength="20" name= "usuario"></TD>
</TR>
<TR>
<TD align="right">Senha:</TD>
<TD><INPUT size="20" type="password" maxlength="8" name="senha"></TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
</TR>
<TR>
<TD colspan="2" align="center">
<INPUT type="submit" name="login" value="Login"
onClick="LOGIN.action='login.jsp?acao=login';LOGIN.submit()";>
<INPUT type="reset" name="limpar" value="Limpar">
</TD>
</TR>
</TBODY>
</TABLE>
</CENTER>
</FORM>
</BODY>
</HTML>

• Listagem – aplicacao.jsp

<%!

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 42


webmaster@dbsystems.com.br
private String strUsuario = "";
%>

<%
if(session.getAttribute("nomeUsuario") == null){
%>
<jsp:forward page="login.jsp" />
<%
} else {
strUsuario = session.getAttribute("nomeUsuario").toString();
}
%>

<HTML>
<HEAD>
<TITLE>aplicacao.jsp</TITLE>
</HEAD>
<BODY>
<FORM METHOD="POST" ACTION="/" NAME="LOGIN">
<CENTER>
<TABLE>
<TBODY>
<TR>
<TD align="center">
<FONT color="#000099" size="5" face="Verdana">
Acesso a aplicação liberado para o usuário:
</FONT>
</TD>
</TR>
<TR>
<TD></TD>
</TR>
<TR>
<TD align="center">
<FONT color="#ff8000" size="5" face="Verdana">
<I><%= strUsuario %></I>
</FONT>
</TD>
</TR>
<TR>
<TD></TD>
</TR>
<TR>
<TD align="center">
<INPUT type="submit" name="voltar" value="Voltar"
onClick="LOGIN.action='login.jsp';LOGIN.submit()";>
</TD>
</TR>
</TBODY>
</TABLE>
</CENTER>
</FORM>
</BODY>
</HTML>

• Listagem – error.jsp

<%@page isErrorPage="true"%>

<html>
<head>
<title>Error Page</title>
</head>
<body>

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 43


webmaster@dbsystems.com.br
<font face="Comic Sans MS" size=4>
<blockquote>
<center>
<h1><font color=red>404 Error Page</font></h1>
</center>
<p>Favor verificar, os dados não confere!
</blockquote>
</font>
</body>
</html>

Rua Valorbe, 123 – Lauzane Paulista – Cep 02442-140 – São Paulo – SP 44


webmaster@dbsystems.com.br