Servlet JSP PDF

Java Web - Servlet e JSP
Online
Java Web - Servlet e JSP - On-Line
Todos os direitos reservados para Alfamdia Prow
AVISO DE RESPONSABILIDADE
As informaes contidas neste material de treinamento so distribudas NO ESTADO

EM QUE SE ENCONTRAM, sem qualquer garantia, expressa ou implcita. Embora
todas as precaues tenham sido tomadas na preparao deste material, a Alfamdia
Prow no tem qualquer responsabilidade sobre qualquer pessoa ou entidade com
respeito responsabilidade, perda ou danos causados, ou alegadamente causados, direta
ou indiretamente, pelas instrues contidas neste material ou pelo software de
computador e produtos de hardware aqui descritos.
02/2012 Verso 1.0.77
Alfamdia Prow
http://www.alfamidia.com.br
2
Sumrio
Captulo 1 Introduo ...................................................................................... 7
Captulo 2 HTTP ............................................................................................. 9
URI .......................................................................................................................................... 10
URI, URL e URN ................................................................................................................ 10
Sintaxe ................................................................................................................................. 11
Parmetros ........................................................................................................................... 11
URIs Absolutos ................................................................................................................... 11
URIs Relativos .................................................................................................................... 12
Request .................................................................................................................................... 12
Mtodos ............................................................................................................................... 12
Cabealhos .......................................................................................................................... 13
Response ................................................................................................................................. 16
Cdigo de Resposta ............................................................................................................. 16
Cabealhos .............................................................................................................................. 20
Captulo 3 Ambiente de Desenvolvimento ................................................... 24
JDK JRE ............................................................................................................................... 25
Ambiente Integrado de Desenvolvimento ............................................................................... 25
Servidor de Aplicao ............................................................................................................. 25
Web Container..................................................................................................................... 25
EJB Container ..................................................................................................................... 26
Captulo 4 Aplicaes Web ........................................................................... 27
A Web Esttica ........................................................................................................................ 27
A Web Dinmica ..................................................................................................................... 27
CGI .......................................................................................................................................... 28
A Resposta da Sun .................................................................................................................. 28
Servlets ................................................................................................................................ 29
JSPs ..................................................................................................................................... 29
Uma Aplicao Web em Java ................................................................................................. 29
Criando Uma Aplicao Java Web com o NetBeans .......................................................... 29
Captulo 5 Servlets ........................................................................................ 32
A API de Servlets .................................................................................................................... 32
A Interface Servlet .............................................................................................................. 32
A Classe GenericServlet...................................................................................................... 33
3
A Classe HttpServlet ........................................................................................................... 34

A Interface ServletConfig ................................................................................................... 34
A Interface ServletContext .................................................................................................. 35
A Classe HttpServletRequest .............................................................................................. 36
A Classe HttpServletResponse ............................................................................................ 37
Criando um Servlet com o NetBeans ...................................................................................... 38
O Deployment Descriptor ....................................................................................................... 41
Ecoando os Dados da Requisio............................................................................................ 42
Captulo 6 JSPs.............................................................................................. 45
A API de JSPs ......................................................................................................................... 45
Tags JSP .................................................................................................................................. 46
Diretivas .............................................................................................................................. 46
Declaraes ......................................................................................................................... 47
Expresses ........................................................................................................................... 48
Scriptlets .............................................................................................................................. 48
Comentrios ........................................................................................................................ 49
Objetos Implcitos ................................................................................................................... 49
Gerenciando Atributos ........................................................................................................ 50
O Objecto pageContext ....................................................................................................... 51
O Objeto request.................................................................................................................. 52
O Objeto session.................................................................................................................. 53
O Objeto application ........................................................................................................... 54
O Objeto exception.............................................................................................................. 55
Captulo 7 JSP Actions.................................................................................. 57
Aes Bsicas.......................................................................................................................... 57
A Tag <jsp:forward> ........................................................................................................... 57
A Tag <jsp:include> ............................................................................................................ 57
Componentes JavaBeans ......................................................................................................... 58
Diretrizes Bsicas ................................................................................................................ 59
A Tag <jsp:useBean> .......................................................................................................... 59
A Tag <jsp:getProperty> ..................................................................................................... 60
A Tag <jsp:setProperty> ..................................................................................................... 60
A Tag <jsp:setProperty> e a Requisio ............................................................................. 61
Captulo 8 Expression Language .................................................................. 62
O Operador . ........................................................................................................................ 63
4
O Operador [ ........................................................................................................................ 64
Usando Arrays ..................................................................................................................... 64
Usando Lists ........................................................................................................................ 65
Usando Maps e Beans ......................................................................................................... 65
Objetos Implcitos ................................................................................................................... 66
Lidando com os Parmetros da Requisio ............................................................................. 67
Operadores .............................................................................................................................. 67
Captulo 9 MVC ............................................................................................ 69
Uma Aplicao Web Sem MVC ............................................................................................. 69
Variaes Sobre um Mesmo Tema ......................................................................................... 71
MVC Modelo 1 ................................................................................................................... 71
MVC Modelo 2 ................................................................................................................... 71
Uma Aplicao Web com MVC ............................................................................................. 71
Os Componentes da Arquitetura MVC ................................................................................... 72
Model .................................................................................................................................. 72
View .................................................................................................................................... 73
Controller ............................................................................................................................ 73
Mquina de Estados ................................................................................................................ 73
Uma Aplicao Web Como Uma Mquina de Estados....................................................... 73
Design-Patterns ....................................................................................................................... 76
O Design-Pattern Command ............................................................................................... 76
O Design-Pattern Abstract Factory ..................................................................................... 77
Captulo 10 JSTL .......................................................................................... 81
Namespaces ............................................................................................................................. 81
Colaborao Entre Tags .......................................................................................................... 82
Colaborao Implcita ......................................................................................................... 82
Colaborao Explcita ......................................................................................................... 83
O Namespace Core .................................................................................................................. 83
Suporte s Variveis ............................................................................................................ 83
Controle de Fluxo ................................................................................................................ 84
Gerenciamento de URLs ..................................................................................................... 86
Tags Variadas ...................................................................................................................... 87
Internacionalizao ................................................................................................................. 88
Preparando os Resource Bundles ........................................................................................ 88
Exibindo Mensagens ........................................................................................................... 89
5
Formatao .............................................................................................................................. 90
Formatando Valores ............................................................................................................ 90
Captulo 11 Custom Tags .............................................................................. 93
A Anatomia de uma Tag ......................................................................................................... 93
Atributos .............................................................................................................................. 94
Corpo ................................................................................................................................... 94
Tag Handler............................................................................................................................. 94
O Descritor da Biblioteca de Tags .......................................................................................... 95
Criando o Arquivo TLD com o NetBeans........................................................................... 96
Tags Clssicas ......................................................................................................................... 98
Classes da API de Tags Customizadas Clssicas ................................................................ 98
O Ciclo de Vida das Tags Clssicas .................................................................................... 99
Implementando Uma Tag Clssica ................................................................................... 102
Tags Simples ......................................................................................................................... 108
Classes da API de Tags Customizadas Simples ................................................................ 109
Implementando Uma Tag Simples .................................................................................... 111
Arquivos de Tags .................................................................................................................. 114
Implementando Um Arquivo de Tag................................................................................. 114
6
Captulo 1 Introduo
O mundo dos negcios no seria o mesmo sem a World Wide Web. Em especial, a tecnologia
das aplicaes web libertou as empresas das dores-de-cabea e custos de se manter uma
aplicao atualizada em centenas de computadores: hoje em dia, com um click do mouse
possvel ter uma aplicao sempre atualizada e imediatamente disponvel para todos os seus
usurios, quer ele estejam na outra sala ou no outro lado do mundo.
Neste curso exploraremos as principais tecnologias oferecidas pela plataforma Java para a
criao de aplicaes web de nvel corporativo, em especial a plataforma Java Enterprise
Edition.
A Java Enterprise Edition (Java EE, anteriormente conhecida como Java 2 Enterprise Edition ou
J2EE) uma plataforma bastante usada para o desenvolvimento de aplicaes de lado servidor
na linguagem de programao Java. A Plataforma Java EE difere do Java SE por adicionar uma
srie de bibliotecas que oferecem funcionalidades para a criao de aplicaes tolerantes a
falhas, distribudas e multi-camadas, baseadas em componentes modulares sendo executados em
um servidor de aplicaes.
A seguir vemos um pequeno apanhado das tecnologias que compe a Java EE, bem como seu
histrico de verses.
Verso Data JSR Principais APIs
J2EE 1.2 12/12/1999 - Enterprise JavaBeans 1.1
JavaServer Pages 1.1
Java Servlet 2.2
Java Data Base Conectivity 2.0
J2EE 1.3 24/09/2001 JSR-58 Enterprise JavaBeans 2.0
Java Servlet 2.3
J2EE 1.4 11/11/2003 JSR-151 Enterprise JavaBeans 2.1
JavaServer Pages 2.0 [JSR-152]
JavaServer Pages Standard Tag Library 1.1
[JSR-52]
Java Servlet 2.4
7
Verso Data JSR Principais APIs

Java EE 5 11/05/2006 JSR-244 Enterprise JavaBeans 3.0 [JSR-220]
Java Persistense API 1.0
Java Servlet 2.5
JavaServer Faces 1.2 [JSR-252]
[JSR-52]
Java Data Base Conectivity 3.0 [JSR-54]
Java EE 6 10/12/2009 JSR-316 Enterprise JavaBeans 3.1 [JSR-318]
Java Persistence API 2.0 [JSR 317]
JavaServer Pages 2.2 - Expression Language
2.2 [JSR-245]
Java Servlet 3.0 [JSR-315]
JavaServer Faces [JSR-314]
[JSR 52]
Java Database Connectivity 4.0 [JSR-221]
8
Captulo 2 HTTP
Se a sua aplicao vai funcionar por meio da World Wide Web, ento ela precisa se ater s
regras da web. Em especial, precisamos compreender e saber como utilizar o principal
protocolo da web, o http.
O Hyper Text Transfer Protocol (HTTP, protocolo de transferncia de hiper-texto) foi criado
por Tim Berners-Lee quando trabalhava no CERN, em 1989.
um protocolo baseado em requisio-resposta, usado para computao cliente-servidor.
O cliente envia uma requisio ao servidor;
O servidor trata a requisio do cliente e lhe envia uma resposta.
Esta resposta pode conter algum contedo a ser exibido/armazenado pelo cliente ou algum tipo
de mensagem de status, indicando as possveis razes pela solicitao ter falhado.
Experimente voc mesmo:
Abra uma janela do DOS e digite a seguinte linha:
telnet www.alfamidia.com.br 80
Quando o comando conseguir conectar com o servidor da Alfamdia a tela ficar preta.
Digite o seguinte request (o cursor se mover, mas voc no ver o que digita na tela, ento
tome cuidado para no errar):
GET /index.html HTTP/1.1
Host: www.alfamidia.com.br
No esquea de colocar uma linha em branco ao final.

Voc obter como resposta um documento imenso parecido com o mostrado abaixo:
HTTP/1.1 404 Not Found
Content-Length: 1635
Content-Type: text/html
Server: Microsoft-IIS/6.0
X-Powered-By: ASP.NET
Date: Mon, 11 Apr 2011 14:06:05 GMT
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"

"http://www.w3.org/TR/html4/st
rict.dtd">
<HTML><HEAD><TITLE>The page cannot be found</TITLE>
<META HTTP-EQUIV="Content-Type" Content="text/html;
charset=Windows-1252">
<STYLE type="text/css">
BODY { font: 8pt/12pt verdana }
9
H1 { font: 13pt/15pt verdana }

H2 { font: 8pt/12pt verdana }
A:link { color: red }
A:visited { color: maroon }
</STYLE>
</HEAD><BODY><TABLE width=500 border=0 cellspacing=10><TR><TD>
<h1>The page cannot be found</h1>

The page you are looking for might have been removed, had its
name changed, or is temporarily unavailable.
<hr>
Pronto, voc acabou de experimentar sua prpria requisio e recebeu de volta sua resposta.
No muito diferente do que um browser faria.
Agora vamos tentar entender alguns dos conceitos por trs disso tudo.
URI
Um Uniform Resource Identifier (URI, ou "identificador uniforme de recurso") uma cadeia de
caracteres usada para identificar um nome ou recurso na Internet.
Este identificador possibilita a interao com recursos (documentos ou mesmo programas)
usando protocolos especficos.
No uso popular e at mesmo em documentos tcnicos e discusses verbais, os termos URI e
URL so frequentemente usados intercambiadamente.
Mas existem diferenas, como veremos a seguir.
Um Uniform Resource Locator (URL, "localizador uniforme de recurso") um URI que
especifica onde um recurso identificado est disponvel e que mecanismo deve ser usado para
recuper-lo:
http://www.google.com/
Um Uniform Resource Name (URN, "nome uniforme de recursos) serve para identificar um
recurso independentemente do local onde ele est armazanado.
Um URN funciona como o nome de uma pessoa enquanto um URL funciona como o endereo
daquela pessoa. Em outras palavras, um URN define a identidade do tem, enquanto que um
URL prov um meio de encontr-lo.
URI, URL e URN

Assim, um URI seria o resultado da unio de um URL com um URN.
http://www.google.com/search?q=http
10
Sintaxe
No exemplo abaixo vemos um URI apontando para um determinado recurso armazenado na
World Wide Web.
[http://<servidor>][:<porta>][/<urn>][#<fragmento>][?<parametro-
1>=<valor-1>&<parametro-2>=<valor-2>]
O elemento servidor indica o nome ou IP do servidor onde o recurso est
hospedado;
O elemento porta indica a porta (ou servio rodando no servidor) que atende quele
tipo de solicitao (se no for passado, para URIs do tipo HTTP o padro 80);
O elemento urn indica o caminho (seja real ou fictcio) at o recurso desejado;
O elemento fragmento indica uma determinada seo dentro do documento;
Os elementos parametro-1 e parametro-2 indicam parmetros adicionais a
serem adicionados na requisio, enquanto que os elementos valor-1 e valor-2
indicam os valores dos respectivos parmetros. Voc pode ter quantos parmetros
quiser em um URI.
Por exemplo, veja o URI de uma pesquisa no Google:
http://www.google.com/search?q=http
No exemplo:
www.google.com indica o nome do servior;
/search indica a URN do recurso;
q=http indica o nome e valor de um parmetro.
Parmetros
Os parmetros so informaes adicionais fornecidas ao se criar um URI (ou ao preencher um
formulrio na web) e que so enviadas ao servidor juntamente com a requisio.
O Google, por exemplo, usa o parmetro q para indicar qual a expresso de busca o usurio
informou na caixa de busca.
Estes parmetros ficam disposio do documento ou aplicao apontado pela requisio, e
podem ser usados para afetar o seu comportamento. Assim o Google consegue devolver ao
cliente apenas as pginas que atendem ao critrio de buscas.
URIs Absolutos
Chamamos de URI absoluto um URI que indica um servidor e recurso na rede, sem
ambiguidades.
11
http://www.alfamidia.com.br
http://www.alfamidia.com.br/default.aspx
http://www.alfamidia.com.br/imgs/logo.png
URIs Relativos
Por outro lado existem URIs em que se aponta para um recurso de maneira relativa ao
documento que se est vendo no momento.
O cdigo fonte do documento http://www.alfamidia.com.br/default.aspx pode
se referenciar imagem logo.png apenas ao indicar como URI o seguinte texto:
/imgs/logo.png
Neste caso cabe ao browser resolver a ambiguidade por adicionar o prefixo (protocolo, host,
porta...) a partir da localizao do documento corrente.
Request
As requisies do protocolo HTTP so basicamente linhas de texto que identificam o mtodo
da requisio, o endereo do recurso desejado e eventuais informaes adicionais a respeito do
cliente e das suas capacidades.
Veja um exemplo:
GET /index.html HTTP/1.1
Host: www.alfamidia.com.br
User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:2.0) Gecko/20100101
Firefox/4.0
Accept:
text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: pt-br,pt;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Mtodos
O protocolo HTTP define nove mtodos usados para indicar a ao que se deseja executar no
recurso apontado. O que este recurso representa (dados pr-existentes ou gerados
dinamicamente) depende apenas da implementao do servidor, mas normalmente o recurso
corresponde a um arquivo fsico ou sada de um programa que reside no servidor.
Mtodo Descrio
HEAD Solicita uma resposta idntica quela que seria
retornada pelo mtodo GET, porm sem o
corpo.
GET Solicita uma representao do recurso
indicado (normalmente uma pgina HTML).
POST Envia dados para serem processados pelo
recurso indicado. Os dados estaro includos
no corpo da requisio.
12
Mtodo Descrio
PUT Envia uma representao do recurso.
DELETE Apaga o recurso especificado.
TRACE Ecoa a requisio recebida, de forma que o
cliente possa ver alteraes que foram feitas
por servidores intermedirios.
OPTIONS Retorna os mtodos HTTP que o servidor
suporta para um dado recurso.
CONNECT Converte a conexo de request em um tnel
TCP/IP, normalmente utilizado para facilitar
trfego SSL.
PATCH usado para aplicar pequenas correes em
um recurso.
Cabealhos
Os cabealhos da requisio so as linhas de texto enviadas logo abaixo da linha de request, e
podem ser usados para identificar o cliente e as suas capacidades, bem como para definir os
parmetros da transao HTTP.
Os cabealhos se apresentam no formato <cabealho>: <valor>, cada um em uma linha.
Em HTTP/1.1 todos os cabealhos exceto o cabealho Host so opcionais.
O final dos cabealhos demarcado por uma linha em branco.
Cabealho Descrio Exemplo
Accept Indica os Content-Types Accept: text/plain
aceitos pelo cliente.
Accept-Charset Indica os conjuntos de Accept-Charset: utf-8
caracteres aceitos pelo
cliente.
Accept-Encoding Indica os encodings Accept-Encoding: <compress | gzip |
aceitos pelo cliente. deflate | sdch | identity>
Accept-Language Indica as lnguas aceitas Accept-Language: en-US
pelo cliente.
Authorization Credenciais de Authorization: Basic
autenticao para a QWxhZGRpbjpvcGVuIHNlc2FtZQ==
autenticao HTTP.
Cache-Control As diretivas que devem Cache-Control: no-cache
ser atendidas por todos os
mecanismos de cache
dentro da cadeia de
request/response.
Connection O tipo de conexo Connection: close
preferida pelo cliente.
13

Cookie Um cookie previamente Cookie: $Version=1; Skin=new;
enviado pelo servidor.
Content-Length O comprimento da Content-Length: 348
requisio em bytes.
Content-MD5 Checksum MD5 do corpo Content-MD5:
da requisio. Q2hlY2sgSW50ZWdyaXR5IQ==
Content-Type O tipo mime do corpo da Content-Type: application/x-www-
requisio (usado em form-urlencoded
requests POST e PUT).
Date A data e hora em que a Date: Tue, 15 Nov 1994 08:12:31 GMT
requisio foi enviada.
Expect Os comportamentos do Expect: 100-continue
servidor que so
esperados pelo cliente.
From O endereo de e-mail do From: user@example.com
usurio fazendo a
requisio.
Host O nome de domnio do Host: en.wikipedia.org
servidor (para hosts
virtuais, obrigatrio
desde o HTTP/1.1).
If-Match O servidor somente If-Match:
executar a requisio se "737060cd8c284d8af7ad3082f209582d"
a entidade enviada
corresponde mesma
entidade no servidor.
Isso til para evitar que
mtodos PUT alterem
recursos de maneira
duplicada.
If-Modified-Since Permite que um status If-Modified-Since: Sat, 29 Oct 1994
304 Not Modified seja 19:43:31 GMT
enviado se o contedo
no foi modificado desde
a data indicada.
If-None-Match Permite que um status If-None-Match:
304 Not Modified seja "737060cd8c284d8af7ad3082f209582d"
enviado se o contedo
no foi modificado.
14

If-Range Se a entidade no foi If-Range:
modificada envia apenas "737060cd8c284d8af7ad3082f209582d"
as partes que o cliente
ainda no tem, caso
contrrio envia todo o
contedo.
If-Unmodified-Since O servidor somente If-Unmodified-Since: Sat, 29 Oct 1994
enviar a resposta se a 19:43:31 GMT
entidade no foi
modificada desde a data
indicada.
Max-Forwards Limita o nmero de vezes Max-Forwards: 10
que a requisio pode
passar por proxies ou
gateways.
Pragma Cabealhos especiais que Pragma: no-cache
podem ter vrios efeitos
dentro da cadeia de
request/response.
Proxy-Authorization Credenciais para conexo Proxy-Authorization: Basic
com um proxy. QWxhZGRpbjpvcGVuIHNlc2FtZQ==
Range Solicita apenas parte de Range: bytes=500-999
uma entidade (em bytes,
comeando com 0).
Referer O endereo da pgina que Referer:
continha o link que foi http://en.wikipedia.org/wiki/Main_Page
seguido para gerar esta
requisio.
TE Os encodings de TE: trailers, deflate
transferncia que o
cliente pode aceitar.
Upgrade Pede ao servidor para Upgrade: HTTP/2.0, SHTTP/1.3,
atualizar para outro IRC/6.9, RTA/x11
protocolo.
User-Agent O nome e verso do User-Agent: Mozilla/5.0 (Windows NT
software enviando a 6.1; rv:2.0) Gecko/20100101
requisio. Firefox/4.0
Via Os proxies pelos quais Via: 1.0 fred, 1.1 nowhere.com
esta requisio passou. (Apache/1.1)
Warning Advertncias a respeito Warning: 199 Miscellaneous warning
de possveis erros com o
corpo da entidade.
15
Response
As respostas HTTP representam o contedo que o atendimento da requisio previamente
enviada pelo cliente gerou.
Elas consistem de algumas linhas de cabealho seguidas de uma linha em branco e o contedo
propriamente dito, tipicamente um arquivo HTML ou algum outro recurso, como um arquivo de
imagem ou PDF, por exemplo.
Veja um exemplo:
HTTP/1.1 200 OK
Date: Mon, 11 Apr 2011 19:44:37 GMT
Server: Microsoft-IIS/6.0
X-Powered-By: ASP.NET
X-AspNet-Version: 2.0.50727
Cache-Control: private
Content-Type: text/html; charset=utf-8
Content-Length: 23404
Cdigo de Resposta
A primeira linha de uma resposta HTTP chamada de linha de status, e serve para indicar o
sucesso ou falha da operao.
As linhas de status vem no formato <verso-do-protocolo> <cdigo-de-status>
<razo>, como por exemplo:
HTTP 1.1 404 Not Found
O primeiro dgito do cdigo de status indica a classe do status, e sozinho j pode nos dar uma
indicao se a requisio foi bem-sucedida ou no.
Classes
Classe Descrio
1xx Informacional A requisio foi recebida, continuando com o
processo.
2xx Sucesso A requisio foi recebida, compreendida e
aceita pelo servidor.
3xx Redirecionamento O cliente deve tomar aes adicionais para
completar a requisio.
4xx Erro do Cliente Aparentemente o cliente errou ao fazer a
requisio, seja por indicar um recurso
inexistente ou por no estar autorizado a ver o
mesmo.
5xx Erro do Servidor O servidor no conseguiu atender uma
requisio aparentemente vlida.
1xx Informacional
Os cdigos de status do grupo 1xx indicam que a requisio foi recebida e que o servidor est
continuando com o processo de atendimento.
16
Cdigo de Status Descrio

100 Continue O servidor recebeu a requisio, e o cliente
pode continuar o mesmo enviando o seu
corpo.
101 Switching Protocols O cliente solicitou a mudana de protocolo, e
o servidor est atendendo.
102 Processing Como uma requisio pode conter muitas sub-
requisies, o servidor pode levar algum
tempo processando-a. Esta mensagem
enviada para informar o cliente de que o
processamento continua, evitando o time-out.
122 Request URI too long O URI solicitado maior do que 2083
caracteres.
2xx Sucesso
As mensagens de status do grupo 2xx indicam que a requisio foi recebida, compreendida e
aceita pelo servidor.
200 OK A requisio foi bem-sucedida.
201 Created A requisio foi bem sucedida e resultou na
criao de uma nova entidade.
202 Accepted A requisio foi aceita, mas o processamento
ainda no se completou.
203 Non-Authoritative Information O servidor processou a requisio, mas est
retornando informaes que podem ser de
outra fonte.
204 No Content O servidor processou a requisio, mas no
tem contedo para enviar.
205 Reset Content O servidor processou a requisio, mas no
tem contedo para enviar, porm, diferente do
status 204, o cliente precisa re-enviar a
requisio.
206 Partial Content O servidor est enviando apenas parte do
contedo, atendendo solicitao Range.
207 Multi-Status A mensagem de resposta que se segue est em
XML e pode conter mltiplos status (um para
cada sub-request).
226 IM Used O servidor atendeu solicitao GET, e a
resposta representa uma ou mais
manipulaes de instncia aplicadas ao
contedo.
17
3xx Redirecionamento
As mensagens do grupo 3xx indicam que o servidor no conseguiu atender na sua plenitude a
solicitao, e que o cliente deve tomar aes adicionais para v-la atendida.
300 Multiple Choices Existem mltiplas opes para o recurso
indicado pelo cliente.
301 Moved Permanently Esta e todas as futuras requisies devem ser
enviadas para um novo URI.
302 Found A resposta pode ser encontrada em outro URI.
Status fora do padro.
303 See Other A resposta pode ser encontrada em outro URI.
304 Not Modified O recurso no foi modificado desde a ltima
requisio.
305 Use Proxy O recurso deve ser solicitado por meio de um
proxy.
306 Switch Proxy Este status no mais usado.
307 Temporary Redirect Nesta ocasio a requisio deve ser
redirecionada para outro URI, mas futuras
requisies podem continuar usando a URI
original.
4xx Erro do Cliente

Os cdigos de status 4xx indicam que o servidor acredita que o cliente cometeu um erro ao fazer
a requisio, seja por indicar um recurso inexistente, seja por no estar autorizado a ver o
mesmo.
400 Bad Request A requisio no pode ser atendida por ter
sido mal-formada.
401 Unauthorized O contedo deve ser acessado depois da
validao das credenciais do cliente.
402 Payment Required Reservado para uso futuro.
403 Forbidden A requisio vlida, mas o usurio no tem
autorizao para ver o contedo.
404 Not Found O recurso requisitado no existe.
405 Method Not Allowed Uma requisio foi feita usando-se um
mtodo no suportado pelo recurso.
406 Not Acceptable O recurso s consegue gerar contedo em um
formato que no suportado pelo cliente.
407 Proxy Authentication Required O cliente deve se registrar com um proxy
primeiro.
18

408 Request Timeout O cliente demorou demais a enviar a
requisio.
409 Conflict Indica que a requisio no pode ser atendida
devido a um conflito.
410 Gone O recurso requisitado no est mais
disponvel.
411 Length Required A requisio no indicou o seu comprimento,
o que exigido pelo servidor.
412 Precondition Failed O servidor no atende um dos pr-requisitos
que o cliente ps na requisio.
413 Request Entity Too Large A requisio maior do que o servidor
consegue atender.
414 Request-URI Too Long O URI da requisio maior do que o
servidor consegue atender.
415 Unsupported Media Type A requisio enviou um tipo de dado que o
servidor no suporta.
416 Request Range Not Satisfied O cliente solicitou uma poro do arquivo,
mas o servidor no pode prover aquela
poro.
417 Expectation Failed O servidor no consegue atender ao cabealho
Expect da requisio.
418 Im a Teapot Cdigo de erro de piada de 1 de Abril.
422 Unprocessable Entity A requisio est bem formada, mas
impossvel atend-la devido a um erro de
semntica.
423 Locked O recurso est bloqueado.
424 Failed Dependency A requisio falhou devido a uma falha na
requisio anterior.
425 Unordered Collection No usado.
426 Upgrade Required O cliente deve usar um protocolo diferente.
444 No Response O servidor detectou um malware na requisio
e fechou a conexo.
449 Retry With A requisio deve ser tentada depois de se
efetuar a ao indicada.
450 Blocked by Windows Parental Control O Windows Parental Control bloqueou a
requisio.
499 Client Closed Request O cliente encerrou a conexo enquanto o
servidor ainda processava a requisio.
19
5xx Erro do Servidor

Os cdigos de status do grupo 5xx indicam uma falha no servidor ao atender uma requisio
aparentemente vlida.
500 Internal Server Error Mensagem genrica usada quando nenhuma
outra se adequa.
501 Not Implemented Ou o servidor no reconhece o mtodo da
requisio ou no tem recursos para atend-la.
502 Bad Gateway O servidor estava atuando como um gateway
ou proxy e recebeu uma resposta invlida do
servidor remoto.
503 Service Unavailable O servidor est indisponvel.
504 Gateway Timeout O servidor estava atuando como um gateway
ou proxy e no recebeu uma resposta do
servidor remoto.
505 HTTP Version Not Supported O servidor no suporta a verso HTTP usada
na requisio.
506 Variant Also Negotiates A negociao transparente de contedo
causou uma referncia circular.
507 Insufficient Storage O servidor no tem espao em disco suficiente
para lidar com a requisio.
509 Bandwidth Limit Exceeded Erro no usado na RFC.
510 Not Extended Extenses requisio so necessrias para
que ela possa ser atendida.
Cabealhos
Os cabealhos da resposta so as linhas de texto enviadas logo abaixo da linha de status, e so
usados para identificar as capacidades do servidor ou meta-dados a respeito do contedo sendo
retornado, bem como para definir os parmetros da transao HTTP.
Assim como ocorre com os cabealhos da requisio, os cabealhos da resposta se apresentam
no formato <cabealho>: <valor>, cada um em uma linha.
Accept-Ranges Os tipos de contedo Accept-Ranges: bytes
parcial que este
servidor suporta.
Age O tempo que o objeto Age: 12
ficou no proxy ou
cache, em segundos.
Allow Aes vlidas para um Allow: GET, HEAD
determinado recurso.
20

Cache-Control Diz ao controle de Cache-Control: max-age=3600
cache o se ele pode
cachear este objeto.
Content-Encoding O tipo de codificao Content-Encoding: gzip
usado nos dados.
Content-Language A lngua na qual o Content-Language: da
contedo foi criado.
Content-Length O comprimento da Content-Length: 348
resposta em bytes
Content-Location Uma localizao Content-Location: /index.htm
alternativa para os
dados retornados.
Content-MD5 A checksum MD5 da Content-MD5:
resposta. Q2hlY2sgSW50ZWdyaXR5IQ==
Content- Uma oportunidade de Content-Disposition: attachment;
Disposition lanar uma caixa de filename=fname.ext
dilogo de download
de arquivo para um
tipo MIME conhecido.
Content-Range A posio deste Content-Range: bytes 21010-47021/47022
segmento no recurso
completo.
Content-Type O tipo MIME deste Content-Type: text/html; charset=utf-8
recurso.
Date A data e hora em que a Date: Tue, 15 Nov 1994 08:12:31 GMT
resposta foi enviada.
ETag A identificao desta ETag: "737060cd8c284d8af7ad3082f209582d"
verso em especial do
recurso.
Expires A data e hora em que a Expires: Thu, 01 Dec 1994 16:00:00 GMT
resposta considerada
vencida.
Last-Modified A data e hora da ltima Last-Modified: Tue, 15 Nov 1994 12:45:26
modificao no GMT
recurso.
Link Expressa um Link: </feed>; rel="alternate"
relacionamento com
outro recurso.
21

Location A localizao do Location:
recurso recm criado, http://www.w3.org/pub/WWW/People.html
ou ento a localizao
que deve ser usada
como resultado de um
redirecionamento (para
respostas com status do
grupo 3xx).
P3P No usado. P3P: CP="This is not a P3P policy! See
http://www.google.com/support/
No entanto, muitos
accounts/bin/answer.py?hl=en&answer=151657
sites usam o cabealho
for more info."
para enganar os
clientes na tentativa de
enviar cookies de
terceiros.
Pragma Cabealhos que podem Pragma: no-cache
ter vrios efeitos dentro
da cadeia de
requisio/resposta.
Proxy- Solicita autenticao Proxy-Authenticate: Basic
Authenticate para acessar o proxy.
Refresh Usado em Refresh: 5;
redirecionamento ou url=http://www.w3.org/pub/WWW/People.html
quando um novo
recurso foi criado.
Retry-After Diz ao cliente para Retry-After: 120
tentar novamente
depois de um
determinado perodo,
quando o recurso est
temporariamente
indisponvel.
Server O nome do software Server: Apache/1.3.27 (Unix) (Red-Hat/Linux)
servidor que gerou esta
resposta.
Set-Cookie Cria um cookie. Set-Cookie: UserID=JohnDoe; Max-Age=3600;
Version=1
Trailer Este campo indica que Trailer: Max-Forwards
um determinado
conjunto de cabealhos
est presente em uma
mensagem codificada.
22

Transfer-Encoding A forma de codificao Transfer-Encoding: chunked
usada para transferir o
contedo para o
cliente.
Vary Indica aos proxies se Vary: *
verses cacheadas
podem ou no ser
usadas para responder
s solicitaes.
Via Informa ao cliente por Via: 1.0 fred, 1.1 nowhere.com (Apache/1.1)
quais proxies esta
response passou.
Warning Uma advertncia geral Warning: 199 Miscellaneous warning
a respeito de possveis
problemas com o corpo
da entidade.
WWW- O esquema de WWW-Authenticate: Basic
Authenticate autenticao que deve
ser usado para acessar
o recurso solicitado.
23
Captulo 3 Ambiente de
Desenvolvimento
Embora seja perfeitamente possvel desenvolver suas aplicaes Java EE exatamente da

maneira que fazia quando desenvolvia aplicaes stand-alone, isso normalmente no
recomendvel.
Aplicaes Enterprise so inerentemente mais complexas e formais, e ter que lidar com toda
essa complexidade sem ferramentas de apoio a receita de um desastre.
So muitas bibliotecas a adicionar, muitos arquivos de configurao a manter, e isso em um
ambiente que normalmente compartilhado por vrios desenvolvedores (j que as aplicaes
corporativas so normalmente maiores, comum termos vrios desenvolvedores trabalhando
em conjunto).
Ento para isso surgem os IDEs.
Alm do mais, rodar a aplicao tambm diferente e requer novos passos.
Quando voc desenvolvia aplicaes Java desktop o JDK bastava, certo? O prprio JDK vem
com o JRE, ento tudo o que voc precisava estava ali.
Aplicaes Java EE, entretanto, so mais exigentes quanto ao ambiente de execuo. Este tipo
de aplicao precisa de um Container, um servidor web capaz de rodar as aplicaes Java.
Pense nisso como se o Apache fosse capaz de executar programas Java ao invs de meramente
servir pginas HTML.
Assim, ao invs de simplesmente executar uma aplicao Java EE voc precisar de alguns
passos extras para torn-la disponvel atravs da Web:
Voc precisar iniciar o container;
Voc precisar instalar a sua aplicao no container;
Voc precisar acess-la de alguma maneira, provavelmente por meio de um browser
web.
Ento, para criar aplicaes Java EE voc vai precisar no mnimo de:
O JDK / JRE devidamente instalado e configurado;
Um ambiente integrado de desenvolvimento (IDE, de Integrated Development
Environment), uma ferramenta que edita, compila, implanta, executa e debuga sua
aplicao;
Um servidor de aplicaes Java EE.
24
JDK JRE
Voc provavelmente j tem isso instalado, mas no custa lembrar... Para executar toda e
qualquer aplicao Java voc vai precisar ter o JRE instalado.
O JRE pode ser obtido atravs do seguinte link:
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Para aplicaes Java EE voc precisa exatamente do mesmo JRE. No h nenhum download
especial de run-time para o Java EE exceto pelos demais componentes descritos aqui (o IDE e o
Servidor de Aplicaes).
Numa mquina de desenvolvimento voc vai precisar tambm do JDK. Numa mquina
servidora, a qual voc no usar para compilar suas aplicaes, voc precisa apenas do JRE. J
seus usurios precisaro apenas de um browser (sequer o JRE necessrio, uma vez que todo o
cdigo Java ocorre no lado servidor).
Ambiente Integrado de Desenvolvimento

Os Ambientes Integrados de Desenvolvimento (IDE, de Integrated Development
Environment) oferecem tudo que um programador precisa para editar, compilar, implantar,
executar e debugar uma aplicao Java.
Hoje em dia so ferramentas praticamente imprescindveis no processo de desenvolvimento.
Dentre os principais ambientes de desenvolvimento para a plataforma Java EE podemos citar:
NetBeans
http://netbeans.org/
Eclipse
http://www.eclipse.org/
IBM Rational Team Concert
http://jazz.net/projects/rational-team-concert/
Oracle JDeveloper
http://www.oracle.com/technetwork/developer-tools/jdev/overview/index.html
IntelliJ IDEA
http://www.jetbrains.com/idea/
Servidor de Aplicao
Um Servidor de Aplicao (AS, de Application Server) basicamente um servidor web com
capacidade de executar aplicaes Java EE.
Existem basicamente duas variantes deste modelo:
Web Container
EJB Container
Web Container
Um Web Container um servidor de aplicaes cujas funcionalidades se restringem a servir
documentos JSP e Servlets.
o conjunto mnimo de requisitos para que um software seja considerado um Servidor de
Aplicao Java.
25
Exemplos de Web Containers incluem:

Apache Tomcat
http://tomcat.apache.org/
Jetty
http://www.eclipse.org/jetty/
Resin
http://www.caucho.com/
EJB Container
J o termo EJB Container se refere queles servidores de aplicao que tem capacidade de
executar aplicaes Java EE mais complexas, incluindo a os Enterprise Java Beans, transaes,
segurana e distribuio.
Dentre os EJB Containers podemos citar:
GlassFish
http://glassfish.java.net/
JBoss
http://www.jboss.org/jbossas/
Apache Geronimo
http://geronimo.apache.org/
IBM WebSphere
http://www-01.ibm.com/software/webservers/appserv/was/
Oracle WebLogic
http://www.oracle.com/us/products/middleware/application-server/index.html
26
Captulo 4 Aplicaes Web
A Web Esttica
Quando foi concebida, no final dos anos 80, a Web era um lugar que seria usado apenas para
hospedar documentos acadmicos. Naquela poca ainda no se antevia a necessidade de se
criar interfaces para a criao de contedos dinmicos; ela foi criada basicamente para
armazenar documentos de pesquisa ou publicaes, palavras congeladas no tempo.
Neste contexto, um Servidor Web era apenas um software capaz de identificar que documento
estava sendo solicitado e entreg-lo ao cliente. basicamente isso que o Apache HTTPd Server
faz ainda hoje.
A Web Dinmica
No entanto no demorou muito para que as pessoas comeassem a antever as possibilidades:
Que tal um site que mostrasse os resultados das partidas de futebol?
Cotaes do mercado em tempo real?
Aplicaes cliente-servidor, porm baseadas na web?
27
CGI
Em 1993 a web ainda era um lugar bem pequeno, mas muito frtil. Alguns dos principais
desbravadores discutiam a respeito das possibilidades na www-talk, uma lista de discusses
hospedada pela NCSA.
Na poca foi proposto que se criasse um padro para chamar arquivos executveis direto do
browser. Tais programas poderiam ser escritos em qualquer linguagem, desde que seguissem
convenes bem simples sobre como obter parmetros e gerar os seus resultados:
O prprio servidor web prepararia variveis de ambiente antes de chamar o aplicativo;
O aplicativo consumiria estas variveis de ambiente (que lhe serviriam de parmetros de
configurao ou, quem sabe, fontes de dados) e geraria sua sada em HTML, a qual
seria simplesmente capturada pelo servidor web e repassada ao cliente.
Nascia o padro CGI (Common Gateway Interface).
A Resposta da Sun
J em 1995 James Gosling imaginava algum tipo de API Java que pudesse ser usada para gerar
contedo web dinamicamente a partir de aplicaes Java.
Com a linguagem ainda no seu nascedouro a ideia foi posta de lado, apenas para ser retomada
mais tarde. Pavani Diwanji usou o conceito para conceber algo que acabou se transformando no
Java Web Server, um servidor web completamente escrito em Java.
A especificao dos Servlets foi publicada em Junho de 1997. Algum tempo depois Anselm
Baird-Smith criou o que viria a se tornar a tecnologia JSP, cuja especificao foi posteriormente
escrita por Satish Dharmaraj.
Tanto os Servlets quanto os JSPs acabaram se tornando parte da distribuio Java 2 Enterprise
Edition (J2EE), lanada em Agosto de 1999.
28
Servlets
Como visto antes, os Servlets nasceram antes do que os JSPs, e na sua essncia se parecem
muito com os scripts CGI apresentados anteriormente. A diferena mais marcante que os
Servlets tem um ciclo de vida diferente:
Eles no so instanciados a cada nova requisio, mas sim mantidos em um cache a
partir da primeira requisio;
Cada nova requisio gera uma nova thread, e no um processo, o que acaba aliviando a
carga do servidor (uma thread consome menos recursos do que um processo, por no
requisitar uma rea isolada de memria);
Os Servlets requerem um container, um aplicativo servidor especial cuja tarefa
principal manter o ciclo de vida dos Servlets.
A API de Servlets j passou por muitas verses. A ltima verso disponvel a 3.0, lanada em
Dezembro de 2009 como parte da plataforma Java EE 6.
JSPs
JavaServer Pages o nome da especificao que visa criar documentos para a web baseados em
Java.
JSPs podem ser encarados como uma abstrao de alto nvel dos Servlets:
Uma pgina JSP escrita como um arquivo HTML com cdigo Java embutido (os
scriptlets);
O cdigo Java responsvel pela gerao do contedo dinmico da pgina;
O container web converte a pgina JSP em um Servlet e, a partir da, passa a tratar
aquele documento como um Servlet.
Do ponto de vista do desenvolvedor, entretanto, o documento JSP muito mais fcil de
codificar, pois existe uma clara separao entre a markup e o cdigo Java.
Uma Aplicao Web em Java

No Java EE trabalhamos com o conceito de contextos web, o que na verdade significa uma
espcie de diretrio (virtual ou no) criado dentro do nosso Web Container.
Cada aplicao instalada ter o seu contexto.
Existe uma estrutura padro de diretrios que todas as aplicaes web em Java precisam seguir.
Basicamente isto implica em criar um diretrio para a aplicao e, l dentro, criar um diretrio
que ser a raz das pginas Web.
Dentro deste diretrio precisa existir um novo diretrio chamado WEB-INF. l dentro que
sero colocados os arquivos de configurao.
Criando Uma Aplicao Java Web com o NetBeans

As imagens a seguir descrevem passo a passo o processo de criao de uma aplicao Java Web
por meio do wizard do NetBeans. Por enquanto vamos aceitar muitos dos valores default, mas
medida que formos progredindo vamos aprender o significado de todos aqueles valores.
29
Comece selecionando Arquivo > Novo Projeto e voc cair na tela mostrada acima. Ali
selecione Java Web e Aplicao Web.
Agora indique um nome para o seu projeto. interessante tambm marcar o checkbox Usar
pasta dedicada para armazenar bibliotecas.
30
Nesta janela selecione o container e a verso de Java EE que deseja utilizar, bem como o
prprio nome do contexto.
Nesta janela simplesmente clique em Finalizar. Ainda no vamos usar qualquer dos
frameworks disponveis.
Pronto, sua primeira aplicao Web est pronta. O NetBeans j cria at um documento JSP para
voc, ento j possvel execut-la no seu browser para ver o que acontece. Experimente
utilizar uma URI parecida com esta, claro que adequando-a ao nome da sua aplicao:
http://localhost:8080/AloMundoServlet/
31
Captulo 5 Servlets
Grosso modo podemos facilmente entender um Servlet como a contra-parte Java de uma
aplicao CGI escrita em Perl ou C, por exemplo: um Servlet simplesmente uma classe Java
capaz de atender solicitaes HTTP e de gerar sada HTML, a qual ser enviada de volta ao
browser do usurio.
Assim como acontece com os programas CGI, tudo o que nosso Servlet mandar imprimir ser
redirecionado para o cliente. Mas o interessante que, sendo o Servlet uma classe Java, pode
desfrutar de toda a poderosa API da linguagem e com um custo de implementao bem baixo.
verdade! Implementar um Serlvet em Java to fcil quanto estender uma classe e gerar
alguns System.out.println(). Vamos dar uma olhada na hierarquia da API e voc logo
vai perceber.
A API de Servlets
A API de Servlet composta por um conjunto de interfaces e classes dentro do pacote
javax.servlet que so usadas para criar aplicaes que atendem a requisies.
A Interface Servlet
O componente mais bsico da API interface Servlet, a qual define o comportamento bsico
de um Servlet.
Esta interface serve como base para as classes GenericServlet e HttpServlet, as quais
vo, aos poucos, acrescentando novos recursos que ficam disponveis para nossos Servlets.
Veja abaixo a hierarquia de classes:
Servlet
GenericServlet
HttpServlet
32
Eis alguns dos mtodos mais importantes definidos pela interface Servlet:
Mtodo Descrio
void destroy() Chamado pelo container web quando o
Servlet estiver sendo retirado de servio.
ServletConfig getServletConfig() Retorna um objeto do tipo ServletConfig, o
qual contm os parmetros de inicializao
para este Servlet.
String getServletInfo() Retorna informaes a respeito deste Servlet,
como por exemplo o seu autor, verso e data.
void init(ServletConfig config) Chamado pelo container quando o Servlet
estiver sendo posto em servio.
void service(ServletRequest req, Chamado pelo container para permitir que um
ServletResponse res) Servlet atenda a uma requisio.
A Classe GenericServlet
A classe javax.servlet.GenericServlet define um Servlet independente de
protocolo. No comum de a usarmos diretamente, pois na maioria das vezes o que queremos
um Servlet capaz de atender requisies HTTP.
Mtodo Descrio
void destroy() Chamado pelo container web quando o
Servlet estiver sendo retirado de servio.
String getInitParameter(String name) Retorna o valor do parmetro de inicializao
indicado, ou null se ele no existir.
Enumeration<String> Retorna os nomes dos parmetros de
getInitParameterNames() inicializao deste Servlet como uma
Enumeration de Strings.
ServletConfig getServletConfig() Retorna o objeto que representa a
configurao deste Servlet.
ServletContext getServletContext() Retorna o objeto que representa o contexto
onde este Servlet est sendo executado.
como por exemplo o autor, verso e data.
String getServletName() Retorna o nome deste Servlet.
void init() Um mtodo de convenincia, de forma que
voc no precise chamar super.init(config).
void log(String msg) Escreve a mensagem indicada no log do
Servlet.
void log(String message, Throwable t) Escreve uma mensagem explicative e um
stack-trace no arquivo de log do Servlet.
abstract void service(ServletRequest req, Chamado pelo container para permitir que o
ServletResponse res) Servlet trate uma requisio.
33
A Classe HttpServlet
A classe abstrata javax.servlet.HttpServlet foi especialmente projetada para lidar
com o protocolo HTTP. desta classe que voc herdar ao criar seus Servlets.
Voc provavelmente precisar sobrescrever pelo menos um dos mtodos doGet() e
doPost(). Opcionalmente pode sobrescrever tambm o mtodo getServletInfo(), se
quiser retornar informaes a respeito do seu Servlet para o ambiente.
Os demais podem ficar inalterados, as verses declaradas em HttpServlet devem cobrir o
bsico.
Servlets rodam em ambientes multithreaded, ento tome cuidado ao lidar com recursos
compartilhados como instncias de objetos, conexes com banco de dados ou de rede.
Mtodo Descrio
void doGet(HttpServletRequest req, Chamado pelo container para permitir que o
HttpServletResponse res) Servlet trate uma requisio do tipo GET.
void doPost(HttpServletRequest req, Chamado pelo container para permitir que o
HttpServletResponse res) Servlet trate uma requisio do tipo POST.
void doPut(HttpServletRequest req, Chamado pelo container para permitir que o
HttpServletResponse res) Servlet trate uma requisio do tipo PUT.
void doDelete(HttpServletRequest req, Chamado pelo container para permitir que o
HttpServletResponse res) Servlet trate uma requisio do tipo DELETE.
void init(ServletConfig config) Chamado pelo container ao inicializar o
Servlet.
void destroy() Chamado pelo container ao destruir o Servlet.
como o nome do autor, a data e verso.
A Interface ServletConfig
A interface javax.servlet.ServletConfig usada pelo container para passar
informaes a um Servlet durante a sua inicializao.
Mtodo Descrio
ServletContext getServletContext() Retorna o objeto que representa o contexto
onde este Servlet est sendo executado.
String getServletName() Retorna o nome deste Servlet.
34
A Interface ServletContext
A interface javax.servlet.ServletContext define um conjunto de mtodos que um
Servlet pode usar para se comunicar com o container, como por exemplo para obter o MIME
type de um arquivo, despachar uma requisio ou escrever no arquivo de log.
Este objeto est contido no ServletConfig que o container passa ao Servlet no momento
que o inicializa.
Mtodo Descrio
Object getAttribute(String name) Retorna o atributo do container com o nome
indicado, ou null se ele no existe.
Enumeration<String> getAttributeNames() Retorna uma Enumeration com os nomes dos
atributos existentes neste ServletContext.
ServletContext getContext(String uripath) Retorna o ServletContext que corresponde
URL indicada.
String getContextPath() Retorna o nome do diretrio da aplicao
corrente.
int getEffectiveMajorVersion() Retorna o nmero de verso da especificao
Servlet que este contexto utiliza.
int getEffectiveMinorVersion() Retorna o nmero da subverso da
especificao Servlet que este contexto utiliza.
int getMajorVersion() Retorna o nmero de verso da especificao
Servlet suportada por este container.
String getMimeType(String file) Retorna o MIME type do arquivo indicado, ou
null se ele for desconhecido.
int getMinorVersion() Retorna o nmero da subverso da
especificao Servlet suportada por este
container.
String getRealPath(String path) Retorna o diretrio real correspondente ao
diretrio virtual (URI) indicado.
Servlet.
void log(String message, Throwable t) Escreve uma mensagem explicativa e um
void removeAttribute(String name) Remove deste ServletContext o atributo de
nome indicado.
35
Mtodo Descrio
void setAttribute(String name, Object object) Associa o objeto ao nome de atributo indicado
dentro deste ServletContext.
boolean setInitParameter(String name, String Atualiza o parmetro de inicializao de nome
value) indicado dentro deste ServletContext.
A Classe HttpServletRequest
Toda vez que um Servlet requisitado o container instancia um objeto do tipo
javax.servlet.HttpServletRequest e o repassa ao Servlet. Este objeto carrega os
dados da requisio, como seus cabealhos e parmetros.
Mtodo Descrio
String getContextPath() Retorna a poro do URI de request que
indica o contexto desta request.
Cookie[] getCookies() Retorna um array contendo todos os cookies
que o cliente enviou com esta request.
long getDateHeader(String name) Retorna o valor do cabealho especificado
como um long que representa uma data.
String getHeader(String name) Retorna o valor do cabealho especificado
como uma String.
Enumeration getHeaderNames() Retorna uma Enumeration com todos os
nomes de cabealho desta request.
Enumeration getHeaders(String name) Retorna todos os valores do cabealho
indicado como uma Enumeration de Strings.
int getIntHeader(String name) Retorna o valor do cabealho indicado como
um int.
String getMethod() Retorna o nome do mtodo HTTP usado para
gerar esta requisio.
String getParameter(String name) Retorna o valor do parmetro indicado como
uma String, ou null se ele no existir.
Enumeration getParameterNames() Retorna uma Enumeration de Strings
contendo os nomes dos parmetros recebidos
nesta requisio.
String[] getParameterValues(String name) Retorna um array de Strings com todos os
valores do parmetro indicado, ou null se ele
no existir.
String getRemoteUser() Retorna o login do usurio responsvel por
esta requisio, se ele fez login, ou null se no
fez.
String getRequestSessionId() Retorna a SessionId especificada pelo cliente.
HttpSession getSession() Retorna a Sesso associada com esta
requisio, ou se a requisio no tem uma
sesso cria uma.
36
Mtodo Descrio
HttpSession getSession(boolean create) Retorna a sesso associada com esta
requisio. Se no existe sesso e create
true, cria uma.
A Classe HttpServletResponse
Assim como acontece com os dados da requisio, cada vez que o servlet chamado o container
instancia um objeto do tipo javax.servlet.HttpServletResponse e o popula com os
dados da resposta.
Voc deve estar se perguntando Como assim, que dados da resposta? Eu ainda no enviei
nada..., mas verdade, o container j prepara uma resposta vazia e a entrega para o seu
servlet. Tudo o que voc precisa fazer preencher os espaos em branco.
Ocorre que uma resposta HTTP cheia de meandros... Imagine ter que preparar voc mesmo
todos aqueles cabealhos necessrios para que a resposta seja bem entendida pelo browser e
voc ver o quanto importante o trabalho do container: ele lhe entrega uma resposta pr-
cozida, quase pronta para ser entregue ao cliente. Voc s precisa gerar o HTML que ser
enviado.
Em outras palavras, voc pode imaginar o objeto response como um envelope carregando uma
carta pronta para ser enviada ao seu destinatrio (o browser). Tudo o que voc precisa fazer
pegar esta carta em branco e escrever sua mensagem (o seu cdigo HTML). O container faz o
resto.
Mtodo Descrio
void addCookie(Cookie cookie) Adiciona o cookie indicado resposta.
void addDateHeader(String name, long date) Adiciona o cabealho do tipo data indicado
resposta.
void addHeader(String name, String value) Adiciona o cabealho do tipo String
resposta.
void addIntHeader(String name, int value) Adiciona o cabealho do tipo inteiro
resposta.
boolean containsHeader(String name) Verifica se o cabealho j contm o elemento
indicado.
String getContentType() Obtm o tipo de contedo MIME usado para
enviar esta resposta.
String encodeRedirectURL(String url) Codifica a URL especificada para ser usada
com o mtodo sendRedirect().
String encodeURL(String url) Codifica a URL especificada, adicionando o
SessionId.
String getHeader(String name) Obtm o valor do cabealho de resposta
indicado.
Collection getHeaderNames() Obtm os nomes de todos os cabealhos nesta
resposta.
37
Mtodo Descrio
Collection getHeaders(String name) Obtm todos os valores do cabealho
indicado.
int getStatus() Retorna o status corrente desta resposta.
PrintWriter getWriter() Obtm um objeto do tipo PrintWriter que
pode ser usado para enviar dados de volta ao
cliente.
void sendError(int sc) Envia uma resposta de erro para o cliente
usando o status code informado.
void sendError(int sc, String msg) Envia uma resposta de erro para o cliente
usando o status code informado.
void sendRedirect(String location) Envia um redirecionamento temporrio para o
cliente usando a URL informada.
void setContentLength(int len) Define o tamanho do corpo desta resposta
(i.e., define o cabealho Content-Length).
void setContentType(String type) Define o tipo de contedo da resposta sendo
enviada para o cliente (i.e., define o cabealho
Content-Type).
Criando um Servlet com o NetBeans

Depois de criar uma aplicao web (voc pode continuar utilizando a que criou no captulo
anterior) clique em Arquivo > Novo Arquivo... e voc ver a tela mostrada abaixo:
38
Nesta janela voc indicar o tipo de arquivo que quer criar. Selecione Web e Servlet e
clique em Prximo.
Agora d um nome ao seu servlet.
39
Nesta janela interessante marcar o checkbox Adicionar informao ao descritor de

implementao (web.xml). Veremos o que isso significa em seguida.
Pronto, voc tem um Servlet no seu projeto.

AloMundoServlet.java
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class AloMundoServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
try {
out.println("<html>");
out.println(" <head>");
out.println(" <title>AloMundoServlet</title>");
out.println(" </head>");
out.println(" <body>");
out.println(" <h1>AloMundoServlet</h1>);
out.println(" </body>");
out.println("</html>");
} finally {
out.close();
}
}
}
Este provavelmente o Servlet mais simples do mundo, mas j serve para demonstrar as
funcionalidades principais.
Em primeiro lugar note os imports: todas as classes e interfaces da API de Servlets esto
includas no pacote javax.servlet ou em seus subpacotes. No caso de um Servlet HTTP a
40
grande maioria das classes estaro presentes no pacote javax.servlet.http. este o

caso das classes HttpServletRequest e HttpServletResponse, por exemplo.
Outro ponto importante a nossa classe em si. Note que ela estende a classe
javax.servlet.http.HttpServlet. Esse um ponto a nosso favor, pois agora temos
todo o poder do container em nossas mos (um Servlet apenas uma classe Java normal, exceto
pelo fato de que o container quem gerencia o seu ciclo de vida). E se o container vai gerenciar
o ciclo de vida, ento temos que ter maneiras de nos comunicarmos com ele, avisando-o sobre o
que queremos fazer e quando.
O principal meio de se fazer isso por meio da definio dos mtodos doGet() e doPost(),
por exemplo. Ao sobrescrevermos estes mtodos indicamos ao container o que queremos fazer
quando uma requisio do tipo GET ou POST alcanar o nosso Servlet. Estes mtodos recebem
dois parmetros, um objeto do tipo javax.servlet.http.HttpServletRequest e
outro do tipo javax.servlet.http.HttpServletResponse, que servem como nosso
ponto de acesso aos dados da requisio (os parmetros enviados por um formulrio, por
exemplo) e da resposta (o pacote que ser enviado de volta ao browser como resultado a
execuo do nosso Servlet).
No exemplo mostrado acima implementamos apenas o mtodo doGet(), ento nosso Servlet
s ser capaz de lidar com requisies do tipo GET (se tentarmos chamar o Servlet por meio de
uma requisio do tipo POST obteremos um erro HTTP cdigo 405 [Method not allowed]).
Ainda no nosso exemplo, tudo o que o nosso mtodo faz obter, a partir do objeto response
que recebeu como parmetro, um objeto do tipo PrintWriter no qual gravaremos nossa
mensagem (o cdigo HTML que queremos enviar ao cliente). Agora basta imprimir usando
out.println() e esse contedo ser enviado ao browser (e por isso que imprimimos
cdigo HTML).
O Deployment Descriptor
Mas criar o cdigo do Servlet no tudo. Precisamos dizer ao container a URL qual queremos
associar esta classe.
Para fazer isso usamos o deployment descriptor (descritor de implantao), um arquivo XML
que armazena as informaes a respeito de todos os servlets que temos em nossa aplicao.
O arquivo fica em /WEB-INF/web.xml.
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
<servlet>
<servlet-name>AloMundoServlet</servlet-name>
<servlet-class>AloMundoServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>AloMundoServlet</servlet-name>
<url-pattern>/AloMundoServlet</url-pattern>
</servlet-mapping>
<session-config>
<session-timeout>
41
30
</session-timeout>
</session-config>
</web-app>
A tag <servlet> define um servlet, ento voc pode ter mltiplas tags deste tipo dentro do
seu arquivo web.xml. L dentro voc encontrar outras duas tags. A primeira, <servlet-
name>, indica um nome lgico para o seu servlet, o nome pelo qual voc vai se referir a ele
dentro deste arquivo. J a segunda, <servlet-class>, o nome plenamente qualificado da
classe que implementa o seu servlet (ou seja, o nome da classe precedido pelos nomes dos seus
pacotes, como por exemplo br.com.alfamidia.agenda.Servlet).
A outra tag, <servlet-mapping> define as URLs que sero utilizadas para invocar seu
Servlet. L dentro voc encontrar outras duas tags: <servlet-name> repete o nome lgico
do Servlet conforme voc definiu em <servlet> (criando assim um vnculo entre as tags
<servlet> e <servlet-mapping>, o que nos permite saber qual URL est associada a
qual classe Java); <url-pattern> indica o padro de URL que voc gostaria de usar para
invocar seu Servlet. Voc pode usar qualquer coisa como um padro de URL: se colocar por
exemplo /servlet, toda vez que o usurio informar no browser uma URL terminando com
aquele valor invocar o seu Servlet:
<url-pattern>/servlet</url-pattern>
Por exemplo:
http://localhost:8080/WebApp1/servlet
Voc tambm pode utilizar o wildcard *, indicando que parte do texto irrelevante, desde que a
outra parte siga o padro:
<url-pattern>/*.servlet</url-pattern>
Este padro casar com qualquer coisa que termine com .servlet, como por exemplo:
http://localhost:8080/WebApp1/qualquercoisa.servlet
Usando o padro certo voc pode at fingir que est carregando um arquivo JPG...
http://localhost:8080/WebApp1/arquivo.jpg
Ecoando os Dados da Requisio

O Servlet de exemplo mostrado abaixo exibe muitas das informaes que podemos obter a
partir dos objetos HttpServletRequest e ServletContext.
Echo.java
import java.io.PrintWriter;
import java.util.Enumeration;
public class Echo extends HttpServlet {
protected void processRequest(HttpServletRequest request,
response.setContentType("text/html;charset=ISO-8859-1");
PrintWriter out = response.getWriter();
try {
42
out.println("<html>");
out.println(" <head>");
out.println(" <title>Echo</title>");
out.println(" </head>");
out.println(" <body>");
out.println(" <h1>Echo Servlet em "
+ request.getContextPath() + "</h1>");
out.println(" <h2>Dados da Requisio</h2>");
out.println(" <h3>Dados Gerais</h3>");
out.println(" contextPath: "
+ request.getContextPath() + "<br />");
out.println(" localAddr: "
+ request.getLocalAddr() + "<br />");
out.println(" localName: "
+ request.getLocalName() + "<br />");
out.println(" localPort: "
+ request.getLocalPort() + "<br />");
out.println(" method: "
+ request.getMethod() + "<br />");
out.println(" protocol: "
+ request.getProtocol() + "<br />");
out.println(" remoteAddr: "
+ request.getRemoteAddr() + "<br />");
out.println(" remoteHost: "
+ request.getRemoteHost() + "<br />");
out.println(" requestURI: "
+ request.getRequestURI() + "<br />");
out.println(" serverName: "
+ request.getServerName() + "<br />");
out.println(" servletPath: "
+ request.getServletPath() + "<br />");
out.println(" serverPort: "
+ request.getServerPort() + "<br />");
out.println(" <h3>Cabealhos</h3>");
Enumeration<String> cabecalhos = request.
getHeaderNames();
while (cabecalhos.hasMoreElements()) {
String nomeDoCabecalho = cabecalhos.nextElement();
String valorDoCabecalho = request.getHeader(
nomeDoCabecalho);
out.println(" " + nomeDoCabecalho + ": "
+ valorDoCabecalho + "<br />");
}
out.println(" <h2>Parmetros</h2>");
Enumeration<String> parametros = request.
getParameterNames();
while (parametros.hasMoreElements()) {
String nomeDoParametro = parametros.nextElement();
String valorDoParametro = request.getParameter(
nomeDoParametro);
out.println(" " + nomeDoParametro + ": "
+ valorDoParametro + "<br />");
}
43
out.println(" <h2>Dados do Contexto</h2>");

out.println(" contextPath: "
+ request.getServletContext().getContextPath()
+ "<br />");
out.println(" effectiveMajorVersion: "
+ request.getServletContext().
getEffectiveMajorVersion() + "<br />");
out.println(" effectiveMinorVersion: "
+ request.getServletContext().
getEffectiveMinorVersion() + "<br />");
out.println(" majorVersion: "
+ request.getServletContext().getMajorVersion()
+ "<br />");
out.println(" minorVersion: "
+ request.getServletContext().getMinorVersion()
+ "<br />");
out.println(" <p>");
out.println(" <a href=\"" +
request.getRequestURI() + "\">Recarregar</a>");
out.println(" </p>");
out.println(" </body>");
out.println("</html>");
} finally {
out.close();
}
}
@Override
processRequest(request, response);
}
@Override
protected void doPost(HttpServletRequest request,
processRequest(request, response);
}
@Override
public String getServletInfo() {
return "Short description";
}
}
mvfm, 2012-02-22, Alfamdia
44
Captulo 6 JSPs
A API de JSPs
Servlets so realmente muito teis, mas so complicados demais para se manter, pois criar
pginas longas fica praticamente invivel, j que o cdigo HTML e o cdigo Java ficam
misturados. Entre outras coisas isso faz com que seja difcil delegar o design para uma equipe
especializada, j que voc teria que entregar seu cdigo Java junto (voc no quer designers
mexendo no seu cdigo Java, quer?).
As JavaServer Pages vieram para inverter esta perspectiva:
O cdigo principal HTML, ao invs de Java.
Usando beans e JSTL fica muito mais fcil separar forma de contedo.
index.jsp
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@page import="java.util.Date"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type"
content="text/html; charset=UTF-8">
<meta http-equiv="Refresh" content= "1; URL=index.jsp">
<title>JSP Page</title>
</head>
<body>
<h1>Hello World!</h1>
<%= new Date() %>
</body>
</html>
Por mais que os dois paream to diferentes, JSPs e Servlets no esto to distantes assim. Na
verdade eles so muito parecidos. Se voc parar para pensar, um Servlet s um JSP virado ao
avesso.
De fato, arquivos JSP so convertidos para Servlets em tempo real: toda vez que chega uma
requisio para um JSP o container verifica se j o conhece. Se ainda no, ento recupera o
cdigo fonte do JSP, valida e gera um Servlet que o representa. Todo o cdigo Java usados no
documento JSP vira trechos de cdigo no mtodo _jspService(HttpServletRequest
request, HttpServletResponse response) no Servlet gerado. O servlet ento
compilado e executado, e seu resultado enviado de volta para o cliente. Ao mesmo tempo, o
45
Servlet gerado guardado em cache, para que no seja necessrio refazer a compilao na
ocasio de uma nova requisio.
Tags JSP
Um documento JSP mistura HTML e Java. No entanto precisamos de uma maneira para marcar
claramente onde o cdigo Java comea, pois o container precisa saber como diferenciar o
cdigo que precisa apenas ser copiado para a sada (o HTML) daquele que precisa ser executado
(o Java).
Para isso foram criadas cinco tags especiais:
Diretivas;
Declaraes;
Expresses;
Scriptlets;
Comentrios.
Diretivas
Diretivas so mensagens para o container JSP, e servem para definir atributos ou especificar
dependncias, de forma que o container possa gerar um cdigo compilvel.
A sintaxe geral :
<%@ diretiva atributo=valor [atributo2=valor2 ...] %>
Ou, na sintaxe XML:
<jsp:directive.diretiva atributo=valor [atributo2=valor2 ...] />
A Diretiva page
A diretiva page permite definir atributos da pgina como o seu tipo de contedo, tamanho do
buffer ou a lista de classes que precisam ser importadas para que o documento JSP seja
compilado com sucesso.
A sintaxe geral :
<%@ page atributo=valor [atributo2=valor ...] %>
Ou, na sintaxe XML:
<jsp:directive.page atributo=valor [atributo2=valor ...] />
Atributo Descrio
import=package.class Permite importar classes necessrias ao
ou arquivo JSP, da mesma maneira que uma
import=package.class[, package.class ...] instruo import atua em um cdigo fonte
Java.
contentType=tipo-mime Especifica o tipo MIME de sada.
isThreadSafe=true | false Indica se seguro executar mais de uma
instncia deste JSP simultaneamente.
session=true | false Indica se queremos trabalhar com a varivel
implcita session ou no. Caso negativo o
objeto implcito no ser declarado.
46
Atributo Descrio
buffer=size-in-kBytes Indica o tamanho do buffer a ser usado
enquanto esta pgina gerada.
autoFlush=true | false Indica se o container deve enviar o contedo
do buffer quando este estiver cheio.
info=mensagem Define uma String que pode ser recuperada
com getServletInfo().
errorPage=url Aponta para uma URL que deve ser chamada
no caso da ocorrncia de um erro.
isErrorPage=true | false Indica se esta uma pgina de tratamento de
erros.
language=Java Define a linguagem na qual esta pgina foi
escrita.
A Diretiva include
A diretiva include permite incluir arquivos no momento em que a pgina JSP convertida
em um Servlet.
Assim, se temos um trecho de cdigo HTML ou JSP que se repete em muitas pginas, podemos
coloc-lo em um arquivo em separado e inclu-lo nos arquivos que precisam, evitando a
redundncia e facilitando a manuteno.
A sintaxe geral :
<%@ include file=URL relativa %>
Ou, na sintaxe XML:
<jsp:directive.include file=URL relativa />
Veja o exemplo:
<%@ include file=/meu-arquivo.html %>
Declaraes
Uma declarao permite definir atributos ou mtodos que sero inseridos no corpo do Servlet
gerado a partir de um documento JSP.
A sintaxe geral :
<%! Declarao em Java %>
Ou, na sintaxe XML:
<jsp:declaration> Declaraes em Java </jsp:declaration>
Veja os exemplos:
<%! private int numeroDeAcessos = 0 %>
<jsp:declaration>
private void sayHello() {
out.println(Hello world !);
}
</jsp:declaration>
47
Um uso particularmente importante para as declaraes de mtodos o tratamento de eventos

ligados ao ciclo de vida de uma pgina JSP.
Evento de Inicializao
Ocorre na primeira vez em que o container JSP recebe uma solicitao para uma determinada
pgina.
public void jspInit()
Voc pode declarar este mtodo para gerenciar recursos dos quais precisar durante a execuo
da pgina, como por exemplo efetuar conexes ao banco de dados ou estabelecer conexes de
rede.
Evento de Destruio
Ocorre quando o container JSP est prestes a descarregar uma pgina JSP, seja porque o
container est sendo desligado ou porque a pgina no tenha sido usada recentemente e o
container precisa reclamar os recursos.
public void jspDestroy()
Voc pode declarar este mtodo para liberar os recursos alocados durante a execuo do mtodo
jspInit().
Expresses
Tags de expresses avaliam o seu contedo e exibem o resultado dentro do HTML gerado.
A Sintaxe geral :
<%= expresso Java %>
Ou, na sintaxe XML:
<jsp:expression> expresso Java </jsp:expression>
Veja os exemplos:
<%= request.getMethod() %>
Ou ento:
<jsp:expression> new java.util.Date() </jsp:expression>
Scriptlets
Scriptlets so provavelmente as tags mais usadas nos documentos JSP, especialmente enquanto
ainda estamos aprendendo a tecnologia. Eles so usados para incluir cdigo Java arbitrrio
dentro de um documento JSP. Este cdigo ser portado sem modificaes para dentro do
mtodo _jspService() do Servlet gerado.
A sintaxe geral :
<% cdigo Java %>
Ou, na sintaxe XML:
<jsp:scriptlet> cdigo Java </jsp:scriptlet>
Veja um exemplo:
<%
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
out.print(i);
out.println(<br>);
}
48
}
%>
Comentrios
Tags de comentrio evitam que o seu corpo seja processado e levado para dentro do Servlet.
A sintaxe :
<%-- comentrio --%>
Veja o exemplo:
<%-- Este cdigo est desabilitado:
out.print(new java.util.Date());
out.println(<br>);
--%>
claro que voc ainda pode usar comentrios HTML (), mas isso
no vai evitar que eventual cdigo JSP presente dentro dele seja processado.
Objetos Implcitos
O container JSP disponibiliza muitos dos seus objetos para o desenvolvedor JSP. Estes objetos
so chamados de implcitos porque a sua disponibilizao nas pginas JSP automtica.
Os objetos implcitos do acesso a algumas funes do container e nos possibilitam armazenar
informaes que sero utilizadas entre mltiplas chamadas.
Objeto Classe Descrio
page javax.servlet.jsp.HttpJspPage Instncia do Servlet da
pgina.
config javax.servlet.ServletConfig Dados de configurao do
Servlet.
request javax.servlet.http.HttpServletRequest Dados da requisio,
incluindo seus
parmetros.
response javax.servlet.http.HttpServletResponse Dados da resposta.
out javax.servlet.jsp.JspWriter Fluxo de sada para o
contedo da pgina.
session javax.servlet.http.HttpSession Dados da sesso
especfica de usurio.
application javax.servlet.ServletContext Dados compartilhados por
todas as pginas da
aplicao.
pageContext javax.servlet.PageContext Dados de contexto para
execuo da pgina.
exception java.lang.Throwable Uma exceo que ocorreu
em um documento JSP.
49
Gerenciando Atributos
Quatro dos objetos implcitos possuem como caracterstica em comum a habilidade de
armazenar e recuperar dados arbitrrios:
pageContext
request
session
application
Podemos utilizar estes objetos, ento, como espao de armazenamento temporrio ou mesmo
para transferir informaes entre pginas diferentes, ou mesmo entre usurios diferentes.
Mtodo Descrio
Object getAttribute(String name) Retorna o valor do atributo indicado, ou null
se o atributo no existe no contexto indicado.
Enumeration getAttributeNames() Retorna uma Enumeration contendo os nomes
de todos os atributos disponveis no contexto
indicado.
void removeAttribute(String key) Remove o atributo indicado do contexto
indicado.
void setAttribute(String name, Object value) Cria ou substitui o atributo nomeado, dando-
lhe o valor indicado.
Armazenando um Objeto
Para que voc possa armazenar uma informao em qualquer um dos contextos citados voc
usar o mtodo setAttribute(String key, Object value). Este mtodo recebe
dois argumentos, uma chave (que representa um identificador nico para o objeto que se deseja
armazenar) e um valor (o dado em questo). Veja o exemplo:
<%
String nomeDoUsuario = "mvfm";
session.setAttribute("login", nomeDoUsuario);
%>
No exemplo acima armazenamos a informao contida na varivel nomeDoUsuario dentro
do contexto de sesso, sob a chave login. Quando quisermos recuperar esta informao, seja
na mesma pgina, seja em outra para a qual o usurio navegou, devemos utilizar a mesma
chave.
Recuperando um Objeto
Quando precisarmos recuperar uma informao a partir de um dos objetos de contexto
precisaremos usar o mtodo getAttibute(String key), o qual recebe como parmetro o
identificador nico do objeto que se deseja recuperar. Este identificador nico, obviamente, tem
que ser o mesmo que foi usado quando colocamos a informao no contexto. Veja o exemplo:
<%
String login = (String) session.getAttribute("login");
%>
Note que o mtodo getAttribute() sempre retorna um dado do tipo Object, ento
precisamos fazer o cast para que possamos dispor do dado em seu estado original.
50
O Objecto pageContext
O objeto pageContext uma instncia da classe javax.servlet.jsp.PageContext,
e alm de ser capaz de armazenar dados arbitrrios, oferece mtodos para acessar os demais
contextos e seus atributos, bem como ferramentas para encaminhar a requisio corrente para
outras pginas ou incluir arquivos externos na sada.
Alm disso, pageContext ainda fornece acesso ao JspWriter usado para gerar a sada,
embora tipicamente voc no precise fazer isso de maneira explcita, j que a API j oferece o
objeto out automaticamente.
Mtodo Descrio
void forward(String relativeUrlPath) Encaminha os objetos request e response
correntes para outra pgina na mesma
aplicao.
Exception getException() Retorna o valor corrente do objeto implcito
exception.
Object getPage() Retorna o valor corrente do objeto page (o
Servlet gerado para este documento JSP).
ServletRequest getRequest() Recupera o valor corrente do objeto implcito
request.
ServletResponse getResponse() Recupera o valor corrente do objeto implcito
response.
ServletConfig getServletConfig() Recupera o valor corrente do objeto implcito
config.
ServletContext getServletContext() Retorna o valor corrente do objeto implcito
application.
HttpSession getSession() Retorna o valor corrente do objeto implcito
session.
void include(String relativeUrlPath) Inclui o output do processamento do URL
local.
void setAttribute(String name, Object value, Adiciona o valor ao contexto indicado, usando
int scope) key como chave.
Enumeration getAttributeNamesInScope(int Recupera os nomes de todos os atributos
scope) presentes em um determinado escopo.
Object getAttribute(String name, int scope) Recupera o valor de um atributo em um
determinado escopo.
void removeAttribute(String name, int scope) Remove o atributo indicado do escopo
especificado.
Object findAttribute(String name) Recupera o valor do atributo indicado,
buscando em todos os escopos.
int getAttributeScope(String name) Retorna o escopo no qual o atributo nomeado
est armazenado.
51
O Objeto request
O objeto request uma instncia da interface
javax.servlet.http.HttpServletRequest e gerenciado pelo container para
representar uma requisio chegando a um Servlet ou documento JSP.
Este objeto tambm pode ser usado para armazenar dados arbitrrios.
Mtodo Descrio
String getContextPath() Retorna a poro da URI de request que
indica o contexto desta request.
Cookie[] getCookies() Retorna um array contendo todos os cookies
que o cliente enviou com esta request.
long getDateHeader(String name) Retorna o valor do cabealho especificado
como um long que representa uma data.
String getHeader(String name) Retorna o valor do cabealho especificado
como uma String.
Enumeration getHeaderNames() Retorna uma Enumeration com todos os
nomes de cabealho desta request.
Enumeration getHeaders(String name) Retorna todos os valores do cabealho
indicado como uma Enumeration de Strings.
int getIntHeader(String name) Retorna o valor do cabealho indicado como
um int.
String getMethod() Retorna o nome do mtodo HTTP usado para
gerar esta requisio.
String getParameter(String name) Retorna o valor do parmetro indicado como
uma String, ou null se ele no existir.
Enumeration getParameterNames() Retorna uma Enumeration de Strings
contendo os nomes dos parmetros recebidos
nesta requisio.
String[] getParameterValues(String name) Retorna um array de Strings com todos os
valores do parmetro indicado, ou null se ele
no existir.
String getRemoteUser() Retorna o login do usurio responsvel por
esta requisio, se ele fez login, ou null se no
fez.
String getRequestSessionId() Retorna a SessionId especificada pelo cliente.
HttpSession getSession() Retorna a Sesso associada com esta
requisio, ou se a requisio no tem uma
sesso cria uma.
HttpSession getSession(boolean create) Retorna a Sesso associada com esta
requisio. Se no existe sesso e create
true, cria uma.
52
O Objeto session
O objeto session uma instncia da interface javax.servlet.http.HttpSession e
prov uma maneira de identificar um usurio nico por entre vrias requisies.
Este objeto criado pelo container para criar uma sesso entre o usurio e o servidor. Esta
sesso persiste por um determinado tempo desde que novas solicitaes continuem sendo
recebidas sem que este perodo se transcorra.
Mtodo Descrio
long getCreationTime() Retorna a hora em que esta sesso foi criada.
String getId() Retorna o ID desta sesso.
long getLastAcessedTime() Retorna a hora em que a ltima solicitao
associada a esta requisio foi recebida.
int getMaxInactiveInterval() Retorna o tempo mximo (em segundos) para
o qual esta sesso ser mantida.
void invalidate() Descarta a sesso, liberando quaisquer valores
armazenados como atributos.
boolean isNew() Retorna true se o navegador do usurio ainda
no tiver confirmado o ID da sesso.
void setMaxInactiveInterval(int interval) Define o tempo mximo (em segundos) para o
qual esta sesso ser mantida.
Percebendo Que Dados Foram Acrescentados Ou Removidos da Sesso

Java oferece um mecanismo de notificao que lhe avisa quando um objeto adicionado ou
removido da sesso. Para fazer uso deste recurso basta que os seus objetos implementem a
interface javax.servlet.http.HttpSessionBindingListener.
Esta interface define dois mtodos:
Mtodo Descrio
void valueBound(HttpSessionBindingEvent Chamado quando o objeto adicionado a uma
event) sesso.
void valueUnbound(HttpSessionBindingEvent Chamado quando o objeto removido da
event) sesso, inclusive quando a sesso est prestes
a ser expirada.
Quando o Cliente No Aceita a Sesso

Pginas JSP devem ser capazes de lidar com aqueles casos em que o cliente escolhe no
participar de uma sesso (como por exemplo quando os cookies esto desligados). At que o
cliente se junte sesso o mtodo isNew() vai retornar true.
Se o cliente optar por no se juntar sesso:
O mtodo getSession() retornar uma nova sesso a cada chamada.
O mtodo isNew() sempre retornar true.
Assim, em uma pgina interna para a qual o usurio no tem acesso direto, se voc perguntar se
a sesso nova e obtiver true como resultado, ento provavelmente o servidor no foi capaz
53
de estabelecer uma sesso para aquele usurio. Neste caso, colocar dados no contexto de sesso
completamente intil.
O Objeto application
O objeto application uma instncia da interface
javax.servlet.ServletContext, a qual define um conjunto de mtodos que um
documento JSP pode utilizar para se comunicar com o container.
Assim como acontece com os objetos pageContext, request e session,
application tambm pode ser usado para armazenar valores arbitrrios. Estes valores
ficam disponveis para todas as pginas e usurios da aplicao.
Mtodo Descrio
Object getAttribute(String name) Retorna o atributo do container com o nome
indicado, ou null se ele no existe.
Enumeration<String> getAttributeNames() Retorna uma Enumeration com os nomes dos
atributos existentes neste ServletContext.
ServletContext getContext(String uripath) Retorna o ServletContext que corresponde
URL indicada.
String getContextPath() Retorna o nome do diretrio da aplicao
corrente.
int getEffectiveMajorVersion() Retorna o nmero de verso da especificao
Servlet que este contexto utiliza.
int getEffectiveMinorVersion() Retorna o nmero da subverso da
especificao Servlet que este contexto utiliza.
int getMajorVersion() Retorna o nmero de verso da especificao
Servlet suportada por este container.
String getMimeType(String file) Retorna o MIME type do arquivo indicado, ou
null se ele for desconhecido.
int getMinorVersion() Retorna o nmero da subverso da
especificao Servlet suportada por este
container.
String getRealPath(String path) Retorna o diretrio real correspondente ao
diretrio virtual (URI) indicado.
Servlet.
54
Mtodo Descrio
void log(String message, Throwable t) Escreve uma mensagem explicative e um
void removeAttribute(String name) Remove deste ServletContext o atributo de
nome indicado.
void setAttribute(String name, Object object) Associa o objeto ao nome de atributo indicado
dentro deste ServletContext.
boolean setInitParameter(String name, String Atualiza o parmetro de inicializao de nome
value) indicado dentro deste ServletContext.
O Objeto exception
O objeto implcito exception fornecido com o intuito de tratamento de erros em JSP.
Este objeto est disponvel apenas s pginas que tenham sido designadas como pginas de
tratamento de erro por meio do atributo isErrorPage da diretiva page.
Pginas comuns tipicamente vo incluir uma diretiva semelhante mostrada abaixo:
<%@page errorPage=erro.jsp%>
Neste caso, quando um erro ocorrer durante o processamento daquela pgina, o controle
transferido automaticamente para a pgina de tratamento de erros indicada (no caso,
erro.jsp).
A pgina de tratamento de erros, por sua vez, precisar incluir a diretiva mostrada abaixo:
<%@page isErrorPage=true%>
Neste caso, quando o controle for transferido para esta pgina pelo container, ela receber ainda
um objeto implcito chamado exception. Este objeto uma instncia de
java.lang.Throwable e representa o erro que fez com que o controle fosse transferido
para a pgina atual.
Abaixo demonstramos os principais mtodos de Throwable:
Mtodo Descrio
String getMessage() Retorna a mensagem de erro descritiva
associada exceo quando ela foi lanada.
void printStackTrace(PrintWriter out) Imprime a pilha de execuo em
funcionamento quando a exceo foi lanada.
String toString() Retorna uma String combinando o nome da
classe da exceo com sua mensagem de erro,
se houver alguma.
Uma Pgina de Tratamento de Erros

Uma pgina de tratamento de erros serve para informar ao usurio que uma situao anormal
ocorreu. Ela tem a diretiva <%@page isErrorPage="true"%> em seu topo, indicando
ao container que o objeto implcito exception deve ser criado. O container redirecionar para
esta pgina automaticamente sempre que pginas marcadas com a diretiva <%@page
errorPage="erro.jsp"%> apontar para esta pgina.
55
erro.jsp
<%@page import="java.io.PrintWriter"%>
<%@page import="java.io.StringWriter"%>
<%@page isErrorPage="true"%>
<html>
<head>
content="text/html; charset=ISO-8859-1">
<title>Erro</title>
</head>
<body>
<h1>Erro</h1>
<p>
O erro a seguir ocorreu:<br>
<b><%= exception %></b><br>
</p>
<pre>
<%
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
exception.printStackTrace(pw);
out.print(sw);
%>
</pre>
</body>
</html>
56
Captulo 7 JSP Actions
Anteriormente examinamos 5 tipos de tags JSP:

Diretivas;
Declaraes;
Expresses;
Scriptlets;
Comentrios.
Aes so um novo tipo de tag, e tem dois papis importantes:
Permitem a transferncia de contedo entre pginas;
Permitem que pginas JSP interajam com objetos JavaBean residindo no servidor.
Aes Bsicas
A Tag <jsp:forward>
A tag <jsp:forward> usada para transferir permanentemente o controle de uma pgina
JSP para outro documento no servidor local.
Note que qualquer contedo que tenha sido gerado pela pgina atual descartado.
O navegador no notificado, ento o usurio no perceber que a sua requisio foi
encaminhada para outro endereo.
A sintaxe geral :
<jsp:forward page=URL local />
Ou:
<jsp:forward page=URL local>
<jsp:param name=parametro value=valor />
<jsp:param name=parametro2 value=valor2 />
</jsp:forward>
A Tag <jsp:include>
A tag <jsp:include> permite a incorporao do contedo gerado por outro documento no
documento atual.
O output do documento includo inserido no output da pgina corrente, e a seguir o
processamento retorna pgina corrente.
A pgina includa pode ser um documento esttico, um CGI, um Servlet ou mesmo outro
documento JSP.
57
A sintaxe geral :
<jsp:include page=URL local flush=true />
Note que a seo flush=true obrigatria a partir da especificao JSP 1.1.
Ou:
<jsp:include page=URL local flush=true>
<jsp:param name=parametro value=valor />
<jsp:param name=parametro2 value=valor2 />
</jsp:include>
Componentes JavaBeans
O uso de componentes JavaBeans em pginas JSP visa afastar a necessidade de se programar
diretamente dentro do JSP.
Esta capacidade de abstrao muito benfica, pois proporciona a diviso de trabalhos entre
designers / programadores. Tudo o que o designer precisa fazer incorporar algumas tags
simples no cdigo fonte HTML. Estas tags parecem HTML, ento seus elementos e atributos
so facilmente reconhecveis pelos designers e suas ferramentas.
O programador, por sua vez, pode programar a aplicao sem sequer tomar conhecimento de
como seus componentes sero usados em pginas JSP.
Parece mgica?
Carro.java
package modelo;
public class Carro {
private String nome;
private int potencia;
private int giros;
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public int getPotencia() {
return potencia;
}
public void setPotencia(int potencia) {
this.potencia = potencia;
}
public int getGiros() {
return giros;
}
public void setGiros(int giros) {
this.giros = giros;
}
}
No cdigo acima, note que a classe Carro uma classe Java comum, com alguns atributos
privados e seus respectivos getters e setters. Agora vamos mostrar como inserir esta classe em
um documento JSP por meio de uma tcnica que ficou conhecida como Componente JavaBean.
58
index.jsp
<jsp:useBean id="carro" class="modelo.Carro" scope="session" />
<jsp:setProperty name="carro" property="nome" value="Passat" />
<html>
<head>
<title>Um Carro</title>
</head>
<body>
<h1>Um Carro</h1>
<b>Nome:</b>
<jsp:getProperty name="carro" property="nome" /><br>
<b>Potncia:</b>
<jsp:getProperty name="carro" property="potencia" />
Cavalos<br>
<b>Giros do Motor:</b>
<jsp:getProperty name="carro" property="giros" /> RPM<br>
</body>
</html>
O documento JSP acima comea com o uso da tag <jsp:useBean>, a qual vincula a classe
criada anteriormente pgina. Depois, tags <jsp:getProperty> e
<jsp:setProperty> leem e gravam dados dos/nos atributos da classe, sem que para isso
seja necessrio usar nenhum cdigo Java explcito dentro da pgina.
Diretrizes Bsicas
Teoricamente qualquer classe Java pode ser usada como um componente JSP. No entanto, estas
classes precisam seguir algumas diretrizes bsicas:
Fazer parte de um pacote arbitrrio;
Incluir um construtor pblico que no recebe parmetros;
Seguir a notao JavaBean para a leitura e escrita de atributos, em especial:
o Toda propriedade passvel de leitura deve oferecer um mtodo pblico <Tipo>
getPropriedade() que no recebe argumentos e retorna o atributo em questo.
o Toda propriedade passvel de escrita deve oferecer um mtodo pblico void
setPropriedade(<tipo> propriedade).
Note que o container JSP faz todas as converses de tipo para voc conforme a necessidade,
desde que eles sejam de tipos primitivos ou, no mximo, String.
A Tag <jsp:useBean>
A tag useBean indica que voc deseja usar um bean na pgina. Voc precisa indicar pelo
menos dois atributos:
Um apelido para o bean;
O nome da classe.
Veja a sintaxe:
<jsp:useBean id=apelido class=classe />
59
Ou:
<jsp:useBean id=apelido class=classe>
Cdigo de inicializao.
</jsp:useBean>
Atributo Descrio
id Um identificador para o bean, o seu apelido.
scope O escopo para o bean (pageScope, request,
session, application). O default page.
class O nome da classe que implementa o bean.
A Tag <jsp:getProperty>
A tag <jsp:getProperty> a maneira de que dispomos para recuperar o valor de uma
propriedade em um bean.
Diferente da tag <jsp:useBean>, que realiza alguma operao de background mas no exibe
nada, <jsp:getProperty> sempre resultar em alguma coisa que poderemos ver no cdigo
HTML gerado. Ela semelhante tag de expresso <%= ... %>.
Esta tag possui apenas dois atributos e no possui corpo.
Atributo Descrio
name Indica o apelido do bean cuja propriedade
queremos acessar (o atributo id usado ao
incorporarmos o bean pgina por meio da
tag useBean).
property Indica o nome da propriedade que queremos
acessar naquele bean.
A classe Java que implementa o bean precisa
definir um mtodo getter correspondente
propriedade sendo recuperada.
A Tag <jsp:setProperty>
Usamos a tag <jsp:setProperty> para alterar o valor de uma propriedade em um bean.
Cabe ao programador do bean implementar a lgica para fazer algo de til com os valores
estabelecidos como propriedades e disponibilizar informao computacional pgina JSP por
meio dos mtodos get().
A maioria dos beans precisar de uma srie de configuraes (chamadas aos mtodos set())
para que esteja pronto para realizar qualquer servio. Normalmente os mtodos get() e
set() so cdigos burros, que apenas atribuem valores aos atributos.
Porm, vez por outra, estes cdigos podem implementar inteligncia, a sim executando alguma
operao mais complexa ao invs de simplesmente atribuir ou recuperar os valores dos
atributos.
Atributo Descrio
name Indica o nome do bean cuja propriedade deve
ser alterada.
60
Atributo Descrio
property Indica o nome da propriedade a alterar.
value Indica o valor a ser atribudo propriedade.
param Indica o parmetro da requisio que ceder o
seu valor propriedade indicada.
A Tag <jsp:setProperty> e a Requisio

Como vimos antes, a propriedade param da tag <jsp:setProperty> pode ler diretamente
um valor chegando ao documento JSP por meio da requisio.
Assim, os dois cdigo abaixo fazem exatamente o mesmo:
<jsp:setProperty name=meuBean
property=minhaProperty
param=meuParam
/>
<jsp:setProperty name=meuBean
property=minhaProperty
value=<%= request.getParameter(meuParam) %>
/>
Note que podemos encadear as tags <jsp:setProperty> e <%= ... %>.
Para facilitar ainda mais o trabalho, JSP oferece um coringa que pode ser usado para casar
automaticamente propriedades e parmetros:
<jsp:setProperty name=meuBean property=* />
O coringa * far com que toda propriedade do bean que tiver um parmetro correspondente na
requisio receba automaticamente o valor do parmetro.
Isso s funciona, claro, se ambos propriedade e parmetro tiverem o mesmo nome.
61
Captulo 8 Expression Language
A Expression Language (EL) foi introduzida com a especificao JSP 2.0 e visa facilitar a
incluso de variveis e objetos em um documento JSP.
Inspirada tanto em JavaScript quanto XPath, a Expression Language possibilita a avaliao de
expresses fora dos elementos JSP, por meio de uma sintaxe simples e fcil de entender.
Elementos da EL podem ser usados em duas situaes:
Como atributos nas JSP Actions (padro ou customizadas);
Em texto de template, como HTML ou elementos no JSP. Neste caso o contedo da
EL avaliado e seu resultado embutido dentro do texto de template.
Carro.java
package modelo;
public class Carro {
private String nome;
private int potencia;
private int giros;
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public int getPotencia() {
return potencia;
}
public void setPotencia(int potencia) {
this.potencia = potencia;
}
public int getGiros() {
return giros;
}
public void setGiros(int giros) {
this.giros = giros;
}
}
index.jsp
<jsp:useBean id="carro" class="modelo.Carro" scope="session" />
<jsp:setProperty name="carro" property="nome" value="Passat" />
<html>
62
<head>
<title>Um Carro</title>
</head>
<body>
<h1>Um Carro</h1>
<b>Nome:</b>
${carro.nome}<br>
<b>Potncia:</b>
${carro.potencia} Cavalos<br>
<b>Giros do Motor:</b>
${carro.giros} RPM<br>
</body>
</html>
O Operador .
Expresses em EL esto sempre dentro de chaves, precedidas pelo smbolo de dlar:
${pessoa.nome}
Normalmente vemos uma expresso, um ponto e uma segunda expresso.
A parte esquerda do ponto o nome de um objeto implcito ou de um atributo.
A parte direita do ponto a chave de um map (se a primeira parte for um map) ou o nome de
uma propriedade bean (se a primeira parte for um bean).
Tal como um atributo bean, a parte direita precisa seguir as convenes de nomenclatura Java:
Comear com uma letra, _ ou $;
A partir do segundo caractere o nome pode incluir nmeros;
No pode ser uma palavra reservada Java.
Veja uma tabela demonstrativa:
${primeiracoisa.segundacoisa}
o primeiracoisa
OBJETO IMPLCITO DA EL
pageScope
requestScope
sessionScope
applicationScope
param
paramValues
header
headerValues
cookie
initParam
63
pageContext
ATRIBUTO
No pageScope
No requestScope
No sessionScope
No applicationScope
o segundacoisa
SE primeiracoisa FOR UM java.util.Map
Uma chave do Map
SE primeiracoisa FOR UM BEAN
Um atributo do Bean
O Operador [
O operador . s funciona quando o que est direita for uma chave map ou uma propriedade
bean para o que est esquerda.
Mas e se a parte esquerda for um array?
Ou uma List?
Ou se a parte direita for algo que no se pode expressar com as regras de nomenclatura
Java?
O operador [, por sua vez, muito mais poderoso:
Isto:
${pessoa[nome]}
igual a isso:
${pessoa.nome}
Veja uma tabela demonstrativa:
${primeiracoisa[segundacoisa]}
o primeiracoisa
java.util.Map
um bean
java.util.List
um array
o segundacoisa
a chave do Map
um atributo do bean
o ndice da List
o ndice do array
Usando Arrays
Suponha que em um determinado momento voc executasse o seguinte cdigo:
String pessoas[] = {"Adriana", "Bernardo", "Cludia", "Daniel"};
request.setAttribute(pessoas, pessoas);
64
Ento, se executasse os cdigos abaixo, obteria as respostas mostradas:

O Cdigo JSP Resulta Em
As pessoas ${pessoas} As pessoas: [Ljava.lang.String;@3e25a5
A primeira pessoa: ${pessoas[0]} A primeira pessoa: Adriana
A segunda pessoa: ${pessoas[1]} Bernardo
Usando Lists
A sintaxe EL para acessar uma List exatamente a mesma que usamos para acessar um array.
Suponha que em algum ponto voc executou o cdigo a seguir:
List pessoas = new ArrayList();
pessoas.add(Adriana);
pessoas.add(Bernardo);
pessoas.add(Cludia);
pessoas.add(Daniel);
request.setAttribute(pessoas, pessoas);
Ento, se em uma pgina JSP, voc executasse os cdigos abaixo, obteria as respostas
indicadas:
As pessoas ${pessoas} As pessoas: [Ljava.lang.String;@3e25a5
A primeira pessoa: ${pessoas[0]} A primeira pessoa: Adriana
A segunda pessoa: ${pessoas[1]} Bernardo
Usando Maps e Beans

Para Maps e Beans voc pode optar entre os operadores . e [ e os resultados sero exatamente
os mesmos. Imagine o cdigo abaixo:
java.util.Map filmes = new java.util.HashMap();
filmes.put(Terror, Alien);
filmes.put(Ao, Predador);
filmes.put(Aventura, Indiana Jones e a ltima Cruzada);
filmes.put(Comdia, Se Beber No Case);
request.setAttribute(filmes, filmes);
Veja exemplos de uso na tabela abaixo:
${filmes.Terror} Alien
${filmes[Terror]} Alien
Com o operador [ voc pode inclusive aninhar elementos:
java.util.Map filmes = new java.util.HashMap();
filmes.put(Terror, Alien);
filmes.put(Ao, Predador);
filmes.put(Aventura, Indiana Jones e a ltima Cruzada);
filmes.put(Comdia, Se Beber No Case);
request.setAttribute(filmes, filmes);
65
String tipos[] = {Terror, Acao, Aventura, Comedia};

request.setAttribute(tiposDeFilmes, tipos);
E os resultados:
${filmes.tiposDeFilmes[0]} Alien
Objetos Implcitos
A Expression Language utiliza nomes talvez um pouco mais consistentes para os objetos
implcitos da JSP, conforme demonstra a tabela abaixo:
Objeto Descrio
pageContext O contexto da pgina JSP. Pode ser usado para acessar todos
os objetos implcitos do JSP, como request, response, session,
out, etc. Por exemplo, ${pageContext.response} retorna o
objeto response.
param Um mapa contendo todos os parmetros recebidos pela pgina.
Por exemplo, ${param.nome} retornaria o valor do parmetro
nome (ou seja, fazendo o mesmo que
request.getParameter(nome) faria).
paramValues Um mapa contendo todos os parmetros recebidos pela pgina,
os quais podem ser acessados como um array. Por exemplo,
${param.name} retornaria um array com todos os valores
recebidos pelo parmetro nome (ou seja, o mesmo que
request.getParameterValues(nome) faria).
header Um mapa contendo todos os cabealhos da requisio. Por
exemplo, ${header.name} retornaria o mesmo que
request.getHeader(name).
headerValues Um mapa contendo todos os cabealhos da requisio, os quais
podem ser acessados como um array. Por exemplo,
${headerValues.name} retornaria um array com todos os
valores do cabealho name (ou seja, o mesmo que
request.getHeaderValues(name) faria).
cookie Um mapa contendo todos os cookies recebidos por este JSP.
Por exemplo, $cookie.name.value retornaria o valor do
primeiro cookie de nome indicado.
initParam Um mapa contendo todos os parmetros de inicializao. Por
exemplo, ${initParam.name} retornaria o parmetro de
inicializao de nome indicado (o mesmo que chamar
ServletContext.getInitParameter(name)).
pageScope Um mapa com todos os objetos em escopo de pgina. Por
exemplo, ${pageScope.objectName} retornaria o objeto com
escopo de pgina indicado, enquanto que
${pageScope.objectName.propertyName} retornaria o valor da
propriedade indicada naquele objeto.
66
Objeto Descrio
requestScope Um mapa com todos os objetos em escopo de requisio. Por
exemplo, ${requestScope.objectName} retornaria o objeto com
escopo de requisio indicado, enquanto que
${requestScope.objectName.propertyName} retornaria o valor
da propriedade indicada naquele objeto.
sessionScope Um mapa com todos os objetos em escopo de sesso. Por
exemplo, ${sessionScope.objectName} retornaria o objeto com
escopo de sesso indicado, enquanto que
${sessionScope.objectName.propertyName} retornaria o valor
da propriedade indicada naquele objeto.
applicationScope Um mapa com todos os objetos em escopo de aplicao. Por
exemplo, ${applicationScope.objectName} retornaria o objeto
com escopo de aplicao indicado, enquanto que
${applicationScope.objectName.propertyName} retornaria o
valor da propriedade indicada naquele objeto.
Lidando com os Parmetros da Requisio

O objeto implcito param perfeito para aquelas situaes em que voc sabe que existe apenas
um valor para um determinado parmetro.
J para os casos em que h mais de um valor para um determinado parmetro (nos casos de
elementos multivalorados, por exemplo), basta usar o objeto implcito paramValues.
Por exemplo, imagine que em um formulrio HTML voc tem a seguinte construo:
<form>
Nome: <input type=text name=nome><br>
Endereo <input type=text name=endereco><br>
Telefone 1: <input type=text name=telefone><br>
Telefone 2: <input type=text name=telefone><br>
<input type=Submit value=Enviar>
</form>
Note que existem dois campos chamados telefone, enquanto que h apenas um chamado
endereo. Assim, para obter os dados armazenados nestes campos voc usar sintaxes
diferentes:
Nome: ${param.nome}<br>
Endereo: ${param.endereco}<br>
Telefone 1: ${paramValues.telefone[0]}
Telefone 2: ${paramValues.telefone[1]}
Operadores
A expression. Language ainda oferece uma srie de operadores que voc poder utilizar para
criar expresses no momento de criar sua pgina JSP.
Tipo Operador Descrio
Aritmticos +, -, *, /, div, %, mod / e div so sinnimos;
% e mod so sinnimos.
67
Tipo Operador Descrio

Lgicos &&, and, ||, or, !, not && e and so sinnimos;
|| e or so sinnimos;
! e not so sinnimos.
Relacionais ==, eq, !=, ne, <, lt, >, gt, <=, == e eq so sinnimos;
le, >=, ge
!= e ne so sinnimos;
< e lt so sinnimos;
> e gt so sinnimos;
<= e le so sinnimos;
>= e ge so sinnimos.
Vazio empty Um operador prefixado que
pode avaliar se o prximo
elemento nulo ou vazio.
Condicional A?B:C Resolve como B ou C
dependendo do resultado da
avaliao de A.
Veja alguns exemplos:
${pessoa.salario div 12}
${pessoa.estadoCivil == Solteiro or pessoa.estadoCivil eq
Divorciado}
${pessoa.idade ge 18}
${!empty pessoa.cpf}
${pessoa.sexo == M : Masculino : Feminino}
68
Captulo 9 MVC
Criar aplicaes web usando Java e JSP pode ser uma atividade perigosa:
Entender ou projetar o fluxo de navegao requer tempo;
Lgica de negcio e lgica de apresentao acabam se misturando, tornando difcil a
diviso de tarefas;
Acrescentar novas funcionalidades pode ser extremamente complicado, frequentemente
incorrendo em efeitos colaterais inesperados;
Por mais que se tomem precaues, a aplicao acaba se tornando especializada: fica
praticamente impossvel usar a lgica de negcios em outro contexto que no seja uma
aplicao web sem que o cdigo precise ser reescrito.
Para resolver estes problemas que foi criada a arquitetura MVC. Mas no s para resolv-los
em Java: MVC antecede ao Java em inmeras maneiras. hoje o padro para o
desenvolvimento de aplicaes Web, mas tambm bastante utilizada mesmo em aplicaes
desktop.
A Arquitetura MVC foi descrita pela primeira vez em 1979, por Trygve Reenskaug, um
cientista e professor de computao noruegus, enquanto visitava o Xerox Palo Alto Research
Center (PARC). A implementao original do padro foi criada para o Smaltalk, mas foi
facilmente adaptada para outras linguagens orientadas a objetos.
Uma Aplicao Web Sem MVC

Imagine que voc foi contratado para desenvolver um site de e-commerce.
Voc comea modelando a lgica de navegao, e depois de muitas conversas com o cliente e
seus usurios chega verso definitiva mostrada no diagrama abaixo.
69
Mas neste ponto voc j devia ter percebido que a nica coisa definitiva na vida a mudana.
Depois que o programa piloto entra no ar o seu cliente percebe que seria interessante adicionar
uma nova pgina logo depois da seleo do produto a comprar, oferecendo sugestes de
produtos relacionados.
O problema que esta nova pgina altera boa parte da sua lgica de navegao cuidadosamente
projetada.
70
Voc vai ter que sair caando e ajustando links para encaixar a nova pgina no meio da sua
lgica de navegao j bastante complexa.
Tem que existir uma soluo melhor...
Variaes Sobre um Mesmo Tema

Quando voc procura por bibliografia a respeito do padro MVC, comum encontrar duas
variaes:
MVC Modelo 1
A requisio chega ao JSP ou Servlet e ento este componente assume toda a responsabilidade
por manipul-la, incluindo processar a requisio, validar os dados, manipular a lgica de
negcio e gerar a resposta.
Este modelo normalmente s usado em aplicaes menores. Sua grande vantagem a
facilidade e rapidez de desenvolvimento. mais ou menos o que temos feito quando usamos
componentes JavaBean dentro das pginas JSP.
Porm inevitavelmente haver uma grande duplicao de cdigo entre JSPs, o que torna a
aplicao mais difcil de manter. Alm do mais, a lgica navegao continua espalhada, ento
os problemas de se adicionar tardiamente uma regra de navegao ainda esto presentes.
MVC Modelo 2
A requisio chega ao controlador, que a processa e atualiza as classes de modelo conforme o
necessrio, passando em seguida o controle para um JSP que apresentar os dados ao usurio e
aguardar pela nova iterao.
Este modelo perfeito para aplicaes maiores, pois fica fcil alterar a ordem de chamada das
views se um novo passo for adicionado.
Porm, por apresentar um nmero maior de componentes, o desenvolvimento pode levar um
pouco mais de tempo, embora a manutenabilidade adicional costumeiramente compense este
efeito.
Uma Aplicao Web com MVC

Em uma aplicao Web com MVC ns desfazemos os vnculos diretos entre as pginas, fazendo
com que todos os links passem pelo Controller.
Assim, adicionar novas regras de navegao fcil: basta alterar o Controller e configurar uma
nova regra.
Ao invs de dizer para onde ir os links agora dizem o que quero fazer. J que as pginas
sempre apontam para o Controller, elas no precisam ser tocadas.
71
Os Componentes da Arquitetura MVC
Model
O modelo, componentes que representam o modelo, os dados sendo tratados pela aplicao.
Em aplicaes Java EE estes componentes so normalmente implementados como Java Beans
(POJOs).
72
View
A viso ou apresentao, componentes que visam apresentar os dados ao usurio e controlar
a interface. Em Java EE estes componentes so normalmente implementados como documentos
JSPs.
Controller
O controle, aqueles componentes que visam encadear as diferentes views em uma sequncia
lgica. Em Java EE estes componentes normalmente so implementados como Servlets.
Mquina de Estados
Uma Aplicao Web Como Uma Mquina de Estados
Uma aplicao web pode ser facilmente encarada como uma mquina de estados. Na verdade
como uma Mquina de Estados Finitos (FSM, Finite State Machine).
Uma FSM um modelo comportamental composto por um nmero finito de estados, as
transies entre estes estados e as aes que devem ocorrer em determinadas situaes. Pode
ser representada com um grafo, o qual podemos usar para inspecionar o fluxo medida que uma
determinada situao ocorre.
As bolhas, ou estados, seriam os pontos terminais, etapas em que a aplicao para e espera por
alguma ao, seja automtica, seja desencadeada pelo usurio.
As linhas so transies e representam o processo que ocorre durante uma mudana de estado.
Podemos pensar em transies como o que ocorre como resposta imediata a um clique em um
boto ou um link, algo que desencadeia um processo qualquer que nos leva a um novo estado.
73
Os estados e transies da sua aplicao seriam representados por:

Um ou mais JavaBeans (o model);
Um documento JSP (a view);
Um servlet (o controller).
Existem implementaes que usam apenas um controller para toda a aplicao, outras que usam
um controller por mdulo e ainda outras que usam um controller por view. A deciso de quantos
controllers usar cabe ao projetista, que normalmente levar em conta a complexidade ou o
tamanho da aplicao.
Existem ainda frameworks que fornecem o seu prprio controle (como o caso do Struts, por
exemplo), ficando o programador encarregado apenas de criar os actions, classes especiais
que efetivamente executam o trabalho pesado. Caber ao controller, ento, apenas decidir que
action usar com base em alguma informao chegando pela requisio.
Um Exemplo Simples
Os exemplos a seguir demonstram rapidamente a ideia de se ter um controller centralizado e
uma pgina JSP que a utiliza como etapa intermediria na realizao de uma tarefa qualquer.
incluir_produto.jsp
<html>
<head>
<title>Incluir Produto</title>
</head>
<body>
<b1>Incluir Produto</b1>
<form action="Controller" method="post">
Nome:
<input type="text" name="nome"><br>
Departamento:
<input type="text" name="departamento"><br>
Preo Unitrio:
<input type="text" name="precoUnitario"><br>
<input type="hidden"
name="acao"
value="incluir_produto"><br>
<input type="Submit" value="Enviar">
</form>
</body>
</html>
74
No exemplo acima note que o atributo action do da tag <form> aponta para o Controller ao
invs de uma pgina qualquer. Alm disso, perceba a presena de um campo hidden chamado
acao. Este campo servir como pista para que o Controller possa perceber que ao se
deseja executar.
Controller.java
public class Controller extends HttpServlet {
protected void doPost(HttpServletRequest request,
String acao = request.getParameter("acao");
if (acao == null || acao.length() == 0) {
request.getRequestDispatcher("index.jsp")
.forward(request, response);
} else if (acao.equals("incluir_produto")) {
String nome = request.getParameter("nome");
String departamento = request.getParameter(
"departamento");
float precoUnitario = Float.parseFloat(
request.getParameter("precoUnitario");
// ... Inserir aqui o cdigo para incluir um produto
// no banco de dados.
// ... E depois move para a prxima JSP no fluxo.
request.getRequestDispatcher("listar_produtos.jsp")
} else if (acao.equals("alterar_produto") {
// ... Inserir aqui o cdigo para alterar um produto
// no banco de dados.
// ... E depois move para a prxima JSP no fluxo.
request.getRequestDispatcher("listar_produtos.jsp")
} // Outros testes e outras aes ...
}
}
Por ser um Servlet nosso Controller pode receber requisies HTTP e atuar sobre elas,
desempenhando as aes pertinentes.
No nosso exemplo, a primeira coisa que ele faz buscar pelo parmetro acao, o qual lhe
indicar o caminho a tomar. Depois, uma srie de ifs escolhe a alternativa correta e
desempenha a tarefa desejada. Por fim, o Servlet lana um redirecionamento que permite ao
usurio ver a pgina de resultado. Tal design permite usar o Servlet para o que ele faz de melhor
(atender uma requisio HTTP e executar lgica) sem que precisemos utilizar o que ele no faz
to bem (gerar sada em HTML).
75
Design-Patterns
Um Design-Pattern (padro de projeto) uma maneira formal de documentar uma soluo para
um problema de projeto em uma determinada rea de expertise.
A ideia foi introduzida pelo arquiteto Christopher Alexander, no campo da construo civl, em
1977, e mais tarde foi adaptada para vrias outras disciplinas, incluindo a a cincia da
computao.
Em engenharia de software, um Design Pattern uma soluo reutilizvel para um problema
comum no projeto de software. uma descrio ou modelo sobre como resolver um problema
que pode ser usado em muitas situaes diferentes.
O livro Design Patterns: Elements of Reusable Object-Oriented Software, lanado em 1994 e
escrito por Erich Gamma, Richard Helm, Ralph Johnson, e John Vlissides (posteriormente
imortalizados como Gang of Four [GoF, a Gangue dos Quatro]), acabou se tornando a
referncia no assunto.
O Design-Pattern Command
Embora o exemplo anterior possa parecer simples, fica evidente que adicionar novas aes torna
o cdigo do Servlet cada vez mais complexo. Alm do mais, ele ainda parece muito
procedural...
O ideal seria implementar uma arquitetura na qual a lgica de negcios ficasse independente do
Servlet, caso contrrio vamos estar apenas trocando uma dependncia (JSP) por outra (Servlets).
E pior, com um monte de ifs no meio do caminho.
O Design-Pattern Command pode nos ajudar, pois permite encapsular uma tarefa como um
objeto, permitindo assim que o Controller no precise saber nada a respeito da tarefa sendo
executada: basta ao Servlet saber que objeto Command implementa a atividade requisitada pelo
usurio por meio do formulrio web.
O Command, por sua vez, no sabe nada a respeito da interface com o usurio nem como a
requisio foi gerada: para ele basta saber que tarefa deve desempenhar.
76
Voc deve estar pensando: certo, entendo o propsito e a motivao do Command, mas ainda
no consigo entender como o Controller vai descobrir que Command usar. Ainda vamos usar os
ifs? A no ser que exista uma soluo mgica....
O Design-Pattern Abstract Factory

Em Orientao a Objetos, Factory um objeto usado para criar outros objetos. Classes Factory
so usadas naquelas situaes em que criar um objeto de um determinado tipo mais complexo
do que simplesmente instanci-lo:
Pode existir algum tipo de lgica para decidir que tipo de objeto criar;
Retornar um objeto a partir de um pool;
Efetuar configuraes complexas no objeto criado antes de entreg-lo ao cliente.
No caso do padro MVC podemos usar Factories para determinar que Command ser
instanciado para atender a determinada solicitao. Assim evitamos a lgica de deciso sobre o
command no controller.
Nos nossos exemplos usaremos o design-pattern Abstract Factory. Existem outros design-
patterns criacionais que poderiam ser igualmente teis. A deciso sobre qual deles usar muitas
vezes se resume ao gosto pessoal.
incluir_produto.jsp
<html>
<head>
<title>Incluir Produto</title>
</head>
<body>
<b1>Incluir Produto</b1>
<form action="Controller" method="post">
Nome:
<input type="text" name="nome"><br>
Departamento:
<input type="text" name="departamento"><br>
Preo Unitrio:
<input type="text" name="precoUnitario"><br>
77
<input type="hidden"
name="acao"
value="IncluirProduto"><br>
<input type="Submit" value="Enviar">
</form>
</body>
</html>
O formulrio deste exemplo praticamente o mesmo mostrado anteriormente, com uma sutil
diferena: o nome da ao a ser executada IncluirProduto, em camel-case. Isso vai
facilitar sobremaneira o trabalho do nosso Factory, como mostraremos em seguida.
Command.java
public interface Command {
public String executar(HttpServletRequest request,
HttpServletResponse response);
}
A nova interface Command define como sero os comandos da nossa aplicao. Basicamente
ela define um mtodo executar() que recebe a requisio e a resposta como parmetros e
retorna uma String. Nosso comando pode inspecionar ou alterar a requisio e a resposta HTTP
durante a realizao do seu trabalho, e ao final retorna a URL da pgina que deve ser executada
em seguida.
CommandFactory.java
public abstract class CommandFactory {
public static Command criarCommand(String acao)
throws ClassNotFoundException, InstantiationException,
IllegalAccessException {
return (Command) Class.forName(acao
+ "Command").newInstance();
}
}
J a classe abstrata CommandFactory a fbrica que ser utilizada para construir objetos do
tipo Command. Ela tem apenas um mtodo, criarCommand(), o qual recebe um nome de
ao e retorna o objeto do tipo Command correspondente.
Note que no nosso exemplo esta classe seria chamada pelo Controller, o qual receberia a
ao a partir da pgina JSP. Se por exemplo o processo partiu da pgina
incluir_produto.jsp, ento o parmetro acao vale IncluirProduto. O que a
factory faz pegar este nome de ao, concatenar a palavra Command ao seu final (gerando
IncluirProdutoCommand) e procurar por esta classe no classpath, retornando-a em
seguida ao chamador.
Controller.java
import java.servlet.ServletException;
public class Controller extends HttpServlet {
78
String acao = request.getParameter("acao");
if (acao == null) {
request.getRequestDispatcher("index.jsp")
}
try {
Command command = CommandFactory
.criarCommand(acao);
String proximaPagina = command
.executar(request, response);
request.getRequestDispatcher(proximaPagina)
} catch (Exception e)
request.setAttribute(
"javax.servlet.jsp.jspException", e);
request.getRequestDispatcher("erro.jsp")
}
}
}
O nosso Controller agora se viu livre de toda a lgica de deciso em relao ao
comportamento a tomar com base na ao indicada: tudo o que ele faz pedir ao
CommandFactory que crie um objeto Command com base no parmetro e depois o executa.
Tudo o que ele precisa saber que todos os Commands se comportam do mesmo jeito, reagindo
a uma chamada a executar() e que retornam a URL do prximo documento a exibir. O
Controller se tornou, finalmente, independente dos comandos que executa. E como a lgica
da CommandFactory tambm bastante simples, para adicionar novos recursos nossa
aplicao agora basta criar o JSP e a classe de command pertinente, o resto todo acontece
automaticamente.
IncluirProdutoCommand.java
public class IncluirProdutoCommand implements Command {
@Override
public String executar(HttpServletRequest request,
HttpServletResponse response) {
// Faz todo o processo de incluso aqui.
// ...
// E depois retorna a URL da prxima pgina a ser mostrada
// ao usurio.
return "index.jsp";
}
}
Por fim, a classe IncluirProdutoCommand a classe de comando que ser disparada pelo
Controller para realizar o trabalho efetivo. Como ela implementa a interface Command, o
seu mtodo executar() recebe a requisio e a resposta como parmetros e retorna, ao seu
final, a URL do prximo documento a ser exibido para o usurio.
79
No meio tempo ela pode desempenhar as funes a que se prope (no nosso caso ela faria uma
incluso no banco de dados). Alm disso, como tem acesso requisio, ela pode buscar outros
parmetros que lhe so pertinentes. Por meio da resposta tambm lhe possvel popular objetos
de contexto ou usar de outras estratgias para se comunicar com o JSP que ser executado a
seguir.
80
Captulo 10 JSTL
Usando componentes JavaBean, Expression Language e o padro MVC, conseguimos nos

aproximar bastante do nosso objetivo de remover completamente os scriptlets dos nossos
documentos JSP. Mas infelizmente h situaes em que isso ainda no possvel.
Rapidamente conseguimos estabelecer pelo menos duas situaes onde nenhum destes
auxiliares consegue bater o poder dos scriptlets:
Contedo condicional, quando um contedo precisa ou no precisa ser gerado com base
em uma ligica booleana;
Iterao entre valores em uma coleo.
JavaServer Pages Standard Tag Library (JSTL) encapsula, como tags, algumas das funes mais
comumente utilizadas em aplicaes web:
JSTL suporta iteraes, condicionais, manipulao de documentos XML,
internacionalizao, SQL e formatao;
JSTL ainda oferece um mecanismo para integrar tags customizadas s tags da prpria
biblioteca;
JSTL prov uma maneira efetiva de embutir lgica dentro de um arquivo JSP sem usar
cdigo Java diretamente.
A verso mais atual, 1.2, foi lanada em 8 de Maio de 2006, como parte da plataforma Java EE
5.
Namespaces
JSTL oferece uma grande variedade de tags para os mais diversos usos. Para refletir isso, assim
como dar a cada rea o seu prprio namespace, JSTL disponibilizada como mltiplas
bibliotecas de tags:
Core;
Internacionalizao;
XML;
SQL;
Funes.
Namespace Prefixo Funes
Core c Suporte s Variveis
http://java.sun.com/jsp/jstl/core Controle de Fluxo
Gerenciamento de URLs
Tags Variadas
81
Namespace Prefixo Funes

Internacionalizao fmt Locale
http://java.sun.com/jsp/jstl/fmt Formatao de mensagens
Formatao de nmeros e
datas
XML x Core
http://java.sun.com/jsp/jstl/xml Controle de Fluxo
Transformao
Banco de Dados sql SQL
http://java.sun.com/jsp/jstl/sql
Funes fn Tamanho de colees
http://java.sun.com/jsp/jstl/functions Manipulao de Strings
Para que se possam utilizar as taglibs em nosso projeto precisaremos acrescentar uma diretiva
nos nossos arquivos JSP indicando a biblioteca de tags desejada:
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>
<%@taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>
<%@taglib prefix=fn"
uri="http://java.sun.com/jsp/jstl/functions" %>
Obviamente voc pode usar quantas taglibs quiser em um mesmo documento JSP.
Colaborao Entre Tags

As tags JSTL normalmente colaboram entre si e com o ambiente de maneiras implcitas ou
explcitas.
Colaborao Implcita
A Colaborao Implcita ocorre por meio de uma interface bem-definida que permite que tags
encadeadas trabalhem de maneira uniforme com sua tag me.
As tags condicionais, por exemplo, utilizam este tipo de colaborao:
<c:choose>
<c:when test=${param.acao == incluir}>
...
</c:when>
<c:when test=${param.acao == alterar}>
...
</c:when>
<c:otherwise>
...
</c:otherwise>
</c:choose>
No exemplo acima vemos que existem tags <c:when> e <c:otherwise> dentro da tag
<c:choose>. Olhando para o cdigo JSP mostrado acima no se percebe nenhum tipo de
82
relacionamento entre estas tags, mas quando as explicarmos em detalhes voc perceber que,
embora no declarado, ele existe.
Colaborao Explcita
A Colaborao Explcita ocorre quando uma tag expe informao para o ambiente. Tags JSTL
expem valores como variveis EL. A conveno usar o nome var para qualquer atributo que
exponha informaes a respeito da tag.
Este o mecanismo usado pela tag forEach, por exemplo:
<c:forEach var=elemento items=${sessionScope.lista}>
${elemento}
</c:forEach>
O Namespace Core
As tags do namespace core so usadas para declarao e manipulao de variveis e controle de
fluxo.
Alm disso, ainda oferecem uma maneira de acessar recursos baseados em URLs cujo contedo
pode ento ser includo ou processado dentro do contexto de um documento JSP.
Grupo Tags
Suporte s Variveis remove
set
Controle de Fluxo choose
when
otherwise
forEach
forTokens
if
Gerenciamento de URLs import
param
redirect
param
url
param
Tags Variadas catch
out
Suporte s Variveis
A Tag <c:set>
A tag <c:set> cria ou inicializa uma varivel EL.
Pode ser usada na forma de atributo:
83
<c:set var=variavel scope=session value=teste />

... Ou por meio do corpo da tag:
<c:set var=variavel>
teste
</c:set>
A Tag <c:remove>
A tag <c:remove> remove uma varivel do contexto indicado.
<c:remove var=variavel scope=session />
Controle de Fluxo
A Tag <c:if>
A tag <c:if> permite a execuo condicional do seu corpo de acordo com o resultado
booleano do seu atributo test.
<c:if test=${!empty param.acao}>
...
</c:if>
A Tag <c:choose>
A tag <c:choose> executa o cdigo condicional embutido em sua subtags <c:when> e
<c:otherwise>.
Ela gera o corpo da primeira tag <c:when> cuja condio de testes (contida no atributo test)
for verdadeira.
O corpo da tag <c:otherwise> ser executado se nenhuma tag <c:when> for atendida.
<c:choose>
<c:when test=${param.acao == incluir}>
...
</c:when>
<c:when test=${param.acao == alterar}>
...
</c:when>
<c:otherwise>
...
</c:otherwise>
</c:choose>
A Tag <c:forEach>
A tag <c:forEach> pode ser usada para iterar em uma coleo de objetos.
Voc especifica a coleo por meio do atributo items, e o tem corrente fica disponibilizado
por meio da varivel de contexto indicada pelo atributo var.
O atributo varStatus define uma varivel que pode ser usada para obter, entre outras coisas,
o nmero de iteraes executadas at o momento.
<c:forEach var=cabecalho
items=${header}
varStatus=status>
O cabealho ${status.count} ${cabecalho}.<br>
84
</c:forEach>
A tag <c:forEach> tambm pode ser usada simplesmente para iterar usando valores limites.
Neste caso os atributos begin e end definem os limites a serem usados.
Opcionalmente, o atributo step pode definir quantos elementos saltar a cada iterao.
<c:forEach var=i
begin=100
end=200
step=10>
${i}<br>
</c:forEach>
Pode-se ainda iterar em uma coleo usando valores limites. Neste caso os atributos begin e
end definem os pontos extremos da coleo que devem ser usados.
O atributo step funciona mesmo nos casos em que se itera por entre valores limites, e neste
caso podemos usar ${status.index} para saber o valor do ndice atual e
${status.count} para saber o nmero de iteraes at o momento.
<c:forEach var=cabecalho
varStatus=status
items=${header}
begin=3
end=7
step=2>
O cabealho ${status.index} ${cabecalho}.<br>
</c:forEach>
E ainda podemos iterar por entre os elementos de um Map. Neste caso o objeto recuperado ser
do tipo java.util.MapEntry.
<c:forEach var=parametro
items=${param}>
O parmetro ${parametro.key} vale ${parametro.value}.<br>
</c:forEach>
A Tag <c:forTokens>
A tag <c:forTokens> pode ser usada para iterar entre os tokens encontrados em uma string
delimitada.
Neste caso o atributo items representa a string delimitada e o atributo delims lista os
delimitadores:
<c:set var=numeros
value=um,dois:trs:quatro;cinco,seis,sete:oito />
<c:forTokens var=num
items=${numeros}
delims=,:;>
${num}<br>
</c:forTokens>
A tag forTokens suporta os mesmos atributos suportados pela tag forEach. Os atributos
begin, end e step funcionam exatamente como esperados, bem como varStatus.
<c:set var=nros
value=um,dois:trs:quatro;cinco,seis,sete:oito />
<c:forTokens var=num
85
varStatus=status
items=${nros}
delims=,:;
begin=3
end=7
step=2>
${status.index}: ${num}<br>
</c:forTokens>
Gerenciamento de URLs
A Tag <c:url>
A combinao das tags <c:url> e <c:param> capaz de lidar eficientemente com a re-
escrita e codificao de URLs.
O atributo value da tag url indica o caminho at o recurso linkado, enquanto que o atributo
var cria uma referncia para aquela URL, a qual pode ser reutilizada mais tarde.
O atributo scope define o escopo no qual a varivel criada por var deve ser adicionada. Ele
pode valer page, request, session ou application.
Por sua vez a tag <c:param> pode ser usada para enviar parmetros de requisio para o
recurso linkado. Seus atributos so name e value.
<c:url value=http://alfanews.com.br/login.jsp
var=minhaURL
scope=request>
<c:param name=nome value=pedro />
<c:param name=senha value=123456 />
</c>
<a href=${minhaURL}>Logar</a>
Outra caracterstica importante sobre a tag <c:url> que ela automaticamente acrescenta o
nome do contexto corrente em URLs relativas. Assim voc no precisa acrescentar o nome da
aplicao como prefixo das suas URLs relativas.
Se por exemplo a nossa aplicao tivesse sido criada no contexto exemplo, a URL...
<c:url value=/paginas/login.jsp />
Geraria uma URL apontando para...
http://localhost/exemplo/paginas/login.jsp
A tag <c:url> tambm pode tratar outros contextos de maneira transparente. Da mesma
maneira que ela adiciona o escopo corrente automaticamente, podemos indicar qual escopo
utilizar.
Assim, a URL a seguir...
<c:url value=/paginas/login.jsp context=/aplicacao2 />
Geraria uma URL apontando para...
http://localhost/aplicacao2/paginas/login.jsp
A Tag <c:import>
Importa um contedo esttico ou dinmico dentro do documento JSP atual.
86
Ao contrrio de <jsp:include>, <c:import> capaz de recuperar documentos que esto

fora do contexto atual (ou seja, a tag <c:import> consegue ler documentos de outras
aplicaes ou mesmo de outros sites).
O atributo url indica a localizao do recurso a ser importado.
<c:import url=ftp://ftp.acme.com/README />
A Tag <c:redirect>
A tag <c:redirect> pode ser usada para enviar um redirecionamento para o cliente.
Quando esta tag alcanada o contedo que a segue no documento atual ignorado e uma
resposta 307 enviada para o cliente, indicando a URL especificada pelo atributo url.
O atributo context pode ser usado para indicar um redirecionamento para uma aplicao
externa.
Subtags param tambm podem ser usadas para definir parmetros de requisio a serem
repassados pgina de destino.
<c:redirect url=/login.jsp context=/aplicacao2>
<c:param name=nome value=pedro />
<c:param name=senha value=123456 />
</c:redirect>
Tags Variadas
A Tag <c:catch>
A tag <c:catch> prov um complemento para o mecanismo de manipulao de erros do JSP.
Ela permite que uma pgina se recupere graciosamente de um erro sem que o controle seja
enviado para a pgina de erros.
Voc deve colocar o cdigo que pode lanar uma exceo no corpo da tag.
Uma vez lanada, a exceo pode ser recuperada por meio da varivel indicada pelo atributo
opcional var, criada no escopo de pgina.
<c:catch var=excecao>

</c:catch>
<c:if test=${excecao != null}>
Desculpe, a operao no pode ser completada.
</c:if>
A Tag <c:out>
A tag <c:out> tem um efeito parecido com <%= expresso %> ou ${expresso}:
usada para enviar texto para o browser.
A tag <c:out>, porm, mais poderosa, podendo codificar os caracteres especiais do XML
nas suas respectivas entidades e fazer uso de valores default.
O atributo value indica o que deve ser impresso, enquanto que o atributo default indica o
que deve ser impresso se value resultar em null.
O atributo escapeXml pode ser usado para codificar os valores especiais do XML.
<c:out value=${cliente.endereco.cidade}
escapeXml=true
87
default=Cidade Desconhecida />

A variao com corpo pode ser usada opcionalmente.
<c:out value=${cliente.endereco.cidade}
escapeXml=true>
Cidade Desconhecida
</c:out>
O atributo escapeXml converte os caracteres <, >, , , e & para as entidades HTML
correspondentes. O caractere >, por exemplo, convertido para >.
Esta converso evita que caracteres com significado especial para o XML embutidos no texto a
ser impresso acabem provocando quebras no documento HTML/XHTML gerado, o que faria o
usurio ver um documento incompleto ou at mesmo uma mensagem de erro.
Por default o mascaramento est habilitado. Para desabilit-lo basta passar o valor false para
o atributo escapeXml.
Internacionalizao
As aplicaes web devem ser capazes de se adaptar s linguagens e convenes de formatao
dos diferentes pases. O processo de projetar uma aplicao com tal capacidade chamado de
internacionalizao (internationalization, ou simplesmente i18n).
O processo de efetivamente traduzir uma aplicao para uma dada lngua chamado de
localizao (localization ou l10n).
H trs grandes conceitos associados internacionalizao:
Locale
o Um locale representa uma regio geogrfica, poltica ou cultural.
representada por um cdigo de linguagem seguido opcionalmente por um
cdigo de pas.
O locale brasileiro, por exemplo, pt_BR, enquanto que o dos Estados Unidos
en_US.
Resource Bundle
o um repositrio que contm objetos associados a uma Locale. Mensagens
armazenadas no bundle ficam associadas a uma chave. No momento de
apresentar uma mensagem usa-se a chave e o engine recupera a mensagem na
lngua apropriada.
Basename
o o nome base do arquivo que armazena as mensagens. Um Resource Bundle
em especfico, ento, obtido a partir da combinao do Basename com um
Locale.
Preparando os Resource Bundles

Resource Bundles tomam a forma de arquivos de propriedades (um arquivo com a extenso
.properties).
Um arquivo .properties um arquivo texto onde cada linha define uma propriedade e seu valor,
em um formato parecido com um arquivo .ini do Windows.
saudacao=Al Mundo
Voc ter um arquivo .properties para cada locale que deseja dar suporte na sua aplicao.
88
Para que a aplicao saiba onde e como localizar seus Resource Bundles voc precisa
especificar o seu Basename no arquivo web.xml.
A tag <context-param> deve ser usada para identificar um parmetro de contexto que
indicar o basename dos resource bundles.
A subtag <param-name> indica o nome do parmetro, que para esta situao ser sempre o
mesmo.
J a subtag <param-value> indica o basename dos seus resource bundles.
web.xml
<web-app ...>
<context-param>
<param-name>
javax.servlet.jsp.jstl.fmt.localizationContext
</param-name>
<param-value>
mensagens
</param-value>
</context-param>
</web-app>
Os resource bundles precisam estar acessveis para o container em algum diretrio dentro do
classpath da sua aplicao. O mais comum que estes arquivos fiquem no raiz do seu diretrio
de arquivos-fonte.
No nosso exemplo, se fossemos oferecer localizao para as lnguas portuguesa e inglesa, o
diretrio /src conteria os seguintes arquivos:
mensagens_pt_BR.properties
mensagens_en_US.properties
Exibindo Mensagens
A Tag <fmt:message>
A tag <fmt:message> pode ser usada para exibir uma mensagem devidamente localizada.
Veja por exemplo o seguinte resource bundle. Seguindo o nosso exemplo anterior o arquivo se
chama mensagens_pt_BR.properties e se localiza no diretrio raiz do cdigo fonte da
aplicao:
mensagens_pt_BR.properties
saudacao=Al mundo!
Ao usarmos a tag <fmt:message> o atributo key serve para indicar a chave a ser buscada no
resource bundle mais adequado.
<fmt:message key=saudacao />
Se o locale selecionado fosse pt_BR este trecho de cdigo resultaria na sada mostrada a seguir:
Al mundo!
Quando precisarmos que o texto exibido ao usurio contenha partes variveis podemos usar
parmetros. Considere o seguinte trecho no arquivo de resource bundle:
parametrizada=Esta mensagem recebeu os valores {0} e {1} como
parmetro.
89
E se o seguinte trecho de cdigo fosse usado:

<fmt:message key=parametrizada>
<fmt:param value=mamo />
<fmt:param value=abacate />
</fmt:message>
O texto a seguir seria apresentado para o usurio:
Esta mensagem recebeu os valores mamo e abacate como parmetro.
bvio que, dependendo da lngua, a mensagem poderia exibir os parmetros em uma ordem
diferente.
Neste caso bastaria ajustar o arquivo de bundle.
Existem ainda outras forma de usar a tag <fmt:message>:
Em uma variao a chave da mensagem pode ir no corpo da tag ao invs de em um atributo.
<fmt:message>
parametrizada
<fmt:param value=mamo />
<fmt:param value=abacate />
</fmt:message>
E uma ltima forma em que, ao invs de imprimir diretamente a mensagem, podemos
armazen-la em uma varivel (para uso com c:out, por exemplo ...
<fmt:message key=saudacao var=variavel />
Neste caso podemos usar tanto as variantes parametrizadas ou no, com corpo ou no.
A Tag <fmt:setLocale>
Para fins de teste voc pode experimentar forar um determinado locale, mesmo que esteja em
outro.
Por exemplo, para obrigar a sua pgina a mostrar as mensagens em ingls mesmo que o seu
browser esteja configurado para requisitar pginas em portugus voc poderia adicionar:
<fmt:setLocale value=en_US />
Para mostrar em portugus bastaria trocar por:
<fmt:setLocale value=pt_BR />
Formatao
Mostrar textos em diversas lnguas no basta para que possamos dizer que a nossa aplicao
est internacionalizada. Ainda temos que nos preocupar com a formatao de nmeros e datas,
j que cada pas pode exibir estas informaes em um formato particular.
Formatando Valores
A Tag <fmt:formatNumber>
A tag <fmt:formatNumber> pode ser usada para exibir um nmero formatado conforme
um locale.
O atributo value ou o corpo da tag especificam o nmero a ser formatado.
90
Os atributos type, pattern, currencyCode, currencySymbol, groupingUsed,

maxIntegerDigits, minIntegerDigits, maxFractionDigits e
minFractionDigits podem ser usados para customizar ainda mais o formato da sada.
Os atributos var e scope podem ser usados para armazenar o resultado da formatao em uma
varivel ao invs de simplesmente imprim-lo.
<fmt:formatNumber value=10.5 type=currency />
Atributo Valores Descrio Exemplo
type number Define o tipo de number
formatao a usar.
currency
percent
pattern # O formato a usar, ##0.00
conforme
0
java.text.DecimalFormat.
.
currencyCode Cdigo de moeda O cdigo de moeda USD
ISO-4217 usado para formatar
BRL
dados monetrios.
currencySymbol O smbolo de moeda a US$
usar.
R$
groupingUsed true Usar separador de true
milhares?
false
maxIntegerDigits Nmero mximo de 4
dgitos a usar para a
parte inteira.
minIntegerDigits Nmero mnimo de 4
parte inteira.
maxFractionDigits Nmero mximo de 4
parte fracionria.
minFractionDigits Nmero mnimo de 4
parte fracionria.
A Tag <fmt:formatDate>
A tag <fmt:formatDate> pode ser usada para apresentar uma data de maneira formatada
conforme o locale corrente.
O atributo value ou o corpo da tag so usados para indicar a data a ser exibida.
Os atributos type, dateStyle, timeStyle, pattern e timeZone podem ser usados
para especificar o formato desejado.
Os atributos var e scope podem ser usados para armazenar a data formatada em uma varivel
ao invs de simplesmente imprim-la.
91
<jsp:useBean id=dataDeHoje class=java.util.Date />

<fmt:formatDate value=${dataDeHoje} type=date />
Atributo Valores Descrio Exemplo
type date Define o tipo de formatao date
a usar.
time
both
dateStyle default O formato de data a usar. mdium
short
medium
long
full
timeStyle default O formato de hora a usar. long
short
medium
long
full
pattern yyyy O formato a usar, conforme yyyy-MM-dd
java.text.SimpleDateFormat
yy
MMM
MM
M
dd
d
timezone O nome da Time Zone a America/Pacific
usar
GMT
92
Captulo 11 Custom Tags
Existem situaes em que nem mesmo a JSTL suficiente. Por mais que ela simplifique a
criao dinmica de contedo com base em lgica booleana, certos contedos parecem
complicados demais para serem gerados sem o uso de scriptlets. Mas existe uma alternativa:
criar as nossas prprias tags.
Uma Tag Customizada (no ingls, Custom Tag) um elemento JSP definido pelo usurio.
Tags Customizadas abrem uma srie de possibilidades:
Customizar o cdigo HTML gerado por meio de atributos passados no cdigo JSP;
Acessar todas as variveis disponveis no ambiente JSP;
Efetuar comunicao entre as tags, tornando possvel criar beans, criar variveis EL que
se referem queles beans em uma tag e usar aquelas variveis EL em outra tag;
Fazer com que tags encadeadas se comuniquem por meio de variveis privadas.
A Anatomia de uma Tag

Para que possamos entender completamente o conceito de tags customizadas primeiro
precisamos definir algumas caractersticas das tags.
Examine o cdigo abaixo, por exemplo:
<form method=post
action=servlet>
<label for=login>
Usurio:
</label>
<input type=text
name=login
id=login
size=20
maxlength=20
/>
<br />
<label for=senha>
Senha:
</label>
<input type=password
name=senha
id=senha
size=20
maxlength=20 />
<br />
93
<input type=submit
value= Enviar />
</form>
No exemplo acima vemos vrias tags, como por exemplo <form>, <input> e <br>.
Algumas delas tm corpo (como o caso das tags <form> e <label>), enquanto que outras
no (<br> e <input>, no exemplo). Algumas delas tm atributos (a tag <form> tem os
atributos method e action), enquanto que outras no (de novo <br>).
Atributos
Usamos atributos para definir caractersticas especiais de uma tag. Veja o exemplo:
<input type=text
name=login
size=20
maxlength=20
/>
Neste caso a tag <input> foi especializada para receber a entrada de texto (por meio do
atributo type). Alm disso, indicamos o nome do componente (atributo name), seu tamanho
aparente (atributo size) e o nmero mximo de caracteres que ele pode comportar (atributo
maxlength).
Corpo
O corpo da tag a informao que aparece dentro da mesma, algo como os dados sob os quais
ela atua.
Tags com corpo usam uma tag de fechamento para indicar onde o seu corpo acaba, como o
caso da tag <label> mostrada abaixo:
<label for=login>
Usurio:
</label>
No exemplo acima, </label> no uma tag propriamente, mas sim apenas a marcao de
fechamento da tag <label>. O texto que aparece entre a tag de abertura e a de fechamento
chamado de corpo da tag.
O corpo das tags pode conter texto (como exatamente o caso da tag <label> mostrada) ou
mesmo outras tags (como o caso da tag <form>, que tem vrios <label>s e <input>s no
seu corpo).
E ainda existem as tags sem corpo. Neste caso no h tag de fechamento (no modelo XHTML a
tag de abertura recebe o marcador /> para indicar que ela no tem tag de fechamento, como o
caso de <br />).
Tag Handler
Se vamos criar nossas prprias tags, precisamos ter uma maneira de descrevermos o que estas
tags fazem. Com Custom Tags criamos classes Java que desempenham a lgica da tag, gerando
cdigo HTML dinamicamente, exatamente da mesma maneira que os Servlets faziam.
Chamamos de Tag Handler a classe que criamos para representar uma tag. Esta classe
gerenciada pelo container, o que significa que ela ser instanciada automaticamente quando o
container perceber que a tag foi utilizada em uma pgina JSP.
94
Alm de instanciar a classe, o container responsvel ainda por copiar os valores de todos os
atributos da tag para os atributos da instncia recm-criada, fazendo uso dos mtodos setters
correspondentes. Assim, se a tag tem os atributos name, id e size, por exemplo, o container
chamaria os mtodos setName(), setId() e setSize(), passando os valores
encontrados no JSP para dentro do objeto.
Sempre h pelo menos dois atributos:
pageContext, que retorna informaes a respeito da pgina onde a tag foi
encontrada;
parent, que retorna informaes a respeito da tag me da tag corrente.
Conforme a especificao JSP foi evoluindo as Custom Tags foram ganhando novos recursos e
o desenvolvimento foi ficando cada vez mais facilitado.
Assim, hoje em dia temos trs grandes modelos:
Tags clssicas;
SimpleTags;
Tag Files.
O Descritor da Biblioteca de Tags

A API de tags customizadas define a existncia de um arquivo XML que serve para ajudar o
container a encontrar as suas classes tag handlers. Chamamos este arquivo de Descritor de
Biblioteca de Tags (TagLibrary Descriptor, ou simplesmente TLD).
Este arquivo deve ter a extenso .tld e fica dentro do diretrio WEB_INF ou em um
sudiretrio deste (WEB-INF/tlds uma localizao comum).
Neste arquivo, alm de associarmos um nome de tag a uma classe Java, configuramos a
existncia dos atributos, seus tipos de dados e obrigatoriedade. Veja um exemplo abaixo:
tags.tld
<taglib version="2.1" xmlns="http://java.sun.com/xml/ns/javaee"
http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd">
<tlib-version>1.0</tlib-version>
<short-name>t</short-name>
<uri>/WEB-INF/tlds/tags</uri>
<tag>
<name>InputClassicTag</name>
<tag-class>classictags.InputClassicTag</tag-class>
<body-content>empty</body-content>
<attribute>
<name>type</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
<type>java.lang.String</type>
</attribute>
<attribute>
<name>name</name>
95
</attribute>
<attribute>
<name>value</name>
</attribute>
</tag>
</taglib>
Podemos definir vrias tags em um mesmo TLD. O arquivo comea com uma tag <taglib>,
que sempre igual e serve para indicar os namespaces utilizados neste arquivo XML. Depois
temos uma tag <tlib-version>, cujo valor um nmero de verso arbitrrio (o nmero de
verso da sua biblioteca de tags). Em seguida temos o <short-name>, que uma sugesto de
prefixo para a utilizao desta biblioteca de tags, assim como a tag <uri> serve para indicar a
URI que estar associada a esta biblioteca (veremos mais sobre estas duas ltimas tags mais
tarde).
Por fim temos uma seo <tag> para cada tag definida nesta biblioteca. Esta seo comea
com uma tag <name>, que indica o nome da tag. Depois vemos a tag <tag-class>, a qual
servir para indicar o nome plenamente qualificado da classe tag handler que implementa a
lgica desta tag. Em seguida temos uma tag <body-content>, a qual serve para indicar o
tipo de contedo suportado no corpo desta tag (o qual pode ser empty para tags que no tem
corpo, JSP para tags que suportam outras tags JSP em seu corpo, scriptless para tags
que no usaro scriptlets ou outros elementos de script em seu corpo, e tagdependant
para aqueles casos em que voc no quer que o container tente interpretar o corpo da tag, j que
ele faz sentido apenas para a prpria classe tag handler).
Ainda dentro da seo tag teremos uma seo <attribute> para cada atributo possvel
naquela tag. L dentro temos a tag <name>, que define o nome do atributo; a tag
<required>, que indica a obrigatoriedade ou no do atributo (true para atributos
obrigatrios, false para atributos opcionais); a tag <rtexprvalue>, que serve para
indicar se o atributo pode ser populado por meio de expresses (true para atributos que
podem receber valores em tempo de execuo por meio de Expression Laugnage, por exemplo,
false para atributos cujos valores devem ser informados como literais no prprio
documento JSP que utiliza a tag); e a tag <type>, a qual indica o tipo de dados Java do
atributo (na forma de um nome plenamente qualificado de classe ou nome de tipo de dados
primitivo).
Criando o Arquivo TLD com o NetBeans

Para criar um arquivo TLD no NetBeans, primeiro crie um projeto Java Web e depois escolha
Arquivo > Novo Arquivo...
A janela abaixo ser mostrada:
96
Aqui escolha a categoria Web e Descritor de Biblioteca de Marcao como tipo de arquivo.
Em seguida clique em Prximo para ver a prxima tela:
Aqui voc poder indicar o nome do seu arquivo TLD, bem como o diretrio onde ele ser
armazenado (que pode ser WEB-INF ou um subdiretrio l dentro). Informe tambm o URI e o
prefixo sugerido.
97
Tags Clssicas
Tags Clssicas representam a metodologia original para o desenvolvimento de Custom Tags na
especificao 1.1 do JSP. A especificao 1.2 adicionou novas funcionalidades e simplificou a
codificao, mas essencialmente o modelo permaneceu o mesmo.
Classes da API de Tags Customizadas Clssicas

As classes e interfaces da API de Tags Clssicas esto todas dentro do pacote
javax.servlet.jsp.tagext, e proporcionam o framework inicial para a criao de tags
customizadas.
Interface Tag
o Esta interface pode ser usada para criar tags clssicas que no tm corpo.
Interface IterationTag
o Esta interface pode ser usada para criar tags clssicas com suporte limitado a
corpo.
Classe TagSupport
o Classe que implementa IterationTag que pode servir como base para suas
tags clssicas com suporte limitado a corpo.
Interface BodyTag
o Esta interface define um mtodo adicional para criar tags clssicas que tm
corpo.
Classe BodyTagSupport
o Classe que implementa BodyTag oferecendo os comportamentos default para
tags com corpo.
Classe BodyContent
o Uma subclasse de JspWriter usada para representar o contedo do corpo de
uma tag enquanto uma classe TagHandler est sendo executada.
Classe PageContext
o Classe que implementa o objeto implcito pageContext, e que alm de
oferecer o acesso a todos os demais objetos implcitos, tambm pode ser usada
para enviar a solicitao de uma pgina para outra.
A Classe BodyTagSupport
A classe javax.servlet.jsp.tagext.BodyTagSupport tipicamente a classe que
estendemos quando estamos criando uma tag clssica, seja para tags com corpo seja para tags
sem corpo. Eis os seus mtodos principais:
Mtodo Descrio
int doAfterBody() Lanada quando o container alcana o final do
corpo desta tag. Por padro no reavalia o
corpo da tag (pois retorna SKIP_BODY).
int doEndTag() Lanada automaticamente quando o container
alcana a tag de encerramento. Por padro
avalia o restante pgina (pois retorna
EVAL_PAGE).
void doInitBody() Lanada automaticamente quando o container
est prestes a avaliar o corpo da tag pela
primeira vez.
98
Mtodo Descrio
int doStartTag() Lanada automaticamente quando o container
encontra a tag de abertura. Por padro retorna
EVAL_BODY_BUFFERED, o que provoca a
avaliao do corpo da tag.
static Tag findAncestorWithClass(Tag from, Encontra a instncia mais prxima de uma
Class klass) dada classe a partir de uma Tag especificada.
BodyContent getBodyContent() Retorna o contedo do corpo desta tag.
String getId() Retorna o valor do atributo id desta tag, ou
null se ele no foi especificado.
Tag getParent() A instncia de Tag mais prxima da instncia
atual no documento.
JspWriter getPreviousOut() Retorna o JspWriter da tag que cerca a tag
atual.
Object getValue(String k) Recupera o valor associado a uma chave.
Enumeration<String> getValues() Enumera as chaves para os valores
armazenados por esta tag.
void release() Libera o estado desta tag.
void removeValue(String k) Remove um valor associado a uma chave.
void setBodyContent(BodyContent b) Prepara para a reavaliao do corpo da tag,
armazenando o contedo atual em um buffer.
void setId(String id) Estabelece o valor do atributo id desta tag.
void setPageContext(PageContext Estabelece o PageContext.
pageContext)
void setParent(Tag t) Estabelece o aninhamento desta tag.
void setValue(String k, Object o) Associa um valor com uma chave.
Os quatro primeiros mtodos so os mais importantes da API, e fazem parte do que chamamos
de gerenciamento do ciclio de vida das custom tags clssicas.
O Ciclo de Vida das Tags Clssicas

Quando o container web encontra uma tag dentro de um documento JSP ele tem de executar
muitas tarefas. Algumas delas so automticas, mas outas dependem do cdigo que voc
escreveu, j que voc quem define o que a tag far.
Nos momentos em que voc tem o controle a API executa alguns mtodos especiais na sua
classe Tag Handler, e os prximos passos a serem tomados dependem dos resultados retornados
por estes mtodos.
A sequncia de passos bsica demonstrada abaixo:
99
Nmero Tarefa Descrio

1 Instanciar um objeto a partir da Quando uma Custom Tag encontrada em um
classe Tag Handler documento JSP a classe Tag Handler
correspondente automaticamente
instanciada.
2 Popular os atributos do objeto O valor de cada atributo encontrado na tag
instanciado a partir da classe Tag dentro do documento JSP copiado para a
Handler instncia recm-criada, por meio da execuo
do mtodo setter correspondente.
3 Executar doStartTag() Este mtodo pode ser utilizado para inicializar
a lgica da sua classe tag handler. Os passos
executados a seguir dependem do seu retorno:
se o mtodo retornar
EVAL_BODY_BUFFERED o processo
continua normalmente, mas se retornar
SKIP_BODY o processo salta para o passo de
nmero 7. Se voc no sobrescrever este
mtodo herdado de BodyTagSupport o valor
retornado ser EVAL_BODY_BUFFERED.
4 Executar doInitBody() Este mtodo pode ser utilizado para configurar
a lgica da sua classe tag handler
imediatamente antes de uma iterao por
dentro do corpo da tag. Ela no afeta a lgica
do ciclo de vida, uma vez que no retorna
valor.
5 Avaliar o corpo da tag O container passa ento a avaliar o corpo da
tag, executando eventuais tags customizadas
ou apenas gerando o contedo HTML
correspondente s tags HTML encontradas no
corpo da tag.
6 Executar doAfterBody() Este mtodo pode ser utilizado para avaliar
uma situao que possa exigir a repetio do
processamento do corpo da tag. Os passos que
o container tomar a seguir dependem do
retorno deste mtodo: se ele retornar
SKIP_BODY o processo continua
normalmente, mas se ele retornar
EVAL_BODY_AGAIN o processamento
retorna ao passo de nmero 4. Se voc no
sobrescrever este mtodo herdado de
BodyTagSupport o valor retornado ser
SKIP_BODY.
100
Nmero Tarefa Descrio

7 Executar doEndTag() Este mtodo pode ser utilizado para liberar os
recursos que voc porventura tenha utilizado
durante a execuo da sua classe tag handler.
O seu retorno afeta os prximos passos
tomados pelo container: se ele retornar
EVAL_PAGE o processo continua
normalmente, mas se retornar SKIP_PAGE o
container ignora o resto do corpo da pgina.
Se voc no sobrescrever este mtodo herdado
de BodyTagSupport o valor retornado ser
EVAL_PAGE.
8 Avaliar o restante da pgina O container passa a avaliar o restante da
pgina. Se encontrar outras tags customizadas
o processo comea novamente, agora com a
instanciao da classe tag handler
correspondente.
A figura abaixo demonstra os principais passos demonstrados acima:
As Constantes de Retorno
As diversas classes e interfaces da API de tags customizadas clssicas declaram vrias
constantes que podem ser utilizadas como retorno dos mtodos do ciclo de vida. So elas:
Constante Descrio
static int EVAL_BODY_AGAIN Faz com que o container avalie novamente o
corpo da tag no stream existente.
Declarada em
javax.servlet.jsp.tagext.IterationTag
101
Constante Descrio
static int EVAL_BODY_BUFFERED Faz com que o container avalie novamente o
corpo da tag no stream existente.
Declarada em
javax.servlet.jsp.tagext.BodyTag
static int EVAL_PAGE Faz com que o container continue avaliando a
pgina.
Declarada em javax.servlet.jsp.tagext.Tag
static int SKIP_BODY Faz com que o container salte a avaliao do
corpo da tag.
static int SKIP_PAGE Faz com que o container ignore o restante da
pgina.
Implementando Uma Tag Clssica

Criando Uma Tag Clssica com o NetBeans
Para criar uma tag clssica no NetBeans primeiro crie o projeto web e depois o TLD. Em
seguida selecione Arquivo > Novo Arquivo... e voc ver a janela mostrada abaixo:
Nesta janela selecione Web em Categoria e Manipulador de Marcao em Tipo de arquivo,

depois clique em Prximo. A tela abaixo ser mostrada:
102
Informe o nome da classe e o seu pacote. Selecione BodyTagSupport como classe de

suporte para indicar que quer criar uma tag clssica. Clique em Prximo para continuar com a
tela mostrada abaixo:
Nesta janela marque o checkbox para adicionar a sua tag handler ao arquivo TLD criado
anteriormente (clique em Procurar... para apontar para o arquivo). Depois selecione o tipo de
103
contedo do corpo e, por fim, clique no boto Novo... para adicionar os eventuais atributos.
Clique em Finalizar para terminar.
Veja o exemplo abaixo:
InputClassicTag.java
package classictags;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.BodyTagSupport;
public class InputClassicTag extends BodyTagSupport {
private String type;
private String name;
private String value;
public void setType(String type) {
this.type = type;
}
public void setName(String name) {
this.name = name;
}
public void setValue(String value) {
this.value = value;
}
@Override
public int doStartTag() throws JspException {
return SKIP_BODY;
}
@Override
public int doEndTag() throws JspException {
JspWriter out = pageContext.getOut();
try {
out.print("<input type=\"");
out.print(this.type);
out.print("\"");
if (this.name != null) {
out.print(" name=\"");
out.print(this.name);
out.print("\"");
}
if (this.value != null) {
out.print(" value=\"");
out.print(this.value);
out.print("\"");
}
out.print(" />");
} catch (IOException ioe) {
throw new JspException("Erro em InputClassigTag.",
ioe);
}
return EVAL_PAGE;
}
}
104
No exemplo acima comeamos nossa tag handler informando que ela estende
BodyTagSupport, que a classe mais utilizada como base para tags clssicas, mesmo para
aquelas que no tem corpo. Depois de definirmos os atributos que guardaro os atributos da tag
(no caso, name, type e value) e seus respectivos setters, passamos a definir os mtodos da
API.
Comeamos por sobrescrever doStartTag() apenas para retornar SKIP_BODY (caso
contrrio a implementao presente em BodyTagSupport seria utilizada, a qual retornaria
EVAL_BODY_BUFFER, forando o container a tentar avaliar o corpo (inexistente) da tag.
Por ltimo sobrescrevemos o mtodo doEndTag(), o qual faz todo o trabalho pesado no
exemplo demonstrado. Ele gera uma sada HTML de uma maneira bastante semelhante que
um Servlet faria, por meio de out.print(). No exemplo ele est gerando uma tag HTML
do tipo <input>, utilizando os atributos que recebeu do documento JSP como base para a
gerao do cdigo HTML. No final do mtodo vemos um retorno EVAL_PAGE, o que faz com
que o container continue processando normalmente o restante do documento JSP.
tags.tld
<tag>
<name>InputClassicTag</name>
<tag-class>classictags.InputClassicTag</tag-class>
<body-content>empty</body-content>
<attribute>
<name>type</name>
<required>true</required>
</attribute>
<attribute>
<name>name</name>
</attribute>
<attribute>
<name>value</name>
</attribute>
</tag>
</taglib>
O arquivo descritor de bibliotecas de tags acima define a nossa tag e seus atributos. Veja que a
tag <name> dentro da seo <tag> define o nome da tag como InputClasicTag. Este o
texto de tag que deveremos incluir em nosso JSP.
105
A seguir vemos que a classe tag handler se chama classictags.InputClassicTag, o

que significa que a nossa classe se chama InputClassicTag e est dentro do pacote
classictags.
Depois vemos que <body-content> foi definido como empty, o que indica que nossa tag
no tem corpo.
E a seguir vemos a definio dos atributos, name, type e value. O nico atributo
obrigatrio name, e todos eles so do tipo String e aceitam valores em tempo de execuo.
index.jsp
<%@taglib prefix="t" uri="/WEB-INF/tlds/tags" %>
<!DOCTYPE html>
<html>
<head>
<title>Tags Clssicas</title>
</head>
<body>
<h1>Tags Clssicas</h1>
<t:InputClassicTag name="nome"
type="text"
value="Joo" />
</body>
</html>
No documento JSP note a presena da diretiva <%@taglib>, a qual define o URI do nosso
arquivo de descrio de bibliotecas de tags (o qual tem que bater com o valor da tag <uri>
dentro do descritor de biblioteca de tags) e o prefixo que usaremos para invocarmos as tags
definidas l dentro.
Por fim temos a invocao da tag propriamente dita, por meio da linha
<t:InputClassicTag ... />.
Se voc executar este documento em seu browser, e se olhar o cdigo fonte que o browser
recebeu, ver o seguinte:
<!DOCTYPE html>
<html>
<head>
<title>Tags Clssicas</title>
</head>
<body>
<h1>Tags Clssicas</h1>
<input type="text" name="nome" value="Joo" />
</body>
</html>
Tags Clssicas com Corpo

Para criarmos tags clssicas que lidam com o corpo precisamos indicar isso no momento da
criao do elemento tag no arquivo TLD.
106
Por exemplo:
<tag>
<name>ToLowerCaseTag</name>
<tag-class>classictags.ToLowerCaseClassicTag</tag-class>
<body-content>JSP</body-content>
</tag>
Para que possamos lidar com o corpo das tags clssicas temos que usar o objeto
BodyContent, o qual pode ser retornado pelo mtodo getBodyContent() definido na
classe BodyTagSupport.
Veja abaixo os principais mtodos da classe BodyContent:
Mtodo Descrio
void clearBody() Limpa o corpo da tag sem lanar qualquer
exceo.
JspWriter getEnclosingWriter() Obtm o objeto JspWriter usado para escrever
o corpo desta tag.
abstract java.io.Reader getReader() Retorna o corpo da tag como um Reader.
abstract String getString() Retorna o corpo da tag como uma String.
abstract void writeOut(java.io.Writer out) Escreve o corpo da tag no Writer fornecido.
No caso de querermos ler o corpo da tag e o substituirmos por algum contedo gerado pela
nossa classe Java, basta que utilizemos o mtodo getEnclosingWriter() da classe
BodyTagSupport para escrevermos o novo contedo.
ToLowerCaseClassicTag.java
public class ToLowerCaseClassicTag extends BodyTagSupport {
@Override
public int doAfterBody() throws JspException {
try {
if (this.getBodyContent() != null) {
String body = this.getBodyContent().getString();
this.getBodyContent().getEnclosingWriter().write(
body.toLowerCase());
}
} catch(IOException ioe) {
throw new JspException("Erro:" + ioe.getMessage());
}
return SKIP_BODY;
}
}
No exemplo acima recuperamos o corpo corrente da tag j convertido para String por meio da
chamada a getBodyContent.getString(). Depois escrevemos o novo corpo por meio
de getBodyContent().getEnclosingWriter().write(), passando como
parmetro o novo corpo.
107
Mas em outras situaes no iremos querer substituir o corpo da tag, mas apenas manipul-lo de
alguma forma. Nestes casos podemos usar os mtodos doAfterBody() e doEndTag()
para controlar o fluxo de execuo.
Podemos usar isso para criarmos uma tag de loop, por exemplo, que ciclicamente fora o corpo
da tag a ser avaliado e por fim imprime o corpo gerado.
LoopClassicTag.java
public class LoopClassicTag extends BodyTagSupport {
private int vezes;
public void setVezes(int vezes) {
this.vezes = vezes;
}
@Override
public int doStartTag() throws JspException {
if (this.vezes > 0) {
return EVAL_BODY_BUFFERED;
} else {
return SKIP_BODY;
}
}
@Override
public int doAfterBody() throws JspException {
if (this.vezes > 1) {
this.vezes--;
return EVAL_BODY_AGAIN;
} else {
return SKIP_BODY;
}
}
@Override
public int doEndTag() throws JspException {
try {
if (this.bodyContent != null) {
this.bodyContent.writeOut(this.bodyContent.
getEnclosingWriter());
}
} catch (IOException ioe) {
throw new JspException(
"Erro: " + ioe.getMessage());
}
return EVAL_PAGE;
}
}
Tags Simples
SimpleTags so uma nova alternativa para a criao de custom tags, introduzidas com a
especificao JSP 2.0 (Novembro de 2003).
108
De codificao mais simples e baseadas em uma arquitetura mais leve, SimpleTags tem quase o
mesmo poder que as tags clssicas. O corpo das SimpleTags, entretanto, no pode conter
scriptlets ou expressions.
Classes SimpleTag usam menos mtodos, tem uma interface diferente para lidar com o corpo
das tags, bem como objetos de contexto diferentes.
Mas a grande vantagem a simplificao no ciclo de vida: no ter que lidar com os vrios
mtodos e constantes de retorno usadas pelas tags clssicas um enorme alvio.
Classes da API de Tags Customizadas Simples

A maior parte das classes e interfaces da API de tags customizadas simples tambm fazem parte
do pacote javax.servlet.jsp.tagext. Veja abaixo algumas das classes principais:
Interface JspTag
o Serve como base para as interfaces Tag e SimpleTag, basicamente para
segurana de tipos e organizao.
Interface SimpleTag
o A interface SimpleTag a base para criar tags simples.
Classe SimpleTagSupport
o Classe utilitria criada com a inteno de ser usada como classe base para todos
os seus tag handlers.
Classe JspContext
o Serve como classe base para PageContext e abstrai toda informao que no
especfica a servlets.
Classe JspFragment
o Encapsula uma poro de cdigo JSP usado como corpo de uma tag em um
objeto que pode ser invocado quantas vezes necessrias.
A Classe SimpleTagSupport
Normalmente voc estender SimpleTagSupport quando estiver desenvolvendo tags
simples. Veja abaixo alguns dos seus principais mtodos:
Mtodo Descrio
void doTag() O nico mtodo do ciclo de vida das tags
simples, aquele que guarda a lgica da tag. A
implementao em SimpleTagSupport no faz
nada.
static jspTag findAncestorWithClass(JspTag Encontra a instncia da classe indicada que a
from, Class klass) mais prxima da tag especificada.
JspFragment getJspBody() Retorna o corpo desta tag conforme passado
pelo container.
JspContext getJspContext() Retorna o contexto de pgina desta tag,
conforme passado pelo container.
JspTag getParent() Retorna a tag me desta tag, para fins de
colaborao.
void setJspBody(JspFragment jspBody) Prov o corpo desta tag como um objeto do
tipo JspFragment, capaz de ser invocado zero
ou mais vezes pela tag handler.
109
Mtodo Descrio
void setJspContext(JspContext pc) Mtodo chamado pelo container para oferecer
o objeto JspContext a esta invocao.
void setParent(JspTag parent) Estabelece a tag me desta tag, para fins de
colaborao.
A Classe JspContext
A classe javax.servlet.jsp.JspContext serve como classe base para
PageContext e abstrai toda informao que no especfica a servlets. a partir dela, por
exemplo, que obteremos o objeto JspWriter que usamos para gerar o contedo HTML.
Mtodo Descrio
Object findAttribute(String name) Retorna o atributo indicado nos escopos page,
request, session e application, ou null se ele
no existir.
Object getAttribute(String name) Retorna o objeto associado com a chave
indicada no escopo de page ou null se ele no
existir.
Object getAttribute(String name, int scope) Retorna o objeto associado chave indicada
no escopo especificado, ou null se ele no
existir.
Enumeration<String> Enumera todos os atributos presentes no
getAttributeNamesInScope(int scope) escopo indicado.
abstract JspWriter getOut() Recupera o objeto JspWriter que deve ser
usado para gerar sada por documentos JSP.
abstract void removeAttribute(String name) Remove o objeto associado chave
especificada do contexto de pgina.
abstract void removeAttribute(String name, Remove o objeto associado chave
int scope) especificada do contexto indicado.
abstract void setAttribute(String name, Object Registra o nome e valor indicados ao contexto
value) de pgina.
abstract void setAttribute(String name, Object Registra o nome e valor indicados ao contexto
value, int scope) especificado.
A Classe JspFragment
A classe JspFragment utilizada para encapsular o corpo de uma tag simples. Podemos usar seu
mtodo invoke() para fazer com que o corpo seja gerado dentro de um documento JSP.
Mtodo Descrio
abstract JspContext getJspContext() Retorna o JspContext que est associado a
este JspFragment.
110
Mtodo Descrio
abstract void invoke(Writer out) Executa o fragmento e dirige toda a sada para
o Writer indicado, ou para o Writer retornado
por JspContext.getOut() se o valor recebido
for nulo.
Implementando Uma Tag Simples

Criando Uma Tag Simples com o NetBeans
Para criar uma tag simples no NetBeans primeiro crie o projeto web e depois o TLD. Em
seguida selecione Arquivo > Novo Arquivo... e voc ver a janela mostrada abaixo:
Assim como fez com as tags clssicas, selecione Web e Manipulador de Marcao e clique
em prximo para ver a tela seguinte:
111
Desta vez, entretanto, selecione SimpleTagSupport como a classe de suporte. Clique em

prximo para escolher o TLD definir os atributos, exatamente como fez para criar uma tag
clssica.
112

Veja um exemplo abaixo:
LoopSimpleTag.java
package simpletags;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.JspFragment;
import javax.servlet.jsp.tagext.SimpleTagSupport;
public class LoopSimpleTag extends SimpleTagSupport {
private int vezes;
public void setVezes(int loop) {
this.vezes = loop;
}
@Override
public void doTag() throws JspException {
JspWriter out = this.getJspContext().getOut();
try {
for (int i = 0; i < this.vezes; i++) {
JspFragment body = this.getJspBody();
if (body != null) {
body.invoke(out);
}
}
113
} catch (java.io.IOException ioe) {

throw new JspException("Erro: ", ioe);
}
}
}
Note que neste exemplo nossa tag ter um nico atributo (vezes, do tipo int), e que no seu
mtodo doTag() fazemos um lao que conta de um at o valor do atributo vezes, exibindo o
corpo da tag a cada iterao. O resultado disso que o corpo da tag exibido tantas vezes
quantas o atributo vezes indicar.
Arquivos de Tags
Arquivos de tags so outra facilidade criada pela especificao JSP 2.0. Atravs deste recurso
mesmo pessoas que no conhecem nada de Java podem criar tags personalizadas (desde que
entendam o bsico de JSTL ...).
Os arquivos de marcao devem ser colocados no diretrio /WEB-INF/tags da sua aplicao
Web e ter a extenso .tag.
Implementando Um Arquivo de Tag

Criando Um Arquivo de Tag com o NetBeans
Para criar um arquivo de tag com o NetBeans primeiro crie o projeto e o TLD. Depois
selecione Arquivo > Novo Arquivo... e voc ver a tela mostrada abaixo:
Neste caso selecione Web e Arquivo de Marcao (Tag), e depois clique em Proximo para
ver a tela seguinte:
114
Nesta janela informe o nome do arquivo de tags que voc deseja criar, o subdiretrio de WEB-
INF onde ele dever ser armazenado e selecione o formato (normalmente a sintaxe padro).
Depois marque o checkbox Adicionar arquivo de marcao ao descritor da biblioteca de
marcaes e clique em Procurar... para selecionar o seu arquivo TLD.
InputTagFile.tag
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@tag description="Uma tag criada para testar tag files"
pageEncoding="UTF-8"%>
<%@attribute name="type"
required="true"
type="java.lang.String"%>
<%@attribute name="name"
<%@attribute name="size"
<input type="${type}"
<c:if test="${name != null}">
name="${name}"
</c:if>
<c:if test="${size != null}">
size="${size}"
</c:if>
>
Note que todos os atributos e configuraes da tag ficam no prprio arquivo de tag. Assim,
tudo o que o TLD precisa fazer indicar a existncia da tag:
tags;tld
115

<tag-file>
<name>InputTagFile</name>
<path>/WEB-INF/tags/InputTagFile.tag</path>
</tag-file>
</taglib>
Tags com Corpo

Para exibir o corpo da tag voc pode usar a tag <jsp:doBody />.
LoopTagFile.tag
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@tag description="Loop Tag File"
pageEncoding="ISO-8859-1"
body-content="scriptless"%>
<%@attribute name="vezes"
type="java.lang.String"
required="true"
rtexprvalue="true"%>
<c:forEach begin="1" end="${vezes}">
<jsp:doBody />
</c:forEach>
116

Servlet JSP PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Servlet JSP PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Java Web - Servlet e JSP

Todos os direitos reservados para Alfamdia Prow

As informaes contidas neste material de treinamento so distribudas NO ESTADO

02/2012 Verso 1.0.77

A Classe HttpServlet ........................................................................................................... 34

Verso Data JSR Principais APIs

No esquea de colocar uma linha em branco ao final.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"

H1 { font: 13pt/15pt verdana }

<h1>The page cannot be found</h1>

URI, URL e URN

Cabealho Descrio Exemplo

Cabealho Descrio Exemplo

Cdigo de Status Descrio

4xx Erro do Cliente

Cdigo de Status Descrio

5xx Erro do Servidor

Cabealho Descrio Exemplo

Cabealho Descrio Exemplo

Cabealho Descrio Exemplo

Embora seja perfeitamente possvel desenvolver suas aplicaes Java EE exatamente da

Ambiente Integrado de Desenvolvimento

Exemplos de Web Containers incluem:

Captulo 4 Aplicaes Web

Uma Aplicao Web em Java

Criando Uma Aplicao Java Web com o NetBeans

Criando um Servlet com o NetBeans

Agora d um nome ao seu servlet.

Nesta janela interessante marcar o checkbox Adicionar informao ao descritor de

Pronto, voc tem um Servlet no seu projeto.

grande maioria das classes estaro presentes no pacote javax.servlet.http. este o

Ecoando os Dados da Requisio

out.println(" <h2>Dados do Contexto</h2>");

Um uso particularmente importante para as declaraes de mtodos o tratamento de eventos

Percebendo Que Dados Foram Acrescentados Ou Removidos da Sesso

Quando o Cliente No Aceita a Sesso

Uma Pgina de Tratamento de Erros

Captulo 7 JSP Actions

Anteriormente examinamos 5 tipos de tags JSP:

A Tag <jsp:setProperty> e a Requisio

Captulo 8 Expression Language

Ento, se executasse os cdigos abaixo, obteria as respostas mostradas:

Usando Maps e Beans

String tipos[] = {Terror, Acao, Aventura, Comedia};

Lidando com os Parmetros da Requisio

Tipo Operador Descrio

Uma Aplicao Web Sem MVC

Variaes Sobre um Mesmo Tema

Uma Aplicao Web com MVC

Os Componentes da Arquitetura MVC

Os estados e transies da sua aplicao seriam representados por:

O Design-Pattern Abstract Factory

Usando componentes JavaBean, Expression Language e o padro MVC, conseguimos nos

Namespace Prefixo Funes

Colaborao Entre Tags

<c:set var=variavel scope=session value=teste />

Ao contrrio de <jsp:include>, <c:import> capaz de recuperar documentos que esto

default=Cidade Desconhecida />

Preparando os Resource Bundles

E se o seguinte trecho de cdigo fosse usado:

Os atributos type, pattern, currencyCode, currencySymbol, groupingUsed,

<jsp:useBean id=dataDeHoje class=java.util.Date />

Captulo 11 Custom Tags