Ebook JSP Serv JSF Struts

Desenvolvendo Web com JSP, Servlet, JSTL, JavaServer
Faces e Struts
Sumrio
Antes de comear................................................................................................................................................... 7
Captulo 1............................................................................................................................................................... 8
As tecnologias de servidor................................................................................................................................. 8
Protocolos, Pedidos e Respostas........................................................................................................................ 8
O Protocolo HTTP............................................................................................................................................. 8
O pedido via GET.............................................................................................................................................. 9
O pedido via POST.......................................................................................................................................... 10
A resposta HTTP............................................................................................................................................. 10
Outros Protocolos............................................................................................................................................ 11
Captulo 2............................................................................................................................................................. 13
A linguagem Java.......................................................................................................................................... 13
Instalando o software de desenvolvimento Java.............................................................................................. 13
Fazendo Download do Java SE 5.0 JDK ........................................................................................................ 14
A Instalao do J2SE 5.0 SDK no Windows................................................................................................... 15
Configurao do kit em seu ambiente operacional.......................................................................................... 22
Testando a configurao do J2SDK................................................................................................................. 24
Em Windows verso 9x.............................................................................................................................. 25
Instalando o J2SE 5.0 JDK no Linux............................................................................................................... 25
Captulo 3............................................................................................................................................................. 30
O que Tomcat?.............................................................................................................................................. 30
Servlets e JSP.................................................................................................................................................. 30
Instalando o Tomcat........................................................................................................................................ 30
Instalao Passo-a-Passo do Tomcat no Windows...................................................................................... 30
Captulo 4............................................................................................................................................................. 36
Introduo aos Servlets.................................................................................................................................... 36
O ciclo de vida de um Servlet.......................................................................................................................... 37
Rodando o Servlet no Tomcat......................................................................................................................... 40
A configurao do arquivo web.xml................................................................................................................ 41
Mapeando um Servlet...................................................................................................................................... 41
Outras formas de mapear um Servlet............................................................................................................... 42
Criando Arquivos Web Archive (WAR).................................................................................................... 43
Undeploy de uma aplicao Web usando o Tomcat 5.5............................................................................. 44
Deploying de uma nova aplicao usando o Tomcat 5.5............................................................................ 44
Captulo 5............................................................................................................................................................. 46
A classe HttpServlet........................................................................................................................................ 46
Criando um Servlet que trabalha com o mtodo POST................................................................................... 46
Trabalhando com o mtodo GET..................................................................................................................... 48
Recuperando strings de consulta com Servlets................................................................................................ 50
Enviando Caracteres Especiais em Query Strings........................................................................................... 51
Captulo 6............................................................................................................................................................. 55
Introduo ao JavaServer Pages....................................................................................................................... 55
A estrutura do JavaServer Pages...................................................................................................................... 55
Preciso compilar uma pgina JavaServer Pages?............................................................................................. 56
Visite: www.integrator.com.br 1
Faces e Struts
JavaServer Pages so Servlets?........................................................................................................................ 56
Como o Servlet Container saber que alterei o arquivo?................................................................................. 56
A configurao do arquivo web.xml................................................................................................................ 56
O ciclo de vida................................................................................................................................................. 57
A estrutura do JavaServer Pages...................................................................................................................... 57
Diretivas.......................................................................................................................................................... 58
Diretiva page.............................................................................................................................................. 58
Usando a diretiva page.................................................................................................................................... 59
Diretiva Include.......................................................................................................................................... 60
taglib................................................................................................................................................................ 61
Como compilar a taglib criada.................................................................................................................... 62
O Descritor da biblioteca de tags (TLD Tag Library Descriptor)............................................................ 63
Como utilizar essa taglib em sua aplicao................................................................................................. 64
Utilizando a tag personalizada em uma pgina JSP.................................................................................... 64
O uso de expresses......................................................................................................................................... 65
Captulo 7............................................................................................................................................................. 66
JavaBeans........................................................................................................................................................ 66
Criando seu primeiro JavaBean....................................................................................................................... 66
Outro exemplo................................................................................................................................................. 68
Compreendendo os JavaBeans......................................................................................................................... 69
As regras..................................................................................................................................................... 70
Usando as Actions <jsp:setProperty /> e <jsp:getPropert />............................................................................ 71
Criando um JavaBean mais dinmico.............................................................................................................. 72
O atributo scope............................................................................................................................................... 74
Validando um formulrio com JavaBeans....................................................................................................... 75
Captulo 8............................................................................................................................................................. 79
Trabalhando com Banco de Dados.................................................................................................................. 79
Introduo ao JDBC........................................................................................................................................ 79
MySQL e o JDBC........................................................................................................................................... 79
A instalao e utilizao do MySQL............................................................................................................... 79
Instalando no Windows................................................................................................................................... 79
Instalando o MySQL no Linux........................................................................................................................ 80
Acessando o banco de dados MySQL.............................................................................................................. 80
No Windows.................................................................................................................................................... 80
No Linux......................................................................................................................................................... 81
O comando CREATE...................................................................................................................................... 81
O comando USE ............................................................................................................................................. 82
Criando tabelas................................................................................................................................................ 82
O comando SHOW.......................................................................................................................................... 82
Configurando usurios..................................................................................................................................... 82
Confirmando o novo usurio........................................................................................................................... 83
Instalando o driver JDBC........................................................................................................................... 83
As APIs JDBC................................................................................................................................................. 83
O pacote java.sql........................................................................................................................................ 84
O javax.sql.................................................................................................................................................. 84
O acesso ao banco de dados e a conexo JDBC......................................................................................... 84
Faces e Struts
Os tipos de dados no Java e na SQL................................................................................................................ 85
Desenvolvendo via JDBC................................................................................................................................ 87
Conectando sua pgina JSP ao banco de dados............................................................................................... 87
Inserindo dados................................................................................................................................................ 90
Entendendo os principais Statements............................................................................................................... 93
Explorando a interface PreparedStatement................................................................................................. 93
Pool de conexes....................................................................................................................................94
Configurando o recurso JNDI JDBC.......................................................................................................... 94
Trabalhando com o aplicativo Web Admin..................................................................................................... 96
Baixando e Instalando o Admin.................................................................................................................. 96
Criando um administrador para acessar a aplicao Admin............................................................................. 96
Como configurar pelo admin o JNDI.......................................................................................................... 98
Captulo 9........................................................................................................................................................... 101
JavaServer Pages Standard Tag Library........................................................................................................ 101
Instalando o JavaServer Pages Standard Tag Library.................................................................................... 101
Criando seu primeiro exemplo em JSTL....................................................................................................... 102
Entendendo o JSTL....................................................................................................................................... 103
O Core Tag Library.................................................................................................................................. 103
Internacionalizando e Formatando............................................................................................................ 103
As tags SQL............................................................................................................................................. 104
As tags que processam XML.................................................................................................................... 104
Colocando na prtica..................................................................................................................................... 104
As actions <c:remove />, <c:when /> e <c:if />........................................................................................ 105
Actions <c:forEach />, <c:forTokens />................................................................................................... 106
A action <c:forTokens />..................................................................................................................... 108
A action de captura de erros..................................................................................................................... 110
Actions relacionadas a URL..................................................................................................................... 111
A action <c:import />............................................................................................................................... 111
A action <c:url />..................................................................................................................................... 112
A action <c:redirect />.............................................................................................................................. 112
A action <c:param />................................................................................................................................ 112
Internacionalizao da aplicao................................................................................................................... 113
A action <fmt:setLocale />....................................................................................................................... 113
Exibindo os textos no idioma definido..................................................................................................... 113
A actions <fmt:bundle /> e <fmt:setBundle />......................................................................................... 113
A Action <fmt:message /> ....................................................................................................................... 114
As actions de formatao.......................................................................................................................... 115
As diversas actions de formatao....................................................................................................... 115
A biblioteca de tags SQL............................................................................................................................... 118
A action <sql:setDataSource />................................................................................................................ 119
A action <sql:query />.............................................................................................................................. 119
A action <sql:update />............................................................................................................................. 121
As actions <sql:param /> e <sql:dateParam /> .................................................................................... 121
Captulo 10......................................................................................................................................................... 125
Model-View-Controller................................................................................................................................. 125
O que MVC?............................................................................................................................................... 125
Faces e Struts
As aplicaes Web......................................................................................................................................... 126
O Model 1................................................................................................................................................. 126
O Model 2................................................................................................................................................. 130
A pgina para logar (view inicial)....................................................................................................... 131
O Model Usuario.java......................................................................................................................... 132
O Controller Servlet Logar.................................................................................................................. 133
A View logado.jsp............................................................................................................................... 134
Captulo 11......................................................................................................................................................... 135
Data Access Object........................................................................................................................................ 135
Utilizando o DAO..................................................................................................................................... 141
Cadastrar novos livros.............................................................................................................................. 145
Captulo 12......................................................................................................................................................... 148
JavaServer Faces........................................................................................................................................... 148
Configurando um projeto JavaServer Faces................................................................................................... 148
Criando um exemplo simples para comear............................................................................................. 149
No diretrio WEB-INF........................................................................................................................ 149
O JavaBean.......................................................................................................................................... 150
O formulrio que enviar o nome........................................................................................................ 152
A pgina que resulta no sucesso do envio............................................................................................ 153
Conhecendo melhor o JavaServer Faces........................................................................................................ 154
As tags padres do JavaServer Faces............................................................................................................. 155
JSF Tags HTML ...................................................................................................................................... 155
JSF Tags Core ......................................................................................................................................... 161
Ciclo de Vida do JSF..................................................................................................................................... 163
Captulo 13......................................................................................................................................................... 164
Struts e NetBeans IDE 5.5............................................................................................................................. 164
Desenvolvendo uma aplicao com Struts..................................................................................................... 164
A camada Modelo..................................................................................................................................... 167
As mensagens...................................................................................................................................... 172
Criando a ao em Struts.......................................................................................................................... 173
O deployment description.................................................................................................................... 179
Passando dados para a View................................................................................................................ 180
O formulrio que enviar o nome........................................................................................................ 181
O bean que receber e enviar o nome................................................................................................ 182
A pgina que resulta no sucesso do envio............................................................................................ 182
O resultado final.................................................................................................................................. 183
As tags do Struts............................................................................................................................................ 183
As tags HTML do Struts................................................................................................................................ 184
A tag form........................................................................................................................................... 186
O atributo action ................................................................................................................................. 187
Tags Logic................................................................................................................................................ 187
Tags Bean ................................................................................................................................................ 189
Apndice A......................................................................................................................................................... 192
Contexto de desenvolvimento Web em Java.................................................................................................. 192
No diretrio WEB-INF............................................................................................................................. 192
Instalando uma aplicao Web em outro local.......................................................................................... 193
Faces e Struts
No Windows................................................................................................................................... 193
No Linux........................................................................................................................................ 193
Apndice B......................................................................................................................................................... 194
O XHTML..................................................................................................................................................... 194
O HTML 4..................................................................................................................................................... 194
Uma Introduo Linguagem HTML........................................................................................................... 194
HyTime - Hypermedia/Time-based Document Structuring Language .......................................................... 194
SGML - Standard Generalized Markup Language ........................................................................................ 195
Como so as Marcaes HTML?................................................................................................................... 195
Documento bsico e seus componentes......................................................................................................... 195
A tag <head />............................................................................................................................................... 196
A tag <body />............................................................................................................................................... 196
Quebra de linha.............................................................................................................................................. 196
Pargrafos...................................................................................................................................................... 196
Formatao de textos..................................................................................................................................... 196
Formatando em negrito............................................................................................................................. 197
Formatando em itlico.............................................................................................................................. 197
Ligando um documento com links................................................................................................................. 197
Tabelas ......................................................................................................................................................... 197
Formulrios................................................................................................................................................... 197
Outros atributos da tag <form />............................................................................................................... 198
enctype .................................................................................................................................................... 198
Entrando com dados...................................................................................................................................... 198
TAGS responsveis por entrada e envio de dados......................................................................................... 198
INPUT...................................................................................................................................................... 198
Campos de entrada de texto...................................................................................................................... 199
Campo de dados senha............................................................................................................................. 199
Outros Atributos....................................................................................................................................... 199
Caixas de checagem (Checkbox).............................................................................................................. 200
Botes de rdio.............................................................................................................................................. 200
CHECKED............................................................................................................................................... 201
Botes de ao............................................................................................................................................... 201
SUBMIT .................................................................................................................................................. 201
RESET ..................................................................................................................................................... 201
BUTTON.................................................................................................................................................. 201
IMAGE..................................................................................................................................................... 202
Caixas de seleo........................................................................................................................................... 202
Agrupando opes......................................................................................................................................... 203
reas de Texto.......................................................................................................................................... 204
Rtulos..................................................................................................................................................... 204
Campo Oculto........................................................................................................................................... 205
Campo de arquivos................................................................................................................................... 205
Botes de formulrio especiais...................................................................................................................... 205
BUTTON.................................................................................................................................................. 206
Somente leitura e Desabilitado...................................................................................................................... 206
READONLY............................................................................................................................................ 206
Faces e Struts
DISABLED.............................................................................................................................................. 206
FIELDSET............................................................................................................................................... 206
Tecla de acesso ............................................................................................................................................. 207
accesskey ................................................................................................................................................. 207
As diferenas entre o HTML 4 e o XHTML ................................................................................................. 207
Requisitos de conformidades para documentos........................................................................................ 207
Diferenas para o HTML 4............................................................................................................................ 208
Os documentos devem ser bem formados...................................................................................................... 208
Elementos e nomes de atributos devem ser em letras minsculas............................................................. 209
O uso de tags de fechamento obrigatrio............................................................................................... 209
Elementos vazios................................................................................................................................. 209
Os valores de atributos devem estar entre aspas....................................................................................... 209
A sintaxe para atributos deve ser escrita por completo............................................................................. 209
Elementos vazios...................................................................................................................................... 210
Em breve nas Melhores Livrarias....................................................................................................................... 211
Bibliografia......................................................................................................................................................... 215
Erratas encontradas neste e-book........................................................................................................................ 216
Faces e Struts
Antes de comear
Em algumas partes desse livro voc encontrar alguns smbolos, que o ajudaro a entender o cdigo
proposto e desenvolvido, que so os mostrados a seguir:
- Indica que o cdigo continua na linha de baixo.
- Indica que haver uma explicao do cdigo onde se encontra, indicado em meio a explicao, no
texto, da seguinte maneira: C .
... - Indica que acima ou abaixo contm mais cdigo, mas que no est sendo exibido por no ter sido
alterado.
Sobre o livro
Esse livro foi escrito com o intuito de ensin-lo, com uma viso superficial, a trabalhar com o
desenvolvimento de Servlets e JavaServer Pages, JavaServer Faces, Struts entre outros, focando no
desenvolvimento e no na utilizao de uma IDE.
No decorrer desse livro, voc aprender no somente a trabalhar com aplicaes Web escritas em Java
como tambm a instalar e configurar um Container Servlet, bem como trabalhar com banco de dados.
Quem deve ler este livro
Programadores com experincia em alguma linguagem de programao e com conhecimentos de
aplicativos Web.
Desenvolvedores em Java que trabalhem com aplicativos Desktop e desejam se aventurar na
construo de aplicaes Web.
Este pequeno Livro foi escrito com base no livro Desenvolvendo Aplicaes Web com JSP, Servlets,
JavaServer Faces, Hibernate, EJB 3 Persistence e Ajax, do autor Edson Gonalves, Cincia
Moderna.
Termos de Uso
Voc pode ler e distribuir este arquivo a todas as pessoas que desejar. Tambm poder ser distribudo
por revistas em CD-ROM, mas que antes dever ser feito um pedido de autorizao ao Integrator
Technology and Design para tal.
1
Faces e Struts
Captulo 1
As tecnologias de servidor
So diversas as tecnologias de servidor, sejam para construir um simples site com contedo dinmico
ou para construir um complexo sistema B2B (Business-To-Business), necessria a utilizao de
ferramentas que possibilitem consultar bancos de dados, integrao com sistemas corporativos, e etc.
Existem diversas tecnologias disponveis atualmente para o desenvolvimento dessa classe de
aplicaes, como PHP, ASP, ASP.NET, JSP, Servlet, CGI e etc.
A utilizao de Servlets e de pginas JSP oferece diversas vantagens em relao ao uso de outras
tecnologias de servidor. As principais vantagens so herdadas da prpria linguagem Java, como:
Portabilidade: a aplicao desenvolvida pode ser implantada em diversas plataformas, como
por exemplo Windows, Linux, Macintosh, sem que seja necessrio modificar ou mesmo reconstruir a
aplicao.
Orientao a Objetos: a programao orientada a objetos, simplificando o desenvolvimento de
sistemas complexos. Alm disso, a linguagem oferece algumas facilidades, como por exemplo o
gerenciamento automtico de memria (estruturas alocadas so automaticamente liberadas, sem que o
desenvolvedor precise se preocupar em gerenciar esse processo).
Flexibilidade: o Java j se encontra bastante difundido, contando com uma enorme comunidade de
desenvolvedores, ampla documentao e diversas bibliotecas e cdigos prontos, dos quais o
desenvolvedor pode usufruir sem a necessidade de gastar algum valor a mais ou at mesmo de
codificar.
Alm dessas vantagens, a arquitetura de servidor escrita em Java possibilita alguns benefcios
adicionais, como escalabilidade, onde na maior parte dos servidores de aplicaes modernos,
possvel distribuir a carga de processamento de aplicaes desenvolvidas em diversos servidores, sendo
que servidores podem ser adicionados ou removidos de maneira a acompanhar o aumento ou
decrscimo dessa carga de processamento.
Protocolos, Pedidos e Respostas
Existem um conjunto de protocolos que auxiliam o mapeamento de aes dos usurios do lado cliente
no uso de aplicaes Web.
A Web uma aplicao cliente/servidor em grande escala, onde o cliente (um navegador Web ou um
programa FTP) se conecta ao servidor usando um protocolo. O mais comum desses protocolos o
HTTP (Hypertext Transfer Protocol), onde em uma requisio do browser devolvido pelo servidor
textos e imagens.
Esse protocolo trabalha com pedidos e respostas.
O Protocolo HTTP
O protocolo HTTP comea com uma solicitao, que por sua vez o devolve com uma resposta. A
seguir voc tem as solicitaes desse protocolo:
Faces e Struts
GET Solicita ao servidor um recurso chamado de solicitao URI. Os parmetros da
solicitao devem ser codificados nessa solicitao, para que o mesmo os entenda. Este o
mtodo mais usado, pois a forma como o browser chama o servidor quando voc digita um
URL para que ele o recupere.
POST Embora similar ao GET, o POST contm um corpo no qual seus parmetros de
solicitao j so codificados. O mais frequente uso desse mtodo na submisso de
formulrios (X)HTML.
HEAD Similar ao mtodo GET, o servidor apenas retorna a linha de resposta e os cabealhos
de resposta.
PUT Esse mtodo permite o envio de arquivos par ao servidor Web.
DELETE Permite a excluso de documentos dentro do servidor Web.
OPTIONS possvel fazer uma consulta de quais comandos esto disponveis para um
determinado usurio.
TRACE Permite depurar as requisies, devolvendo o cabealho de um documento.
O pedido via GET
Aps enviar a solicitao, o navegador pode enviar alguns cabealhos que fornecem informaes a
respeito da solicitao, seu contedo, o browser que enviou sua solicitao e etc. Os cabealhos
aparecem em linhas consecutivas. Se voc faz um pedido via GET a um endereo Web, como
www.integrator.com.br, voc recebe as seguintes informaes:
GET / HTTP/1.1
Host: www.integrator.com.br
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; pt-BR; rv:1.8.0.4) Gecko/20060508 Firefox/1.5.0.6
Connection: Keep-Alive
De incio voc tem o mtodo utilizado para fazer o pedido dos dados, no caso o GET, seguido de uma
barra /, indicando que a informao requisitada direta a raiz do domnio. Caso haja um chamado a
um diretrio especfico, tambm chamado de Diretrio Virtual, voc veria GET /ajax/ HTTP/1.1,
indicando que o diretrio parte da raiz, contendo o nome indicado logo aps, no caso ajax. H tambm
um outra situao, a de enviar uma string de consulta, conhecida como query string, podendo tambm
ser visto da seguinte forma: GET
/eclipse/?empresa=Integrator%20Technology%20and%20Design. Nesse caso, voc ver o
caractere especial de interrogao ? indicando que existem uma string de consulta, seguido do nome
da varivel chamado no caso de empresa, um sinal de igual indicando a atribuio de valor e o valor
da varivel, que no caso contm uma codificao da URL, comum nos browsers modernos, onde o
espao, por exemplo, substitudo por %20. Na mesma linha voc tem o protocolo usado, chamado de
HTTP verso 1.1 HTTP/1.1, que se trata de um protocolo que implementa a possibilidade de ter
Faces e Struts
mltiplos hosts sobre um mesmo IP, conhecidos como Virtual Hosts.
Na segunda linha voc tem o Host, que indica o objetivo do pedido, no caso o endereo digitado. Essa
informao uma exigncia do protocolo HTTP 1.1, pois como j foi dito, em uma maquina pode
haver mltiplos hosts, e o servidor precisa saber para qual host ele deve apontar.
A terceira linha voc tem o cabealho User-Agent, que acessvel ao servidor e ao cliente, onde indica
o browser que voc est usando, bem como o sistema operacional e a lngua usada. A quarta e ltima
linha se trata do cabealho Connection, que tipicamente tem o valor de Keep-Alive.
O pedido via POST
Um pedido via POST muito similar ao pedido via GET, mas se diferencia pela quantidade de
informaes que podem ser transmitidas por essa forma.
Tipicamente, voc veria os seguintes cabealhos em um pedido via POST:
POST / HTTP/1.1
Host: www.integrator.com.br
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; pt-BR; rv:1.8.0.4) Gecko/20060508 Firefox/1.5.0.4
Content-Type: application/x-www-form-urlencoded
Content-Length: 57
Connection: Keep-Alive
empresa=Integrator%20Technology%20and%20Design&nome=Edson
A primeira linha indica o mtodo utilizado, no caso o POST. Os cabealhos HOST e User-Agent so
iguais ao do mtodo GET.
O cabealho Content-Type indica como o corpo do pedido codificado. Os browsers sempre
codificam os dados postados como application/x-www-form-urlencoded, que o MIME type usado
para codificar URL simples (similar ao %20 visto no envio de informaes com espao pelo mtodo
GET).
O cabealho Content-Length indica o comprimento de bytes transmitidos, que no caso so 57. Aps o
cabealho Connection voc tem uma linha em branco, seguida das informaes transmitidas pelo
mtodo. Nesse caso voc tem a transmisso de duas variveis (empresa e nome), seguidas de suas
respectivas informaes. Note o & e - comercial, o separador padro utilizado para envio de mais de
uma varivel.
A resposta HTTP
A resposta HTTP tem uma linha de status (como a de solicitao) e cabealhos de resposta, assim como
o corpo de resposta opcional.
No caso de voc entrar em um site e ele estiver disponvel, voc teria a seguinte resposta:
Faces e Struts
HTTP/1.1 200 OK
Date: Sat, 15 Apr 2006 18:21:25 GMT
Content-Type: text/html;charset=ISO-8859-1
Content-Length: 2541
<html>
<head>
<title> Integrator Technology and Design </title>
</head>
<body>

Existem respostas no qual o servidor encaminha ao browser que contm nmeros no qual voc, como
desenvolvedor de aplicaes Web deve decorar, que so:
200 (OK): Confirmao de que a requisio foi respondida com sucesso.
304 (NOT MODIFIED): Os recursos no foram modificados desde a ltima vez quem que
voc fez um pedido. Isso ocorre por causa dos mecanismos de cache do browser.
401 (UNAUTHORIZED): O cliente no tem acesso autorizado para acessar a rea requisitada.
Pode ocorrer de o browser pedir um nome de usurio e senha, devido ao acesso restrito a essa
rea no servidor.
403 (FORBIDDEN): O acesso rea requisitada falhou. Isso pode ocorrer em caso de acesso a
reas que exigem login e senha e no houve autorizao para aquele usurio.
404 (NOT FOUND): No encontrado. Ocorre quando voc tenta acessar uma rea inexistente
no endereo passado, por exemplo, pginas removidas ou recursos excludos.
O servidor devolver um cabealho Date que indica a data e hora em que a resposta foi gerada no
servidor. O cabealho de Content-Type especifica o MIME type para HTML (text/html) com uma
codificao ISO-8859-1 (padro para recursos cujas informaes contenham acentos, como ocorre em
nosso idioma). O cabealho Content-Length similar ao visto em POST. O restante so informaes
que sero exibidas no browser, ou seja, o contedo, propriamente dito, do site.
Outros Protocolos
No menos importante que o protocolo HTTP, voc tem tambm os seguintes protocolos disponveis
na Internet:
TCP A sigla significa Transport Communication Protocol e representa a camada de transporte
de dados e comunicao entre mquinas, cliente e servidor.
HTTPS Similar ao HTTP, mas com SSL (Secure Socket Layer) sobre esse protocolo, possui
criptografia que assegura a troca de dados entre cliente e servidor, evitando assim a leitura dos
dados por terceiros que no contenham a chave da criptografia.
FTP Sigla para File Transfer Protocol, onde muito usado para transmisso de arquivos para
um servidor. Fornece os principais comandos para troca de arquivos.
SMTP A sigla significa Simple Message Transfer Protocol, e fornece os comandos
necessrios para envio de mensagens a um servidor de e-mail.
POP Sigla para Post Office Protocol, onde permite que um cliente acesse e manipule
Faces e Struts
mensagens de correio eletrnico disponveis em um servidor.
IMAP A sigla significa Internet Message Access Protocol e permite que um cliente acesse e
manipule mensagens de correio eletrnico disponveis em um servidor, assim como ocorre no
protocolo POP.
Faces e Struts
Captulo 2
A linguagem Java
De tempos em tempos o mundo conhece uma grande mudana. No mundo do desenvolvimento, uma
delas aconteceu quando Java foi anunciado, em maio de 1995, pela empresa Sun Microsystems, no qual
lanava naquele momento uma linguagem de programao que trabalhava em sites produzidos na
World Wide Web.
O que chamava ateno nessa linguagem era o fato de que ela podia ser portvel para outros sistemas
operacionais. Alm, sua fama cresceu rapidamente porque a Web como conhecemos hoje estava em
ascenso, e Java possibilitava fazer diversas coisas, como animaes, que at ento no eram possveis
em pginas existentes na World Wide Web.
Seu tamanho tambm era um fator importante, onde depois de instalado uma mquina virtual em sua
mquina, os arquivos Applet, como so conhecidos at hoje, eram pequenos assim como a velocidade
de transmisso na poca, o que facilitava a visualizao desses aplicativos.
O Java amadureceu e com as mudanas ocorridas no mundo, muitas implementaes foram criadas,
com o intuito de abranger essas mudanas. Hoje voc pode estar usando tanto aplicativos desktop,
pginas para a Internet ou at mesmo aplicativos pequenos em celulares. Todos criados com a
linguagem Java.
A linguagem Java nos dias de hoje utilizada por grandes bancos, pois fornece extrema segurana.
Tambm utilizada por grandes empresas que desejam trafegar uma grande quantidade de dados e
necessita de estabilidade e portabilidade entre outras empresas.
Milhes de pessoas j aprenderam essa linguagem e, grandes empresas a esto usando. Lugares como a
NASA, IBM, ESPN entre outros so apenas exemplos da confiabilidade que a linguagem Java
demonstra em seus utilizadores.
As variaes de formas e sistemas criados em Java so imensos. Voc encontra Java em:
Servidores Web
Bancos de dados relacionais
Computadores de grande porte
Telefones mveis
Sistemas de carto de crdito entre outros
Instalando o software de desenvolvimento Java
Atualmente, o SDK (Sotware Development Kit) est em sua verso 5 e est disponvel para as
seguintes plataformas:
Microsoft Windows
Faces e Struts
Linux
Sun Solaris
Mac Os
Entre outros
Voc pode baixar o programa no site Web sobre Java da Sun no endereo http://java.sun.com.
A Sun publica periodicamente releases do SDK e costuma numer-los com um ponto extra e um dgito
logo aps o nmero da verso principal, como por exemplo: 1.4.1, 1.5.0.1 e etc.
Obs.: Cuidado na hora de baixar o kit de desenvolvimento, pois existem outros kits, no qual o que
voc precisar est descrito logo a seguir.
Fazendo Download do Java SE 5.0 JDK
O primeiro passo para que voc comece a desenvolver programas em Java, consiste em obter o Kit de
Desenvolvimento Java, que j est na verso 1.5, atualmente conhecido como Java SE. Para conseguir
o Java SE 5.0 JDK voc deve acessar o endereo: http://java.sun.com/javase/downloads/index.jsp.
Aps acessar o endereo anterior, a pgina de download do Java SE 5.0, voc ver vrios produtos,
referentes ao Java SE, para download. Logo a seguir voc ter uma descrio dos mais utilizados pelos
iniciantes em Java:
JDK 5.0 with NetBeans IDE Consiste em uma IDE (Ambiente de Desenvolvimento Integrado
como o Eclipse) mais o Java SE 5.0 JDK.
JDK 5.0 with Java EE Consiste em modelos de componentes, gerenciamento, web services e
APIs de comunicao necessrios para o desenvolvimento de aplicaes Web mais o Java SE 5.0 JDK
(voc ver a respeito mais adiante).
JDK 5.0 Este o kit de desenvolvimento Java. Este kit consiste em um compilador (javac), uma
ferramenta de execuo (java), uma ferramenta para gerao de documentao (javadoc), um conjunto
de bibliotecas prontas para o uso e etc.
Java Runtime Environment (JRE) 5.0 Este o ambiente runtime do Java, usado apenas para
executar os programas feitos em Java.
J2SE 5.0 Documentation A documentao do J2SE. Esta documentao contm as informaes
sobre todas as bibliotecas do Java.
Clique no link Download JDK, a pgina de termos de uso (Terms of Use) ser mostrada, para efetuar o
download do JDK, voc deve aceitar os termos de uso do Java SE, clique na caixa de checagem
Accept e em seguida no boto Continue. Em seguida a pgina de Download ser carregada.
Observe que na pgina de Download existem diversos Java SE. Existem Java SE para plataforma
Windows, Linux, Solaris SPARC, Solaris x86 e Linux AMD64. No seu caso voc efetuar o download
do Java SE para o seu sistema operacional.
Faces e Struts
A Instalao do J2SE 5.0 SDK no Windows
Aqui, neste exemplo, eu irei abordar a instalao do SDK na plataforma Windows, mais
especificamente no sistema operacional Windows XP.
O mesmo processo se aplica as outras plataformas Microsoft.
Aps efetuar o download do SDK, d um duplo clique no arquivo executvel. No momento em que
escrevo esse livro, a verso baixada era jdk-1_5_0_07-windows-i586-p.exe.
A primeira etapa da instalao a tela de licena. Clique na caixa de seleo I accept the terms in the
license agreement, e clique em Next. Esta tela descreve os temos de licena do J2SE 5.0 JDK.
Figura 1
Faces e Struts
Figura 2
Na segunda etapa, voc tem a tela de configurao. Nesta tela voc pode configurar o tipo de instalao
que deseja. . Clique apenas no boto Change... se desejar alterar o diretrio onde o J2SDK ser
instalado.
Faces e Struts
Figura 3
Alterando o diretrio de instalao do J2SDK:
Caso voc queira alterar o diretrio onde ser instalado o J2SDK, na caixa Folder Name altere seu
caminho para C:\jdk1.5.0_07\, deixando igual ao da Figura 4 e clique no boto OK, para retornar a
tela anterior. Clique no boto Next em seguida.
Faces e Struts
Figura 4
Aguarde at o fim do processo de instalao do J2SDK.
Faces e Struts
Figura 5
Na Tela de Configurao do Runtime do Java (Figura 6) clique no boto Next para continuar, no
necessrio mudar o diretrio.
Faces e Struts
Figura 6
Nesta etapa voc habilita os browsers para suportar programas desenvolvidos em Java, os Java Applets
(Figura 7). Depois clique no boto Next e aguarde os arquivos serem copiados.
Faces e Struts
Figura 7
Pronto, o processo de instalao do J2SE 5.0 JDK, bem como o Runtime do Java foram
completamente instalados. Clique no boto Finish para finalizar.
Faces e Struts
Figura 8
Configurao do kit em seu ambiente operacional
Um problema muito comum encontrado nos iniciantes em programao Java a configurao do kit no
seu ambiente operacional.
Para configurar qualquer varivel de ambiente em um sistema Windows na verso NT, voc deve
entrar no Painel de Controle, Sistema e na guia Avanado clique no boto Variveis de Ambiente.
Faces e Struts
Figura 9
Nota: As variveis de ambiente so seqncias de caracteres que contm informaes como unidade,
caminho ou nome de arquivo. As variveis de ambiente controlam o comportamento de vrios
programas. Como exemplos de variveis de ambiente temos: PATH, CLASSPATH, USER, TEMP,
JAVA_HOME e etc.
Estas variveis de ambiente so utilizadas por muitos programas, para definir um espao em memria
principal (RAM), onde alguns processamentos sero executados.
A varivel PATH contm uma lista de diretrios (caminhos de programas) separados por pontos-e-
vrgulas.
V at o fim da varivel e adicione um ponto-e-vrgula, se esse j no houver, e adicione o caminho
onde seu SDK est instalado, seguido do texto \bin, que neste caso seria (Figura 10):
C:\jdk1.5.0_07\bin;
Faces e Struts
Figura 10
Confirme as caixas de dilogos e logo aps faa o teste.
Testando a configurao do J2SDK
Aps a configurao do J2SDK, voc dever fazer um teste para ver se tudo ocorreu com sucesso. O
processo de teste consiste em abrir o Promp de comando do Windows:
Boto Iniciar, Todos os programas, Acessrios e finalmente Prompt de comando.
Na tela do prompt de comando digite java version:
Faces e Struts
Figura 11

Em Windows verso 9x
Voc deve editar o arquivo autoexec.bat, encontrado em C:\autoexec.bat e adicionar as variveis
como o exemplo a seguir:
set JAVA_HOME= C:\jdk1.5.0_07
Onde o local indicado no exemplo, onde voc tem instalado o JDK.
Instalando o J2SE 5.0 JDK no Linux
Aps a concluso do download do SDK, abra o terminal do Linux e siga os passos a seguir. No
momento em que escrevo esse livro, a verso baixada era jdk-1_5_0_07-linux-i586.bin.
Digamos que voc tenha baixado no diretrio /tmp, como foi o caso na elaborao desse livro. No se
esquea estar como root para fazer a instalao.
No terminal digite os comandos a seguir em destaque:
Para entrar no diretrio, caso voc j no esteja nele:
shell# cd /tmp
Alterando a permisso do arquivo para executvel, assim voc poder instal-lo:
shell# chmod +x jdk-1_5_0_07-linux-i586.bin
Executando o arquivo:
shell# ./jdk-1_5_0_07-linux-i586.bin
Faces e Struts
Figura 12
Assim que iniciar a instalao, voc ver a tela de licena da instalao, como mostra a imagem seguir
(Figura 13):
Faces e Struts
Para visualizar toda a licena, use as setas para cima e para baixo do seu teclado. As teclas Page Up e
Page Down tambm podem ser usadas.
Ao final voc ver a pergunta de que aceita os termos de licena Do you agree to the above licence
terms? [yes or no]. Digite y (Figura 14):
Figura 13
Faces e Struts
A instalao ser iniciada. Ao seu trmino, mova o diretrio criado para o local que voc achar mais
indicado ou para um outro diretrio se desejar (Figura 15):
shell# mv jdk1.5.0_07 /usr/local/
Figura 14
Faces e Struts
Entre no arquivo profile em /etc/profile e adicione as linhas:
JAVA_HOME=/ jdk1.5.0_07
JRE_HOME=/ jdk1.5.0_07/jre
export JAVA_HOME
export PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/lib
export MANPATH=$MANPATH:$JAVA_HOME/man
As variveis usadas so explicadas rapidamente a seguir, dando a voc noo do que cada uma faz:
JAVA_HOME - Diretrio onde a JDK est instalada
JRE_HOME - Diretrio onde a mquina virtual est instalada
PATH - Diretrio dos executveis, onde inclui o do Java
CLASSPATH - Diretrio das libs
MANPATH - Diretrio do manual, acessvel por man javac.
java -version
Surgindo as informaes, a instalao foi feita com sucesso.
Figura 15
Faces e Struts
Captulo 3
O que Tomcat?
Tomcat tem suas origens no incio da tecnologia servlet. A Sun Microsystems criou o primeiro
continer servlet, o Java Web Server, para demonstrar a tecnologia, mas no era um servidor robusto,
para uso na Web como se necessitava. Ao mesmo tempo, o Apache Software Foundation (ASF) criou
JServ, um servlet engine que integrava com o servidor Web Apache.
Em 1999, a Sun Microsystems doou o cdigo do Java Web Server para o ASF, e os dois projetos se
fundiram para criar o Tomcat. A verso 3.x foi primeira da srie Tomcat e teve a descendncia direta
do cdigo original que a Sun Microsystems doou ao ASF.
Em 2001, o ASF liberou a verso 4.0 do Tomcat, que era uma completa arquitetura redesenhada do
Tomcat no qual teve um novo cdigo base. A srie Tomcat, verso 4.x um RI (reference
implementation) de especificaes Servlet 2.3 e JSP 1.2.
A verso Tomcat 5.x a atual e a RI de especificaes Servlet 2.4 e JSP 2.0, no qual esse livro est
baseado.
Tecnicamente, o Tomcat um Container Web (como j dito anteriormente). Mas o Tomcat tem a
capacidade de atuar tambm como servidor Web/HTTP assim como pode funcionar integrado a um
servidor web dedicado como o Apache ou o Microsoft IIS. O Tomcat, porm, no implementa at o
momento um container EJB.
Servlets e JSP
J2SE (Standard Edition) planejado para desenvolvimento do lado cliente e pode ser usada para
desenvolver as tradicionais aplicaes baseadas em cliente/servidor.
As aplicaes para Web esto aladas em Java EE (Enterprise Edition). A implementao de aplicaes
Web usando o padro Java EE bastante complexa.
Servlets e JSP so duas tecnologias desenvolvidas pela Sun Microsystems para desenvolvimento de
aplicaes Web a partir de componentes Java que executem do lado servidor.
Instalando o Tomcat
Para instalar o Tomcat, inicialmente, voc dever ter tambm instalado o Java em sua mquina.
Se voc apenas for rodar aplicaes no Tomcat, basta ter o JRE (mquina virtual do Java) instalado.
Mas se voc desenvolve, o ambiente JDK dever estar instalado (como j visto anteriormente).
A srie estvel de verses 5.5.x para o Tomcat 5, uma ramificao da srie 5.0.x, focada para o J2SE
5.0, com uma nova modelagem de vrios componentes estruturais visando maior desempenho,
estabilidade e facilidade de manuteno. Para quem utiliza o J2SE 1.4, o Tomcat 5.0.x ainda o mais
recomendado. O uso do Tomcat 5.5 com J2SE 1.4 requer o download e instalao de um pacote
adicional de compatibilidade (jakarta-tomcat-5.5.?-compat.zip).
Instalao Passo-a-Passo do Tomcat no Windows
Siga o anexo correspondente verso desejada, para um passo-a-passo do processo de instalao e
Faces e Struts
configurao inicial do Tomcat:
1. Inicie o programa de instalao. O assistente de instalao ser iniciado. Na caixa de dilogo de
Boas-vindas, clique no boto Next.
Figura 1
2. Clique no boto I Agree para aceitar os termos de licena e prosseguir.
Figura 2
Faces e Struts
3. Na escolha de componentes do software, o padro o tipo de instalao Normal, que inclui,
alm do ncleo essencial (core) do Tomcat Servlet container, toda a documentao, exemplos
de Servlet e JSP e os cones no Menu Iniciar. Esta seleo adequada para o uso geral.
A instalao Normal no tem a ativao automtica do Tomcat como servio e o cdigo-fonte
do mesmo.
Figura 3
4. A instalao do Tomcat 5 sempre cria um servio do Windows (NT/2000/XP/2003) para o
Tomcat.
Faces e Struts
Figura 4
5. A seguir, ser confirmado o local de instalao do software. Selecione o local onde o Tomcat
ser instalado e clique no boto Next para prosseguir.
Figura 5
Faces e Struts
6. O dilogo Configuration Options permite a voc definir duas opes administrativas do
Tomcat: o porta HTTP pelo qual o Tomcat ser acessvel, trabalhando como um servidor web
com o propsito de testes e administrao, e o usurio (User Name) e senha (Password) para o
acesso ao Manager.
A senha do usurio administrativo do Tomcat (j padronizado como admin) pode ser deixado
em branco ou alterado, mas para fins didticos apenas defina uma senha e clique no boto Next
para prosseguir:
Figura 6
7. O instalador do Tomcat procura detectar uma verso de Java Runtime (JRE) instalada,
necessria para seu funcionamento.
8. Terminada as configuraes solicitadas pelo assistente, clique no boto Install para instalar o
Apache Tomcat.
Faces e Struts
Figura 7
9. No final da instalao, o assistente dar duas opes: uma de executar o Tomcat (Run Apache
Tomcat) e de visualizar o arquivo leia-me (Show Readme).
Figura 8
Faces e Struts
Captulo 4
Introduo aos Servlets
Servlets so classes Java, desenvolvidas de acordo com uma estrutura bem definida, e que, quando
instaladas junto a um Servidor que implemente um Servlet Container (um servidor que permita a
execuo de Servlets, muitas vezes chamado de Servidor de Aplicaes Java), podem tratar requisies
recebidas de clientes.
A seguir voc tem um exemplo de Servlet:
MeuPrimeiroServlet.java
package meupacote;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MeuPrimeiroServlet extends javax.servlet.http.HttpServlet {
public void destroy() {
super.destroy();
}
public void init() throws ServletException {
super.init();
}
protected void service(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=ISO-8859-1");
String html = "<html>" +
"<head><title>Trabalhando com Servlet</title></head>" +
"</head>" +
"<body>" +
"<h1>Meu Primeiro Servlet</h1>" +
"</body>" +
"</html>";
PrintWriter out = response.getWriter();
out.print(html);
}
}
O mtodo setContentType(String s) C Especifica o tipo de contedo (MIME Media Types) da
resposta para o navegador. O MIME Type ajuda o navegador a determinar como exibir os dados. O
1
Faces e Struts
MIME (Multipurpose Internet Mail Extensions) Type nesse caso "text/html", indicando que a
resposta um documento HTML. Para ver uma lista completa de tipos de contedo, visite o site
http://www.iana.org/assignments/media-types/.
Caso voc altere o MIME Type de sada, seu navegador poder se comportar chamando o programa
que represente a leitura da media no seu sistema operacional ou ento colocar para download caso no
o reconhea.
O ciclo de vida de um Servlet
Todo Servlet segue um ciclo de vida composto de 3 fases: inicializao, atendimento as requisies e
finalizao.
A inicializao ocorre quando o Servlet Container carrega o Servlet: se o parmetro <load-on-statup
/> estiver presente e contiver um inteiro positivo, abordado mais adiante, essa carga ocorre quando o
prprio servidor iniciado; caso contrrio, essa carga ocorre quando recebida a primeira requisio a
ser mapeada para a aplicao que contm o Servlet.
Aps a inicializao, o Servlet pode atender requisies. Assim, enquanto o servidor estiver ativo, e a
aplicao que contm o Servlet estiver carregada, este permanecer na fase 2 de seu ciclo. Uma
vantagem da tecnologia de Servlets e pginas JSP com relao a outras tecnologias que o fato do
Servlet permanecer carregado permitindo assim com que dados armazenados em variveis de classe
persistam ao longo dos diversos pedidos recebidos. Assim, possvel manter um pool de conexes ao
banco de dados, por exemplo, de maneira que no haja necessidade de iniciar e estabelecer uma nova
conexo ao banco de dados a cada novo pedido recebido.
Finalmente, quando o servidor finalizado, ou quando a aplicao tornada inativa pelo Servlet
Container, o Servlet finalizado.
Figura 1 - Ciclo de Vida de um Servlet
Faces e Struts
O cdigo anterior, feito na plataforma Eclipse, um Servlet chamado de MeuPrimeiroServlet, uma
classe Java que estende a classe javax.servlet.http.HttpServlet, uma classe abstrata que estende
javax.servlet.GenericServlet. Essa ltima implementa a interface javax.servlet.Servlet, que a fonte
de toda a programao Servlet, onde temos a abstrao central dessa tecnologia. Todo Servlet
implementa essa interface, direta ou indiretamente.
O funcionamento bsico de um Servlet compreende em:
void init (ServletConfig config) - A inicializao do Servlet para parmetros que podem ser lidos e
variveis comuns a todas as requisies que devem ser inicializadas. Um exemplo disso so as
conexes ao banco de dados estabelecidas aqui, na inicializao.
void service(HttpServletRequest req, HttpServletResponse res) Chamadas ao mtodo de servio,
pelo Servlet Container, onde seu servlet responde as suas solicitaes. aqui onde o Servlet vai
interagir com os pedidos, processar e responder.
void destroy( ) - Esse mtodo libera os recursos que estavam sendo usados pelo Servlet e chamado
quando finalizado pelo servidor em que est sendo executado.
Nota: O servlet criado est baseado em HttpServlet, a classe abstrata que gera aplicaes web baseadas
no protocolo HTTP. No entando, a API no foi criada somente para esse protocolo.
Faces e Struts
A criao de Servlets exige as classes do pacote javax.servlet e javax.servlet.http, que pertencem a
API Servlet do Java, que faz parte do Java EE.
Para compilar o cdigo, voc precisa incluir no classpath o arquivo servlet-api.jar, que fica no
diretrio lib do Tomcat: $CATALINA_HOME/common/lib/servlet-api.jar, onde
$CATALINA_HOME do diretrio de instalao do seu TOMCAT.
Figura 2
Faces e Struts
Para compilar, voc deve fazer:
javac -classpath $CATALINA_HOME/common/lib/servlet-api.jar Site/MeuPrimeiroServlet.java
Digamos que no Windows, seu Tomcat esteja instalado em C:\Tomcat, ento voc teria que executar
da seguinte maneira:
javac -classpath C:\Tomcat\common\lib\servlet-api.jar Site\MeuPrimeiroServlet.java
Um arquivo com a extenso .class criada.
Rodando o Servlet no Tomcat
Para fazer o exemplo rodar no Tomcat, voc deve fazer a seguinte configurao de diretrios:
Dentro de $CATALINA_HOME, em webapps, crie um diretrio chamado Site e dentro dele a
sequncia de diretrios e o arquivo .class gerado, como mostra a seguir:
Tomcat\
webapps\
Site\
WEB-INF\
classes\
meupacote\
MeuPrimeiroServlet.class
Dentro do diretrio WEB-INF, voc dever criar um arquivo descritor da sua aplicao. Esse arquivo
se chamar web.xml e ter a seguinte aparncia:
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app id="WebApp_ID">
<description>
Descritor do contexto de desenvolvimento.
</description>
<display-name>
Meu Primeiro Servlet
</display-name>
<servlet>
<servlet-name>MeuPrimeiroServlet</servlet-name>
<servlet-class>
meupacote.MeuPrimeiroServlet
</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>MeuPrimeiroServlet</servlet-name>
<url-pattern>/MeuPrimeiroServlet</url-pattern>
</servlet-mapping>
</web-app>
Faces e Struts
Depois de configurado, digite no navegador o URL do seu Tomcat chamando o Servlet:
http://localhost:8080/ProjetoJavaWeb/MeuPrimeiroServlet
O resultado ser como mostrado a seguir:
Para entender os Servlets, uma breve explicao do pacote javax.servlet e javax.servlet.http:
javax.servlet Pacote dos servlets genricos, independe de protocolo;
javax.servlet.http Estende a funcionalidade do pacote javax.servlet para uso do protocolo HTTP.
A configurao do arquivo web.xml
O arquivo descritor de contexto (Deployment Descriptor) padro de uma aplicao Web, segundo a
especificao Java Servlet/Java EE. As informaes nele contidas detm as configuraes especificas
da aplicao. Onde voc tem:
Informaes textuais de ttulo (elemento <display-name />, nome para exibio no Manager) e
comentrio da descrio (<description />) do contexto, teis para identificao e
documentao.
O elemento <servlet /> indica o nome do Servlet bem como sua classe.
No elemento <servlet-mapping /> voc mapeia o Servlet para que seja melhor acessvel no
navegador. Para entender essa ltima situao, veja a explicao a seguir:
Mapeando um Servlet
Chamar um Servlet pelo pacote e nome da classe uma situao incomum e estranha, por isso mapear
um Servlet uma boa prtica para acesso a mesma. Para isso, o elemento <servlet /> e <servlet-
mapping /> entram em ao. A Figura 4 a seguir demonstra essa situao:
Figura 3
Faces e Struts
O acesso a esse Servlet pelo navegador ser digitando MeuServlet no caminho da sua aplicao Web:
http://localhost:8080/Site/MeuServlet
Outras formas de mapear um Servlet
Existe uma outra forma de mapear o Servlet, especificando diversas urls, apontando assim para o
mesmo Servlet. Se voc marcar o elemento <url-pattern /> como /MeuServlet/*, toda url que acessar
o padro http://localhost:8080/Site/MeuServlet/* ir ter acesso ao Servlet criado:
web.xml
...
<servlet-mapping>
<servlet-name>UmServlet</servlet-name>
<url-pattern>/MeuServlet/*</url-pattern>
</servlet-mapping>
...
Tambm poder ser acessado da seguinte forma:
http://localhost:8080/Site/PrimeiroServlet.java
Figura 4 - Servlet chamada de UmServlet mapeada como MeuServlet
Faces e Struts
web.xml
...
<servlet-mapping>
<servlet-name>PrimeiroServlet</servlet-name>
<url-pattern>*.java</url-pattern>
</servlet-mapping>
...
O elemento <load-on-startup /> indica que este Servlet deve ser carregado quando a aplicao for
iniciada.
O contedo desse elemento deve ser um inteiro indicando a ordem na qual o Servlet ser carregado. Se
o valor um inteiro negativo, ou no for apresentado (se esse elemento no existir), o container carregar o
Servlet que quiser. Se o valor um inteiro positivo ou 0 (zero), o container deve carregar e inicializar o
Servlet assim que a aplicao iniciada. O container deve garantir que os Servlets marcados com
inteiros contendo valores menores devem ser carregados primeiramente.
Veja um exemplo de sua utilizao:
web.xml
...
<servlet>
<servlet-name>PrimeiroServlet</servlet-name>
<servlet-class>
meupacote.MeuPrimeiroServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
...
No elemento <load-on-startup /> C voc determina a ordem de carregamento desse Servlet.
Observao: Com relao a esse processo de inicializao que o Servlet somente poder receber
requisies aps a concluso de seu processo de inicializao.
Criando Arquivos Web Archive (WAR)
Um arquivo Web Archive (WAR) uma aplicao Web empacotada. Voc pode usar arquivos WAR
para importar uma aplicao Web em um servidor Web.
Web ARchive e um formato compactado, baseado no mesmo formato de compactao de arquivos
ZIP, para distribuir aplicaes, ou bibliotecas, atravs de um s arquivo.
1
Faces e Struts
Em um arquivo WAR podem-se incluir quaisquer tipos de arquivos como: classes, imagens,
configuraes, entre outros.
Utilize o comando a seguir para gerar um WAR file, selecionando todos os arquivos existentes no
diretrio. Entre no diretrio Site e execute o comando jar para criar o WAR file:
jar cfv Site.war *
Note que surgir um arquivo chamado Site.war, como determinado.
Undeploy de uma aplicao Web usando o Tomcat 5.5
Como voc j tem instalado, devido a operao executada anteriormente, a aplicao Web chamada
Site, voc ir primeiramente aprender a remover uma aplicao usando o Tomcat. O comando
undeploy EXCLUI sua aplicao:
http://localhost:8080/manager/undeploy?path=/Site
No navegador voc receber a seguinte mensagem:
OK - Undeployed application at context path /Site
Deploying de uma nova aplicao usando o Tomcat 5.5
O processo de instalao de uma aplicao Web conhecido como deploy. O deploy da aplicao
compactada necessita do seguinte comando para que seja instalada:
http://{hostname}:{portnumber}/manager/deploy?path={context_path}
No caso da aplicao criada, digite o exemplo a seguir no Windows, partindo do principio que seu
Figura 5
Faces e Struts
arquivo WAR est no endereo C:\Site:
http://localhost:8080/manager/deploy?path=/Site&war=file:/C:\Site\Site.war
No Linux, voc faria de forma similar, no se esquecendo do endereo onde se encontra seu arquivo
WAR:
http://localhost:8080/manager/deploy?path=/Site&war=file:/home/edson/Site/Site.war
Para visualizar se sua aplicao est funcionando corretamente, digite o endereo no navegador:
http://localhost:8080/Site
Faces e Struts
Captulo 5
A classe HttpServlet
A classe HttpServlet sobrescreve o mtodo service para distinguir entre as solicitaes tpicas
recebidas de um navegador Web cliente. Os dois mtodos mais comuns e usados de solicitao HTTP
so GET e POST.
As utilizaes dos dois mtodos so muito comuns, uma vez que o mtodo GET pode tanto obter
informaes, onde voc pode requisitar um arquivo ou uma imagem, como tambm pode enviar dados,
que neste caso temos o limite do cabealho HTTP.
O mtodo POST no requisita informaes, e sim as envia (posta), dados para o servidor. As
utilizaes mais comuns de solicitaes POST consistem em enviar ao servidor informaes de um
formulrio HTML em que o cliente insere dados ou enviar informaes ao servidor para que esse possa
pesquisar em um banco de dados e etc.
A classe HttpServlet define os mtodos doGet e doPost para responder as solicitaes GET e POST
vindas de um cliente.
Os dois mtodos recebem como argumentos um objeto HttpServletRequest e um objeto
HttpServletResponse que permitem interao entre o cliente e o servidor.
Criando um Servlet que trabalha com o mtodo POST
A seguir voc tem um Servlet que trabalha com o mtodo POST:
TrabComPost.java
package pacote;
public class TrabComPost extends javax.servlet.http.HttpServlet {
super.destroy();
}
protected void doPost(HttpServletRequest request,
String usuario = request.getParameter("usuario");
String senha = request.getParameter("senha");
1
2
Faces e Struts
String html = "<html><head>"+
"<title>Trabalhando com Post em Servlet</title>"+
"</head>"+
"<body>";
if(usuario.equals("edson") && senha.equals("123")){
html += "Seja bem vindo Edson";
}
else{
html += "Usurio ou senha invlidos";
}
html += "</body></html>";
response.setContentType("text/html");
PrintWriter writer = response.getWriter();
writer.print(html);
writer.close( );
}
super.init();
}
}
Utilizando o mtodo doPost( ) C voc recupera valores vindos pelo mtodo POST. Quando uma
requisio HTTP recebida por uma classe que estende HttpServlet, seu mtodo service( ) chamado,
sendo que a implementao padro desse mtodo ir chamar a funo correspondente ao mtodo da
requisio recebida. Ou seja, caso um envio seja feito pelo mtodo POST, como no exemplo, o mtodo
doPost( ) implementado por voc ser chamado.
A interface HttpServletRequest trabalha com alguns mtodos e no caso, voc conheceu o mtodo
getParamenter( String n ) C . Esse mtodo retorna o valor associado com um parmetro enviado
para o Servlet como parte de uma associao GET ou POST. O argumento n representa o nome do
parmetro. No caso do seu servlet foi usuario e a senha, no qual vinham das tags <input /> do xhtml
de mesmo nome.
Atravs de uma condicional if C voc verifica se foram passados valores como usuario e senha iguais
ao valor verificado pelo mtodo equals(String s).
A interface HttpServletResponse contm a resposta ao cliente. Uma grande nmero de mtodos so
fornecidos para permitir ao Servlet formular uma resposta. No seu caso, o mtodo setContentType(
String tipo) define o tipo MIME da resposta ao navegador. O tipo MIME permite ao navegador
determinar como exibir os dados. No caso o tipo MIME de resposta foi text/html, que indica que a
resposta um documento HTML.
Para dar uma resposta ao cliente, voc pode usar a OutputStream ou o PrintWriter que retornado
do objeto response.
PrintWriter writer = response.getWriter(); C
3
4
Faces e Struts
OutputStream stream = response.getOutputStream();
Tambm possvel redirecionar o usurio para outra pgina atravs do mtodo sendRedirect(String):
response.sendRedirect(logado.html);
Ateno: Voc s se deve chamar um dos trs mtodos mostrados. Escrevendo atravs do writer, o
cabealho enviado ao cliente e impede o redirecionamento, enquanto que se voc chamar o mtodo
getWriter e depois o getOutputStream ocorrer um erro.
index.html
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>Login e Senha</title>
</head>
<body>
<form action="ServletPost" method="post">
Login:<input type="text" name="usuario" /> <br />
Senha:<input type="password" name="senha" /> <br />
<input type="submit" value="Logar" />
</form>
</body>
</html>
C - A tag <form /> envia os dados via POST para o action indicado, que no caso se chama
ServletPost, o nome mapeado no arquivo web.xml.
C - Os dados enviados so compostos por dois campos, um do tipo text, que envia o usuario e
outro do tipo password que envia a senha.
Trabalhando com o mtodo GET
O mtodo GET trabalha com informaes enviadas via URL. Esse mtodo pode ser usado via query
string de um link ou via formulrio com o atributo method em GET.
Uma string de consulta parte do URL que aparece depois de um ponto de interrogao. Por exemplo,
o URL a seguir contm uma string de consulta:
http://integrator.com.br/buscar/?p=Hypertext+Preprocessor
Nesse exemplo, a string de consulta contm uma varivel denominada p cujo valor Hypertext
Preprocessor.
As strings de consulta so usadas para transmitir informaes do navegador para o servidor.
Normalmente, voc no digita a string de consulta diretamente na barra de endereos do navegador. Ao
1
2
Faces e Struts
contrrio, cria um link em uma pgina que contm a string de consulta.
http://integrator.com.br/TrabComGetServlet?email=edson@integrator.com.br
Voc pode transmitir diversas variveis de consulta em uma nica string. Para fazer isso, basta separ-
las com o caractere &(e comercial).
http://integrator.com.br/TrabComGetServlet?nome=Edson&email=edson@integrator.com.br
A pgina a seguir demonstra um link transmitindo mais de uma string de consulta:
index.html
<head>
<title>Trabalhando com Metodo GET</title>
</head>
<body>
<a href="TrabComGetServlet?nome=Edson&email=edson@integrator.com.br">
Meu nome
</a>
<br />
<a href="TrabComGetServlet?email=edson@integrator.com.br">
Meu e-mail
</a>
</body>
</html>
C - Note o envio de mais de uma string de consulta, onde se tem a varivel nome do valor
Edson e a outra varivel email do valor edson@integrator.com.br separados por um & e-
comercial.
C - Aqui voc tem o envio de apenas uma string de consulta.
1
2
Faces e Struts
Recuperando strings de consulta com Servlets
Para recuperar uma string de consulta com um Servlet, crie o seguinte arquivo:
TrabComGetServlet.java
package meupacote;
public class TrabComGetServlet extends javax.servlet.http.HttpServlet {

super.destroy();
}
protected void doGet(HttpServletRequest request,
String nome = request.getParameter("nome");
String email = request.getParameter("email");
"<title>Trabalhando com GET em Servlet</title>"+
"</head>"+
"<body>"+
"Nome: <strong>"+nome+"</strong><br />"+
"E-mail: <strong>"+email+"</strong><br />" +
"A query string enviada : <strong>"+
request.getQueryString()+"</strong>" +
"</body></html>";
writer.print(html);
writer.close();
}
super.init();
}
}
Note que voc pode recuperar uma query string (string de consulta) da mesma forma que voc recupera
no mtodo doPost( ), s que a diferena que pelo mtodo doGet( ).
O mtodo getParameter(String s) C alm de retornar o valor informado, tambm retorna null caso
1
2
Faces e Struts
no recupere o valor indicado entre os parnteses.
Caso voc queira toda a string de consulta, basta usar o mtodo getQueryString( ) C, que retorna a
query string completa, aquela aps o sinal de interrogao ?.
Enviando Caracteres Especiais em Query Strings
Em alguns casos voc vai precisar enviar caracteres especiais em seus links e que, sem isso, com
certeza situaes indesejadas acontecero.
Um problema clssico do usurio querer enviar caracteres especiais que causam problemas quando
so tratados de maneira comum na URL, como o caso do & e-comercial. Quando a string
codificada, possveis caracteres problemticos sero substitudos.
Uma outra situao que apontaria esse tipo de utilizao e em sistemas de busca cujo transmitem
informaes via HTTP, exigindo assim uma codificao dos caracteres especiais.
O Servlet a seguir trata exatamente disso:
EnvCaractEspec.java
package meupacote;
import java.net.URLEncoder;
public class EnvCaractEspec extends javax.servlet.http.HttpServlet {
super.destroy();
}
Figura 1
1
Faces e Struts
String queryString =
URLEncoder.encode("Cidado&Joo","ISO-8859-1");
"<title>Enviando Caracteres especiais</title>"+
"</head>"+
"<body>" +
"<a href=\"RecCaractEspec?dados="+queryString+"\">" +
"Clique aqui para enviar" +
"</a>"+
"</body></html>";
writer.print(html);
writer.close();
}
super.init();
}
}
C - A importao do pacote java.net.URLEncoder necessrio para que voc possa utilizar o
mtodo encode(String s, String s) para codificar a query string que deseja enviar para um outro
Servlet, JSP ou outra aplicao Web. A classe URLEncoder contm mtodos estticos por converter
uma String para o formato MIME application/x-www-form-urlencoded. Caso voc queira saber mais a
respeito dessa codificao, o link http://www.w3.org/TR/html4/ poder ajud-lo.
C - O mtodo encode(String text, String enc) chamado da classe URLEncoder, possibilitando
assim a converso do caractere & (e-comercial) para o seu equivalente em URL encode (%26). Os
acentos tambm utilizados sero codificados pelos seus equivalentes, enviando assim uma string de
consulta totalmente aceitvel nos padres da Web. Embora o segundo parmetro seja opcional, ele
torna o mtodo depreciado, portanto o certo ter o dois obrigatoriamente. O segundo parmetro indica
a codificao que ser utilizada, como no caso ser em ISO-8859-1. Mas se seu documento for salvo no
padro UTF-8, utilize esse encode.
C - Nesse momento a varivel queryString recebe os dados com o encode aplicado e colocado no
link que ser gerado pelo Servlet.
A Servlet a seguir receber essa string.
2
3
Faces e Struts
RecCaractEspec.java
package meupacote;
public class RecCaractEspec extends javax.servlet.http.HttpServlet {
super.destroy();
}
String dados = request.getParameter("dados");
"<title>Recebendo caracteres especiais</title>"+
"</head>"+
"<body>"+
"Os dados recebidos so: <strong>"+dados+"</strong><br />"+
"A query string recebida : <strong>"+
request.getQueryString()+"</strong>" +
"</body></html>";
writer.print(html);
writer.close();
}
super.init();
}
}
Esse Servlet no ter explicao pois seu contedo no tem nenhum tipo de novidade.
Faces e Struts
Figura 2
Faces e Struts
Captulo 6
Introduo ao JavaServer Pages
Enquanto que desenvolver um Servlet, voc tem que inserir muitos cdigos Java, a parte de layout da
pgina fica a cargo do Web Designer, no qual trabalha com imagens, cores e outros elementos visuais
existentes em um web site.
Graas a esse problema, a equipe da Sun desenvolveu uma tecnologia baseada em Servlets chamada de
JavaServer Pages (JSP).
JavaServer Pages so pginas HTML embebidas em cdigo Java. Dessa forma a pgina dinmica
gerada pelo cdigo JSP. A primeira vez que uma pgina JSP carregada pelo container JSP, o cdigo
Java compilado gerando um Servlet que executado. As chamadas subseqentes so enviadas
diretamente ao Servlet, no havendo mais a recompilao do cdigo Java.
A estrutura do JavaServer Pages
Como o JavaServer Pages so cdigos Java embebidos em pginas HTML, voc pode definir o local
que deseja colocar seu cdigo.
Dentro do arquivo, voc insere elementos pertencentes ao JSP, seguindo a sintaxe:
index.jsp
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<head>
<title>Trabalhando com JavaServer Pages</title>
</head>
<body>
<%
String s = "<h2>Esse um cdigo JSP embebido no HTML</h2>";
out.write(s);
%>
</body>
</html>
O arquivo index.jsp, diferente do Servlet, no fica dentro do diretrio classes, em WEB-INF, mas sim
diretamente na raiz da sua aplicao. Observe tambm que o arquivo, embora contenha cdigos
HTML, tem a extenso modificada para .jsp.
Para escrever cdigo Java em sua pgina basta coloc-lo entre as tags <% e %>. Esse cdigo
chamado de scriplet.
Scriplet o cdigo escrito entre <% e %>, nome composto da palavra script (linguagem de script) com
1
Faces e Struts
o sufixo let, que indica pequeno.
Curiosidade: Esse costume adotado pela Sun Microsystems, foi assim com Servlet e agora com
Scriplet entre outras nomenclaturas que no vem ao caso.
C - Existem variveis j implcitas no jsp, onde todo arquivo jsp j possui uma varivel chamada out
(do tipo JspWriter) que permite imprimir objetos atravs do mtodo write, print ou println:
<% out.write(s); %>
Preciso compilar uma pgina JavaServer Pages?
Uma das grandes vantagens de desenvolver em JavaServer Pages que voc no precisa compilar seu
cdigo. Voc cria a pgina e a coloca pra rodar no Servlet Container. Caso precise alterar, altere e
pronto.
JavaServer Pages so Servlets?
O JSP um arquivo de script interpretado inicialmente e depois compilado em um Servlet. O arquivo
pr-compilado numa classe Java quando acontecer o primeiro chamado desse arquivo.
Voc pode visualizar o Java criado, assim como o compilado no Tomcat em:
$CATALINA_HOME/work/Catalina/localhost/SiteJSP/org/apache/jsp
Como o Servlet Container saber que alterei o arquivo?
O compilador verifica a data de alterao do arquivo que contm a pgina JSP e caso essa data se
modifique, o processo de compilao executado novamente para garantir que as alteraes feitas na
pgina sejam visveis para os usurios da aplicao.
Devido a todo esse processo de compilao / recompilao, aps a modificao, assim como na
criao, de uma pgina JSP, sempre mais lento que os acessos seguintes.
Por trs de uma pgina JSP existe um Servlet especial, chamado Page Compiler, que intercepta
requisies direcionadas a recursos com extenso .jsp.
A configurao do arquivo web.xml
No caso da criao de arquivos JSP, voc adiciona novos elementos no arquivo web.xml para ter a
chamada de um arquivo inicial, quando sua aplicao for chamada:
Faces e Struts
web.xml
<display-name>
TrabComJSP
</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.html</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
</web-app>
Note a adio do elemento <welcome-file-list /> que contm um sub-elemento <webcome-file />,
indicando um ou mais nomes de arquivos que devero ser carregados automaticamente caso voc no
digite o nome do arquivo na chamada da aplicao no navegador. Como voc j deve ter notado, o
primeiro da lista o chamado para ser a pgina default, caso no seja encontrada, a segunda da lista o
arquivo inicial e assim por diante at o fim.
Ao executar essa aplicao no Servlet Container, voc notar que a chamada inicial lenta, isso graas
a sua compilao. Depois disso, na segunda chamada em diante fica consideravelmente mais rpido,
como j dito anteriormente.
O ciclo de vida
O fato de uma pgina JSP ser convertida para um Servlet faz com que ela tenha o mesmo ciclo de vida
apresentado pelo Servlet, onde existe a inicializao, a requisio , e finalmente a finalizao.
No existem mtodos equivalentes ao doGet e doPost de um Servlet para o atendimento as
requisies, j que o prprio contedo da pgina contm o cdigo a ser executado e retornado para o
browser a cada chamada.
Por outro lado, existem os mtodos jspInit( ) e jspDestroy( ) que possibilitam a implementao de
cdigos de inicializao e finalizao, respectivamente, da pgina JSP.
A estrutura do JavaServer Pages
Em pginas dinmicas escritas em JSP voc tem as tags de abertura <% e fechamento %>, como j
dito anteriormente, para se adicionar o comando desejado.
As tags mais comuns so:
1
Faces e Struts
Comentrios: <%-- esse um comentrio em JSP --%> e
<%
/* esse comentrio tem
mais de uma linha */ %>
Declarao de atributos ou mtodos: <%! %>
Expresso de um resultado: <%= %>
Tags Personalizadas: <%@ taglib %>
Exemplo de tag personalizada:
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
Onde uri o nome definido no arquivo TLD e prefix o nome da tag que ser utilizada na pgina JSP.
Diretivas
Diretivas so usadas para fornecer informaes especiais ditas ao container sobre a pgina JSP quando
esta compilada para Servlet..
Voc tem trs tipos de diretivas principais:
page: permite importao de classes, customizao de super classes servlet entre outras;
include: permite que um contedo seja inserido de um arquivo no servlet.
taglib: permite que o ambiente JSP importe uma determinada biblioteca de tags.
Para cada um desses tipos de diretivas, existem conjuntos de atributos especficos utilizados para
parametrizar a diretiva.
Diretiva page
Conforme o prprio nome indica, a diretiva page serve para se definir diretivas da pgina. A diretiva
page tem a seguinte sintaxe: <%@ page %>
Os atributos mais usados so:
language="java" Especifica a linguagem que est sendo usada.
extends="pacote.classe" Define se a super classe do servlet por herana.
import="pacote.classe.*" Pacote que deve ser importado.
session="true | false" Permite ou no variveis de sesso.
buffer="none | 10kb" Tamanho do buffer em KB para o JspWriter out. O buffer padro
definido pelo servidor.
info="mensagem" - Define uma string que pode ser recuperada pelo mtodo getServletInfo( ).
Com esse atributo o desenvolvedor pode adicionar uma documentao pgina que
resume sua funcionalidade.
errorPage="erro.jsp" Define a pgina de erro no qual ser desviado caso isso ocorra.
isErrorPage="true | false" Define se uma pgina de controle de erro.
contentType="text/html" Informaes sobe a pgina, o MIME type do documento.
Faces e Struts
pageEncoding="ISO-8859-1" Define o conjunto de caracteres para a pgina JSP.
autoFlush="true | false" - O valor true (padro) indica se o buffer deve ser esvaziado quando
estive cheio. Em false, indica que uma exceo deve ser mostrada quando ocorrer overflows.
Usando a diretiva page
A pgina JSP a seguir demonstra alguns atributos da diretiva page:
data.jsp
<%@ page language="java"
contentType="text/html"
pageEncoding="ISO-8859-1"
info="Escrito por Edson Gonalves"
import="java.util.*"
import="java.text.SimpleDateFormat"
%>

<head>
<title>Usando a Diretiva page</title>
</head>
<body>
Esse um exemplo da utilizao da diretiva <strong>page</strong>
<br />
<%
Date hoje = new Date();
SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yy");
%>
A data de hoje : <strong><%= formato.format(hoje) %></strong>
</body>
</html>
C - Voc pode notar que no incio da sua pgina JSP existe a diretiva page com vrios atributos,
discutidos no incio desse tpico. O mais importante nesse ponto compreender a simplicidade perto
do desenvolvimento usando Servlets.
C - No captulo 7 desse livro voc j havia visto a utilizao da classe SimpleDateFormat.
Novamente lembrando, caso queira mais informaes a respeito, v at o Apndice no final desse livro.
C - Como resultado da diretiva page em conjunto com o atributo import voc pode manipular a data
do servidor e format-la, dando como resultado o visto na imagem a seguir:
1
2
3
Faces e Struts
Voc ver mais a diretiva page em ao em captulos posteriores.
Diretiva Include
A diretiva include permite que sejam includos arquivos na hora em que a pgina JSP compilada em
servlet. Sua sintaxe similar a:
<%@ include file="topo.html" %>
Para exemplificar essa diretiva, voc ir criar trs pginas: usandoDiretivaImport.jsp,
cabecalho.html e rodape.html.
cabecalho.html
<h1 style="color:red; background-color:#EEEEEE">Esse o cabealho </h1>
rodape.html
<strong>Esse texto faz parte do rodap</strong>
A nica pgina dinmica no caso, ou seja, feita em JSP o usandoDiretivaImport.jsp:
usandoDiretivaImport.jsp
<head>
<title>Usando a Diretiva import</title>
</head>
<body>
<%@ include file="cabecalho.html" %>
<h3>Esse o contedo da pgina</h3>
<%@ include file="rodape.html" %>
</body>
</html>
Figura 1
1
Faces e Struts
A vantagem de utilizar essa diretiva est no fato de que voc pode manter contedo esttico ou
dinmico comum a diversas pginas JSP em arquivos separados, includos, atravs dessa diretiva,
conforme a necessidade. Sendo assim, um menu, cabealho, rodap e outras situaes que podem se
repetir ao longo de diversas pginas no site podem ser inclusos, no necessitando de ser refeito a cada
nova pgina e, auxiliando assim, na administrao do contedo.
taglib
O objetivo nesse exemplo criar uma tag simples que no tem a inteno de ser reutilizvel, mas de
apresentar o desenvolvimento de uma taglib personalizada. Esse simples exemplo necessrio,
principalmente porque envolvem uma srie de detalhes com a construo que o ajudar a entender
melhor sua aplicabilidade.
A tag que voc ir produzir ir simplesmente imprimir uma frase: Desenvolvendo com taglib como
resultado em uma pgina HTML.
A classe a seguir demonstra como criar uma tag personalizada:
DesenvolvendoTaglibs.java
package meupacote;
import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.TagSupport;
public class DesenvolvendoTaglibs extends TagSupport {
public int doStartTag() throws JspException {
try {
pageContext.getOut().print("Desenvolvendo com taglib");

} catch (IOException ioe) {
throw new JspTagException("Erro: IOException");
}
return SKIP_BODY;
}
}
Figura 2
1
2
3
4
5
Faces e Struts
C - A classe abstrata TagSupport parte das APIs de tags JSP e define todos os mtodos que o JSP
precisa em tempo de execuo para chegar na funcionalidade da tag.
C - O mtodo pblico doStartTag( ) chamado em runtime(tempo de execuo) para trazer as tags
personalizadas. Observe que no existe um construtor explcito para essa tag e nem mesmo um mtodo
main( ) para chamar a classe. Isso acontece porque o processador de tag no uma classe
independente, mas sim instanciado em runtime pelo JSP quando chama seus mtodos. A API de tags
personalizadas define um conjunto de mtodos para essas tags.
C - A tag quando chamada ir imprimir na tela a mensagem Desenvolvendo com taglib para o
usurio, usando o mtodo print de pageContext.
C - Caso haja um erro na execuo, disparado um erro, uma exceo IOException.
C - O retorno da constante SKIP_BODY necessrio, como exigido pelo mtodo, para que diga ao
runtime como proceder quando encontrar a tag. Esse retorno diz ao mecanismo de execuo para
simplesmente ignorar o corpo da tag, se houver um, e prosseguir avaliando o restante da pgina.
Evidentemente existem outros valores de retorno vlidos para doStartTag( ), mas que no est sendo
explorado aqui, nesse momento.
Nota: Mesmo que voc veja eu citando a palavra runtime, no significa que o que voc desenvolver
ser recompilado toda vez que chamar uma pgina JSP. Na verdade, o JSP chamado e compilado
somente uma vez, sem ter uma alterao posterior, transformando-se em um Servlet, como j dito
anteriormente.
Como compilar a taglib criada
A compilao bem simples, como se faz quando voc quer compilar um Servlet. A compilao exige
o CLASSPATH para uma determinada biblioteca que o ajudar na compilao da tag desenvolvida.
Para compilar, no Windows faa:
>javac -classpath $CATALINA_HOME\common\lib\jsp-api.jar
meupacote\DesenvolvendoTaglibs.java
Onde a compilao seria mais ou menos da seguinte forma:
Digamos que seu Tomcat esteja instalado no Windows no diretrio tomcat no drive C:, e que o local
onde se encontra sua aplicao seja em C:\tomcat\webapps\TrabTagLib, sendo assim, voc faria:
C:\Tomcat\webapps\TrabTaglib\WEB-INF\classes>javac -classpath C:\Tomcat\common\lib\jsp-api.jar
meupacote\DesenvolvendoTaglibs.java
Note que a navegao foi feita at o diretrio classes, e l se originou a compilao. Mas isso no
obrigatrio, pois poderia ser feito assim, caso o seu Tomcat esteja instalado no drive C: e que tem o
nome Tomcat 5.5 no diretrio:
C:\>javac -classpath "C:\Tomcat 5.5\common\lib\jsp-api.jar" "C:\Tomcat
5.5\webapps\TrabTaglib\WEB-INF\classes\meupacote\DesenvolvendoTaglibs.java"
Faces e Struts
No Linux, voc segue a mesma regra, partindo do princpio que voc tem o Tomcat instalado no
diretrio /usr/local/tomcat:
shell# javac -classpath /usr/local/tomcat/common/lib/jsp-api.jar
/usr/local/tomcat/webapps/TrabTaglib/WEB-INF\classes\meupacote\DesenvolvendoTaglibs.java
O Descritor da biblioteca de tags (TLD Tag Library Descriptor)
Depois de compilado, voc tem uma classe dentro do diretrio classes, no pacote meupacote, chamado
de DesenvolvendoTaglibs em WEB-INF.
Dentro desse mesmo diretrio, WEB-INF, voc vai criar um outro diretrio chamado de tld, e
adicionar o arquivo mostrado a seguir, dentro dele com a extenso .tld:
TrabComTaglib.tld
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//
EN" "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">
<taglib>
<tlibversion>1.0</tlibversion>
<jspversion>1.2</jspversion>
<shortname></shortname>
<uri>desenvolvendoTaglibs</uri>

<tag>
<name>frase</name>

<bodycontent>empty</bodycontent>
<info>
Desenvolvendo com taglibs
</info>
</tag>
</taglib>
C - O elemento <uri /> define o nome para a a referencia da taglib que voc ainda vai fazer na sua
pgina JSP.
C - No elemento <name /> voc define o nome para o elemento que ser chamado pela pgina JSP
para imprimir na pgina o contedo desenvolvido na classe DesenvolvendoTaglibs.
C - O elemento <tagclass /> define o caminho para a sua classe, onde se encontra a tag personalizada.
Note que segue a mesma lgica dos Servlets, se houver um pacote (o que por conveno deve sempre
haver) o nome do pacote vem antes e separado por ponto o nome da classe.
C - O elemento <bodycontent /> determina que sua tag personalizada no ter um corpo, ou seja, no
iniciar como alguns elementos HTML, como <h2> e terminar com </h2>.
1
2
3
4
Faces e Struts
Como utilizar essa taglib em sua aplicao
Depois de desenvolvido e configurado o TLD, voc precisa configurar o seu deployment descriptor
(web.xml) para que seja possvel rodar a aplicao utilizando essa tag personalizada.
web.xml
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
<web-app>
<display-name>
TrabComTagLib</display-name>
<welcome-file-list>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
<taglib>
<taglib-uri>desenvolvendoTaglibs</taglib-uri>
<taglib-location>/WEB-INF/tld/TrabComTaglib.tld</taglib-location>
</taglib>
</web-app>
C - No deployment descriptor da sua aplicao voc obrigado a colocar o elemento <taglib />
envolvendo os elementos:
<taglib-uri /> - que deve ser adicionado o mesmo nome dados pelo elemento <uri /> definido no TLD
TrabComTaglib.tld.
<taglib-location /> - aqui voc define o local onde se encontra o arquivo TLD criado.
Utilizando a tag personalizada em uma pgina JSP
Depois de desenvolvido e configurado, voc precisa apenas chamar essa tag personalizada. Para
cham-la a pgina a seguir demonstra como fazer:
utilizandoTagPers.jsp
<%@ taglib uri="desenvolvendoTaglibs" prefix="jsps" %>
1
1
Faces e Struts
<head>
<title>Trabalhando com taglibs</title>
</head>
<body>
<h3> <jsps:frase /> </h3>

</body>
</html>
C - Depois de todo o desenvolvimento, que a primeira vista assusta um iniciante, voc tem a diretiva
taglib em ao, onde voc utiliza o atributo uri necessrio para chamar a sua tag personalizada. No
elemento prefix voc define o nome de um prefixo que ser colocado na chamada a tag personalizada.
C - Para chamar a tag personalizada, voc utiliza o nome dado no atributo prefix, da diretiva taglib,
separado por dois-pontos e o nome da tag personalizada. S para lembr-lo, esse nome voc definiu no
TLD TrabComTaglib.tld no elemento <name />.
O uso de expresses
Em algumas pginas JSP construdas at agora utilizamos um elemento dinmico chamado de
expresso, e esse elemento serve para imprimir o resultado na pgina do usurio Web, convertendo o
valor em uma String.
<%= expresso %>
Note que a expresso contm um sinal de igual = e no termina com ponto-e-vrgula.
2
Figura 3
Faces e Struts
Captulo 7
JavaBeans
JavaBeans so classes que possuem o construtor sem argumentos e mtodos de acesso get e set.
Tecnicamente isso no necessrio, para uma classe ser considerada um JavaBean. So amplamente
utilizados em conjunto com JSP, com a caracterstica de separar a lgica do visual.
Essa classe pode realizar qualquer tipo de tarefa dentro de uma aplicao Java. O JavaServer Pages
possui um conjunto de tags para definir o uso dos JavaBeans.
A action <jsp:useBean /> altamente flexvel, e sua funcionalidade controlada pelos atributos
passados action.
A action <jsp:useBean /> extremamente flexvel e sua funcionalidade exata controlada pelos
atributos passados ao.
Se usada corretamente, essa ao pode reduzir a quantia de cdigo scriptlet que seria necessrio em
caso contrrio.
Curiosidade: O JavaBeans no existe apenas para o desenvolvimento Web, como largamente usado.
Sua concepo inicial era a reutilizao de programao visual, os famosos Beans do Swing.
Tecnicamente JavaBeans o termo correto para a reutilizao de partes de programas visuais, com
certas funcionalidades, mas essa forma de reutilizao de componentes passou a ser conhecida
popularmente como componentes, na programao visual para desktop.
Criando seu primeiro JavaBean
Como voc j sabe, possvel converter boa parte do cdigo scriplet, presente em uma pgina JSP,
para um JavaBean, ou componente, visando a reutilizao de objetos. A parte mais importante disso a
separao da lgica da aplicao com a parte visual, facilitando assim o trabalho do designer e tambm
o do desenvolvedor.
Para utilizar um JavaBean, voc precisa primeiro cri-lo. O JavaBean a seguir um simples exibidor de
mensagem, visando introduz-lo nessa forma desenvolvimento.
MeuPrimeiroJavaBean.java
package meupacote;
public class MeuPrimeiroJavaBean {
private String mensagem = "";
public String getMensagem() {
return mensagem;
}
public void setMensagem (String mensagem) {
this.mensagem = mensagem;
}
}
Faces e Struts
Para utilizar esse JavaBean, crie a seguinte pgina JSP:
usandoMeuPrimJavaBean.jsp
<head>
<title>Usando meu primeiro JavaBean</title>
</head>
<body>
<jsp:useBean id="primeirojb" class="meupacote.MeuPrimeiroJavaBean"/>
A mensagem atual <strong><%= primeirojb.getMensagem() %> </strong>
<br />
A mensagem, aps adicionada :<br />
<strong>
<%
primeirojb.setMensagem("Meu primeiro JavaBean");
out.println(primeirojb.getMensagem());
%>
</strong>
</body>
</html>
A action <jsp:useBean /> cria uma instncia da classe JavaBean e armazena uma referncia para ela
em uma varivel scripting, chamada primeirojb. Uma expresso JSP simples usada para chamar o
mtodo getMensagem( ) para trazer a mensagem existente. No existindo nenhuma mensagem, o
mtodo setMensagem( String m ) lhe d a possibilidade de colocar um texto e depois recuper-lo com
getMensagem( ). Evidentemente esse exemplo muito bsico e no vem a ser a verdadeira lgica por
trs desse recurso, no qual sua utilidade est aqui apenas para ensin-lo de forma simplificada.
A imagem a seguir demonstra o resultado ocorrido na utilizao desse JavaBean.
Figura 1
Faces e Struts
Outro exemplo
A idia desse exemplo criar um JavaBean que formatar suas datas.
FormatandoDatas.java
package meupacote;
import java.util.Date;
import java.text.*;
public class FormatandoDatas {
private DateFormat dateFormat;
private Date data;
public FormatandoDatas() {
dateFormat = DateFormat.getInstance();
data = new Date();
}
public String getData() {
return dateFormat.format(data);
}
public void setData(Date data) {
this.data = data;
}
public void setFormato(String formato) {
this.dateFormat = new SimpleDateFormat(formato);
}
}
Para utilizar esse JavaBean crie a pgina JSP a seguir:
TrabComDatas.jsp
<%@ page language="java" contentType="text/html" pageEncoding="ISO-8859-1"%>
<head>
<title>Usando JavaBeans para formatar datas</title>
</head>
<body>
<jsp:useBean id="data" class="meupacote.FormatandoDatas"/>
A data atual <strong><%= data.getData() %></strong>
</body>
</html>
1
Faces e Struts
Esse exemplo bem simples, pois o JavaBean chama a data atual e atravs da formatao executada
pelo mtodo getInstance( )C da classe DateFormat. Esse mtodo retorna um formato no estilo
SHORT, apresentando a data como mostra a imagem a seguir, do seu resultado:
Mas lgico que voc pode manipular essa sada e a forma que voc pode usar simples:
TrabComDatas.jsp
...
<body>
<% data.setFormato("dd/MM/yy"); %>

</body>
...
Veja que basta, antes de chamar o mtodo getData( ), chamar o mtodo setFormato(String f) e dar a
ele o formato de data que quer exibir.
Compreendendo os JavaBeans
Como voc pode ter notado, at o momento, um JavaBean nada mais do que uma classe que obedece
a um conjunto de regras, utilizando mtodos getters e setters. Mas essas regras so adotadas
voluntariamente pelo desenvolvedor, onde se ele desejar, poder iniciar seus mtodos com outros
nomes.
claro que isso implicaria em outras situaes que no esto em discusso nesse momento. O que
realmente voc deve entender que, qualificar uma classe como sendo um JavaBean uma situao
exclusivamente sua. O compilador no lhe dir: isso um JavaBean. Voc diz a ele.
Figura 2
1
Faces e Struts
As regras
Em uma situao tcnica, voc tambm tem que seguir algumas regras, para que o que voc est
desenvolvendo seja realmente um JavaBean.
Os JavaBeans, como j foi dito anteriormente, existem tanto para modelar sistemas grficos criados
para desktop ou tambm para aplicaes Web em conjunto com pginas JSP. Isso, na prtica, implica
em duas diferenas iniciais bsicas:
1. JavaBeans criados para trabalhar em desenvolvimento de aplicaes grficas desktop precisam
implementar a interface java.io.Serializable. Isso acontece porque so armazenados em
arquivos. J no caso de pginas JSP, isso no necessrio, uma vez que, normalmente, s
existem em memria.
2. Os JavaBeans desenvolvidos para aplicaes desktop tem uma tendncia dos nomes com
mtodos iniciando com set e get coincidirem com os nomes dos atributos da classe, pois esses
representam, numa maioria das vezes, objetos visuais que necessitam ser configurados.
A tabela a seguir demonstra as regras de trabalho com JavaBeans:
Tabela 1
Regra Descrio da Regra
Construtor Se o JavaBean no contiver nenhum construtor declarado explicitamente, o
interpretador Java considerar, j faz parte da definio da linguagem, a
existncia de um construtor implcito sem argumentos sem nenhuma
utilidade.
Persistncia Os JavaBeans podem implementar a interface java.io.Serializable. Mas
como j foi dito, essa regra no precisa ser obedecida. A no existncia
dessa implementao o impossibilita de ser salvo em arquivo ou ser enviado
de um computador para outro em uma aplicao distribuda.
Atributos Se o JavaBean criado possui um atributo que voc deseja obter o seu valor,
ele deve ser acessvel por um mtodo pblico que, de preferncia, deve ter o
mesmo nome, com o prefixo get. Por exemplo: um atributo chamado teste
deve ser acessvel externamente por um mtodo public getTeste( ).
No caso de querer alterar o valor do atributo, o mesmo deve ser feito por um
outro mtodo, tambm pblico, void, com o prefixo set; tendo tambm, um
parmetro de mesmo tipo para tal mudana. Por exemplo: seguindo o caso
anterior, o atributo teste ser alterado em seu valor atravs do mtodo
public void setTeste(Tipo valor).
Executando essa normativa, voc tem os atributos encapsulados. Portanto
esses mesmos atributos devem ser qualificados como protected ou private.
Faces e Struts
Usando as Actions <jsp:setProperty /> e <jsp:getPropert />
Como voc viu, os JavaBeans, acessveis atravs da action <jsp:useBean />, so simples de trabalhar
dentro das pginas JSP. Ma a utilizao ainda de scriplets no agrada no seu trabalho. Evidentemente
voc j deve ter concludo que deve existir actions especficas para isso.
Como o nome j sugere, a tag <jsp:setProperty /> usada para alterar uma propriedade existente em
seu JavaBean.
Para um JavaBean, usando o exemplo da data feito anteriormente, voc pode setar uma propriedade
chamada data, desde exista o mtodo setData( ). A seguir voc tem a sintaxe dessa tag:
<jsp:setProperty name="data" property="formato" value="dd/MM/yy"/>
Para colocar em prtica, voc vai alterar o exemplo ltimo, tirando o scriptlet e o substituindo pela
action <jsp:setProperty />, como mostra a seguir o detalhe em destaque:
TrabComDatas.jsp
...
<body>
<jsp:setProperty name="data" property="formato" value="dd/MM/yyyy"/>
</body>
</html>
O resultado obtido o mesmo do scriptlet, mas com a diferena que voc est usando uma tag.
Da mesma forma que voc pode alterar um valor, atravs de uma action, voc tambm pode capturar
um valor de uma propriedade. Para isso, a action <jsp:getProperty /> C captura o valor existente na
propriedade chamada. Como no exemplo anterior, se eu desejo capturar o valor de uma propriedade
chamada data, eu posso desde que exista um mtodo chamado getData( ). A seguir voc tem a sintaxe
dessa tag:
<jsp:getProperty name="data" property="data"/>
Para propsitos mais prticos, altere como mostrado a seguir, na sua pgina JSP desse captulo:
1
Faces e Struts
TrabComDatas.jsp
...
<body>
<jsp:setProperty name="data" property="formato" value="dd/MM/yyyy"/>
A data atual
<strong>
<jsp:getProperty name="data" property="data"/>
</strong>
</body>
</html>
Note que houve uma simplificao do cdigo, tornando-o mais claro a um usurio sem experincia com
Java e, possibilitando assim, um melhor trabalho em equipe, onde a colaborao pela clareza do cdigo
ajuda no desenvolvimento do design.
Criando um JavaBean mais dinmico
At o momento voc criou JavaBeans estticos, que trazem e levam informaes, mas todas sem
interao com o usurio. O exemplo a seguir demonstra a criao de um JavaBean interagindo com o
usurio:
InteragindoBean.java
package meupacote;
public class InteragindoBean {
private String nome;
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
}
O JavaBean criado simples e portanto no ser comentado.
Para acess-lo, voc vai criar a seguinte pgina:
Faces e Struts
interagindo.jsp
<head>
<title>Interagindo com o Usurio</title>
</head>
<body>
<jsp:useBean id="interagindo"
<jsp:setProperty name="interagindo" property="*" />
Seu nome : <strong>
<jsp:getProperty name="interagindo" property="nome" />
</strong>
<form method="post" action="interagindo.jsp">
Nome: <input type="text" size="20" name="nome" /> <br />
<input type="submit" name="submit" value="Enviar" />
</form>
</body>
</html>
Se na tag <jsp:setProperty /> voc usar o valor * para o atributo property C , significa que todos
os valores de elementos de formulrios que possurem nomes iguais propriedades sero transferidos
para as respectivas propriedades no momento do processamento da requisio. No exemplo dado, voc
tem um atributo chamado nome em seu JavaBean e, para enviar esse valor, chamou a tag
<jsp:setProperty atribuindo o valor * ao atributo property, indicando o nome da tag HTML <input/>,
no atributo name com o valor nome C.
Os valores dos parmetros enviados pelo cliente para o servidor so sempre do tipo String. Os valores
String so convertidos para outros tipos de dados para serem utilizados pelas propriedades encontradas
no JavaBean.
Essa converso mostrada pela tabela a seguir:
Tabela 2 : A converso do <jsp:setProperty />
Tipo da Propriedade O valor String convertido usando
boolean ou Boolean java.lang.Boolean.valueOf(String s)
byte ou Byte java.lang.Byte.valueOf(String s)
char ou Character java.lang.Character.valueOf(String s)
double ou Double java.lang.Double.valueOf(String s)
1
2
Faces e Struts
integer ou Integer java.lang.Integer.valueOf(String s)
float ou Float java.lang.Float.valueOf(String s)
long ou Long java.lang.Long.valueOf(String s)
Observao: Quando voc usar o atributo property="*", as propriedades do Bean no precisam
aparecer necessariamente como no formulrio HTML e vice-versa.
O atributo scope
Existe um atributo chamado scope, do qual ainda no foi visto, que aparece na tag <jsp:useBean />. O
escopo dos JavaBeans indicam a utilizao daquele objeto. Existem quatro valores possveis para o
escopo de um objeto: page, request, session e application. A seguir voc tem uma tabela com a
descrio de cada uma desses escopos:
Tabela 3
Escopo Descrio
page Objetos declarados com esse escopo so vlidos at a resposta ser enviada ou o pedido
ser encaminhado para outro programa no mesmo ambiente, ou seja, s podem ser
referenciados nas pginas onde forem declarados e removido no fim da execuo da
mesma. Objetos declarados com o escopo page so referenciados pelo objeto
pageContext.
request Objetos declarados com esse escopo so vlidos durante o pedido e so acessveis
mesmo quando esse pedido encaminhado outro programa no mesmo ambiente.
Somente est disponvel durante a execuo do request, ou seja, a cada novo pedido, um
JavaBean instanciado para atender a requisio.
Objetos declarados com o escopo request so referenciados pelo objeto request.
session Objetos declarados com esse escopo so vlidos durante a sesso existente, desde que a
pgina seja definida para funcionar em uma sesso e removido quando a sesso
expirar ou se for encerrada explicitamente. Objetos declarados com o escopo session
so referenciados pelo objeto session.
application Objetos declarados com esse escopo so acessveis por pginas no mesmo servidor de
aplicao e removido quando o servidor Web parado ou quando a aplicao Web
reiniciada. Objetos declarados com o escopo application so referenciados pelo objeto
application.
Faces e Struts
Validando um formulrio com JavaBeans
A idia desse exemplo mostrar como validar formulrios usando JavaBeans, mas de forma muito
simplificada, claro.
O JavaBean a seguir ir capturar o valor de todos os campos em questo, inclusive o boto de enviar:
ValidandoCadastroJBean.java
package meupacote;
import java.util.Hashtable;
public class ValidandoCadastroJBean {
private String nome="";
private String email="";
private String url="";
private String enviar;
private Hashtable<String, String> erros =
new Hashtable<String, String>();
this.nome = nome;
}
return nome;
}
public void setEmail(String email) {
this.email = email;
}
public String getEmail() {
return email;
}
public void setUrl(String url) {
this.url = url;
}
public String getUrl() {
return url;
}
public void setEnviar(String enviar) {
this.enviar = enviar;
}
public boolean isSubmit(){
boolean r=true;
if( enviar == null)
r=false;
return r;
}
public boolean isValid(){
1
2
3
Faces e Struts
boolean r=true;
if( (nome == null) || nome.equals("") )
{
erros.put("nome","Por favor, digite um nome.<br />");
r=false;
}
if( (email == null) || email.equals("") || (email.indexOf("@")==-1) )
{
erros.put("email","Por favor, digite um e-mail vlido.<br />");
r=false;
}
return r;
}
public String errors(String s)
{
String msg=(String) erros.get(s);
return (msg==null)? "": msg;
}
}
A classe Hashtable<String, String> C, de java.util.Hashtable, mapeia chaves a valores. Qualquer
objeto no nulo pode ser usado como uma chave ou como um valor. Para adicionar chaves e valores a
esse hashtable, voc utiliza o mtodo put(key, value).
Similar aos outros JavaBeans j criados, voc conta com um conjunto de getter e setter para trabalhar.
Um detalhe interessante que voc encapsula enviar apenas com um mtodo set, pois o mesmo no
necessita de um mtodo get. importante entender que no voc no obrigado a criar getters e
setters mesmo que no o utilize. Lembre-se do que j foi dito, uma JavaBean aquilo que voc disser
ao runtime da pgina JSP e no o que ela decidir que seja, independente de mtodos getters e setters.
O mtodo booleano, chamado de isSubmit( ) C, criado para verificar se voc submeteu o
formulrio. Ele faz isso validando um campo, no caso o boto de enviar, que ter obrigatriamente que
ter o nome de enviar. Evidentemente que voc pode flexibilizar isso, criando um mtodo que pode
indicar pelo nome qual seria o campo de validao no qual voc definiu como sendo o necessrio para
dizer se o seu formulrio foi enviado ou no, ou simplesmente pelo retorno null dos seus campos de
textos do formulrio j ser a indicao de que no foi submetido, pois tudo s depende de voc.
Com o mtodo booleano isValid( ) C voc define quais so os campos que devero ser vlidos. No
caso temos dois campos, um o nome e o outro o email. O mtodo put(key,value) chamado para
armazenar a chave(se for o campo nome por exemplo, ter como key a palavra nome) e o valor (uma
mensagem que queremos exibir ao usurio caso esse no preencha corretamente o campo).
Para exibir os erros, voc chama o mtodo errors(String s) C, que tem como finalidade exibir a
mensagem armazenada caso um dos campos no sejam vlidos em seu preenchimento. Note que esse
mtodo recebeu um parmetro, pois o mesmo deve receber o nome da chave para que seja pesquisada
no hashtable. Isso feito usando o mtodo get(key), que retorna o valor existente no hashtable atravs
da key procurada. Se no houver valores, evidentemente no surgir nenhuma mensagem.
A pgina a seguir demonstra como usar esse JavaBean:
4
Faces e Struts
validandoComJBean.jsp
<%@ page language="java" contentType="text/html"
<head>
<title>Validando com JavaBeans</title>
</head>
<body>
<jsp:useBean id="valc" class="meupacote.ValidandoCadastroJBean" scope="request"/>
<jsp:setProperty name="valc" property="*" />
<%
if(valc.isSubmit()){
if(!valc.isValid()){
out.println(valc.errors("nome"));
out.println(valc.errors("email"));
}
}
%>
<strong>Ateno:</strong> Campos com <strong>*</strong> so obrigatrios
<form action="validandoComJBean.jsp" method="post">
* Nome:<input type="text" name="nome"
value="<jsp:getProperty name="valc" property="nome"/>" /><br />
* E-mail:<input type="text" name="email"
value="<jsp:getProperty name="valc" property="email"/>" /><br />
URL: <input type="text" name="url"
value="<jsp:getProperty name="valc" property="url"/>" /><br />
<input type="submit" name="enviar" value="Enviar" />
</form>
</body>
</html>
Utilizar esse Bean bem mais simples do que cri-lo. Antes de qualquer coisa, voc, claro, precisa
dizer a sua pgina JSP qual o seu JavaBean e dar a ele um nome. Depois, basta utiliz-lo, como de
costume.
Um scriptlet foi usado para chamar o mtodo isSubmit( ) C do seu JavaBean para verificar se o
formulrio foi enviado e aninhada a essa verificao voc valida se no vlido os campos enviados,
atravs do mtodo isValid( ) C. Caso no sejam vlidos os campos, a chamada aos seus erros feita
pelo mtodo errors(String key) C do seu JavaBean.
1
2
3
Faces e Struts
Figura 3 - JavaBeans em ao
Faces e Struts
Captulo 8
Trabalhando com Banco de Dados
Trabalhar com banco de dados em aplicaes Web a coisa mais comum no desenvolvimento. Esse
captulo tratar do uso de banco de dados em aplicaes Web com Servlets e pginas JSP. Existem
atualmente dezenas de bancos de dados no mercado. Os mais populares so o Oracle, MySQL, SQL
Server, PostgreSQL, DB2, Interbase, Firebird. Todos eles so baseados no conceito relacional de
dados.
Introduo ao JDBC
JDBC uma API includa dentro da linguagem Java para o acesso a banco de dados. Consiste em um
conjunto de classes e interfaces escritas em Java que oferecem uma completa API para a programao
com banco de dados, por tanto uma soluo 100% Java.
JDBC uma especificao formada por uma coleo de interfaces e classes abstratas, que devem
implementar todos os fabricantes de drivers que queiram realizar uma implementao de seu driver
100% Java e compatvel com JDBC.
Devido ao JDBC ser escrito completamente em Java tambm passa a ter a vantagem de ser
independente de plataforma. Sendo assim, no ser necessrio escrever um programa para cada tipo de
banco de dados, uma mesma aplicao escrita utilizando JDBC poder trabalhar com banco de dados
como Oracle, Sybase, SQL Server, MySQL, Firebird, PostgreSQL e etc. Para que isso acontea, basta
alterar o JDBC referente ao banco de dados usado e o seu sistema passar a se comunicar com o banco
de dados configurado.
MySQL e o JDBC
Sendo um dos sistemas de gerenciamento de bancos de dados mais usados do mundo, sua velocidade e
capacidade de ser multiplataforma s poderiam chamar a ateno de quem desenvolve em Java.
O driver JDBC escolhido para fazer os exemplos neste livro foi o Connector/J. Usando o driver
Connector/J, todos os tipos de aplicaes de Java podem acessar um banco de dados e seus dados,
desde que seja em MySQL claro.
A instalao e utilizao do MySQL
O MySQL tem diferentes formas de instalao quando se trata de sistemas operacionais. No caso do
Windows, voc pode baixar a ltima distribuio atravs do site:
http://www.mysql.com/downloads.
Instalando no Windows
Procure pelo formato executvel. O arquivo vem compactado no formato .zip.
Descompacte e instale. A instalao, como no poderia deixar de ser, feita por um assistente. Siga os
Faces e Struts
passos at a finalizao.
Caso sua mquina tenha o sistema operacional Windows pertencente a famlia NT( NT, 2000 ou XP), o
MySQL instalado como servio. Ento basta iniciar ou parar o servio, encontrado no Painel de
Controle>Ferramentas Administrativas>Servios.
Voc tambm pode utilizar o comando pelo prompt, desde que voc saiba o nome do servio do seu
MySQL:
Para iniciar o servio
net start mysql
Para parar o servio
net stop mysql
Instalando o MySQL no Linux
O MySQL Server pode ser instalado no Linux de vrias formas. A forma recomendada a que est em
formato RPM.
Voc deve baixar dois arquivos para instalar o MySQL na sua mquina. Esses arquivos so:
MySQL-server-[verso].i386.rpm para instalar o servidor mysqld no Linux
MySQL-client-[verso].i386.rpm para instalar o cliente mysql para executar os comandos no Linux.
A instalao poder ser feita atravs do comando rpm, no Shell do seu Linux. Um exemplo seria:
Shell> rpm ivh MySQL-server-5.0.1.i386.rpm MySQL-client-5.0.1.i386.rpm
A verso RPM j vem com pr-configuraes e assim que ocorrer a instalao, para iniciar ou parar o
servidor, a seguinte sintaxe poder ser feita:
Shell>/etc/init.d/./mysql start para iniciar o servidor MySQL
Shell>/etc/init.d/./mysql stop para parar o servidor MySQL
Nota: Se o seu sistema operacional for Linux e sua distribuio for o Debian ou baseados nesta distro,
voc pode compilar os fontes ou converter em .deb usando o Alien. O Alien permite converter pacotes
.rpm, que originalmente seriam destinados a distribuies como o Fedora, Red Hat Enterprise em .deb.
Acessando o banco de dados MySQL
No Windows
Se voc estiver usando o sistema operacional Windows e utilizou a instalao padro do programa,
abra o prompt de comando e digite a seqncia:
>cd\mysql\bin
Faces e Struts
Lembrando que voc deve estar no drive em que o MySQL est instalado. Por padro voc o instala no
drive C.
Digitando o comando a seguir voc entra no MySQL.
# mysql u root -p
Tecle ENTER e receber o pedido de senha:
password
Digite a senha que voc configurou na instalao e tecle ENTER novamente.
Nota: Verses mais modernas do MySQL para o sistema operacional Windows no necessitam de
tantos passos para iniciar, bastando ir at o atalho encontrado no menu Iniciar do sistema e no atalho
do MySQL iniciar o prompt de comando encontrado neste local.
No Linux
Se voc utilizou a instalao binria, em rpm (recomendado), basta abrir o terminal e digitar a
seqncia:
shell>mysql u root
Se j estiver logado como root, no seu sistema operacional, no h necessidade de colocar o u root
depois do comando mysql.
O comando CREATE
H muitas maneiras diferentes de criar banco de dados no MySQL (assim como h em outros bancos
da mesma categoria). Ao criar um banco de dados, voc normalmente ter o layout inteiro pronto.
Normalmente adicionaria as tabelas imediatamente depois de criar o banco de dado, mas, teremos uma
etapa por vez.
A primeira etapa para criar um banco de dados no MySQL inserir o comando CREATE DATABASE
nome_banco_de_dados da SQL (Structured Query Language) no monitor MySQL, onde
nome_banco_de_dados o nome do banco de dados que voc est criado.
No prompt de comando, no monitor do MySQL, insira o seguinte comando:
mysql> CREATE DATABASE livraria;
Note que no foi utilizado acentuao e em casos de palavras compostas no insira espaos, se for o
caso insira sublinhado _ .
Faces e Struts
O comando USE
Depois de confirmado a criao do banco de dados, voc dever utilizar o comando USE para utilizar o
banco de dados livraria.
USE livraria;
Um ponto importante que o MySQL no torna ativo o banco de dados que voc criou, isso deve ser
implcito.
Criando tabelas
Criar tabela no MySQL uma tarefa relativamente fcil. Para se criar uma tabela basta usar a
seqncia:
shell>mysql u root -p
Aps estar no monitor do MySQL digite a seguinte seqncia:
mysql> USE livraria;
mysql> CREATE TABLE livros(
-> isbn CHAR(13) NOT NULL PRIMARY KEY,
-> titulo VARCHAR(50),
-> edicao_num TINYINT(2),
-> ano_publicacao YEAR,
-> descricao TEXT
-> );
O comando SHOW
Assim que criada sua primeira tabela. Para ver o resultado basta digitar a seqncia:
SHOW TABLES FROM livraria;
Para ver as colunas que existem na sua tabela digite:

SHOW COLUMNS FROM livros;
Configurando usurios
O comando GRANT utilizado para fornecer direitos aos usurios do MySQL. Ele pode ser concedido
nos seguintes nveis:
Faces e Struts
Global
Banco de dados
Tabela
Coluna
O comando para criar um usurio com privilgios como mostrado a seguir:
mysql> grant all
-> on livraria.*
-> to edson identified by 'integrator';
Com isso voc concede todos os privilgios de manipulao do banco de dados livraria somente ao
usurio edson, com a senha integrator.
Confirmando o novo usurio
Para confirmar a criao do novo usurio, voc deve executar o comando a seguir:
mysql> flush privileges;
Ateno: No final desse livro voc tem o Apndice referente ao trabalho com esse banco de dados.
Instalando o driver JDBC
O arquivo que ser adicionado, o ajudar a se conectar ao banco de dados MySQL. Esse arquivo JAR
o driver JDBC chamado de Connector/J, que voc poder baixar no site
http://www.mysql.com/downloads. No momento em que escrevo, o driver que estou utilizando o
mysql-connector-java-5.0.3-bin.jar. O arquivo pode ser baixado em formato .zip ou formato .tar.gz.
Aps baixar, descompacte e coloque o arquivo citado anteriormente no diretrio lib.
As APIs JDBC
As APIs JDBC consistem em diversos pacotes que possibilita ao desenvolvedor de aplicativos vrios
servios.
A verso 2.0 da API JDBC contm duas partes principais: o JDBC 2.1 Core API (representado atravs
de classes nos pacotes java.sql) e o JDBC 2.0 Optional Package API (representado atravs das classes
nos pacotes javax.sql). Na verso 3.0 da API JDBC, as duas partes principais foram combinadas em
uma, o JDBC API; porm em sua verso 3.0, permanece o pacote original que ainda nomeia todas as
classes. O JDBC API 4.0 busca melhorar a aplicao Java ao acesso a dados SQL, com o intuito de
melhorar o desenvolvimento, aproveitando os recursos do Java SE 5, como os Generics e Annotations,
alm de adicionar novas classes utilitrias. Apesar de mencionado, o JDBC API verso 4 ser
disponibilizado pelo Java SE 6, de codinome Mustang, que at o momento em que esse livro escrito,
se encontra em verso beta.
Faces e Struts
O pacote java.sql
Este pacote contm as classes core e interfaces que so necessrias para lidar com o bancos de dados.
Esses elementos relacionam as tarefas como as mostradas a seguir:
Fazer uma conexo ao banco de dados pelo DriverManager;
Enviar declaraes SQL para um banco de dados, inclusive elementos como Statement,
PreparedStatement e Connection;
Lidar com respostas e atualizaes via ResultSet;
Mapeamento padro de tipos SQL para classes e interfaces na linguagem Java, inclusive
elementos como Array, Blob, Clob, Date, Time e Timestamp,
Obter metadados de um banco de dados por DatabaseMetaData, colunas em um ResultSet via
ResultSetMetaData
Lidar com excees tal como o SQLException.
O javax.sql
Este pacote contm as classes e interfaces que so usadas pelo acesso de lado servidor de fonte de
dados.
A principal incluso como parte de javax.sql o DataSource que possibilita uma alternativa para
DriverManager. Tambm inclui coisas como pool de conexes, transaes distribudas, e a
implementao de RowSet.
O acesso ao banco de dados e a conexo JDBC
A tabela a seguir descreve algumas das classes mais comuns e interfaces usadas para conexes de
banco de dados e a execuo de querys no banco de dados.
Tabela 1
Classe Descrio
java.sql.DriverManager Prov um servio bsico para administrar drivers JDBC.
Em JDBC 2.0, este foi cedido pelo uso de javax.sql.DataSource.
javax.sql.DataSource Permite localizar o objeto que prov uma interface para a atual conexo
de banco de dados. O DataSource implementado pelo autor do driver
JDBC e pode ter os seguintes resultados quando o mtodo
getConnection( ) invocado:
Basic: Chamadas devolvero um objeto standard Connection.
Connection pooling: As chamadas produziro um objeto Connection que
automaticamente participa em um pool de conexes.
Transao distribuda: As chamadas produziro um objeto Connection
que pode ser usado em uma transao distribuda, e na maioria dos casos
ser capaz de participar em um pool conexes.
java.sql.Statement Um Statement usado para executar uma declarao SQL esttica e
Faces e Struts
Classe Descrio
devolver os resultados. Apenas um nico ResultSet pode estar aberto
para um Statement por vez. Aplicaes que necessitam de mltiplos
ResultSets abertos tem que criar objetos Statements separados.
java.sql.PreparedStatement Um PreparedStatement uma sub-interface de Statement e isso
representa uma declarao SQL pr-compilada. Esta declarao SQL
pode incluir parmetros que podem ser mudados a cada chamada, sem
re-especificar a declarao. Uma declarao parametrizada, por exemplo,
pode ser "SELECT * FROM LIVROS WHERE ISBN=?".
java.sql.CallableStatement Uma sub-interface de PreparedStatement, CallableStatement,
prov um modo padro para chamar procedimentos armazenados (stored
procedure) pelo JDBC de maneira independente de banco de dados.
Um CallableStatement pode devolver um ou mais objetos ResultSet.
java.sql.ResultSet Um ResultSet contm as linhas retornadas de um Statement (incluindo
Prepared e Callable) examinando o banco de dados.
ResultSet tem um cursor que pode ser usado para interagir atravs dos
resultados. Dependendo do ResultSet, pode ser navegvel em direes
mais de uma direo, alm de pode ser atualizvel.
Os tipos de dados no Java e na SQL
No novidade alguma dizer que a linguagem Java diferente da linguagem SQL, tanto em suas
estruturas como em tipo de dados. Evidentemente isso no um problema, uma vez que voc pode
desenvolver classes Java que usam comandos SQL, podendo traduzir de um modelo para o outro. Para
que isso seja possvel, voc precisa mapear os tipos de dados do Java para os tipos de dados da SQL. A
tabela a seguir mostra os tipos de objeto Java e seus similares no tipo JDBC:
Tabela 2 - Tipos de Objeto Java mapeados para tipos JDBC
Tipo de Objeto Java Tipo JDBC
String CHAR, VARCHAR ou LONGVARCHAR
java.math.BigDecimal NUMERIC
Boolean BIT
Integer INTEGER
Long BIGINT
Float REAL
Double DOUBLE
byte[] BINARY, VARBINARY ou LONGVARBINARY
java.sql.Date DATE
Faces e Struts
Tipo de Objeto Java Tipo JDBC
java.sql.Time TIME
java.sql.Timestamp TIMESTAMP
Clob CLOB
Blob BLOB
Array ARRAY
Struct STRUCT
Ref REF
Java class JAVA_OBJECT
Para ajud-lo a compreender o mapeamento no uso do banco de dados MySQL, o mtodo
ResultSet.getObject( ) usa as converses de tipo entre MySQL e tipos Java, seguindo a especificao de
JDBC onde apropriado. O valor devolvido por ResultSetMetaData.GetColumnClassName( ) tambm
mostrado a seguir:
Tabela 3 - Tipos MySQL para tipos Java em ResultSet.getObject( )
Tipos MySQL
Valor retornado de
GetColumnClassName
Retornado como Classe Java
BIT(1) (MySQL 5.0) BIT java.lang.Boolean
BIT( > 1) (MySQL 5.0) BIT byte[]
TINYINT TINYINT
java.lang.Boolean se TINYINT se a
configurao da propriedade tinyInt1isBit
definida como true (o padro) e
armazenado um tamanho de 1 ou
java.lang.Integer para mais.
BOOL, BOOLEAN TINYINT
Veja TINYINT, como TINYINT(1) para
valores booleanos
SMALLINT[(M)]
[UNSIGNED]
SMALLINT [UNSIGNED]
java.lang.Integer (indiferentemente se
UNSIGNED ou no)
MEDIUMINT[(M)]
[UNSIGNED]
MEDIUMINT [UNSIGNED]
java.lang.Integer, se UNSIGNED
java.lang.Long
INT,INTEGER[(M)]
[UNSIGNED]
INTEGER [UNSIGNED]
java.lang.Integer, se UNSIGNED
java.lang.Long
BIGINT[(M)]
[UNSIGNED]
BIGINT [UNSIGNED]
java.lang.Long, se UNSIGNED
java.math.BigInteger
FLOAT[(M,D)] FLOAT java.lang.Float
DOUBLE[(M,B)] DOUBLE java.lang.Double
DECIMAL[(M[,D])] DECIMAL java.math.BigDecimal
DATE DATE java.sql.Date
DATETIME DATETIME java.sql.Timestamp
TIMESTAMP[(M)] TIMESTAMP java.sql.Timestamp
Faces e Struts
Tipos MySQL
Valor retornado de
GetColumnClassName
Retornado como Classe Java
TIME TIME java.sql.Time
YEAR[(2 ou 4)] YEAR
Se a configurao da propriedade
yearIsDateType definida para false,
ento o tipo de objeto retornado
java.sql.Short. Se for true (o padro) ento
o tipo java.sql.Date (com a data fixada
em 1 de Janeiro, meia noite). Exemplo,
um ano armazenado como 2006, retorna
2006-01-01.
CHAR(M) CHAR
java.lang.String (a menos que o caractere
fixado para a coluna seja BINARY, ento
byte[] retornado)
VARCHAR(M)
[BINARY]
VARCHAR
java.lang.String (a menos que o caractere
fixado para a coluna seja BINARY, ento
byte[] retornado)
BINARY(M) BINARY byte[]
VARBINARY(M) VARBINARY byte[]
TINYBLOB TINYBLOB byte[]
TINYTEXT VARCHAR java.lang.String
BLOB BLOB byte[]
TEXT VARCHAR java.lang.String
MEDIUMBLOB MEDIUMBLOB byte[]
MEDIUMTEXT VARCHAR java.lang.String
LONGBLOB LONGBLOB byte[]
LONGTEXT VARCHAR java.lang.String
ENUM('valor1','valor2',...) CHAR java.lang.String
SET('valor1','valor2',...) CHAR java.lang.String
Desenvolvendo via JDBC
Os exemplos mostrados a seguir demonstram o trabalho de pginas JSP usando a API JDBC. Embora
essa prtica de desenvolvimento no seja recomendada nos dias atuais, importante que voc, como
desenvolvedor iniciante, aprenda como utiliz-la.
Conectando sua pgina JSP ao banco de dados
Para que voc entenda como funciona a conexo e a leitura de dados de um banco de dados, a pgina
JSP a seguir demonstra de forma simples como trabalhar com o MySQL.
Faces e Struts
trabComDBusandoJSPeJDBC.jsp
import="java.sql.*"
%>
<head>
<title>Trabalhando com Banco de dados usando JDBC e JSP</title>
</head>
<body>
<table border="1">
<thead>
<tr>
<th>ISBN</th><th>Ttulo</th>
</tr>
</thead>
<tbody>
<%
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
Class.forName("com.mysql.jdbc.Driver").newInstance();
conn =
DriverManager.getConnection("jdbc:mysql://localhost/livraria",
"edson","integrator");
st = conn.createStatement();
rs = st.executeQuery("select isbn, titulo from livros");
while(rs.next()) {
%>
<tr>
<td><%= rs.getString("isbn") %></td>
<td><%= rs.getString("titulo") %></td>
</tr>
<%
} //end while
} catch (Exception ex) {
ex.printStackTrace();
2
3
4
5
6
7
1
Faces e Struts
} finally {
if (rs != null) rs.close();
if (st != null) st.close();
if (conn != null) conn.close();
}
%>
</tbody>
</table>
</body>
</html>
Dentro do bloco try...catch voc define o trabalho com o banco de dados para se conectar e executar a
instruo SQL.
Ao importar o pacote java.sql.* C , atravs da diretiva page, voc tem acesso as classes e interfaces
para manipular os bancos de dados relacionais em Java.
O driver de banco de dados deve ser empregado antes do programa se conectar ao banco de dados.
A linha anterior utiliza o mtodo static forName C da classe Class (pacote java.lang) para carregar a
definio de classe para o driver de banco de dados.
Se a classe no for localizada, ele dispara uma exceo: java.lang.ClassNotFoundException.
Um objeto Connection gerencia a conexo entre o programa Java e o banco de dados. Ele tambm
fornece suporte ao programa para executar instrues SQL.
Atravs do mtodo static getConnection C, a classe DriverManager tenta uma conexo com o banco
de dados especificado pela string: jdbc:mysql://localhost/livraria. Os argumentos seguintes so o
nome de usurio e a senha, demonstrados pela String edson e integrator respectivamente.
Caso a classe DriverManager no conseguir se conectar ao banco de dados, o mtodo getConnection
dispara uma exceo:
A responsabilidade principal da interface Statement executar sentenas SQL no banco de dados.
Com o mtodo pblico createStatement C voc cria um objeto Statement para enviar declaraes
SQL ao banco de dados. Se houver um erro, dispara tambm a exceo java.sql.SQLException.
Com o mtodo executeQuery C, voc tem o retorno de um objeto que implementa ResultSet e que
contm os resultados da consulta.
Atravs de um loop while voc varre os resultados encontrados, onde o mtodo next( ), de
ResultSet, retorna um valor booleano true, quando o resultado das linhas pesquisadas na query forem
exauridas.
O mtodo getString( ) C, de ResultSet, traz o valor da coluna designada na fila atual deste ResultSet
como uma String na linguagem Java.
Depois de consumidos, os recursos devem ser retornados ao servidor, utilizando o mtodo close( ) .
Nesse caso a clusula usada finally, que liberar os recursos, caso os resultados sejam bem sucedidos
ou no.
8
Faces e Struts
Inserindo dados
O exemplo que ser feito agora ir ilustrar a insero de dados no banco de dados. Voc ter em uma
pgina HTML comum um formulrio contendo os campos necessrios para inserir. Esse formulrio ir
enviar os dados, via mtodo POST, para uma outra pgina, no caso JSP, que recuperar esses dados e
os enviar para o banco de dados MySQL.
Como voc est usando a tabela livros, ser baseado nessa tabela esse exemplo.
formInserindoDados.html
<head>
<title>Inserindo dados via JDBC com JSP</title>
</head>
<body>
<form action="inserindoDados.jsp" method="post">
<table>
<tr>
<td>ISBN:</td><td><input type="text" name="isbn" /></td>
</tr>
<tr>
Figura 1
Faces e Struts
<td>Ttulo:</td><td><input type="text" name="titulo" /></td>
</tr>
<tr>
<td>Edio:</td><td><input type="text" name="edicao" /></td>
</tr>
<tr>
<td>Publicao:</td><td><input type="text" name="publicacao" /></td>
</tr>
<tr>
<td>Descrio:</td>
<td><textarea name="descricao" rows="5" cols="25"></textarea></td>
</tr>
<tr>
<td colspan="2">
<input type="submit" name="btCadastrar" value="Enviar" />
</td>
</tr>
</table>
</form>
</body>
</html>
Como essa uma simples pgina HTML, com um formulrio bsico no haver comentrios sobre o
mesmo.
A pgina JSP que ir receber esses valores mostrada a seguir:
Figura 2
Faces e Struts
inserindoDados.jsp
contentType="text/html; "
import="java.sql.*"
%>
<%
String isbn = request.getParameter("isbn");
String titulo = request.getParameter("titulo");
String edicao = request.getParameter("edicao");
String publicacao = request.getParameter("publicacao");
String descricao = request.getParameter("descricao");
PreparedStatement pst = null;
try {
Class.forName("com.mysql.jdbc.Driver").newInstance();
conn =
String SQL = "INSERT INTO livros (isbn, titulo, edicao_num, " +
"ano_publicacao, descricao) " +
"values (?, ?, ?, ?, ?)";
pst = conn.prepareStatement(SQL);

pst.setString(1, isbn);
pst.setString(2, titulo);
pst.setInt(3, Integer.parseInt(edicao));
pst.setString(4, publicacao);
pst.setString(5, descricao);
pst.executeUpdate();

pst.clearParameters();
} finally {
if (pst != null) pst.close();
}
%>
<head>
1
2
4
3
5
Faces e Struts
<title>Dados recebidos</title>
</head>
<body>
O ISBN <strong><%=isbn %></strong> foi inserido com sucesso!
</body>
</html>
A interface PreparedStatement tem um papel semelhante a interface Statement, o que nos permite
executar sentenas SQL sobre uma conexo estabelecida com um banco de dados. Porm, neste caso,
voc utiliza sentenas mais especializadas, como a de inserir dados, onde voc pode receber vrios
parmetros como entrada.
Um parmetro de entrada C aquele cujo valor no se especifica quando a sentena criada. No seu
lugar a sentena recebe um sinal de interrogao (?) para cada parmetro de entrada. Antes de executar
a sentena, voc deve especificar um valor para cada parmetro, atravs dos mtodos set apropriados.
Para criar um objeto PreparedStatement voc deve lanar um mtodo prepareStatement(String s) C
da interface Connection sobre o objeto que representa a conexo estabelecida com o banco de dados.
Atravs do mtodo setString(int i, String s) C, voc prepara os dados que esto vindo dos campos do
seu aplicativo para inserir no banco de dados. Como voc mesmo j concluiu, o tipo string foi utilizado
graas ao tipo existente no banco de dados.
O mtodo setInt(int i, int i) C faz o mesmo que o anterior, mas exige um valor inteiro. Com o mtodo
executeUpdate( ) C voc executa a sentena SQL para o tipo, que no caso de insero (INSERT).
Esse mtodo tambm serve para os atualizaes (UPDATE) e excluses (DELETE).
Aps utilizar os mtodos setter, voc pode limp-los usando o mtodo clearParameters( ) C.
Entendendo os principais Statements
Como voc viu, Statements so essenciais para se comunicar com uma base de dados que usa a
linguagem SQL. H trs principais tipos de Statements. O primeiro a interface Statement. Quando so
criados objetos pela implementao da interface Statements , estes so geralmente usados para executar
declaraes SQL genricas que no levam qualquer parmetro. O segundo tipo o PreparedStatement
que herda da interface Statement. Objetos PreparedStatement so teis quando voc precisar criar e
compilar declaraes SQL antes do tempo. Objetos PreparedStatement tambm aceitam parmetros IN.
O tipo final de statement o CallableStatement. O CallableStatement herda de PreparedStatement e
aceita parmetros IN e OUT. Seu propsito principal executar procedimentos armazenados de banco
de dados.
Explorando a interface PreparedStatement
Se voc precisar executar declaraes SQL muitas vezes, o PreparedStatement a escolha perfeita para
essa tarefa, isso porque aumenta a eficincia e desempenho do programa. O PreparedStatement a
escolha lgica do nome para a interface porque contm uma declarao SQL que previamente foi
compilada e enviada ao DBMS de sua escolha, por isso o termo prepared.
O PreparedStatement d o desenvolvedor que a habilidade de embutir parmetros na declarao SQL
Faces e Struts
contidos no objeto PreparedStatement. Estes parmetros IN (de entrada) so denotadas na declarao
SQL pelo smbolo de interrogao (?).
A tabela a seguir mostra os mtodos setters que indicam os tipos para PreparedStatement:
Tabela 4
Mtodo void Descrio
setBoolean(int paramIndex, boolean b) Parmetro de entrada com valor booleano.
setDate(int paramIndex, Date d) Parmetro de data de entrada. Deve ser um valor
java.sql.Date.
setDouble(int paramIndex, double d) Parmetro de entrada com valor double.
setFloat(int paramIndex, float f) Parmetro de entrada com valor float.
setInt(int paramIndex, int i) Parmetro de entrada com valor int.
setLong(int paramIndex, long l) Parmetro de entrada com valor long.
setString(int paramIndex, String s) Parmetro de entrada com valor String.
clearParameters( ) Limpa os parmetros enviados pelos mtodos setters.
Pool de conexes
Quando uma aplicao Web acessa um banco de dados remoto, esse acesso pode ser feito por uma
conexo JDBC, como visto anteriormente. Tipicamente, uma conexo de JDBC fsica estabelecida
entre a aplicao cliente e o servidor de banco de dados por uma conexo TCP/IP.
Pool de conexes reduzem expressivamente o tempo de conexes estabelecidas criando uma conexo
fsica no incio do sistema.
Quando uma aplicao requerer uma conexo, uma destas conexes fsicas provida a essa aplicao.
Em um sistema comum, sem o pool de conexo, quando a aplicao termina de usar a conexo, este a
desconecta, como feito anteriormente usando o mtodo close( ). Porm, no caso de uma conexo fsica,
essa devolvida somente para o pool de conexes, onde espera o prximo pedido da aplicao para um
novo acesso ao banco de dados.
Configurando o recurso JNDI JDBC
Usando recursos JNDI no Tomcat para configurar acesso a dados via JDBC o modo indicado para
proporcionar acesso ao banco de dados por aplicaes Web.
Primeiramente adicione a biblioteca JDBC do MySQL em $CATALINA_HOME/common/lib, onde
$CATALINA_HOME o local onde se encontra instalado o Tomcat.
No arquivo server.xml, localizado em $CATALINA_HOME/conf, procure a linha onde se encontra a
sua aplicao Web e adicione como mostrado a seguir:
Faces e Struts
server.xml
...
<Context path="/Site">
<Resource name="jdbc/LivrariaDB" auth="DADOS"
type="javax.sql.DataSource"
driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/livraria"
username="edson"
password="integrator"
maxActive="30"
maxIdle="20000"
maxWait="120"/>
</Context>
...
C - A configurao para o pool de conexes ser atravs do contexto da sua aplicao. No caso foi
ilustrado aqui com o nome de /Site, mas verifique o nome que voc deu.
C - Dentro do contexto, voc configura os dados necessrios para o acesso ao banco de dados. Para
que voc entenda o significado de cada atributo dado, veja na Tabela a seguir:
Tabela 5
Atributo Descrio
driverClassName O nome da classe do driver JDBC.
maxActive O nmero mximo de conexes ativas neste pool
maxIdle O nmero mximo de conexes inativas nesse pool
maxWait Em milissegundos, indica o mximo de espera para uma conexo,
gerando aps uma exceo.
username Nome do usurio
password Senha
url O URL JDBC compatvel especificando o banco de dados para ser
usado
validationQuery Uma query SQL opcional usada para validar uma conexo,
exemplo:
validationQuery="select * from testdata;"
Depois de configurado e entendido o que significa cada atributo, voc ir configurar o arquivo
web.xml, em WEB-INF da sua aplicao Web:
2
1
Faces e Struts
web.xml:
...
<resource-ref>
<res-ref-name>jdbc/LivrariaDB</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>DADOS</res-auth>
</resource-ref>
</web-app>
Com o elemento <resource-ref /> C voc define o JNDI configurado no Tomcat. A interface
javax.sql.DataSource foi introduzida como parte do JDBC 2.0 Standard Extension para proporcionar
em aplicaes Java um modo padro para fazer administraoda conexo do banco de dados e poll de
conexo provida para aplicaes de servidores Java.
Obs: Caso o Tomcat diga que no est encontrado o driver JDBC do MySQL porque voc
adicionou o driver com o Tomcat rodando. Pare e inicie a instncia do Tomcat para que esse venha a
reconhec-lo.
Trabalhando com o aplicativo Web Admin
Uma das principais vantagens de uma configurao GUI baseada na Web a potencialidade para
executar remotamente. O Tomcat tem uma ferramenta de administrao baseada em Web que voc
pode usar para administrar o servidor e aplicaes Web individuais. Essa ferramenta lhe permite editar
o arquivo server.xml. Para que se possa usar essa ferramenta, antes, voc deve efetuar download da
mesma, pois esse no vem instalado com o Tomcat por padro.
Baixando e Instalando o Admin
Inicialmente voc ter que voltar ao site do projeto Tomcat e baixar o Admin, que, como j foi dito,
no vem com a distribuio.
Volte novamente pgina para download http://tomcat.apache.org/download-55.cgi e v at o item
Binary Distributions.
Em Administration Web Application voc pode escolher em qual formato voc vai baixar.
Descompacte o arquivo e, se o Tomcat estiver rodando, pare-o por uns instantes. No diretrio onde se
encontra o $CATALINA_HOME, arraste o diretrio conf ou copie-o, como preferir. O mesmo dever
ser feito com o diretrio server. Feito isso, voc s ir acrescentar os itens inexistentes no Tomcat. O
diretrio conf que estava compactado vem com a configurao para a execuo do admin, arquivo esse
chamado de admin.xml. Em server voc tem um diretrio webapps que contm o subdiretrio admin,
onde se encontram os arquivos da aplicao GUI Web do admin.
Criando um administrador para acessar a aplicao Admin
Para configurar um novo administrador, v em $CATALINA_HOME/conf/tomcat-users.xml.
Edite o arquivo como mostrado em destaque a seguir:
1
Faces e Struts
tomcat-users.xml
<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
<role rolename="tomcat"/>
<role rolename="role1"/>
<role rolename="manager"/>
<role rolename="admin"/>
<user username="admin" password="admin" roles="manager, admin"/>
<user username="tomcat" password="tomcat" roles="tomcat"/>
<user username="both" password="tomcat" roles="tomcat,role1"/>
<user username="role1" password="tomcat" roles="role1"/>
</tomcat-users>
Inicie novamente o Tomcat. Entre no endereo, pelo seu navegador:
http://localhost:8080/admin
A Figura a seguir mostra a entrada do Tomcat Web Server Administration Tool, o Admin, no qual tem
um formulrio para se logar, diferente do Manager visto anteriormente.
Perceba que voc adicionou um role chamado admin (referindo-se a aplicao), mas no foi necessrio
acrescentar outro usurio. O usurio admin foi mantido, o mesmo do usado para acessar o Manager,
precisando apenas adicionar o rolename ao atributo roles, separando apenas por uma vrgula do role j
existente.
1
Figura 3
Faces e Struts
Como voc j sabe, coloque admin no campo User Name e admin no campo Password.
Ao entrar, voc ter uma pgina como a mostrada na Figura a seguir:
Como configurar pelo admin o JNDI
Digamos que voc no tenha feito a configurao para acessar a livraria ou exclua essa configurao.
Para criar uma nova, usando o admin, v em Data Sources da sua aplicao Web, e em Data Source
Actions, no menu drop down selecione Create New Data Source.
Preencha os campos como mostrado na Figura a seguir:
Figura 4
Faces e Struts
Figura 5
Salve as alteraes clicando no boto Save.
A seguir voc tem a pgina JSP que acessa o JNDI configurado:
usandoJNDIDB.jsp
<%@ page language="java" contentType="text/html;"
import="java.sql.*"
%>
<head>
Faces e Struts
<title>Usando Pool de Conexo</title>
</head>
<body>
<table border="1">
<tr>
<th>ISBN</th><th>Ttulo</th>
</tr>
<%
Statement st = null;
try {
javax.naming.InitialContext ctx = new javax.naming.InitialContext();
javax.sql.DataSource ds =
(javax.sql.DataSource) ctx.lookup("java:comp/env/jdbc/LivrariaDB");
conn =
ds.getConnection();
st = conn.createStatement();
rs = st.executeQuery("select isbn, titulo from livros");
while(rs.next()) {
%>
<tr>
<td><%= rs.getString("isbn") %></td>
<td><%= rs.getString("titulo") %></td>
</tr>
<%
}
} finally {
if (st != null) st.close();
}
%>
</table>
</body>
</html>
Nota que o nome do seu JNDI que o jdbc/LivrariaDB C com um prefixo adicionado
java:comp/env/. Este prefixo indica ao recipiente que o recurso um recurso interno.
1
Faces e Struts
Captulo 9
JavaServer Pages Standard Tag Library
Devido complicada sintaxe que o JSP traz, tanto no desenvolvimento de pginas web como na
manuteno, novos formatos de negcios comearam a surgir, tanto para suprir essas necessidades
como tambm para agilizar o processo de construo de web sites com a linguagem Java.
A especificao JavaServer Pages Standard Tag Library (JSTL) teve seu primeiro release (verso
1.0) liberado em junho de 2002 e a sua chegada foi um marco para os desenvolvedores de pginas JSP.
A especificao JSTL engloba vrias aes comuns que so projetadas para controlar a maioria das
tarefas mais comuns que os desenvolvedores de pginas JSP necessitam. JSTL consiste em uma
coleo de bibliotecas, tendo cada uma um propsito bem definido, que permite escrever pginas JSPs
sem cdigo Java, aumentando assim a legibilidade do cdigo e a interao entre desenvolvedores e web
designers, proporcionando assim maior rapidez no desenvolvimento de um web site.
Uma pgina JSTL uma pgina JSP contendo um conjunto de tags JSTLs. Cada tag realiza um
determinado tipo de processamento, onde cada uma dessas tags, faz parte de uma biblioteca JSTL.
Sendo assim, uma pgina JSTL pode utilizar vrias bibliotecas JSTLs.
Alguns dias depois que a especificao JSTL havia sido libertada, o projeto Jakarta Taglibs do grupo
Apache seguiu com uma implementao de referncia da especificao pronta para uso.
O primeiro release de manuteno do JSTL (JSTL 1.1) foi completado em novembro de 2003. Um
segundo release de manuteno, JSTL 1.2, foi iniciado em junho de 2004.
Instalando o JavaServer Pages Standard Tag Library
Originalmente, a implementao de referncia (RI - Reference Implementation) do JSTL foi fornecido
pelo projeto Apache Jakarta como parte de seu projeto de Taglibs. Subseqentemente, a Sun
Microsystems incluiu o RI como parte do Java Web Services Developer Pack (JWSDP).
Dessa forma, voc tem mais de uma opo para obter a implementao de referncia. Se voc precisar
de s do JSTL, voc pode baix-lo no projeto Jakarta no endereo Web:
http://jakarta.apache.org/taglibs. Alternativamente, voc pode adquirir tambm o JWSDP da Sun no
endereo: http://java.sun.com/webservices/jwsdp.
Um endereo mais direto pode ser usado em:
http://www.apache.org/dist/jakarta/taglibs/standard/binaries/.
Entre nesse ltimo endereo e baixe os binrios .zip ou tar.gz.
Aps descompactar, pegue apenas dois arquivos JAR:
jstl.jar
standard.jar
Coloque-os dentro do diretrio lib da sua aplicao Web.
Faces e Struts
Criando seu primeiro exemplo em JSTL
Depois de instalado na sua aplicao Web, voc precisa aprender a utilizar essas tags.
primeiroExemploUsandoJSTL.jsp
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<head>
<title>Meu primeiro exemplo usando JSTL</title>
</head>
<body>
<h1><c:out value="Meu primeiro exemplo usando JSTL"/></h1>
</body>
</html>
C - Para usar o JSTL em uma pgina JSP, voc precisa primeiro definir o cabealho. Esse cabealho
definido na diretiva taglib j vista anteriormente. A URI nesse caso um endereo Web, e no se trata
de uma requisio a ser feita no protocolo HTTP, e sim para seja feita uma busca nos arquivos JARs
que se encontram no diretrio lib da sua aplicao. No JSTL existem quatro APIs bsicas, sendo a
CORE a que voc est usando. O prefixo usado a letra "c", que um padro definido pela Sun.
C - Ao ter o cabealho definido, a sua utilizao se faz simples, uma vez que so tags. Nesse caso voc
usou a tag out para imprimir o valor "Meu primeiro exemplo usando JSTL". O resultado esse
texto impresso na tela do seu browser.
1
2
Figura 1
Faces e Struts
Entendendo o JSTL
O JSTL uma coleo de quatro bibliotecas tags. Cada biblioteca de tags fornece aes teis (ou tags)
baseados nas seguintes reas funcionais:
Core
Internacionalizao (I18n) e formatao
Acesso a banco de dados relacional (tags SQL)
Processamento de XML (tags XML)
O Core Tag Library
Esta biblioteca contm um centro de aes de propsito geral, que fornecem solues simples, mas
efetivas, a problemas comuns que os desenvolvedores experimentaram em quase toda aplicao JSP.
Tarefas simples como exibir contedo, condies ou iteraes em cima de uma coleo de itens e etc.
Esse grupo de tags so as mais usadas freqentemente e incluem:
<c:if /> para condies
<c:forEach /> e <c:forTokens /> para interao
<c:choose />...<c:when />....<c:otherwise /> para um fluxo seletivo
<c:set /> e <c:remove /> para trabalhar com escopo de variveis
<c:out /> para fazer a sada de valores de variveis e expresses
<c:catch /> para trabalhar com excees Java
<c:url /> para criar e trabalhar com URLs
Internacionalizando e Formatando
Como a Internet alcanada em todos os cantos do planeta, empresas em todo o mundo passaram e se
preocupar em fornecer um contedo internacionalizado, muitas vezes com a lingua nativa e em outros
idiomas. O processo de construir uma aplicao de forma se possa adaptar a vrios idiomas e regies
sem qualquer esforo de desenvolvimento adicional so conhecidas com a internacionalizao, ou I18n
(internationalization uma palavra de 20 caracteres que comea com a letra i e termina com n ,
tendo 18 letras entre i e n). A biblioteca de Internacionalizao e Formatao fornece uma srie de
aes que o ajudam no uso dos trs componentes chaves associados com a internacionalizao: locales,
resource bundles e base names.
Esse grupo de tags incluem como as mais usadas:
Para Internacionalizao
<fmt:setBundle />: Carrega um pacote de recurso para um escopo especifico, como as
mensagens encontradas dentro de um arquivo .properties.
<fmt:setLocale />: Determina o local (a lngua a ser usada) na internacionalizao do contedo.
<fmt:message />: Para mostrar uma mensagem internacionalizada.
Para Formatao
<fmt:formatNumber />: Para formatar um valor numrico com a especfica preciso ou
formato.
Faces e Struts
<fmt:formatDate />: Para formatar a data e a hora em um especfico formato (de acordo com a
conveno internacional do local especificado)
As tags SQL
Como no poderia deixar de ter, o JSTL contm tags para trabalhar com banco de dados de relacional
podendo desde armazenar informaes como tambm manipul-las. Embora seja prefervel usar a
arquitetura baseada no paradigma Model-View-Controller (MVC) para separar a lgica de negcios do
acesso a banco de dados da camada de apresentao, s vezes voc pode precisar acessar um banco de
dados em pginas JSP.
O JSTL prov um conjunto de aes pela biblioteca de tags SQL para facilitar a interao com um
banco de dados de relacional usando comandos SQL como SELECT, INSERT, UPDATE e DELETE.
Em seu conjunto temos:
<sql:setDataSource />: Essa tag cria um DataSource para a conexo com um banco de dados.
<sql:query />: Executa instrues SQL do comando SELECT.
<sql:update />: Executa instrues SQL como UPDATE, INSERT e DELETE.
As tags que processam XML
O uso de XML para representar e trocar dados est se tornando o padro da indstria rapidamente.
XML atualmente visto com mais importncia pelo desenvolvedor de pginas JSP. Era de se esperar
que a biblioteca de tags JSTL fornecesse um conjunto de tags separadas para lidar com processo de
XML. As aes de XML fornecidas suprem s necessidades bsicas do XML e provvel que um
desenvolvedor de pginas JSP necessite tambm de aes mais complexas para controle do XML e
tambm para suas transformaes.
A seguir voc tem algumas tags do seu conjunto:
<x:forEach />: Essa tag usada para varrer colees.
<x:if /> e <x:choose />: Essas tags usada para fornecer operao condicional e permite
escolher entre opes mutuamente exclusivas.
<x:out />: Essa tag usada para fazer a sada, similar ao scriptlet <%= %>.
Colocando na prtica
muito comum utilizar o JSTL em conjunto com EL. Por esse motivo voc far alguns exemplos de
sua utilizao utilizando essa dupla.
Faces e Struts
usandoJSTLComEL.jsp
contentType="text/html;"
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<head>
<title>Desenvolvendo com JSTL e EL</title>
</head>
<body>
<c:set var="email" value="edson@integrator.com.br"/>
Seu e-mail : <strong><c:out value="${email}"/></strong>
</body>
</html>
C - Voc pode usar a action <c:set /> para declarar uma varivel em uma parte da aplicao Web
(page, request, session ou application), e freqentemente usada junto com a action <c:out />.
C - Note que na action <c:out /> voc utiliza a EL para trazer a varivel.
As actions <c:remove />, <c:when /> e <c:if />
O exemplo a seguir demonstra mais algumas tags JSTL CORE em conjunto:
maisTagsJSTLemAcao.jsp
<head>
<title>Desenvolvendo com JSTL</title>
</head>
<body>
<c:if test="${param.nome != null}">
<c:set var="nome" value="${param.nome}" />
Seu nome : <c:out value="${nome}" />
<br />
</c:if>
1
2
1
Faces e Struts
<c:remove var="nome" />
<c:choose>
<c:when test="${nome != null}">
A varivel ${'${'}nome} contm o valor ${nome}<br />
</c:when>
<c:otherwise>
A varivel ${'${'}nome} foi removida
</c:otherwise>
</c:choose>
<form action="${pageContext.request.requestURI}" method="post">
Nome: <input type="text" name="nome" /><br />
<input type="submit" value="Enviar" />
</form>
</body>
</html>
C - A tag <c:if /> a condio IF conhecida da programao Java. Dentro de seu corpo (o que seria o
bloco da condio), voc declara a criao de uma varivel chamada nome com o valor resultante do
nome transmitido pelo formulrio.
C - A tag <c:remove /> remove a varivel nome.
C - A tag <c:choose /> tambm faz testes de condio, onde a condio est em <c:when />, que no
caso verifica a varivel nome diferente de null. Caso no seja, a tag <c:otherwise /> entra em ao.
Combinado as actions <c:choose />, <c:when /> e <c:otherwise /> voc tem uma srie de condies
alternativas de uma maneira semelhante aos blocos if, elseif e else ou switch/case das linguagens de
programao modernas.
Actions <c:forEach />, <c:forTokens />
A action <c:forEach /> provavelmente um das aes mais teis provido pelo JSTL que habilita seu
contedo de corpo a ser processado vrias vezes. O <c:forEach>action repetidamente processos seu
contedo de corpo em cima de uma coleo de objetos ou at um nmero fixo de repeties foi
alcanado.
H duas sintaxes alternadas para o <c:forEach>action.
forEach.jsp
<head>
3
2
Faces e Struts
<title>A tag forEach</title>
</head>
<body>
<c:set var="str"
value="A,B,C,D,E" />
<strong>A varivel ${'${'}str }:</strong>
<br />
<c:out value="${str}" />
<br />
<strong>Usando forEach em uma coleo:</strong>
<br />
<c:forEach var="letras" items="${str}">
<c:out value="${letras}" />
<br />
</c:forEach>
<br />
<strong>Usando forEach de 1 at 10:</strong>
<br />
<c:forEach var="i" begin="1" end="10">
<c:out value="${i}" />
<br />
</c:forEach>
<br />
<strong>Usando forEach para nmeros pares de 2 at 10:</strong>
<br />
<c:forEach var='i' begin='2' end='10' step='2'>
<c:out value='${i}'/>
<br />
</c:forEach>
</body>
</html>
Voc pode usar a action <c:forEach /> de duas maneiras: para interao sobre de um conjunto de
valores inteiros ou para interagir em cima de um conjunto de informaes contidas em uma estrutura de
dados. Para realizar essas tarefas, a action <c:forEach /> oferece os seguintes atributos:
items: O atributo items de <c:forEach /> interage em cima de uma estrutura de dados vlidos
para este atributo. Este atributo no necessrio quando voc interage sobre de valores
explicitamente inteiros.
var: O nome de uma varivel de escopo que referncia o item atual da repetio. Se voc
interage sobre de valores inteiros explcitos, aquela varivel de escopo contm o valor inteiro
atual. Caso a interao seja sobre um conjunto de dados, o valor contido ser o objeto atual
daquela estrutura.
1
Faces e Struts
varStatus: O nome de uma varivel de escopo que referncia um objeto que tem propriedades
correspondentes ao status da repetio. Esse objeto do tipo
javax.servlet.jsp.jstl.core.LoopTagStatus.
begin: Se estiver interagindo sobre valores inteiros, esse atributo especifica o valor inicial. Se
estiver interagindo sobre um conjunto de dados, esse atributo especifica o ndice do primeiro
item acessado naquela estrutura. Se voc especificar este atributo, seu valor deve ser maior que
ou igual a zero.
end: Interagindo sobre um valor inteiro, esae atributo especifica o valor final. Interagindo sobre
um conjunto de dados, esse atributo especifica o ndice do ltimo item acessado naquela
estrutura. Especificando esse atributo, seu valor deve ser maior que ou igual ao valor
especificado para o atributo begin.
step: O valor que o loop deve incrementar durante todo o ciclo de uma repetio. Especificando
esse atributo, seu valor deve ser maior que ou igual a 1.
A action <c:forTokens />
A segunda action de interao disponibilizada pelo JSTL <c:forTokens />, no qual interage sobre
Strings separados por um determinado delimitador, quebrando-os, da mesma forma que a classe de
java.util.StringTokenizer trabalha, como voc j pode comprovar em Captulo anterior.
varrendoComForTokens.jsp
<head>
<title>A action forTokens</title>
</head>
<body>
<form method="post" action="${pageContext.request.requestURI}">
<table border="0">
<tr>
<th>Digite a sequencia de dados:</th>
</tr>
<tr>
<td><input width="20" maxwidth="20"
name="palavras" size="50" value="${param.palavras}" /></td>
</tr>
<tr>
Faces e Struts
<td><input type="submit" name="enviar" value="Enviar" /></td>
</tr>
</table>
</form>
<c:if test="${pageContext.request.method=='POST'}">
<table border="1">
<c:set var="i" value="1" />
<c:forTokens items="${param.palavras}" var="palavra" delims=" ,.-:;|">
<tr>
<td><strong>Palavra <c:out value="${i}" /> </strong></td>
<c:set var="i" value="${i+1}" />
<td><c:out value="${palavra}" /></td>
</tr>
</c:forTokens>
</table>
</c:if>
</body>
</html>
A action <c:forTokens /> contm os seguintes atributos:
items: O string para tokenize
delims: O delimitador de caracteres
begin: Se especificado, deve ter um valor maior ou igual a zero.
end: Se especificado, o valor deve ser maior ou igual a begin.
step: Se especificado, deve ter um valor maior ou igual a um.
var: O nome de uma varivel de escopo que referncia o item atual da repetio.
varStatus: O nome da varivel de escopo que representa o status da interao. Esse objeto do
tipo javax.servlet.jsp.jstl.core.LoopTagStatus.

O resultado desse cdigo mostrado na Figura a seguir:
1
Faces e Struts
A action de captura de erros
Capturar excees algo muito comum no desenvolvimento de aplicaes Web escritas em Java. Voc
as captura usando o bloco try...cath.
No caso do JSTL, voc utiliza a action <c:catch />. O exemplo a seguir demonstra a sua utilizao:
capturandoExcecoes.jsp
<head>
<title>Capturando Excees em JSTL</title>
</head>
<body>
<c:catch var="e">
<jsp:include page="naoExiste.jsp" />
<jsp:setProperty name="erro" property="sem" value="Invlido" />
</c:catch>
Figura 2
1
Faces e Struts
<c:if test="${e!=null}">
A exceo :<c:out value="${e}" />
</c:if>
<c:if test="${e==null}">
Caso no tenha exceo
</c:if>
</body>
</html>
C - A exception capturada pela action <c:catch /> e armazenada na varivel e.
C - Depois essa varivel utilizada em um teste dentro da action <c:if /> e, no caso de ser diferente de
null (quando ocorre uma exceo), essa exceo impressa com a action <c:out />.
Actions relacionadas a URL
Trabalhar com aplicaes Web utilizar a URL para transmitir informaes. Evidentemente o JSTL
possui caractersticas relativas a URL como importar arquivos, links, redirecionamentos e captura de
informaes.
A seguir voc tem as actions que compem essas caractersticas.
A action <c:import />
Esta ao importa o contedo de um recurso baseado em URL e fornece um modo simples e genrico
para acessar esses recursos podem ser includos ou podem ser processados dentro de uma pgina JSP.
O seu uso bsico:
<c:import url="http://www.integrator.com.br" />
Copiando o contedo para uma varivel:
<c:import url="http://www.integrator.com.br" var="conteudo" />
A action <c:import /> aceita os seguintes atributos:
Tabela 1
Atributo Descrio
charEncoding Permite especificar o encoding dos caracteres (exemplo: ISO-8859-1).
context Especifica a URL bsica que ser usada para solucionar uma URL relativa dada pelo
atributo url.
scope Especifica o escopo para a varivel pelo atributo var. O padro page.
2
Faces e Struts
Atributo Descrio
url Especifica a URL que deseja importar.
var Especifica a varivel que vai receber a sada da URL.
A action <c:url />
A action <c:url /> fornece uma forma de construir corretamente URLs formatadas. Uma situao de
seu uso seria a de transmitir a sesso de um usurio via URL.
Os browsers modernos fornecem um mecanismo de sesso armazenando-os em cookies (arquivos de
texto pequenos armazenados na mquina do usurio), que so mandados de volta com cada pedido que
o usurio faz durante uma sesso. Como esses browsers permitem o usurio de incapacitar o
armazenamento de cookies (normalmente por razes de segurana), voc precisa se assegurar de que a
sesso est sendo mantida, reescrevendo a URL, passando assim esses dados pelo endereo da
aplicao Web.
Um exemplo de uma URL reescrita com a sesso transmitida:
http://www.integrator.com.br/livros.jsp;jsessionid=33eab537dc4
Um exemplo de usa utilizao:
<c:url value="http://www.integrator.com.br/livros.jsp" />
A action <c:redirect />
Como o prprio nome sugere, a action <c:redirect /> envia um redirecionamento HTTP para um
cliente.
Seu escopo :
<c:redirect url="http://www.integrator.com.br" />
A action <c:param />
A action <c:param /> leva dois atributos bsicos: name e value; que representam o nome do parmetro
pedinte junto ao seu valor respectivamente.
Um exemplo de sua utilizao:
Faces e Struts
...
<c:url value="http://www.integrator.com.br/livros.php" var="url" >
<c:param name="isbn" value="123456" />
</c:url>
<br /><strong>O resultado da URL :</strong>
<c:out value="${url}"/>
...
Ou de uma outra forma, representada com o seguinte escopo:
<c:param name="isbn">123456</c:param>
Onde sua sada seria: O resultado da URL : http://www.integrator.com.br/livros.php?isbn=123456
Internacionalizao da aplicao
Internacionalizar uma aplicao Web nos dias de hoje uma situao muito comum entre os
desenvolvedores. A biblioteca JSTL facilita seu desenvolvimento, disponibilizando tags especiais para
essa funcionalidade.
A action <fmt:setLocale />
Esta action pode ser usada para alterar o local do cliente especificado no processamento de uma pgina
JSP.
Um exemplo de sua utilizao:
<fmt:setLocale value ="en_US" scope="session" />
O local escolhido armazenado em uma varivel chamada javax.servlet.jsp.jstl.fmt.locale e pode ser
armazenado em qualquer extenso escolhida.
O atributo value especifica um cdigo de duas partes que representa o cdigo de idioma ISO-639 e o
cdigo do pas ISO-3166.
Exibindo os textos no idioma definido
Com local definido, ou pela configurao do browser do cliente ou atravs de uso da action
<fmt:setLocale />, o JSTL precisa usadar textos pr-definidos no idioma escolhido para exibir o
contedo no browser com o idioma identificado por seu local.
Para isso, necessrio que voc, como desenvolvedor, fornea uma coleo de recursos (normalmente
Strings) para cada local que voc pretende aderir. Para isso, voc utiliza uma coleo de recursos que
conhecida como resource bundle e implementada por padro de uma chave=valor em um arquivo de
propriedades (com a extenso .properties). Para mais informaes, d uma olhada no javadoc da classe
java.util.ResourceBundle.
A actions <fmt:bundle /> e <fmt:setBundle />
Para habilitar o uso de textos no idioma definido, voc precisa especificar o pacote de recursos exigido
que fornecem as mensagens localizadas.
Sendo assim, voc usa a action <fmt:bundle /> ou <fmt:setBundle /> para especificar um recurso. Uma
vez declarado, o pacote do recurso pode ser usado para fornecer os texto no idioma definido.
Faces e Struts
Embora sejam semelhantes, as actions <fmt:bundle> e <fmt:setBundle> so usadas de diferentes
modos para fornecer mensagens localizadas em pginas JSP.
A action <fmt:bundle /> usada para declarar uma localizao de contexto I18n para usar por tags
dentro de seu corpo:
<fmt:bundle basename="Rotulos">
<fmt:message key="rotulos.nome"/>
<fmt:message key="rotulos.email"/>
</fmt:bundle>
O resource bundle com o nome rotulo declarado para fornecer recursos localizados para as actions
<fmt:message />.
Como a action <fmt:bundle /> projetada para trabalhar com aninhamento da action <fmt:message /> ,
um atributo opcional tambm pode ser usado:
<fmt:bundle basename="Rotulos" prefix="rotulos">
<fmt:message key="nome"/>
<fmt:message key="email"/>
</fmt:bundle>
O atributo opacional prefix habilita a colocao de um prefixo pr-definido que fundamental para
qualquer action <fmt:message /> aninhada tornando seu uso mais simplificado.
A action <fmt:setBundle /> tambm fornece funcionalidade semelhante a action <fmt:bundle />, mas
com uma diferena sutil. Em vez de ter que aninhar qualquer action <fmt:message/> como contedo de
corpo, a action <fmt:setBundle /> habilita um pacote de recursos a serem armazenados na varivel de
configurao javax.servlet.jsp.jstl.fmt.localizationContext, assim qualquer action <fmt:message /> que
aparecer, em qualquer parte da pgina JSP, pode acessar o pacote sem ter que ser declarada
continuamente:
<fmt:setBundle basename="Rotulos" />
<fmt:message prefix="rotulos.nome" />
A Action <fmt:message />
J mencionado anteriormente, a action <fmt:message /> usa um parmetro fundamental, key, para
extrair a mensagem do pacote de recursos e imprimir com JspWriter. .
Outro parmetro opcional, var, habilita a mensagem localizada a ser armazenada em um parmetro em
vez de ser impresso pelo JspWriter. Como com a maioria das tags JSTL, a extenso desta varivel pode
ser fixada usando o atributo scope.
Faces e Struts
As actions de formatao
Alm do idioma, usurios de diferentes localizaes tm padres diferentes relativos a algumas
situaes como:
Datas e horas
Formatos numricos
Formatos de Moedas
Felizmente, para tornar o seu trabalho mais fcil, a biblioteca de tags do JSTL fornece actions que
formatam essas situaes.
As diversas actions de formatao
As actions <fmt:timeZone /> e <fmt:setTimeZone /> complementam uma a outra de uma forma
similar as actions <fmt:bundle /> e <fmt:setBundle /> mostradas anteriormente. A action
<fmt:timeZone /> usada para especificar uma zona de tempo para aninhamentos que aparecem
dentro de seu contedo de corpo, considerando que a action <fmt:setTimeZone /> seja usada para
armazenar uma referncia de qualquer lugar para uma zona de tempo em uma varivel exportvel para
uso em uma pgina JSP.
A action <fmt:formatDate /> fornece uma flexvel formatao de zona de tempo utilizando objetos de
java.util.Date de forma que a data e a hora depende do modo da zona de tempo do cliente. Em sua
forma mais simples, a action <fmt:formatDate /> aplica o formato padro da zona de tempo atual e tem
a sada com JspWriter.
Com a action <fmt:parseDate /> voc tem uma funcionalidade complementar para a action
<fmt:formatDate /> analisando gramaticalmente e convertendo a representao de datas e horas que
foram formatadas de acordo com as configuraes locais ou customizada. Esta action particularmente
til se voc precisa permitir aos usurios ao redor do mundo a entrar com informaes de data e horas
em seu prprio formato local e ter corretamente uma anlise de acordo com o considerado correto ao
servidor.
A action <fmt:formatNumber /> tambm flexvel e capaz de formatar um valor numrico em um
determinado local ou formatar de acordo com as configuraes locais como um nmero, moeda
corrente ou porcentagem.
O exemplo a seguir demonstra essas action com alguns atributos em ao:
diversasActionsDeFormatacao.jsp
<%@taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"%>
<head>
Faces e Struts
<title>Formataes de data, hora, nmero e moeda</title>
</head>
<body>
<h2>Padro atual</h2>
<jsp:useBean id="data" class="java.util.Date" />
Data padro : <fmt:formatDate value="${data}"/><br />
Somente a data no formato dd/MM/yyyy :
<fmt:formatDate value="${data}" type="DATE" pattern="dd/MM/yyyy"/><br />
A hora: <fmt:formatDate value="${data}" type="TIME" dateStyle="default"/>
<br />
<h2>So Paulo Time Zone</h2>
<fmt:timeZone value="America/Sao_Paulo">
Formato padro : <fmt:formatDate value="${data}"/> <br />
Data no formato dd/MM/yyyy :
<fmt:formatDate value="${data}" type="DATE" pattern="dd/MM/yyyy"/> <br />
Hora estilo FULL:
<fmt:formatDate value="${data}" type="TIME" timeStyle="FULL"/><br />
</fmt:timeZone>
<br />
<h2>Los Angeles Time Zone</h2>
<fmt:timeZone value="America/Los_Angeles">
Default format : <fmt:formatDate value="${data}"/><br />
Data no formato dd/MM/yyyy :
<fmt:formatDate value="${data}" type="DATE" pattern="MM-dd-yyyy"/><br />
Hora estilo SHORT:
<fmt:formatDate value="${data}" type="TIME" timeStyle="SHORT"/><br />
</fmt:timeZone>
<hr />
<h2>Formatao de Moeda</h2>
<c:set var="salario" value="5000" />
<fmt:setLocale value="en_US"/>
<fmt:formatNumber type="CURRENCY" value="${salario}" /><br />
<fmt:setLocale value="pt_BR"/>
<fmt:formatNumber type="CURRENCY" value="${salario}" /><br />
<hr />
<h2>Formatao de Nmeros</h2>
<c:set var="numero" value="1000" />
<fmt:formatNumber type="NUMBER" groupingUsed="true" minFractionDigits="2"
value="${numero}" />
<hr />
<h2>Formatao de Porcentagem</h2>
<c:set var="porcentagem" value="0.05" />
<fmt:formatNumber type="PERCENT" value="${porcentagem}" />
</body>
</html>
Embora muito simples de compreender, primeiramente voc tem os Time Zones C que definem a data
correspondente ao local indicado. Evidentemente voc deve saber qual time zone pretende mostrar.
1
Faces e Struts
Caso voc queira ver o time zone da regio desejada, execute o trecho a seguir em uma pgina JSP com
as taglibs JSTL devidamente configuradas:
...
<jsp:useBean id="data" class="java.util.Date" />
<table border="1">
<c:forEach var="timezone"
items="<%=java.util.TimeZone.getAvailableIDs()%>">
<tr>
<td width="51%">
<c:out value="${timezone}" />
</td>
<td width="49%">
<fmt:timeZone value="${timezone}">
<fmt:formatDate value="${data}" timeZone="${zn}"
type="both" />
</fmt:timeZone>
</td>
</tr>
</c:forEach>
</table>
...
Esse cdigo varrer as Time Zones onde na primeira coluna voc poder ter o local desejado.
A imagem a seguir ilustra a sada do arquivo feito anteriormente:
Faces e Struts
Tabela 2 - Atributos da action <fmt:formatDate />
Atributos Descrio
type Pode ser time, date ou both. Usado para imprimir somente a hora, data ou ambos.
dateStyle Pode ser usado short, medium, long ou full (ou default). Usado para imprimir a data.
timeStyle Pode ser short, medium, long ou full (ou default). Usado para imprimir a hora.
value Um valor do tipo java.util.Date usado para renderizar a data e a hora.
A biblioteca de tags SQL
Embora seja desencorajado o uso de tags SQL da biblioteca JSTL em aplicaes de pginas JSP, essa
parte do captulo existe para ensin-lo como trabalhar com essas actions.
Figura 3
Faces e Struts
A action <sql:setDataSource />
As aes fornecidas pela tag da biblioteca SQL operam em uma fonte de dados definida pela classe
java.sql.DataSource. A action <sql:setDataSource /> configura uma fonte de dados e transmite essa
informao atravs do atributo var, em uma fonte de dados criada no escopo da pgina ou em
dataSource para uma fonte de dados fsica.
A fonte de dados configurada usada pelas actions restantes da biblioteca de SQL que podem executar
as instrues SQL j conhecidas.
Voc pode configurar o data source da seguinte forma:
<sql:setDataSource var="dataSource" driver="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost/livraria" user="edson" password="integrator"/>
Tabela 3
Atributo Descrio
driver O nome da classe JDBC que ser usada.
scope A varivel de escopo definida pelo atributo var. Por padro esse atributo page.
url O URL do data source.
user O usurio para acessar o banco de dados configurado no atributo url.
password A senha para acessar o banco de dados configurado no atributo url.
var A varivel de escopo criada para acessar o data source em outras actions.
O data source tambm pode ser definido como:
<sql:setDataSource dataSource="jdbc/LivrariaDB"/>
Como voc pode ver, possvel fornecer um caminho relativo a um recurso Java Naming and
Directory Interface (JNDI) pelo atributo opcional dataSource. Se voc tiver um nome JNDI para o
dataSource, ento o atributo dataSource acessar pela pgina JSP a fonte de dados JNDI. Neste caso,
voc no precisa fornecer quaisquer um dos demais atributos, porque eles j so fornecidos como parte
do recurso acessado pelo JNDI.
A action <sql:query />
A action <sql:query /> fornece a funcionalidade de executar querys do tipo SELECT:
Faces e Struts
<sql:query var="livros" dataSource="${dataSource}" >
SELECT * FROM livros
</sql:query>
O exemplo a seguir demonstra o uso da conexo e da execuo de uma query com as tags SQL do
JSTL:
usandoSQLComJSTL.jsp
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql"%>
<head>
<title>Usando instrues SQL com JSTL</title>
</head>
<body>
<sql:setDataSource var="dataSource"
driver="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost/livraria"
user="edson" password="integrator" />
<sql:query var="livros" dataSource="${dataSource}">
SELECT * FROM livros
</sql:query>
<table border="1">
<tr>
<th>ISBN</th>
<th>Ttulo</th>
<th>Atualizar</th>
<th>Excluir</th>
</tr>
<c:forEach var="row" items="${livros.rows}">
<tr>
<td><c:out value="${row.isbn}" /> </td>
<td><c:out value="${row.titulo}" /></td>
<td>
<a href="formAtualizaJSTL.jsp?isbn=
<c:out value="${row.isbn}" />">
Atualizar
1
2
3
4
5
Faces e Struts
</a>
</td>
<td>
<a href="excluirJSTL.jsp?isbn=
<c:out value="${row.isbn}" />">
Excluir
</a>
</td>
</tr>
</c:forEach>
</table>
</body>
</html>
C - Os cabealhos so definidos na diretiva taglib, como j vista anteriormente. A URI do primeiro
cabealho chama as tags CORE e o segundo cabealho so as tags de SQL. O prefixo usado a letra
"sql", que um padro definido pela Sun.
C - O data source definido nesse caso com a conexo feita diretamente na pgina. No se esquea de
que necessrio colocar o .jar da ponte JDBC do MySQL no diretrio lib de WEB-INF.
C - A query criada, nesse caso selecionando todos os registros encontrados na tabela livros.
C - Com a action <c:forEach /> voc tem uma varredura dos resultados encontrados dentro da tabela
livros, resultantes da SELECT. Dentro do atributo items voc determina a varivel livros usando a EL
e separando por um "." ponto seguido da palavra rows.
C - Os resultados so exibidos utilizando-se a EL contendo a varivel determinada no atributo var
existente na action <c:forEach />, separado por ponto . e o nome da coluna a ser exibida.
A action <sql:update />
A action <sql:update /> possibilita a manipulao de dados via SQL (SQL Data Manipulation
Language) com as declaraes INSERT, UPDATE e DELETE serem executados. Tambm possvel
executar declaraes SQL Data Definition Language, como uma criao de tabela ou declaraes de
alterao.
A sintaxe desta action semelhante a j usada <sql:query />. Novamente, um atributo var est
disponvel para armazenar o resultado da action <sql:update /> embora no seja obrigatrio.
O tipo do parmetro var java.lang.Integer.
As actions <sql:param /> e <sql:dateParam />
As actions <sql:param /> e <sql:dateParam /> so usadas ambas nas actions <sql:query /> e
<sql:update/>. Essas actions so aninhadas so usadas para passar parmetros em um string de SQL
parametrizado.
A seguir voc tem a sua sintaxe em conjunto com a action <sql:update />:
<sql:update var="r" dataSource="${dataSource}">
DELETE FROM livros WHERE isbn = ?
Faces e Struts
<sql:param value="${param.isbn}"/>
</sql:update>
Ou a sintaxe em conjunto com a action <sql:query />:
SELECT * FROM livros WHERE isbn = ?
<sql:param value="${param.isbn}"/>
</sql:query>
Os valores so passados pela action <sql:param /> e substitudos para cada parmetro marcado com o
caractere ? na instruo SQL. A ordem no qual as actions <sql:param /> aparecem determina qual
parmetro ser substitudo.
formAtualizaJSTL.jsp
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql"%>

<head>
<title>Formulrio de Atualizao</title>
</head>
<body>
<sql:setDataSource var="dataSource"
driver="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost/livraria"
user="edson" password="integrator" />
SELECT * FROM livros WHERE isbn=?
<sql:param value="${param.isbn}" />
</sql:query>
<c:set var="row" value="${livros.rows[0]}" />
<c:set var="data" value="${row.ano_publicacao}"/>
<form action="atualizaJSTL.jsp" method="post">
<table>
<tr>
2
3
1
Faces e Struts
<td>ISBN:</td>
<td>
<input type="text" name="isbn"
value="<c:out value="${row.isbn}" />" readonly="readonly" />
</td>
</tr>
<tr>
<td>Ttulo:</td>
<td>
<input type="text" name="titulo"
value="<c:out value="${row.titulo}" />" />
</td>
</tr>
<tr>
<td>Edio:</td>
<td>
<input type="text" name="edicao"
value="<c:out value="${row.edicao_num}" />" />
</td>
</tr>
<tr>
<td>Publicao:</td>
<td>
<input type="text" name="publicacao"
value="<fmt:formatDate value="${data}" type="DATE"
pattern="yyyy"/>" />
</td>
</tr>
<tr>
<td>Descrio:</td>
<td>
<textarea name="descricao" rows="5" cols="25">
<c:out value="${row.descricao}" /></textarea>
</td>
</tr>
<tr>
<td colspan="2">
<input type="submit" name="btAtualizar" value="Atualizar" />
</td>
</tr>
</table>
</form>
</body>
</html>
C - Do link criado na pgina anterior, voc transmite o cdigo do ISBN para essa pgina. Esse ISBN
passado pela action <sql:param /> e substitudo.
C - Como se trata de exibir o contedo de apenas uma linha, no ser necessrio um loop. Por esse
motivo uma varivel chamada row foi declarada. Atente ao detalhe de exibio de apenas uma linha,
4
Faces e Struts
usando a EL: ${livros.rows[0]}.
C - O ano de publicao existente na tabela de livros ser armazenado em uma varivel chamada data.
C - A varivel data formatada usando a action <fmt:formatDate />.
Faces e Struts
Captulo 10
Model-View-Controller
Este captulo o introduzir em um dos muitos conceitos arquitetnicos importantes do desenvolvimento
de aplicaes Web escritas em Java, que o ajudaro na construo dessas aplicaes que tm como
base exibir uma interface a um usurio de um sistema. Esta a arquitetura conhecida como Model-
View-Controller, ou mais popularmente abreviada como MVC. A estrutura do MVC oferece
benefcios significantes para aplicaes Web, e estando familiarizado com isso, voc aumentar sua
compreenso de uma gama de conceitos, alguns dos quais usam ou emprestaram de MVC.
O que MVC?
MVC um conceito de desenvolvimento e design que tenta separar uma aplicao em trs partes
distintas. Uma parte, a Model, est relacionada ao trabalho atual que a aplicao administra, outra
parte, a View, est relacionada a exibir os dados ou informaes dessa uma aplicao e a terceira parte,
Controller, em coordenar os dois anteriores exibindo a interface correta ou executando algum trabalho
que a aplicao precisa completar.
A arquitetura MVC foi desenvolvida para ser usada no projeto de interface visual em Smalltalk.
Estas partes so respectivamente:
Model: O Model (Modelo) o objeto que representa os dados do programa. Maneja esses dados
e controla todas suas transformaes. Esse modelo no tem conhecimento especfico dos
controladores (controller) e das apresentaes (views), nem sequer contm referncia a eles.
Portanto, o Model so as classes que trabalham no armazenamento e busca de dados. Por
exemplo, um cliente pode ser modelado em uma aplicao, e pode haver vrios modos de criar
novos clientes ou mudar informaes de um relativo cliente.
View: A View (Apresentao) o que maneja a apresentao visual dos dados representados
pelo Model. Em resumo, a responsvel por apresentar os dados resultantes do Model ao
usurio. Por exemplo, uma Apresentao poder ser um local administrativo onde os
administradores se logam em uma aplicao. Cada administrador poder visualizar uma parte
do sistema que outro no v.
Controller: O Controller (Controlador) o objeto que responde as ordens executadas pelo
usurio, atuando sobre os dados apresentados pelo modelo, decidindo como o Modelo devera
ser alterado ou devera ser revisto e qual Apresentao devera ser exibida. Por exemplo, o
Controlador recebe um pedido para exibir uma lista de clientes interagindo com o Modelo e
entregando uma Apresentao onde esta lista poder ser exibida.
Como voc pode ver, o modelo MVC uma forma de desenvolvimento que ajuda na manuteno do
sistema, sendo como um padro muito aceito no desenvolvimento de aplicaes Java, principalmente
no de aplicaes escritas para a Web.
A separao lgica da aplicao nestas partes assegura que a camada Modelo no sabe nada
praticamente do que exibido; restringido por representar as partes de componentes do problema que
Faces e Struts
resolvido pela aplicao. Igualmente, a camada de Apresentao s est relacionada a exibir dados e
no com implementar lgica de negcios que controlada pela camada Modelo. O Controlador, como
um gerenciador de trfego, dirige as apresentaes a serem exibidas e com as devidas mudanas de
dados e recuperaes vindas da camada Modelo.
As aplicaes Web
muito comum vermos ainda nos dias de hoje o desenvolvimento de aplicaes Web construdas com
cdigo HTML e cdigo servidor em uma mesma pgina, criando uma embaraosa confuso.
exatamente isso que aconteceu nos exemplos de JDBC e JSTL, cdigos de SQL, juntas a cdigos de
programao, e sadas de resultados ao usurio, tudo em um s local.
Esse tipo de desenvolvimento conhecido como embutir a lgica de negcios ao resultado final. Essa
prtica condenada pelos desenvolvedores atuais, principalmente os de aplicaes escritas em JSP, por
isso os padres Model 1 e Model 2 so adotados, baseados no paradigma MVC original.
O Model 1
A primeira arquitetura, conhecida como Model 1, muito comum no desenvolvimento de aplicaes
Web, chamada de page-centric. Esta arquitetura fornece o modo mais fcil de reunir uma aplicao
Web. Envolve simplesmente a construo de uma aplicao como um conjunto de pginas JSP.
A sucesso de eventos explicada neste exemplo simples, uma vez que voc j fez o desenvolvimento
de uma aplicao Web (mesmo sem um padro):
1. O usurio pede uma pgina de Webpor exemplo, a pgina principal, index.jsp.
2. O container Servlet executa a lgica contida na pgina index.jsp como tambm inclui pginas para
que se possa apontar. Esta execuo pode incluir a recuperao de dados de um banco de dados ou
outras funes que satisfaam a lgica de negcios. Os JavaBeans fornecem as representaes de dados
dentro da pgina JSP.
3. Unido junto a lgica de negcios da pgina, sero confeccionadas e apresentados o HTML ao
usurio.
4. Como resultado do processo, construdo o HTML final e exibido ao usurio.
Faces e Struts
Para exemplificar sua aplicao, tome o exemplo a seguir, que cria um suposto carrinho de compras
dos livros selecionados:
A pgina de produtos.jsp:
session="true"%>
<head>
<title>Selecione o livro</title>
</head>
<body>
<a href="comprar.jsp?livro=Dominando+AJAX&cmd=add">Dominando AJAX</a><br />
<a href="comprar.jsp?livro=Dominando+Eclipse&cmd=add">Dominando Eclipse</a><br />
<a href="comprar.jsp?livro=Dominando+NetBeans&cmd=add">Dominando NetBeans</a>
</body>
</html>
Figura 1 - Arquitetura Model 1
Faces e Struts
A pgina comprar.jsp:
<head>
<title>Livros Comprados</title>
</head>
<body>
<jsp:useBean id="carrinho" scope="session"
class="meupacote.CarrinhoDeCompras" />
<jsp:setProperty name="carrinho" property="*" />
<%
String[] livro = request.getParameterValues("livro");
if (livro != null) {
carrinho.process(livro);
}
String[] prods = carrinho.getProds();
if (prods.length > 0) {
%>
<table border="1">
<tr>
<th colspan="2">Carrinho de Compras</th>
</tr>
<%
for (int i = 0; i < prods.length; i++) {
%>
<tr>
<td><%=prods[i]%></td>
<td><a href="?livro=<%=prods[i]%>&cmd=r">Excluir</a></td>
</tr>
<%
}
%>
<tr>
<td colspan="2"><a href="utilizandoCarrinho.jsp">Comprar mais</a>
</td>
</tr>
</table>
<%
} else {
out.println("<h2>Voc no tem produtos no seu carrinho</h2>"
+ "<a href=\"utilizandoCarrinho.jsp\">Comprar mais</a>");
}
%>
</body>
</html>
Faces e Struts
O JavaBean CarrinhoDeCompras.java:
package meupacote;
import java.util.Vector;
public class CarrinhoDeCompras {
Vector<String> v;
String cmd=null;
public CarrinhoDeCompras(){
v = new Vector<String>();
}
private void add(String[] objs){
for(int i=0;i<objs.length;i++){
v.addElement(objs[i]);
}
}
private void remove(String[] objs){
for(int i=0;i<objs.length;i++){
v.removeElement(objs[i]);
}
}
public void setCmd(String s){
cmd=s;
}
public String[] getProds(){
String[] s =new String[v.size()];
v.copyInto(s);
return s;
}
public void process(String[] prods){
if(prods!=null && cmd!=null){
if(cmd.equals("add")){
add(prods);
}
else{
remove(prods);
}
reset();
}
}
private void reset(){
cmd = null;
}
}
As explicaes foram omitidas de seu funcionamento pois o mesmo serve apenas para demonstrar sua
utilizao no padro Model 1. Evidentemente no se trata de um carrinho de compras do mundo real, o
que o tornaria bem mais complexo. Se trata apenas de um exemplo.
Faces e Struts
O Model 2
O Model 1, para uma aplicao pequena com quantias limitadas de lgica de negcios, essa arquitetura
indicada, uma vez que simples e efetiva. Porm, em uma aplicao mais complexa, onde a lgica de
negcios no s mais detalhada, mas a lgica de exibio necessria tambm significante, uma
arquitetura de desenvolvimento baseada no Modelo 1 far com que seja um tanto bagunado. Voc j
percebeu, em exemplos contidos nesse livro, que quando voc coloca a lgica de negcios em um
modelo simples de desenvolvimento, uma repetio de cdigo acaba ocorrendo. Isso impossibilita uma
rpida manuteno e evidentemente, em um crescimento da aplicao, no haver uma possvel
extensibilidade. E isso porque no estamos contando com o fator de testes.
Desafiado por estas desvantagens bvias, os desenvolvedores identificaram uma arquitetura mais
sofisticada que usa Servlets e JSP. Esta arquitetura fora batizada de Model 2 (Modelo 2), que est
baseada em uma adaptao da arquitetura MVC original. Nessa implementao, um Servlet usado
como um Controlador, recebendo pedidos do usurio, enquanto efetuando mudanas no Modelo, e
fornecendo a apresentao ao usurio.
As apresentaes ainda implementadas nesta arquitetura usam pginas JSP, mas a lgica que elas
contm s a de exibir a interface ao usurio. A camada de Modelo foi encapsulada em objetos Java.
Figura 2
Faces e Struts
Embora maior a sua execuo, um pouco mais complexo:
1. O usurio pede para o URL de um Servlet. No pedido h uma indicao do trabalho a ser executado.
Por exemplo, no URL voc pode ter algo como: /Livraria?action=mostrarLivros, onde action
representa o trabalho que a camada Controlador deve empreender.
2. A camada Controlador recebe o pedido e determina o trabalho baseando-se no pedido. Essa camada
executa chamadas a camada Modelo que empreende a lgica de negcios exigida.
3. A camada Modelo instruda a fornecer uma lista de objetos de Livros pelo Controlador. Esse, nesse
caso, pode acessar algum tipo de camada de persistncia, como um banco de dados.
4. Para a camada Controlador proporcionada a lista de objetos de Livros para exibir na camada de
Apresentao. A camada Controlador tambm determina a apresentao apropriada para fornecer ao
usurio. Usando o despachante de pedido, o Servlet pode fornecer a lista de objetos de Livros camada
de Apresentao selecionada (pgina JSP mais indicada).
5. A camada de Apresentao tem uma referncia agora aos dados fornecidos e faz a exibio da lista
conforme sua lgica definida.
6. O HTML gerado no resultado desse processo fornecido em resposta ao usurio. isso que ele ver.
Para exemplificar esse MVC, voc ir criar os exemplos a seguir:
A pgina para logar (view inicial)
Essa uma simples pgina que contm um formulrio onde os usurios podero se entrar com
informaes de usurio e senha. Caso esteja incorreta as informaes postadas, uma mensagem aparece
C:
Figura 3 - Arquitetura Model 2
Faces e Struts
logar.jsp
<head>
<title>Logar no Sistema</title>
</head>
<body>
<form action="Logar" method="post">Usurio:<input type="text"
name="usuario" /><br />
Senha: <input type="password" name="senha" /><br />
<input type="submit" name="btLogar" value="Logar" /></form>
<%
String msg = (String) request.getAttribute("msg");
if (msg != null)
out.println(msg); //exibe a mensagem caso exista
%>
</body>
</html>
O Model Usuario.java
O Model Usuario.java um JavaBean que apenas fornece a possibilidade de se capturar os dados do
usurio (login e senha) e se logar na aplicao. Como voc no est trabalhando com banco de dados,
esse JavaBean auto-executa.
Usuario.java
package meupacote;
public class Usuario {
private String usuario=null;
private String senha=null;
public void setUsuario(String usuario) {
this.usuario = usuario;
}
public String getUsuario() {
return usuario;
}
public void setSenha(String senha) {
this.senha = senha;
}
public String getSenha() {
return senha;
}
1
Faces e Struts
public boolean verificaUsuario(){
if(this.usuario != null && this.senha != null){
if(this.usuario.equals("edson") && this.senha.equals("123"))
return true;
}
return false;
}
}
O Controller Servlet Logar
O Servlet criado a seguir demonstra a parte Controladora, que tem o objetivo de determinar qual ser a
Apresentao que ir ser mostrada ao usurio que est logando.
Logar.java
package meupacote;
import javax.servlet.http.HttpSession;
public class Logar extends javax.servlet.http.HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
response.setHeader("Cache-Control", "no-cache, must-revalidate");
response.setHeader("Pragma", "no-cache");
response.setHeader("Expires", "Fri, 25 Dec 1980 00:00:00 GMT");
String usuario = request.getParameter("usuario");
String senha = request.getParameter("senha");
Usuario user = new Usuario();
user.setUsuario(usuario);
user.setSenha(senha);
if(user.verificaUsuario()){
HttpSession sessao = request.getSession();
sessao.setAttribute("USER", usuario);
request.getRequestDispatcher("/logado.jsp").forward(request, response);
}
else{
request.setAttribute("msg", "Usurio ou Senha invlidos");
request.getRequestDispatcher("/logar.jsp").forward(request, response);
}
}
protected void doPost(HttpServletRequest request, HttpServletResponse response)
1
2
3
Faces e Struts
doGet(request, response);
}

}
Como esse Servlet faz o controle da aplicao, a explicao em si ser feita nele.
C - O Servlet verifica atravs da chamada ao JavaBean Usuario( ) enviando o usurio e a senha
digitados no formulrio se eles so vlidos. O mtodo verificaUsuario( ) que se encontra dentro do
JavaBean retorna um valor booleano, como voc mesmo pode comprovar no arquivo Usuario.java.
C - O usurio sendo validado, aberta uma sesso e registrado USER. O mtodo
getRequestDispatcher(String path ) recebe como parmetro o nome da pgina que ser visualizada.
O mtodo forward(request req, response res) se responsabiliza por redirecionar para o local
desejado.
C - Em caso contrrio, haver o registro de uma mensagem, atravs do atributo msg que fornecer
informaes ao usurio que est tentando logar na aplicao. Novamente h um redirecionamento de
recursos, mas nesse caso, para a pgina que contm o formulrio para logar, uma vez que no obteve
sucesso em sua entrada.
A View logado.jsp
Essa View demonstra o que exibido caso o usurio faa a entrada de dados com sucesso, recuperando
a sesso criada no Servlet C :
logado.jsp
session="true"
%>
<head>
<title>Usurio autenticado</title>
</head>
<body>
Seja bem vindo <%= session.getAttribute("USER") %>
</body>
</html>
importante lembrar que executar esses desenvolvimentos sem um Framework altamente
desaconselhvel. Um Framework rene em si as melhores prticas, desde que seja bom, claro.
1
Faces e Struts
Captulo 11
Data Access Object
Quando voc desenvolveu aplicaes usando JDBC, deve ter percebido que colocar as instrues SQL
em meio os scriptlets somados ao HTML era uma situao confusa e desordeira.
Embora aquele mtodo funcione, no o melhor meio de se desenvolver aplicaes JSP. Pensando
nessas situaes, os desenvolvedores passaram a adotar padres de desenvolvimento. No captulo
anterior, voc conheceu o padro MVC. Nesse captulo voc conhecer o padro DAO (Data Access
Object).
Sempre que voc precisa acessar um banco de dados que est mantendo seu modelo de objetos,
melhor empregar padro DAO. O Padro DAO fornece uma interface independente que voc pode usar
para persistir objetos de dados. A idia e colocar todas as funcionalidades encontradas no
desenvolvimento de acesso e trabalho com dados em um s local, tornando simples sua manuteno.
Tipicamente um DAO inclui mtodos para inserir, selecionar, atualizar e excluir objetos de um banco
de dados. Dependendo de como voc implementa o padro DAO, voc poder ter um DAO para cada
classe de objetos em sua aplicao ou poder ter um nico DAO que responsvel tudo de seus
objetos.
Para entrar nesse padro, voc primeiramente ir construir a classe de conexo a seguir:
ConnectionLivrariaFactory.java
package meupacote.dao;
import java.sql.Connection;
import java.sql.DriverManager;
public class ConnectionLivrariaFactory{
public static Connection getConnection() throws LivrosDAOException {
try{
Class.forName("com.mysql.jdbc.Driver");
return
}catch(Exception e){
throw new LivrosDAOException(e.getMessage());
}
}
public static void closeConnection(Connection conn, Statement stmt,
ResultSet rs) throws LivrosDAOException {
close(conn, stmt, rs);
}
public static void closeConnection(Connection conn, Statement stmt)
throws LivrosDAOException {
close(conn, stmt, null);
1
2
Faces e Struts
}
public static void closeConnection(Connection conn)
close(conn, null, null);
}
private static void close(Connection conn, Statement stmt, ResultSet rs)
try {
if (stmt != null) stmt.close();
} catch (Exception e) {
throw new LivrosDAOException(e.getMessage());
}
}
}
Essa classe bem simples cria apenas uma conexo e retorna o resultado C para quem a chamar. Note o
pacote criado, chamado de meupacote.dao.
Uma exceo ser lanada toda vez que houver um erro. A classe LivrosDAOException ser sua
classe de excees.
Mtodos chamados de closeConnection( ) C so criados para fechar a conexo, o ResultSet ou o
Statement. Isso ocorre com a chamada do mtodo privado close( ) C .
LivrosDAOException,java
public class LivrosDAOException extends Exception {
public LivrosDAOException() {
}
public LivrosDAOException(String arg) {
super(arg);
}
public LivrosDAOException(Throwable arg) {
super(arg);
}
public LivrosDAOException(String argS, Throwable argT) {
super(argS, argT);
}
}
3
Faces e Struts
Perceba que voc poder tanto transmitir um texto para exceo, uma exceo ou os dois ao mesmo
tempo usando essa classe.
Mas para se comunicar com o usurio e esse ao banco de dados, voc precisar criar uma camada. O
JavaBean a seguir ser o usado para enviar e retornar os dados.
Livros.java
package meupacote;
public class Livros implements java.io.Serializable{
private String isbn;
private String titulo;
private int edicao;
private String publicacao;
private String descricao;
public Livros(){
}
public Livros(String isbn, String titulo, int edicao,
String publicacao,String descricao ){
this.isbn = isbn;
this.titulo = titulo;
this.edicao = edicao;
this.publicacao = publicacao;
this.descricao = descricao;
}
public void setIsbn(String isbn) {
this.isbn = isbn;
}
public String getIsbn() {
return isbn;
}
public void setTitulo(String titulo) {
this.titulo = titulo;
}
public String getTitulo() {
return titulo;
}
public void setEdicao(int edicao) {
this.edicao = edicao;
}
public int getEdicao() {
return edicao;
}
public void setPublicacao(String publicacao) {
Faces e Struts
this.publicacao = publicacao;
}
public String getPublicacao() {
return publicacao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public String getDescricao() {
return descricao;
}
}
Um JavaBean simples, seguindo o padro dos demais com getters e setters. Note que nesse JavaBean o
pacote meupacote apenas.
Agora, o problema criar os mtodos necessrios para encapsular as clusulas SQL, isolando assim em
um ponto do seu desenvolvimento, em uma camada.
O DAO com os mtodos necessrios para a comunicao com o banco de dados:
TrabComDAO.java
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import meupacote.Livros;
public class TrabComDAO implements LivrosDAO {
private Connection conn;
public TrabComDAO() throws LivrosDAOException{
try
{
this.conn = ConnectionLivrariaFactory.getConnection();

}
catch( Exception e )
{
throw new LivrosDAOException( "Erro: " +
":\n" + e.getMessage() );
}
}
1
Faces e Struts
public void insert(Livros livro) throws LivrosDAOException {
PreparedStatement ps = null;
if (livro == null)
throw new LivrosDAOException("O valor passado no pode ser nulo");
try {
String SQL = "INSERT INTO livros (isbn, titulo, edicao_num, "+
"ano_publicacao, descricao) " +
"values (?, ?, ?, ?, ?)";
conn = this.conn;
ps = conn.prepareStatement(SQL);
ps.setString(1, livro.getIsbn());
ps.setString(2, livro.getTitulo());
ps.setInt(3, livro.getEdicao());
ps.setString(4, livro.getPublicacao());
ps.setString(5, livro.getDescricao());
ps.executeUpdate();
} catch (SQLException sqle) {
throw new LivrosDAOException("Erro ao inserir dados "+ sqle);
} finally {
ConnectionLivrariaFactory.closeConnection(conn, ps);
}
}
public List findAll() throws LivrosDAOException {
try {
conn = this.conn;
ps = conn.prepareStatement("select * from livros");
rs = ps.executeQuery();
List<Livros> list = new ArrayList<Livros>();
while( rs.next() )
{
String isbn = rs.getString( 1 );
String titulo = rs.getString( 2 );
int edicao = rs.getInt( 3 );
String publicacao = rs.getString( 4 );
String descricao = rs.getString( 5 );

list.add( new Livros(isbn, titulo, edicao,
publicacao,descricao ) );

2
3
Faces e Struts
}
return list;
throw new LivrosDAOException(sqle);
} finally {
ConnectionLivrariaFactory.closeConnection(conn, ps, rs);
}
}
public Livros findByISBN(String isbn) throws LivrosDAOException {
try {
conn = this.conn;
ps = conn.prepareStatement("select * from livros where isbn=?");
ps.setString(1, isbn);
rs = ps.executeQuery();
if( !rs.next() )
{
throw new LivrosDAOException( "No foi encontrado nenhum registro
com o ISBN: " + isbn );
}

String titulo = rs.getString( 2 );
int edicao = rs.getInt( 3 );
String publicacao = rs.getString( 4 );
String descricao = rs.getString( 5 );

return new Livros(isbn, titulo, edicao,
publicacao,descricao ) ;
throw new LivrosDAOException(sqle);
} finally {
ConnectionLivrariaFactory.closeConnection(conn, ps, rs);
}
}
}
4
Faces e Struts
Como voc pode perceber, o desenvolvimento do DAO simplesmente isolar todas as formas de
acessar os dados em uma classe, concentrando assim a facilidade de manuteno.
Os mtodos criados aqui so:
C - O construtor que inicia a conexo com o banco de dados;
C - A insero de dados passados pelo JavaBean Livros;
C - O mtodo que retorna todos os dados encontrados na tabela Livros, retornando um List;
C - O mtodo que retorna os dados de um Livro apenas, utilizando-se do Bean criado.
Utilizando o DAO
Para comear a utilizao desse padro, o DAO, voc ir criar um sistema simples, claro que no padro
MVC, para retornar os dados vindos do mtodo findAll( ).
Primeiro voc vai criar um Servlet que acessar o DAO.
LivrariaServlet.java
package meupacote.web;
import javax.servlet.RequestDispatcher;
import meupacote.dao.*;
public class LivrariaServlet extends javax.servlet.http.HttpServlet {

protected void service(HttpServletRequest request,

try
{
TrabComDAO dao = new TrabComDAO();
List livrosList = dao.findAll();
request.setAttribute( "livrosList", livrosList );
RequestDispatcher rd =
request.getRequestDispatcher( "/mostrarLivrosCads.jsp" );
rd.forward( request, response );
}
1
2
3
4
Faces e Struts
{
e.printStackTrace();
throw new ServletException( e );
}
}

}
Primeiro voc instncia o DAO C para que possa utilizar-se do mtodo findAll( ) C, que por sua vez
retorna um List. Esse List armazenado com o mtodo setAttribute( ) C, que guardar o List em um
atributo de nome livrosList.
O resultado desse conjunto direcionado pgina mostrarLivrosCads.jsp C.
Para trazer os resultado desse DAO, voc criar a pgina a seguir:
mostrarLivrosCads.jsp
<%@ page language="java" contentType="text/html"
import="java.util.*, meupacote.Livros"
%>
<head>
<title>Trabalhando com DAO Pattern</title>
</head>
<body>
<table align="center" border="1">
<tr><th>ISBN</th><th>Ttulo</th></tr>
<%
List livrosList = ( List )request.getAttribute( "livrosList" );
for( Iterator i=livrosList.iterator(); i.hasNext(); )
{
Livros l = ( Livros )i.next();
%>
<tr><td><%=l.getIsbn()%></td><td><%=l.getTitulo()%></td></tr>
<%
}// end for
%>
</table>
</body>
</html>
Essa pgina listar o resultado vindo do atributo livrosList C, quebrando-os pelo loop for C e os
1
2
3
Faces e Struts
imprimindo pelos mtodos getters C existentes no Bean Livros.
Detalhe: Um detalhe importante que, antes de rodar essa aplicao, voc deve ter o driver do MySQL
no diretrio lib. Lembre-se de que, sem isso, o banco de dados no ser acessvel, gerando um erro.
O arquivo web.xml dever ser algo como:
web.xml
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
<web-app>
<display-name>
MeuPrimeiroDao
</display-name>
<servlet>
<display-name>LivrariaServlet</display-name>
<servlet-name>LivrariaServlet</servlet-name>
<servlet-class>
meupacote.web.LivrariaServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>LivrariaServlet</servlet-name>
<url-pattern>/LivrariaServlet</url-pattern>
</servlet-mapping>
<welcome-file-list>
</web-app>
A organizao final dos seus arquivos (classes e pginas) dever ser como mostrado a seguir:
Faces e Struts
/MeuPrimeiroDao
|____ /WEB-INF
| |____ /classes
| |____ /meupacote
| |____ Livros.class
| /dao
| |____ ConnectionLivrariaFactory.class
| |____ LivrosDAOException.class
| |____ TrabComDAO.class
| /web
| |____ LivrariaServlet.class
| /lib
| |____ mysql-connector-java-5.0.3-bin.jar
| web.xml
|
|____ mostrarLivrosCads.jsp
Para trazer os livros cadastrados, simplesmente digite no seu navegador:
http://localhost:8090/MeuPrimeiroDao/LivrariaServlet
Figura 1
Faces e Struts
Cadastrar novos livros
Aproveitando o DAO, voc vai criar um formulrio que ir cadastrar os dados do novo livro que deseja
armazenar:
formInserindoDados.html
<head>
<title>Trabalhando com DAO</title>
</head>
<body>
<form action="LivrariaServlet?cmd=addliv"
method="post">
<table>
<tr>
<td>ISBN:</td><td><input type="text" name="isbn" /></td>
</tr>
<tr>
<td>Ttulo:</td><td><input type="text" name="titulo" /></td>
</tr>
<tr>
<td>Edio:</td><td><input type="text" name="edicao" /></td>
</tr>
<tr>
<td>Publicao:</td><td><input type="text" name="publicacao" /></td>
</tr>
<tr>
<td>Descrio:</td>
<td><textarea name="descricao" rows="5" cols="25"></textarea></td>
</tr>
<tr>
<td colspan="2">
<input type="submit" name="btCadastrar" value="Enviar" />
</td>
</tr>
</table>
</form>
</body>
</html>
Note no detalhe do atributo action da tag <form /> C que o mesmo Servlet ser chamado, mas que
dessa vez com um parmetro. Isso est sendo feito para que voc no tenha que criar um Servlet novo a
cada ao executada pelo usurio. No mundo real, projetos grandes ficariam rodeados de dezenas de
arquivos (Servlets, pginas e etc), causando enormes transtornos no desenvolvimento.
Para que funcione corretamente, uma alterao dever ser feita no Servlet criado, que ser:
1
Faces e Struts
LivrariaServlet.java
...
protected void service(HttpServletRequest request, HttpServletResponse response)
String cmd = request.getParameter( "cmd" );
if(cmd==null)
cmd = "principal";
TrabComDAO dao;
Livros livro = new Livros();
if(cmd!=null || !cmd.equalsIgnoreCase("principal")){
livro.setIsbn(request.getParameter("isbn"));
livro.setTitulo(request.getParameter("titulo"));
String edicao = request.getParameter("edicao");
if(edicao==null)
edicao="1";
livro.setEdicao(Integer.parseInt(edicao));
livro.setPublicacao(request.getParameter("publicacao"));
livro.setDescricao(request.getParameter("descricao"));
}
try
{
dao = new TrabComDAO();
RequestDispatcher rd = null;
if( cmd.equalsIgnoreCase("listar") ){

List livrosList = dao.findAll();
request.setAttribute( "livrosList", livrosList );
rd = request.getRequestDispatcher( "/mostrarLivrosCads.jsp" );
}
else if( cmd.equalsIgnoreCase( "addliv" ) ){

dao.insert( livro );

rd = request.getRequestDispatcher("LivrariaServlet?cmd=listar");
}
else if( cmd.equalsIgnoreCase("principal") ){
rd = request.getRequestDispatcher("/index.html");
}

rd.forward( request, response );
}
{
e.printStackTrace();
throw new ServletException( e );
}
}
...
1
2
3
4
Faces e Struts
A alterao desse Servlet far com que voc passe um parmetro chamado cmd C, onde cada um ter
um papel, como listar todos os livros cadastrados C, ou inserir dados C. Dependendo do comando
obtido e do resultado, a pgina redirecionada C. Com certeza esse cdigo pode ser muito melhorado,
mas que est assim para melhor assimilao do leitor iniciante.
Para finalizar, uma boa prtica de programao criar uma interface dos mtodos desenvolvidos na
classe TrabComDAO.
LivrosDAO.java
import meupacote.Livros;
public interface LivrosDAO {
public abstract void insert(Livros livro) throws LivrosDAOException;
public abstract List findAll() throws LivrosDAOException;
public abstract Livros findByISBN(String isbn) throws LivrosDAOException;
}
A classe TrabComDAO deve implementar essa interface, sendo assim altere na declarao da classe:
...
public class TrabComDAO implements LivrosDAO {
...
No Servlet tambm haver alterao, portanto:
...
if(cmd==null)
cmd = "principal";
LivrosDAO dao;
Livros livro = new Livros();
if(cmd!=null || !cmd.equalsIgnoreCase("principal")){
...
No lugar de TrabComDAO, voc altera para LivrosDAO C na declarao da varivel dao.
1
Faces e Struts
Captulo 12
JavaServer Faces
JavaServer Faces uma tecnologia do mundo de Java EE e desenhado para simplificar o
desenvolvimento de aplicaes Web.
JSF torna fcil o desenvolvimento atravs de componentes de interface de usurio (GUI) e conecta
esses componentes a objetos de negcios. Tambm automatiza o processo de uso de JavaBeans e
navegao de pginas.
Configurando um projeto JavaServer Faces
Para trabalhar com o JavaServer Faces, primeiramente ser preciso configurar os arquivos e a estrutura
necessria.
Como voc est acompanhando esse livro, o container Servlet usado o Tomcat 5.5, portanto faa
download no endereo http://java.sun.com/j2ee/javaserverfaces/download.html. Como voc ir
trabalhar com JavaServer Faces voltado para um container compatvel com a tecnologia J2EE 1.4, voc
dever baixar a verso JSF 1.1, a utilizada nesse livro.
Ao baixar o arquivo, simplesmente desempacote em um diretrio de sua escolha.
H dois modos de voc tornar o JSF e as bibliotecas de JSTL disponvel para sua aplicao Web
rodando no Tomcat. Ambos necessitam por oito arquivos do tipo JAR que esto localizados no
diretrio lib de cada distribuio descompactada, em um local que pode ser acessado pelo servidor ou
pela aplicao Web:
Seis JARs JSF:
1. commons-beanutils.jar
2. commons-collections.jar
3. commons-digester.jar
4. commons-logging.jar,
5. jsf-api.jar
6. jsf-impl.jar
Dois JARs JSTL:
1. jstl.jar
2. standard.jar
No precisa dizer que torn-los disponveis em sua aplicao simples, bastando apenas colocar esses
arquivos listados e coloc-los dentro do diretrio lib, encontrado em WEB-INF de sua aplicao Web.
Alternativamente, se voc tiver mais de uma aplicao construda com JSF, voc pode pr os arquivos
de JARs em um local comum a essas aplicaes. Para o Tomcat, o local
$CATALINA_HOME/common/lib (onde $CATALINA_HOME o local onde voc tem instalado o
seu tomcat). Se os arquivos JARs ficarem situados no diretrio common do Tomcat, todas as
aplicaes Web correntes no servidor de aplicao tem acesso a esses arquivos.
Faces e Struts
Preste ateno em reiniciar o Tomcat caso voc coloque os arquivos JARs no diretrio common, pois
ele s os reconhecer aps essa execuo.
Criando um exemplo simples para comear
Assim que configurado, voc apenas precisa criar um exemplo para comear a entender como funciona
o JavaServer Faces.
O JavaServer Faces que voc ir criar um campo de envio de nome. bem simples e enviar o nome
que voc digitar. Caso voc digite com um valor no alfabtico, ele retornar um erro.
Caso retorne o erro, alm de manter preenchido o campo onde voc digita o nome, tambm mostrar
uma mensagem, avisando do erro.
No diretrio WEB-INF
No diretrio WEB-INF, voc dever colocar os JARs indicados anteriormente. Alm do arquivo
web.xml (deployment descriptor) padro, voc ir acrescentar um outro arquivo, chamado de faces-
config.xml.
Inicialmente apenas o arquivo web.xml ser alterado:
web.xml
<display-name>DesJSF</display-name>
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>
javax.faces.webapp.FacesServlet
</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.faces</url-pattern>
</servlet-mapping>
<welcome-file-list>
</web-app>
O elemento <servlet-class /> declara javax.faces.webapp.FacesServlet fazendo com que seja
carregado inicialmente. O Servlet mapeado no contexto pelo elemento <url-pattern /> para que
qualquer aplicao tenha uma extenso .faces. Mais adiante voc conhecer o arquivo face-config.xml,
responsvel pela configurao da sua aplicao Web escrita em JavaServer Faces.
1
Faces e Struts
O JavaBean
O JavaBean mostrado a seguir ser o responsvel pela comunicao entre a pgina inicial, que voc
digitar o seu nome em um formulrio, e a pgina que resultar na mensagem de boas vindas, caso seja
enviada a pgina inicial com sucesso.
MeuBean.java
package meupacote;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
public class MeuBean {
private String nome = null;
this.nome = nome;
}
return nome;
}
public String acao() {
boolean sucesso = true;
FacesContext context = FacesContext.getCurrentInstance();
if (nome != null) {
for (int i = 0; i < nome.length(); i++) {
char c = nome.charAt(i);
if (!Character.isLetter(c) && !Character.isSpaceChar(c)) {
FacesMessage message =
new FacesMessage("Digite somente caracteres alfabticos.");
context.addMessage("formulario", message);
sucesso = false;
break;
}
}
} else {
sucesso = false;
}
return (sucesso ? "sucesso" : "falha");
}
}
Esse Bean, comum como outros j vistos, tem um mtodo especial chamado de acao( ) C, que tem
duas responsabilidades:
Inicialmente ele verificar se o nome transmitido no um caractere literal e se no um espao. Caso
essa seja a realidade, o valor digitado no transmitido e uma mensagem retornada. Note o return no
1
Faces e Struts
final do mtodo, onde uma String transmitida em caso de sucesso ou em caso de falha.
faces-config.xml
<!DOCTYPE faces-config PUBLIC
"-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN"
"http://java.sun.com/dtd/web-facesconfig_1_1.dtd">
<faces-config>
<managed-bean>
<managed-bean-name>MeuBean</managed-bean-name>
<managed-bean-class>meupacote.MeuBean</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
</managed-bean>
<navigation-rule>
<from-view-id>/trabComJSF.jsp</from-view-id>
<navigation-case>
<from-outcome>sucesso</from-outcome>
<to-view-id>/boasVindas.jsp</to-view-id>
</navigation-case>
<navigation-case>
<from-outcome>falha</from-outcome>
<to-view-id>/trabComJSF.jsp</to-view-id>
</navigation-case>
</navigation-rule>
</faces-config>
O arquivo faces-config.xml bem simples de compreender. Primeiramente voc tem um elemento,
chamado de <managed-bean /> C, que voc configura o nome do JavaBean, a classe desse Bean e o
escopo (no caso session).
No elemento <navigation-rule />, voc tem um elemento chamado de <from-view-id />, que
determina a pgina vista inicialmente na sua aplicao C.
O elemento <navigation-case /> C determina qual a pgina dever ser exibida, caso receba a
mensagem de sucesso, que voc configura dentro do elemento <from-outcome />, ou de falha,
exibindo a pgina determinada atravs do elemento <to-view-id />.
2
1
3
Faces e Struts
O formulrio que enviar o nome
Para que essas regras funcionem, primeiro voc tem que criar a pgina que submeter os dados
digitados e exibir a mensagem de erro:
trabComJSF.jsp
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<head>
<title>Meu Primeiro JSF</title>
</head>
<body>
<f:view>
<h:form id="formulario">
Digite seu nome:
<h:inputText id="nome" value="#{MeuBean.nome}" required="true" />
<h:commandButton action="#{MeuBean.acao}" value="Enviar" id="submit" />
<BR />
1
2
3
4
Figura 1
Faces e Struts
<h:messages />
</h:form>
</f:view>
</body>
</html>
Assim como ocorre com outras bibliotecas de tags, o JavaServer Faces configurado atravs da
diretiva taglib C, onde existem as bibliotecas que manipulam o HTML e outras.
Dentre as tags JSF adicionadas na pgina, uma em especial, <h:form /> C, cria um formulrio para
envio de dados pelo JSF. Note o atributo formulario, que usado no mtodo acao( ) do JavaBean
criado anteriormente para determinar o local onde ser exibida a mensagem de erro, se houver.
A tag <h:inputText /> C a responsvel pela gerao da caixa de texto que receber o nome a ser
digitado. O atributo id determina seu nome. No atributo value voc tem o EL referente ao Bean criado,
dando assim a voc o retorno garantido do valor digitado em caso de erro. Com o atributo required em
seu valor true voc diz ao container que esse campo obrigatrio em seu preenchimento.
Com a tag <h:commandButton /> C voc cria o boto de envio, determinando sua execuo no
atributo action, que por sua vez chama o mtodo acao( ) existente no JavaBean MeuBean. Com isso, a
pgina direciona seus dados conforme trabalho do mtodo. O atributo id determina o tipo de boto que
voc est criando e o atributo value o rtulo para o boto (como ocorre no HTML como voc j
conhece).
Por fim voc tem a tag <h:messages /> C que resulta em mensagem trazidas pela API do JSF ou pela
JavaBean configurado.
A pgina que resulta no sucesso do envio
A pgina a seguir mostra o nome que voc enviou e que somente exibida se for bem sucedido o
envio:
boasVindas.jsp

<head>
<title>Trabalhando com JSF</title>
</head>
5
Faces e Struts
<body>
<f:view>
Ol <h:outputText value="#{MeuBean.nome}"/><BR/>
</f:view>
</body>
</html>
C - A sada do nome, como resultado positivo, vindo do Bean, feito pela tag <h:outputText />.
Conhecendo melhor o JavaServer Faces
Agora que voc j fez sua primeira aplicao em JSF, mais fcil de entender os servios que o
framework JSF oferece ao desenvolvedor. Como voc pde ver, o framework JSF responsvel por
interagir com o usurio (cliente), e fornece ferramentas para criar uma apresentao visual, a aplicao
lgica e a lgica de negcios de uma aplicao Web. Porm, o escopo de JSF restringido camada de
apresentao. A persistncia de banco de dados e outras conexes de back-end esto fora do escopo de
JSF.
Para melhor compreenso, a seguir voc tem um resumo de como funciona o JavaServer Faces:
A arquitetura Model-View-Controller
JSF conecta a apresentao e ao modelo. Como voc viu, um componente de apresentao pode ser
unido a uma propriedade Bean de um objeto modelo:
<h:outputText value="#{MeuBean.nome}"/>
Alm disso, JSF opera como o controlador (controller) que reage ao usurio processando a ao e os
eventos de alterao de valores, enquanto dirige o codigo para atualizar o modelo ou a apresentao.
Por exemplo, voc invocou o mtodo acao( ) para conferir se um usurio havia digitado apenas
caracteres alfabticos e fez isso usando:
<h:commandButton action="#{MeuBean.acao}" value="Enviar" id="submit" />
1
Figura 2: O Bean em ao em caso de erro
Faces e Struts
Quando o boto clicado e o formulrio enviado (submetido) ao servidor, a implementao JSF
invoca o mtodo para checar o bean do usurio. Aquele mtodo pode entrar em ao arbitrria para
atualizar o modelo e devolver para a navegao o ID da prxima pgina ser exibida.
Converso de dados
Usurios entram com os dados em um formulrio Web como texto. Os objetos de negcios querem
dados como nmeros, datas ou outros tipos de dados. JavaServer Faces pode personalizar a regra de
converso.
Validao e manipulao de erros
JSF faz isto com regras de validao para campos como "este campo obrigatrio". Claro que, quando
os usurios entrarem com dados invlidos, voc precisa exibir mensagens de erros mais apropriadas.
Como j fora feito anteriormente no exemplo dado.
FacesMessage message =
new FacesMessage("Digite somente caracteres alfabticos.");
context.addMessage("formulario", message);
Internacionalizao
JSF fornece suporte a internacionalizao como codificaes de caractere e a seleo de pacotes de
recursos.
Componentes customizados
O desenvolvedor de componentes pode desenvolver componentes sofisticados que so chamado pelos
designers simplesmente arrastando para suas pginas.
Alm disso, por padro, o JSF produz HTML em sua sada, mas extensvel o suficiente para produzir
outros tipos de sadas. Com todas essas situaes, de se entender porque esse framework vem sendo
apontado como o melhor do mercado em matria de desenvolvimento GUI para Web em aplicaes
escritas em Java.
As tags padres do JavaServer Faces
Desenvolver em JavaServer Faces, como voc j pode perceber, requer conhecimento em suas tags, o
que determina sua utilizao. A seguir voc ter um resumo dessas tags.
JSF Tags HTML
A biblioteca de tags HTML contm elementos de ao que representam componentes de JSF
associados com renderers que trabalham como os elementos HTML. A maioria das aes nesta
biblioteca representa um componente HTML padro que fornece uma interface com mtodo acessor
para a combinao das propriedades do tipo de componente genrico e os atributos suportados pelo
renderer associado.
Essas tags podem ser chamadas atravs da diretiva taglib existente em uma pgina JSP:
Faces e Struts
Como voc pode notar, a biblioteca HTML do JSF chamada pela URI:
http://java.sun.com/jsf/html
E que contm o prefixo padro h.
A tabela a seguir demonstra as tags HTML de JSF:
Tabela 1 - Tags HTML do JSF
Tag Descrio
form
Um formulrio HTML
inputText
Um caixa de texto de entrada: <input type="text" />
inputTextarea
Uma caixa de texto de mltiplas linhas: <textarea />
inputSecret
Uma caixa de texto de senha: <input type="password" />
inputHidden
Campo oculto: <input type="hidden" />
outputLabel
Rtulo de um determinado campo: <label />
outputLink
ncora HTML: <a />
outputText
A sada de texto em uma nica linha
outputFormat
Como outputText, mas com formatos
commandButton
Boto (submit, reset, or pushbutton): <input type="submit" />
commandLink
Link com ao como um pushbutton
message
Mostra a mensagem para um componente
messages
Mostra todas as mensagens
Faces e Struts
Tag Descrio
graphicImage
Mostra uma imagem: <img />
selectOneListbox
Caixa de listagem
selectOneMenu
Menu de seleo
selectOneRadio
Boto de rdio
selectBooleanCheckbox
Checkbox
selectManyCheckbox
Multiplos checkboxes
selectManyListbox
Multi-seleo da caixa de listagem
selectManyMenu
Multi-seleo de menu
panelGrid
Tabela HTML: <table />
panelGroup
Dois ou mais componentes que so dispostos como um
dataTable
Tabela preenchida com informaes vindas de uma persistncia
de dados
column
Coluna em um dataTable
Atributos suportados pertencentes ao HTML
As tags HTML JSF suportam a maioria dos atributos que a especificao do HTML 4.01.
Tabela 2 - Atributos suportados mas pertencentes tambm ao HTML
Nome do
atributo
Tipo no
Java
Descrio
accept String
Uma lista separada por vrgula de content types que diz ao servidor como
processar corretamente o controle do formulrio.
acceptcharset String
Corresponde ao atributo HTML accept-charse. Um espao e /ou
uma lista separado por vrgulas de caracteres aceitos pelo servidor no
Faces e Struts
Nome do
atributo
Tipo no
Java
Descrio
processamento do formulrio.
alt String
Texto alternativo mostrado pelo browser quando no possvel mostrar o
elemento.
border String
O nmero em pixels do quadro ao redor da tabela.
cellpadding String
A quantidade de espao entre o limite da clula e o contedo seu
contedo, em pixels ou em porcentagem.
cellspacing String
A quantidade de espao entre as clulas, em pixels ou em porcentagem.
charset String
O encode de caracteres.
coords String
Uma lista de valores separados por vrgula indicando a posio do
elemento na tela.
dir String
A direo do texto: ltr (left-to-right) ou rtl (right-to-left).
disabled boolean
Se true, o elemento desabilitado.
enctype String
O content type usado para o formulrio no envio de dados POST.
frame String
Pode ser um: void, above, below, hsides, lhs, rhs,
vsides, box, ou border. Especifica os lados visveis de um quadro.
hreflang String
Usado somente com o atributo href. Especifica a linguagem do recurso
referido.
lang String
A linguagem base.
longdesc String
A descrio de uma imagem.
onblur String
Evento executado ao perder o foco do elemento no lado cliente que.
onchange String
Evento executado no elemento quando h uma alterao no lado cliente.
Somente vlidos para <input/>, <select/> e <textarea/>.
Faces e Struts
Nome do
atributo
Tipo no
Java
Descrio
onclick String
Evento executado quando o elemento (objeto HTML) clicado no lado
cliente.
ondblclick String
Evento executado quando o elemento recebe um duplo-clique no lado
cliente.
onfocus String
Evento executado quando o elemento ganha o foco. Vlido para <a/>,
<area/>, <label/>, <input/>, <select/>, <textarea/>e
<button/>.
onkeydown String
Evento executado quando o elemento detm o foco e uma tecla
pressionada e mantida; no lado cliente.
onkeypress String
Similar ao onkeydown, com a diferena que apenas pressionada.
onkeyup String
Evento executado quando o elemento detm o foco e uma tecla foi
pressionada e solta no lado cliente.
onmousedown String
Evento executado quando o elemento clicado e se mantm pressionado
no lado cliente.
onmousemove String
Evento executado quando um arraste feito pelo mouse sobre o
elemento no lado cliente.
onmouseout String
Evento executado quando o ponteiro do mouse sai do elemento no lado
cliente.
onmouseover String
Evento executado quando o ponteiro do mouse est sobre o elemento no
lado cliente.
onmouseup String
Evento executado quando o mouse foi pressionado e solto no lado
cliente
onreset String
Evento somente vlido para formulrios no lado cliente. Executa
reiniciando seus valores padro.
onselect String
Evento executado quando h uma seleo no lado cliente. Para campos
Faces e Struts
Nome do
atributo
Tipo no
Java
Descrio
<input /> e <textarea />.
onsubmit String
Evento no lado cliente executado quando o formulrio submetido.
readonly boolean
Se true, o elemento contm um contedo somente para leitura.
rel String
Uma lista espaos separada de tipos de links, descrevendo a relao do
documento atual e do documento referenciado.
rev String
Uma lista de espaos separados por tipos de links, descrevendo o link
reverso para o documento referido.
rules String
Pode ser: none, groups, rows, cols ou all. Especifica a regra de
visibilidade entre clulas em uma tabela.
shape String
Pode ser: default, rect, circle ou poly. Especifica a forma de
uma regio.
size String
A largura de um campo input em nmeros de caracteres visveis ou
nmero visvel de opes em uma lista de seleo.
style String
Folhas de Estilo ( CSS ) explcito.
styleClass String
Um ou mais nomes de classes de folhas de estilo separadas por espao.
No HTML o atributo para isso class, mas que infelizmente no pode
ser usado por uma tag personalizada (customizada) do JSP (palavra
reservada). O atributo class, no HTML, utilizado para chamar um
estilo.
summary String
Um resumo do propsito de uma tabela.
tabindex String
A posio do elemento ordenando em tabulao, um nmero entre 0 e
32767.
target String
O nome do quadro que devera exibir a resposta resultante do pedido
disparado pelo elemento.
title String
Usado como tool-tip (dica de tela) do elemento.
Faces e Struts
Nome do
atributo
Tipo no
Java
Descrio
type String
Quando usado com um elemento <a />, uma sugesto sobre o content
type do recurso referenciado.
width String
A largura de uma tabela, em pixels ou em porcentagem sobre o espao
avaliado na pgina em questo.
JSF Tags Core
A biblioteca de tags Core contm elementos de ao que representam objetos de JSF que so
independentes da linguagem de marcao da pgina, como conversores e validadores.
Como voc pode notar, a biblioteca HTML do JSF chamada pela URI:
http://java.sun.com/jsf/core
E que contm o prefixo padro f (no a letra c para no ter problemas com o padro JSTL).
A tabela a seguir demonstra as tags HTML de JSF:
Tabela 3: JSF Tags Core
Tag Descrio
view
Cria uma view de nvel superior
subview
Cria uma subview de uma view
facet
Adiciona um facet para um componente
attribute
Adiciona um atributo (key/value) para um componente
Faces e Struts
Tag Descrio
param
Adiciona um parmetro para um componente
actionListener
Adiciona uma ao ouvinte para um componente
valueChangeListener
Adiciona um ouvinte para verificar mudanas nas propriedades de um
componente
converter
Acrescenta um conversor arbitrrio a um componente
convertDateTime
Adiciona um conversor para data e hora em um componente
convertNumber
Adiciona um conversor numrico para um componente
validator
Adiciona um validador para um componente
validateDoubleRange
Valida um intervalo double para o valor de um componente
validateLength
Valida a largura de um componente
validateLongRange
Valida um intervalo long para o valor de um componente
loadBundle
Carrega um pacote de recursos, armazena propriedades como um Map
selectitems
Especifica itens para uma seleo ou seleciona muitos componentes
selectitem
Especifica um item para uma seleo ou seleciona muitos componentes
verbatim
Adiciona markup para uma pgina JSF
Faces e Struts
Ciclo de Vida do JSF
Todos os pedidos devem ser controlados pelo FacesServlet. O FacesServlet a parte de Controller do
padro MVC. Controla roteando o trfico e administrando o lifecycles dos beans e componentes de
interface do usurio (UI).
Os componentes UI so organizados em uma estrutura de rvore. O componente raiz o UIViewRoot
e so representados no JSP usando a tag <f:view />. Cada componente pode ser associado com os
mtodos e atributos de um bean. Cada componente tambm pode ser associado com uma funo de
validao ou classe.
Resumindo, um ciclo de vida do JSF composto vrias fases. Numa requisio podemos passar por
todas essas fases ou por nenhuma, dependendo do tipo de requisio, de erros que ocorrem durante as
validaes e converses e do tipo de resposta.
Uma requisio e uma resposta so consideradas faces request/response se contiverem tags JSF, assim
como as que no as contm so chamadas de non-faces request/response. Uma non-faces request pode
vir de um clique em um link, por exemplo.
Como j dito, toda requisio recebida pelo FacesServlet e prossegue a passagem pelas fases at uma
resposta ser retornada ao cliente.
O FacesServlet recupera uma instncia de FacesContext do FacesContextFactory, fornecendo uma
implementao de LifeCycle. O processamento do ciclo de vida ento delegado a interface LifeCycle,
a partir da chamado ao mtodo execute. A implementao de LifeCycle inicia as fases do ciclo de vida.
Se existir algum validador associado a algum campo do formulrio este inicializado nessa primeira
fase. A rvore armazenada pelo contexto e ser utilizada nas fases seguintes. Tambm o estado do
formulrio salvo automaticamente.
Faces e Struts
Captulo 13
Struts e NetBeans IDE 5.5
Jakarta Struts um framework open source, escrita em Java, de desenvolvimento Web, mantida pela
Apache Software Foundation (ASF).
O framework Struts foi criado por Craig R. McClanaham e doado para a ASF no ano 2000.
Como implementao do paradigma MVC (Model-View-Controller), utilizando um padro similar a
Model 2, esse framework um dos mais populares entre os desenvolvedores.
Este captulo mostrar uma introduo de como trabalhar com Struts utilizando o NetBeans IDE 5.5.
Desenvolvendo uma aplicao com Struts
A primeira aplicao que voc vai desenvolver com Struts ser para que haja uma maior compreenso
do como desenvolver nesse framework. O que voc precisa inicialmente entender o de quais
bibliotecas sua aplicao precisa para que Struts seja utilizado.
Inicie criando um novo projeto no NetBeans, exatamente como voc aprendeu no livro Dominando
NetBeans. Lembrando que atualmente estamos utilizando um NetBeans que contm o nosso idioma.
Figura 1
Faces e Struts
Na segunda etapa do projeto, digite o nome do projeto que desejar.
O Servidor ser Tomcat nesse caso. Os demais itens pode deixar como est e avance para a terceira
etapa clicando no boto Prximo.
Na terceira e ltima etapa, selecione o Framework Struts, marcando a opo Struts 1.2.9. Em sua
configurao, abaixo nessa tela do assistente, altere o pacote j preenchido no campo Recurso do
Aplicativo para meupacote.struts.ApplicationResource e clique no boto Finalizar.
Figura 2
Faces e Struts
Como voc pode ver ao expandir o projeto, no item Bibliotecas existem os arquivos necessrios para o
desenvolvimento de Struts em suas pginas.
Figura 3
Faces e Struts
Para uma aplicao Struts as seguintes bibliotecas esto disponveis:
Oito JARs Struts:
1. commons-beanutils.jar
2. commons-fileupload.jar
3. commons-digester.jar
4. commons-logging.jar
5. commons-validator.jar
6. antlr.jar
7. jakarta-oro.jar
8. struts.jar
Em uma eventual exportao para um ambiente de produo, essas bibliotecas devem estar disponveis
em sua aplicao dentro do diretrio lib, encontrado em WEB-INF.
A camada Modelo
Para comear, voc vai criar uma classe que receber um Nome de um formulrio que ainda ser
criado. Para isso, crie um novo arquivo no NetBeans.
Essa classe, em Struts representa os dados entre a camada de Apresentao (a pgina JSP) e a camada
Figura 4
Faces e Struts
Controle.
Selecione na caixa de dilogo em Categorias o item Web e tem Tipos de Arquivo o item Bean
ActionForm do Struts. Clique no boto Prximo para ir at a segunda etapa do assistente.
Na segunda etapa, coloque em Nome da Classe o nome NomeForm e em pacote deixe apenas escrito
meupacote. Clique no boto Finalizar para concluir o assistente.
Figura 5
Faces e Struts
A classe gerada pelo NetBeans contm uma pr-configurao que o ajudar a desenvolver o exemplo.
Para isso, voc vai alterar o atributo name. Clique com o direito do mouse sobre esse atributo e
selecione no menu de contexto o item Refatorar e clique em Renomear.
Figura 6
Faces e Struts
Na caixa de dilogo digite nome em Novo Nome e clique no boto Prximo.
Figura 7
Figura 8
Faces e Struts
Na parte inferior da sua IDE, uma janela chamada Refatorar surgir. Confirme as alteraes que
ocorrero em seu arquivo simplesmente clicando no boto Refatorar.
Deixe-o como mostrado na listagem da classe NomeForm a seguir.
NomeForm.java
package meupacote;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionMessage;
public class NomeForm extends org.apache.struts.action.ActionForm {

return nome;
}

public void setNome(String string) {
nome = string;
}

public NomeForm() {
super();
}
Figura 9
Faces e Struts

public ActionErrors validate(ActionMapping mapping,
HttpServletRequest request) {
ActionErrors errors = new ActionErrors();
if (getNome() == null || getNome().length() < 1) {
errors.add("nome", new ActionMessage("erro.nome.obrigatorio"));
}
return errors;
}
}
A classe NomeForm estende org.apache.struts.action.ActionForm, no qual trata eventos de
formulrio.
Para todo campo no Form HTML, h uma varivel com mtodos getters e setters, no bean Form. O
controller Struts popula o Form HTML chamando os mtodos getter no bean Form. Quando o usurio
submeter o formulrio, o controller Struts povoa o bean Form com dados vindos do formulrio HTML
chamando mtodos setters na instncia do bean Form.
Com o mtodo validate( ) C voc retorna um objeto ActionErrors. A classe ActionErrors encapsula
um ou mais erros que so encontrados pela aplicao. Os problemas encontrados so representados
pela instncia de org.apache.struts.action.ActionError.
Para mostrar a mensagem ao usurio, uma classe chamada para isso. A classe
org.apache.struts.action.ActionMessage opera da mesma maneira que a classe ActionError. Na
realidade, a classe ActionMessage foi acrescentada como superclasse classe ActionError.
As mensagens
Abra o arquivo ApplicationResource e adicione as seguintes linhas:
Usada pela tag Struts <html:errors /> na pgina que voc vai desenvolver, os textos encontrados no
arquivo ApplicationResource personalizado e portanto poder conter as informaes que desejar.
1
Figura 10
Faces e Struts
Voc tambm pode adicionar tags HTML se assim desejar dar um formato melhor nos textos de sada
gerados pelas pginas Struts.
Criando a ao em Struts
A ao em Struts ser a responsvel pela recuperao do nome digitado pelo usurio e a interao com
a camada Modelo. Sua responsabilidade dar navegao e Controle para a camada Apresentao.
Crie um novo arquivo e na caixa de dilogo, na Categoria Web selecione Action do Struts em Tipos
de arquivo. Clique no boto Prximo.
Na etapa seguinte, voc digitar ControleAction no campo Nome da Classe. O pacote ser
meupacote e em Caminho da Action digite /NomeForm. Clique no boto Prximo.
Figura 11
Faces e Struts
Na ltima etapa voc define o campo Recurso de Entrada selecionando a pgina welcomeStruts.jsp.
Para selecion-la, clique no boto Procurar. Termine o assistente clicando no boto Finalizar.
Figura 12
Faces e Struts
Altere a classe ControleAction como mostrado a seguir:
ControleAction.java
package meupacote;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionForward;
import org.apache.struts.taglib.html.Constants;
public class ControleAction extends Action {
Figura 13
1
Faces e Struts

private final static String SUCCESS = "success";

public ActionForward execute(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
throws Exception {

String nome =
(String) PropertyUtils.getSimpleProperty(form, "nome");

MeuBeanModelo mb = new MeuBeanModelo( );
mb.setNome(nome);

request.setAttribute( Constante.NOME_KEY, mb);
return mapping.findForward(SUCCESS);

}
}
Uma classe org.apache.struts.action.Action C no framework Struts uma extenso do componente
controller.
A classe Action pega o pedido cliente para o modelo de negcios. A classe Action tambm pode
executar outras funes, como autorizao, loggin e validao de sesso, antes de invocar a operao
de negcios.
A Action Struts contm diversos mtodos, mas o mais importante o mtodo execute( ) C.
Esse mtodo contm a seguinte assinatura:
public ActionForward execute(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
throws Exception
O mtodo execute( ) chamado pelo controlador quando um pedido recebido de um cliente. O
controlador cria uma instncia da classe Action se ainda no existir.
O framework Struts cria somente uma instncia de cada classe Action em sua aplicao. Como podem
haver muitos usurios, voc tem que assegurar que todas suas classes Action operem corretamente em
um ambiente de multithreaded, da mesma maneira que voc faria ao desenvolver um servlet.
O mapeamento Action parte da informao da configurao Struts encontrado em um arquivo XML
2
3
Faces e Struts
especial. Essa informao configurada carregada na memria na inicializao e avaliado para o
framework em tempo de execuo. Esse elemento representado na memria por uma instncia da
classe org.apache.struts.action.ActionMapping. O objeto ActionMapping contm o atributo path
O, encontrado no arquivo XML, em contraste a uma poro de URI do pedido entrante.
struts-config.xml
...
<action-mappings>
<action input="/welcomeStruts.jsp"
name="NomeForm"
path="/NomeForm"
scope="request"
type="meupacote.ControleAction">

</action>
<action path="/Welcome" forward="/welcomeStruts.jsp"/>
</action-mappings>
...
Para que seja determinada para onde ser enviado os dados, voc precisa utilizar o mtodo
findForward( ).
A assinatura do mtodo execute( ) na classe Action, voc pode ter notado que o tipo de retorno para o
mtodo uma classe org.apache.struts.action.ActionForward.
A classe ActionForward representa um destino para o qual o controlador pode retornar uma vez que a
Action foi completa.
A action forward especificada no arquivo de configurao XML (struts-config.xml), similar a action
mapping.
Embora o NetBeans j tenha configurado boa parte das informaes contidas no arquivo struts-
config.xml, voc precisar mapear para onde ser enviado os dados preenchidos no formulrio caso
seja bem sucedido.
Com o direito do mouse sobre o local mostrado anteriormente, entre a tag <action />, clique com o
direito do mouse e selecione Struts e clique no item Adicionar Encaminhamento.
1
Faces e Struts
Na caixa de dilogo Adicionar Encaminhar digite no campo Nome de Encaminhamento a palavra
success, que como voc deve lembrar, retornado pelo mtodo findForward( ) da classe
ControleAction. No campo Arquivo de Recurso, voc deve adicionar a pgina que receber os dados
enviados pela Action, chamada de sucesso.jsp. Essa pgina ainda ser criada, portanto apenas digite.
Ao terminar, confirmando no boto Adicionar, o elemento <forward /> adicionado no arquivo
struts-config.xml. Perceba que o atributo name e path foram adicionados com as informaes
transmitidas.
Figura 14
Figura 15
Faces e Struts
struts-config.xml
...
<action-mappings>

<action input="/welcomeStruts.jsp"
name="NomeForm"
path="/NomeForm"
scope="request"
type="meupacote.ControleAction">
<forward name="success" path="/sucesso.jsp"/>

</action>
<action path="/Welcome" forward="/welcomeStruts.jsp"/>
</action-mappings>
...
Para transmitir o nome digitado para a outra pgina, o mtodo getSimpleProperty C da classe
PropertyUtils recebe do formulrio o contedo do campo nome.
Para que voc possa recuperar a informao enviada pelo formulrio, um bean ser criado para persistir
a informao passada para outra pgina.
O bean ser chamado de MeuBeanModelo e conter apenas a possibilidade de captar e transmitir o
nome digitado no formulrio que ser criado na pgina JSP utilizando Struts mais adiante.
O deployment description
O arquivo web.xml configurado automaticamente pelo NetBeans, adicionando o configurador struts-
config.xml, assim como a extenso utilizada nas aplicaes:
web.xml
<web-app version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
<init-param>
Faces e Struts
<param-name>debug</param-name>
<param-value>2</param-value>
</init-param>
<init-param>
<param-name>detail</param-name>
<param-value>2</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<session-config>
<session-timeout>
30
</session-timeout>
</session-config>
<welcome-file-list>
<welcome-file>
index.jsp
</welcome-file>
</web-app>
Passando dados para a View
Voc viu como a classe Action passou o valor recebido pelo campo nome do formulrio para a
prxima pgina, que ainda ser criada, atravs do mtodo setAttribute( ).
Quando voc passa um objeto de ActionClass para o componente encontrado na View (uma pgina
JSP) usando request.setAttribute( ), voc precisa fornecer um nome, ou identificador String que o
arquivo JSP possa usar para recuperar o objeto.
Para isso, voc cria uma Constante como a mostrada a seguir:
Constante.java
package meupacote;
public final class Constante {

public static final String NOME_KEY = "meupacote";

}
Essa constante chamada na sua classe ControleAction:
Faces e Struts
request.setAttribute( Constante.NOME_KEY, mb);
O formulrio que enviar o nome
Como o NetBeans tem o costume de iniciar um projeto com arquivos j pr-configurados, entre no
arquivo welcomeStruts.jsp e altere o contedo como mostrado a seguir:
welcomeStruts.jsp
<%@ taglib uri="http://jakarta.apache.org/struts/tags-bean" prefix="bean"%>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-html" prefix="html"%>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-logic" prefix="logic"%>
<html:html>
<head>
<title>Minha primeira pgina Struts</title>
<html:base/>
</head>
<body bgcolor="white">
<html:form action="/NomeForm.do" >
Nome: <html:text property="nome" size="16" maxlength="16"/>
<br />
<html:submit property="submit" value="Enviar"/>
</html:form>
<p>
<html:errors/>
</p>
</body>
</html:html>
Assim como ocorre com outras bibliotecas de tags, o Struts configurado em sua pgina atravs da
diretiva taglib C, onde existem as bibliotecas que manipulam o HTML e outras.
Dentre as tags Struts adicionadas na pgina, uma em especial, <html:form /> C, cria um formulrio
para envio de dados pelo Struts. No atributo action voc configura para onde o formulrio ser
enviado, no caso NomeForm.do. Lembre-se de que o elemento <action-mappings/> no sub-elemento
<action /> voc configurou esse caminho para o envio de dados.
A tag <html:text /> C a responsvel pela gerao da caixa de texto que receber o nome a ser
1
2
3
4
5
Faces e Struts
digitado. Atravs do atributo property voc determina o nome da caixa de texto.
Com a tag <html:submit /> C voc cria o boto de envio e o tipo do boto determinado pelo atributo
property. O atributo value indica o rtulo do boto, como ocorre no HTML comum.
Por fim voc tem a tag <html:errors /> C que resulta na mensagem de erro trazida pela classe
NomeForm.
O bean que receber e enviar o nome
O Bean mostrado a seguir contm apenas o acesso ao atributo nome, no qual ser enviado pela Action
e recuperado pela pgina sucesso.jsp, que recuperar os dados enviados.
MeuBeanModelo.java
package meupacote;
public class MeuBeanModelo {

public MeuBeanModelo( ) {
}
public String getNome( ) {
return nome;
}
this.nome = nome;
}
}
A pgina que resulta no sucesso do envio
A listagem a seguir demostra o nome que voc enviou e que somente exibida se for bem sucedido o
envio:
sucesso.jsp
<html:html>
<head>
<title>Seja bem vindo</title>
</head>
<body bgcolor="white">
Faces e Struts

<logic:present name="meupacote" scope="request">

<h2>
<bean:write name="meupacote" property="nome" />
</h2>
</logic:present>
</body>
</html:html>
Na pgina que receber o resultado enviado pelo formulrio, voc determina se existe uma informao
enviada atravs da tag <logic:present/> que atravs do atributo name verifica meupacote.
Caso exista, a tag <bean:write /> recupera o valor enviado e o imprime na tela.
O resultado final
O resultado de todos esses passos um pequeno formulrio contendo um campo e um boto. Caso no
seja digitado nada e enviado, o erro aparece logo abaixo da caixa:
Caso seja digitado alguma informao, o texto submetido e recuperado pela pgina sucesso.jsp.
As tags do Struts
As tags do Struts so divididas em cinco bibliotecas:
html: permite a criao e manipulao de tags HTML com o Struts, principalmente formulrios;
logic: permite a criao de estruturas de condio e repetio, alm da administrao do fluxo
da aplicao;
bean: permite a criao e manipulao de JavaBeans dentro da pgina;
nested: permite a definio de modelos de objetos aninhados e a capacidade de represent-los e
administr-los;
Figura 16
Faces e Struts
template: permite a criao de modelos dinmicos de pginas JSP que compartilham de um
formato comum.
Destas cinco bibliotecas, aqui voc aprender mais detalhadamente as trs primeiras.
As tags HTML do Struts
A biblioteca de tags HTML do Struts contm tags para renderizar o HTML, como conhecemos. Voc
conheceu algumas tags na pgina mostrada como exemplo anterior. Agora voc ter uma melhor viso
das tags que podem ser utilizadas atravs do framework Struts. Estas tags so personalizadas pela
biblioteca e facilitam a comunicao com as configuraes geradas pelas classes desenvolvidas para
esse fim.
Como voc pode notar, a biblioteca HTML do Struts chamada pela URI:
http://jakarta.apache.org/struts/tags-html
E que contm o prefixo padro html.
A tabela a seguir demonstra as tags HTML do Struts:
Tabela 1- Tags HTML do Struts
Nome da Tag Descrio
base Cria um elemento HTML base
button
Cria um boto com a tag input
cancel
Cria um boto cancel
checkbox
Cria uma caixa de checagem (input checkbox)
errors
Renderiza mensagens de erros enviados
file
Cria um campo HTML file
Faces e Struts
Nome da Tag Descrio
form Define um elemento (tag) HTML form
frame Cria um elemento HTML frame
hidden
Cria um campo HTML hidden
html Cria um elemento HTML html
image
Renderiza uma tag input do tipo "image"
img Cria uma tag HTML img
javascript
Renderiza uma validao JavaScript baseada na validao carregada pelo
ValidatorPlugIn
link
Cria uma tag HTML anchor ou hyperlink
messages
Condicionalmente mostra as mensagens transmitidas pela classe
multibox
Cria mltiplos campos caixa de checagem (input checkbox)
option
Cria a tag select option
options
Cria uma coleo de tags select options
optionsCollection
Cria uma coleo de tags select options
password
Cria um campo input password
radio
Cria um boto de radio (input radio)
reset
Cria um boto reset
rewrite
Renderiza uma URI
Faces e Struts
Nome da Tag Descrio
select Renderiza uma tag select
submit
Renderiza um boto submit
text
Cria uma tag input field do tipo "text"
textarea Cria uma tag textarea
A tag form
A tag Struts form uma das mais importantes tags encontradas na biblioteca de tags HTML. com
esta tag que renderizado a tag padro form do HTML e cria um link com a ActionForm configurada
para a aplicao.
Como a tag <html:form /> do Struts controla aspectos importantes de uma pgina, a seguir voc tem
uma tabela que contm os elementos nela existentes:
Tabela 2 - Os atributos da tag Struts <html:form />
Nome do
atributo
Descrio
action
A URL para o qual o formulrio ser submetido
enctype
O content encoding para o qual ser usado na submisso do formulrio.
focus
O nome do campo no qual haver um foco inicial.
method
O mtodo HTTP no qual ser usado para submeter os dados.
name
O nome da ActionForm do qual as propriedades sero usadas para popular os valores
dos campos input.
onreset
Tratador de evento JavaScript executado se o formulrio reiniciado.
onsubmit
Tratador de evento JavaScript executado se o formulrio for submetido.
Faces e Struts
Nome do
atributo
Descrio
scope O escopo da ActionForm para este formulrio.
style
Os estilos CSS para ser aplicado nas tags HTML desse elemento.
styleClass
Classe CSS para ser aplicado neste elemento HTML.
styleId
O identificados para a assinatura deste elemento HTML.
target
O alvo para acessar um determinado frame quando o formulrio for submetido.
type O nome de classe completamente qualificado de ActionForm para esta pgina.
O atributo action
O valor para o atributo action da tag Struts <html:form /> usado para selecionar ActionMapping onde
assumido o nome suposto da pgina que processar o pedido, do qual voc pode identificar o
ActionForm apropriado e a extenso.
Se a extenso mapeada em uso for (*.do), o valor do atributo action dever ser igual ao valor do
atributo path correspondente para esse elemento, opcionalmente seguido pelo sufixo de extenso
correto:
<html:form action="NomeForm.do" focus="nome">
Ou:
<html:form action="NomeForm" focus="nome">
Tags Logic
A biblioteca de tags Logic contm tags utilizadas para o gerenciamento condicional tag library contains
tags that are useful for managing conditional gerando sada de texto, loop sobre de colees de objeto
para gerao repetitiva de sada de texto e administrao de fluxo da aplicao.
Faces e Struts
Como voc pode notar, a biblioteca Logic do Struts chamada pela URI:
http://jakarta.apache.org/struts/tags-logic
E que contm o prefixo padro logic.
A tabela a seguir demonstra as tags Logic do Struts:
Tabela 3 - Tags Logic do Struts
Nome da Tag Descrio
empty
Avalia o contedo do corpo aninhado desta tag e se a varivel pedida for
um null ou uma string vazia.
equal
Avalia se o contedo existente no corpo aninhado desta tag uma varivel
igual ao valor especificado.
forward
Despacha o controle para a pgina especificada pela entrada
ActionForward.
greaterEqual
Avalia o contedo no corpo desta tag no qual a varivel pedida contm um
valor maior que ou igual ao valor especificado.
greaterThan
Avalie o contedo do corpo desta tag se a varivel pedida for maior que o
valor especificado.
iterate
Repita o contedo de corpo desta tag sobre uma coleo especificada.
lessEqual
Avalia o contedo de corpo desta tag se a varivel pedida for menor que ou
igual ao valor especificado.
lessThan
Avalia o contedo de corpo desta tag se a varivel pedida for menor que o
valor especificado.
match
Avalia o contedo de corpo desta tag se o valor especificado for uma
substring apropriada para a varivel pedida.
messagesNotPresent Gera o contedo do corpo desta tag se a mensagem especificada no estiver
Faces e Struts
Nome da Tag Descrio
presente neste pedido.
messagesPresent
Gera o contedo do corpo desta tag se a mensagem especificada estiver
notEmpty
Avalia o contedo do corpo desta tag se a varivel pedida no for null nem
uma String vazia.
notEqual
Avalia o contedo do corpo desta tag se a varivel pedida no for igual ao
valor especificado.
notMatch
Avalia o contedo do corpo desta tag se o valor especificado no for uma
substring apropriada para a varivel pedida.
notPresent
Gera o contedo do corpo desta tag se o valor especificado no estiver
present
Gera o contedo do corpo desta tag se o valor especificado estiver presente
neste pedido.
redirect
Renderiza um redirecionamento HTTP.
Seu uso pode ser visto na pgina sucesso.jsp:
<logic:present name="meupacote" scope="request">
<h2>
</h2>
</logic:present>
Tags Bean
As tags que fazem parte da biblioteca de tags Bean so usadas para acessar JavaBeans e outras
propriedades associadas como tambm por definir novos beans que sero acessveis para o resto da
pgina por variveis scripting e atributos de escopo de pgina. Mecanismos convenientes para criar um
bean novo baseado nos valores de pedidos de cookies, cabealhos e parmetros que so fornecidos.
Faces e Struts
Como voc pode notar, a biblioteca Bean do Struts chamada pela URI:
http://jakarta.apache.org/struts/tags-bean
E que contm o prefixo padro bean.
A tabela a seguir demonstra as tags Bean do Struts:
Tabela 4 - As tags Bean do Struts
Nome da tag Descrio
cookie
Define uma varivel baseada no(s) valore(s) especificados no cookie pedido.
define
Define uma varivel baseada no(s) valore(s) especificados na propriedade bean.
header
Define uma varivel baseada no(s) valore(s) especificados no pedido header.
include
Carrega a resposta para uma aplicao dinmica pedida e a torna disponvel como um
bean.
message
Renderiza uma mensagem string internacionalizada para a resposta.
page
Expe um item especificado do contexto da pgina como um bean.
parameter
Define uma varivel baseada no(s) valore(s) especificados no parmetro pedido.
resource
Carrega um recurso da aplicao web e a torna disponvel como um bean.
size Define um bean contendo o nmero de elementos em um Collection ou Map.
struts
Expe para um Struts nomeado um objeto de configurao interno como um bean.
write
Renderiza o valor de uma propriedade bean especfica.
Faces e Struts
Voc utilizou a tag Struts <bean:write /> para imprimir o nome transmitido pelo formulrio na pgina
sucesso.jsp.
Faces e Struts
Apndice A
Contexto de desenvolvimento Web em Java
Para desenvolver os exemplos das aplicaes Web escritas em Java, voc primeiro precisa criar um
contexto de desenvolvimento de sua aplicao Web, para que tudo funcione perfeitamente.
Crie um diretrio chamado de Site no local que desejar. Para que voc no tenha dvidas, se voc
estiver usando o Windows crie, por exemplo, no drive C. No Linux pode ser criado dentro do diretrio
home do seu usurio. Dentro desse diretrio, crie os demais diretrios como apresentados:
Site/
WEB-INF/
classes/
lib/
Note que dentro do diretrio Site existe o diretrio WEB-INF. No diretrio WEB-INF, existem dois
diretrios, um chamado de classes e outro de lib.
No diretrio WEB-INF
No diretrio WEB-INF adicione o arquivo web.xml:
web.xml
<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
version="2.4">
<display-name>Texto mostrado no manager</display-name>
<description>
Descritor do contexto de desenvolvimento.
</description>
<session-config>
<session-timeout>
30
</session-timeout>
</session-config>
<welcome-file-list>
Faces e Struts
</web-app>
O arquivo WEB-INF/web.xml o descritor de contexto de uma aplicao web, segundo a
especificao Java Servlet/J2EE. As informaes nele contidas so as configuraes especficas da
aplicao.
Instalando uma aplicao Web em outro local
Talvez voc queira criar uma aplicao Web em um caminho diferente do habitual webapps do
Tomcat. Nesse caso, voc dever configurar um arquivo de contexto, contendo o nome da aplicao e o
caminho onde se encontra:
context.xml
<Context path="/Site" docBase="C:\Site"
debug="0">

<ResourceLink name="users" global="UserDatabase"
type="org.apache.catalina.UserDatabase"/>
</Context>
No atributo docBase voc coloca o caminho fsico da sua aplicao Web, no Windows, como mostrado
a seguir ou no Linux, por exemplo: docBase="/var/www/Site".
No URL do navegador, digite como mostrado a seguir, nos exemplos:
No Windows
http://localhost/manager/deploy?path=/Site&config=file:/C:/Site/context.xml
No Linux
http://localhost/manager/deploy?path=/Site&config=file:/home/Site/context.xml
A mensagem a seguir ser mostrada no navegador, o que indicar que a aplicao foi configurada com
sucesso:
OK - Deployed application at context path /Site
Faces e Struts
Apndice B
O XHTML
XHTML uma famlia de mdulos e documentos atuais e futuros que reproduzem, englobam e
ampliam o HTML 4. Os documentos da famlia XHTML so baseados em XML e modernamente tm
sido projetados para trabalhar em conjunto com aplicaes XML de usurios.
XHTML 1.0 (a presente especificao) o primeiro tipo de documento da famlia XHTML. uma
reformulao dos trs tipos de documentos HTML 4 como aplicaes de XML 1.0. Foi concebida para
ser uma linguagem de contedos em conformidade com XML e seguindo algumas diretrizes simples
ser tambm compatvel com aplicaes de usurios em HTML 4.
O HTML 4
HTML 4 uma aplicao SGML (Standard Generalized Markup Language) em conformidade com a
International Standard ISO 8879, e est mundialmente reconhecida como a linguagem padro para
publicao World Wide Web.
SGML uma linguagem para descrever linguagem de marcao, particularmente aquela linguagem
utilizada para troca, gerenciamento e publicao eletrnica de documentos. HTML um exemplo de
linguagem definida em SGML.
SGML tem sido usada, desde os meados dos anos 80 e tem permanecido uma linguagem estvel. Est
estabilidade deve-se ao fato de SGML ser ao mesmo tempo diversificada e flexvel. Contudo esta
flexibilidade tem seu pro, e o preo est no alto nvel de complexidade da linguagem, o que tem
inibido sua adoo em diversos ambientes, incluindo a a World Wide Web.
HTML, foi concebida originariamente para ser uma linguagem destinada ao trfego de documentos de
carter cientfico e tcnico, adaptada para ser usada por no especialistas naqueles tipos de documentos.
HTML contorna o problema da complexidade do SGML especificando um pequeno conjunto de tags
com caractersticas estruturais e semnticas adaptadas para gerenciar documentos relativamente
simples. Alm de simplificar a estrutura dos documentos HTML adicionou suporte para HiperTexto.
As facilidades de multi-mdia foram acrescidas posteriormente.
Uma Introduo Linguagem HTML
HTML (HyperText Markup Language - Linguagem de Formatao de Hipertexto) fruto do
"casamento" dos padres HyTime e SGML.;
HyTime - Hypermedia/Time-based Document Structuring Language
Hy Time (ISO 10744:1992) - padro para representao estruturada de hipermdia e informao
baseada em tempo. Um documento visto como um conjunto de eventos concorrentes dependentes de
tempo (udio, vdeo, etc.), conectados por webs ou hiperlinks.
Faces e Struts
O padro HyTime independente dos padres de processamento de texto em geral. Ele fornece a base
para a construo de sistemas hipertexto padronizados, consistindo de documentos que alocam os
padres de maneira particular
SGML - Standard Generalized Markup Language
Padro ISO 8879 de formatao de textos: no foi desenvolvido para hipertexto, mas torna-se
conveniente para transformar documentos em hiper-objetos e para descrever as ligaes.
SGML no padro aplicado de maneira padronizada: todos os produtos SGML tm seu prprio
sistema para traduzir as etiquetas para um particular formatador de texto.
DTD - Document Type Definition - define as regras de formatao para uma dada classe de
documentos. Um DTD ou uma referncia para um DTD deve estar contido em qualquer documento
conforme o padro SGML.
Portanto, HTML definido segundo um DTD de SGML.
Como so as Marcaes HTML?
As marcaes do HTML - tags - consistem do sinal (<), (o smbolo de "menor que"), seguida pelo
nome da marcao e fechada por (>) ("maior que").
De um modo geral, as tags aparecem em pares, por exemplo, <h1> Cabealho</h1>. O smbolo que
termina uma determinada marcao igual quele que a inicia, antecedido por uma barra (/) e
precedido pelo texto referente.
No exemplo, a tag <h1> avisa ao cliente Web para iniciar a formatao do primeiro nvel de cabealho
e </h1> avisa que o cabealho acabou.
H excees a esse funcionamento em pares das marcaes. A tag que indica quebra de linha - <br /> -
tambm no precisa de uma correspondente, e outras tais como <hr /> por exemplo.
Documento bsico e seus componentes
A estrutura de um documento HTML apresenta os seguintes componentes:
<html>
<head><title>Titulo do Documento</title></head>
<body>
texto,
imagem,
links,
...
</body>
</html>
As tags HTML no so sensveis letras maisculas e minsculas (case sensitive). Traduzindo: tanto
faz escrever <htmL>, <Html>, <html>, <HtMl>, ...
Mas por conveno, o HTML sempre dever ser escrito em minsculo, isso devido ao novo modelo
Faces e Struts
XHTML.
Os documentos se dividem em duas sees principais: <head /> e <body />.
A tag <head />
A tag <head /> contm informaes sobre o documento; a tag <title />, por exemplo, define um ttulo,
que mostrado no alto da janela do browser. Nesta pgina, por exemplo, est definido assim:
<head>
<title>Exemplo de documento em HTML</title>
</head>

Todo documento WWW deve ter um ttulo; esse ttulo referenciado em buscas pela rede, dando uma
identidade ao documento.
A tag <body />
Tudo que estiver contido na tag <body /> ser mostrado na janela principal do browser, sendo
apresentado ao leitor. A tag <body /> pode conter cabealhos, pargrafos, listas, tabelas, links para
outros documentos, e imagens.
Quebra de linha
Quando voc quer mudar de linha, usamos a tag <br />. Isso s necessrio se voc precisar de uma
quebra de linha em determinado ponto, pois os browsers j quebram as linhas automaticamente para
apresentar os textos.
Com sucessivas tags <br /> podemos inserir diversas linhas em branco nos documentos.
Pargrafos
Voc pode criar pargrafos usando a tag <p />. Um pargrafo se distingue de uma quebra de linha por
pular uma linha, deixando-a em branco.
Formatao de textos
Existem diversas tags HTML que voc pode usar para formatar textos existentes em sua pgina.
Veja algumas dessas tags logo a seguir:
Faces e Struts
Formatando em negrito
A tag de negrito representada por <strong />. Assim, se voc precisar colocar uma palavra ou um
trecho de texto em destaque, voc far a seguinte forma:
<strong> Esse texto est em negrito </strong>
Formatando em itlico
A tag de itlico representada por <em />. Assim, se voc precisar colocar uma palavra ou um trecho
de texto em destaque, como no caso do negrito, voc far a seguinte forma:
<em> Esse texto est em itlico </em>
Ligando um documento com links
A tag anchor <a /> a responsvel por ligaes de hipertexto entre uma pgina e outra. Para criar um
link voc dever fazer da seguinte forma:
<a href="nome_da_pagina.jsp">Esse um exemplo de link</a>
Tabelas
As tabelas so representadas pela tag <table /> e tem como sua funcionalidade principal organizar
informaes em uma pgina.
muito usada para organizar objetos de formulrio em pginas HTML. Sua sintaxe :
<table border="1">
<tr>
<th>Clula de Cabealho 1</th><th>Clula de Cabealho 2</th>
</tr>
<tr>
<td>Clula 1</td><td>Clula 2</td>
</tr>
</table>
As tags que criam linhas so representadas por <tr />. J as colunas ou divises so representadas pelas
tags <td />.
As tags que representam colunas de cabealho so representadas por <th />.
Formulrios
Os formulrios so usados para transmitir dados, sejam apenas textos ou tambm, arquivos em geral.
As tags de formulrio so definidas por <form />.
Faces e Struts
<form method="post" action="pagina_para_recbimento.jsp">
<label for="nome">Nome:</label>
<input type="text" name="nome" id="nome" />
<input type="submit" name="btEnviar" id="btEnviar" value="Enviar" />
</form>
A tag <form /> contm alguns atributos, como no caso method que representa a forma de envio dos
dados, sejam POST ou GET.
O atributo action define o local para onde voc enviar os dados do formulrio.
Um formulrio pode ser formado de diversas outras tags, onde cada uma representa uma forma de
transmitir informaes.
Outros atributos da tag <form />
A tag < form /> tambm pode apresentar um outro atributo:
enctype
Indica o tipo de codificao dos dados enviados atravs do formulrio. O tipo default application/x-
www-form-urlencoded.
Caso seja necessrio enviar arquivos, voc deve definir a codificao multipart/form-data.
<form action="recebe.jsp" method="post"
enctype="multipart/form-data" name="form1" id="form1">
</form>
Entrando com dados
Os formulrios podem conter qualquer tipo de formatao. Como padro colocamos tabelas dentro da
marcao de formulrios para organizar seus campos. Dentro da marcao da tag <form /> voc pode
colocar tags de campos de entrada e botes, onde as tags mais comuns so: <input />, <select />,
<textarea /> e <label />.
Todos os campos de entrada de dados tm um atributo chamado name , ao qual associamos um nome,
utilizado posteriormente por um script, tanto no lado cliente, para validao de dados, como por
exemplo o JavaScript como no lado servidor, que ser o responsvel por captar as informaes
adicionadas e depois trat-las.
TAGS responsveis por entrada e envio de dados
INPUT
A tag <input /> tem um atributo principal chamado type, ao qual atribumos seis valores diferentes que
Faces e Struts
geram seis tipos diferentes de entrada de dados.
Campos de entrada de texto
O mais comum dos tipos de entrada de dados o text.
<form action="recebe.jsp" method="post">
Nome: <input type ="text" name = "nome" />
</form>
Campo de dados senha
Entrada de texto na qual os caracteres so mascarados, impedindo a sua visualizao real na tela,
disfarando geralmente com asteriscos ou bolinhas (XP Theme)
<form action="login.jsp" method="post">
Login: <input type="text" name="login" /><br />
Senha: <input type="password" name="senha" />
</form>
Outros Atributos
VALUE
Pode ser usado para dar um valor inicial a um campo de tipo texto ou senha. Desse modo, se o usurio
no preencher este campo, ser adotado este valor padro.
Login: <input type="text" name="login" value="aprendarapido" />
SIZE
Especifica o tamanho visual para o campo do formulrio. S vlido para campos text e password . O
valor padro 20.
Login: <input type="text" name="login" size="15" /><br />
Senha: <input type="password" name="senha" size="15" />
</form>
MAXLENGHT
Nmero de caracteres mximo aceito em um campo de dados. Este atributo s vlido para campos de
entrada text e password.
Faces e Struts
<form action="cadastro.jsp" method="post">
e-mail: <input type="text" name="email" size="35" maxlenght="100" />
<br />
UF: <input type="text" name="uf" size="5" maxlenght="2" />
</form>
NAME
Assim como type um atributo chave. Como j dito anteriormente, esse atributo usado por scripts
para recepo de dados ou para validao. importante salientar que nesse atributo voc no pode
colocar caracteres especiais nem acentos.
ID
Assim como em outros elementos HTML, o atributo id muito importante nas especificaes do
XHTML. Tambm possui uma ligao fundamental com a tag <label /> que ser vista posteriormente.
Caixas de checagem (Checkbox)
CHECKBOX
Insere um boto de escolha de opes. Pode ser escolhida mais de uma alternativa.
<form action="musicas.jsp" method="post" name="form1">
Selecione os estilos de msica que mais gosta:<br />
<input type="checkbox" name="rock" />ROCK <br />
<input type="checkbox" name="pop" /> POP <br />
<input type="checkbox" name="dance" /> DANCE <br />
</form>
Botes de rdio
RADIO
Insere um boto de rdio, onde voc tem vrias opes mas somente uma alternativa entre elas pode ser
escolhida.
<form action="cadastro.jsp" method="post" name="form1">
<input type="radio" name="sexo" value="masculino" />Masculino <br />
<input type="radio" name="sexo" value="feminino" /> Feminino <br />
</form>
Faces e Struts
Note que o atributo name o mesmo nas duas opes. Isso ocorre porque, se os nomes fossem
diferentes, voc poderia marcar mais de uma opo. O que difere um boto de rdio do outro o
atributo value.
CHECKED
Atributo comum entre os dois ltimos tipos acima, colocando essa opo, a caixa de checagem ou
boto de rdio fica marcado por padro.
<input name="sexo" type="radio" value="masculino" checked="checked" />
Botes de ao
SUBMIT
O boto tem o comportamento de enviar dados (submeter) ao servidor.
Senha: <input type="password" name="senha" size="15" /><br />
<input type="submit" name="enviar" value="Entrar" />
</form>
O atributo value nesse caso tem o comportamento de rtulo no boto.
RESET
Restaura os valores iniciais dos campos existentes no formulrio, limpado qualquer entrada que voc
tenha feito ou selecionado.
<input type="reset" name="limpar" value="Limpar" />
</form>
BUTTON
Boto sem ao padro alguma. Muito usado pelos desenvolvedores para chamada de scripts que
rodam do lado cliente, como o JavaScript.
Faces e Struts
<input type="button" value="Chama script" onclick="enviar()" />
</form>
IMAGE
Boto que contm as caractersticas de envio semelhante ao SUBMIT mas que no lugar de um boto
comum voc tem uma imagem inserida.
<input type="image" name="enviar" src="imagem.gif" />
</form>
Caixas de seleo
Comuns em programas desktop, as caixas de seleo servem, assim como os botes de rdio, para
restringir as opes do usurio escolhendo uma entre as opes.
Estado:
<select name= "estado" >
<option value="SP">So Paulo</option>
<option value="RJ">Rio de Janeiro</option>
<option value="MG">Minas Gerais</option>
<option value="0" selected="selected">Selecione o Estado</option>
</select>
</form>
As caixas de seleo contm mltiplas opes geradas com a tag <option /> e os valores (VALUE) so
atribudos nessa TAG.
SELECTED
Atributo que seleciona uma opo como padro, similar ao checked das tags <checkbox /> e <radio />.
SIZE
Atributo que amplia a quantidade de opes visveis no campo:
Estado:
<select name= "estado" size="4">
Faces e Struts
</select>
</form>
Nesse caso, os quatro itens da caixa sero mostrados.
MULTIPLE
Com esse atributo, a caixa de seleo passa a ter a capacidade de poder ter mltiplas selees, que
podero ser feitas com a tecla SHIFT pressionada para uma seleo uniforme ou com a tecla CTRL
para uma seleo aleatria.
Estado:
<select name= "estado" size="4" multiple="multiple">
</select>
</form>
Agrupando opes
<optgroup />
O elemento <optgroup /> serve para criar grupos de opes, dentro de uma lista select, formando
listas hierrquicas. O texto exibido pelo optgroup apenas um rtulo (gerado pelo atributo LABEL)
e no pode ser selecionado, ou seja, no uma opo vlida da lista.
Estado:
<select name= "estado" size="4" multiple="multiple">
<optgroup label="SUDESTE">
Faces e Struts
</optgroup>
</select>
</form>
reas de Texto
<textarea />
Uma rea para entrada de texto, utilizada para grande quantidade de informaes.
<textarea cols="40" rows="5" name="comentario">
Coloque aqui seu comentrio
</textarea>
</form>
COLS
O atributo COLS determina a quantidade de caracteres na horizontal que sero exibidos.
ROWS
Com esse atributo voc tem a quantidade de linhas que sero exibidas.
WRAP
O atributo WRAP define se a mudana de linha ser automtica durante a digitao ("on"), ou
somente quando for pressionado ENTER ("off").
O parmetro WRAP pode assumir tambm uma das seguintes opes:
VIRTUAL - o texto digitado sofre o efeito na tela de quebra de linha, porm o texto enviado numa
nica linha;
PHYSICAL - o texto digitado sofre o efeito na tela de quebra de linha, e tambm o texto enviado
com as quebras de linha;
Rtulos
<label />
Utilizado como rtulo de uma caixa de entrada, boto de checagem ou de seleo, tem como principal
caracterstica possibilitar o usurio de clicar em seu rtulo e esse por sua vez jogar o foco na caixa de
texto ou marcar uma opo.
<form action="cadastro.jsp" method="post" name="form1">
<input type="radio" name="sexo" value="masculino" id="m" />
Faces e Struts
<label for="m">Masculino </label><br />
<input type="radio" name="sexo" value="feminino" id="f" />
<label for="f">Feminino</label> <br />
</form>
No caso acima, clicando no rtulo, por exemplo em Masculino, a tag <label /> localizar o atributo ID
com o valor m, e o selecionar.
Campo Oculto
HIDDEN
Existem campos que, de certa forma, voc quer passar valores, mas no quer que o usurio final no os
veja. Isso muito comum no uso de programao servidora e voc aprender nos cursos de PHP, ASP
ou JSP.
<input type="hidden" name="oculto" value="valor oculto ao usurio na pgina" />
</form>
Campo de arquivos
FILE
O campo FILE transporta arquivos para o servidor, o chamado UPLOAD. O atributo
enctype="multipart/form-data" deve ser definido na declarao do formulrio.
<form action="recebe_arquivo.jsp" method="post"
enctype="multipart/form-data" name="form1" id="form1">
<input name="arquivo" type="file" id="arquivo" />
</form>
Botes de formulrio especiais
Eu os chamo de especiais por conter caractersticas inovadoras e interessantes introduzidas no HTML.
importante salientar que nem todos os browsers podem suportar todos, mas que os principais e atuais
o suportam.
Faces e Struts
BUTTON
Existem trs tipos de botes: SUBMIT, RESET e BUTTON:
<button type="submit" name="enviar" value="Enviar">
<img src="enviar.gif" /> Enviar
</button>
</form>
O boto acima aparece com uma imagem e um rtulo escrito Enviar. Seu comportamento similar ao
boto do SUBMIT visto anteriormente. Abaixo voc tem o RESET e o BUTTON, que possuem as
mesmas caractersticas vistas anteriormente nos controles INPUT.
<button type="reset" name="limpar" value="Limpar">Limpar</button>
<button type="button" name="nada" value="Nada">Nada</button>
</form>
Somente leitura e Desabilitado
READONLY
Esse atributo torna o campo somente leitura em seu contedo.
e-mail: <input type="text" name="email" size="35" readonly="readonly"
value="aprendarapido@aprendarapido.com.br" />
</form>
DISABLED
Esse atributo desabilita um campo, no podendo nem sequer selecionar seu contedo.
e-mail: <input type="text" name="email" size="35"
disabled="disabled" value="aprendarapido@aprendarapido.com.br" />
</form>
FIELDSET
Um rtulo especial, que envolve um conjunto de campos, geralmente usados para agrupar certos pontos
do formulrio ou botes de rdio ou de checagem. Um ttulo aparece na parte superior e uma linha
envolve a rea.
Faces e Struts
<form action="musicas.jsp" method="post" name="form1">
<fieldset style="width: 50%;">
<legend title="Qual msica voc mais gosta">
Qual msica voc mais gosta
</legend>
<input type="checkbox" name="rock" id="rock" />
<label for="rock">ROCK </label><br />
<input type="checkbox" name="pop" id="pop" />
<label for="pop">POP</label> <br />
<input type="checkbox" name="dance" id="dance" />
<label for="dance">DANCE</label>
</fieldset>
</form>
Tecla de acesso
accesskey
O atributo accesskey associa uma tecla de acesso a um elemento. Uma tecla de acesso deve ser um
nico caractere. Quando a tecla de acesso ativada (no Windows, combinada com ALT), o controle
correspondente recebe o foco. Os seguintes elementos suportam o atributo accesskey: button, input,
label, legend e textarea, alm dos elementos HTML a e area.
<form action="enviar.jsp" method="post">
e-mail: <input type="text" name="email" size="35" accesskey="m" />
</form>
No caso acima, voc pode colocar o foco no componente apenas pressionando a tecla ALT em
conjunto com a tecla m.
As diferenas entre o HTML 4 e o XHTML
Requisitos de conformidades para documentos
Esta verso da XHTML define as conformidades de documentos em modo XHTML 1.0 "strict", os
quais esto restritos a elementos e atributos XML e XHTML 1.0 namespaces. 3.1.1. Requisitos de
conformidades para documentos no modo "strict"
Um documento "strict" conforme com XHTML um documento XML que atende somente as
facilidades descritas como mandatrias nesta especificao. Documentos nestas condies devem
Faces e Struts
satisfazer os seguintes critrios:
1. Estar conforme com as declaraes contidas em uma das trs DTDs
2. O elemento raiz do documento deve ser html.
3. O elemento raiz do documento deve conter uma declarao xmlns para o namespace em
XHTML . O namespace em XHTML definido como:
http://www.w3.org/1999/xhtml. Abaixo, um exemplo de elemento raiz:
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
4. Deve haver no documento, uma declarao DOCTYPE que precede o elemento raiz do
documento. A declarao de identificador pblico contida no DOCTYPE deve referenciar-se a
uma das trs DTDs encontradas em DTDs atravs do uso do respectivo Formal Public Identifier
(Identificador Pblico Formal). O sistema identificador adaptar-se-a s caractersticas do
sistema local.
<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">
5. O subconjunto das DTD no deve ser usado para sobrescrever entidades parmetros nas DTD.
Uma declarao XML no requerida em todo documento XML, contudo recomenda-se que os autores
de documentos XHTML usem a declarao XML nos seus documentos. Tal declarao requerida
quando a codificao de caracteres do documento for outra que no a a codificao default UTF-8 ou
UTF-16 e nenhuma codificao for determinada por um protocolo de nvel superior.
Diferenas para o HTML 4
Esta seo informativa.
Dado ao fato de que XHTML uma aplicao XML, certas prticas que so legais em HTML 4
baseado em SGML [HTML4] devem ser modificadas.
Os documentos devem ser bem formados
Bem formado um conceito novo introduzido por [XML]. Em essncia, isto significa que todos os
elementos devem ter suas tags de fechamento ou serem escritos com uma sintaxe especial ( descrita
adiante) e ainda, que todos os elementos devem estar convenientemente aninhados.
Faces e Struts
Embora "overlapping" seja ilegal em SGML, amplamente tolerado pelos navegadores em uso.
CORRETO: elementos aninhados.
<p>aqui, um pargrafo em <em>negrito</em>.</p>
INCORRETO: elementos em "overlapping"
<p>aqui, um pargrafo em<em>negrito.</p></em>
Elementos e nomes de atributos devem ser em letras minsculas
Documentos XHTML devem usar minsculas para todos os elementos do HTML, bem como para
nomes de atributos. Esta diferena necessria porque XML case-sensitive (sensvel a caracteres
maisculos e minsculos). Por exemplo, <li> e <LI> so tags diferentes. Isso no decorrer do curso deve
ser observado e que foram colocados os elementos, bem como atributos, em maisculo para melhor
assimilao do cdigo e contedo, mas que devem seguir as especificaes normativas.
O uso de tags de fechamento obrigatrio
Em SGML - HTML 4 permitido para determinados elementos, omitir-se a tag de fechamento. XML
no permite omisso de qualquer tag de fechamento. Todos os elementos excetuados aqueles vazios
declarados nas DTD, tem que ter tag de fechamento. Os elementos vazios declarados nas DTD podem
ter tag de fechamento ou usar uma abreviao para elemento vazio.
Elementos vazios
Elementos vazios devem ter uma tag de fechamento ou a tag de abertura deve terminar com />. Como
exemplo: <br /> ou <hr />.
CORRETO: Elementos vazios com terminao
<br /><hr />
INCORRETO: Elementos vazios sem terminao
<br><hr>
Os valores de atributos devem estar entre aspas
Todos os valores de atributo devem ser declarados entre aspas, mesmo aqueles valores com caracteres
nmericos.
<td rowspan="3">
A sintaxe para atributos deve ser escrita por completo
XML no suporta abreviaes na sintaxe para atributos. Valores de atributos devem ser escritos por
Faces e Struts
completo. Nomes de atributos tais como readonly e checked no podem ocorrer em elementos sem
que seus respectivos valores sejam declarados.
<input name="rock" type="checkbox" id="rock" checked="checked" />
Elementos vazios
Inclua um espao antes de / > (barra-sinal de maior) nos elementos vazios. Por exemplo, <br />, <hr
/> e <img src="imagem.jpg" alt="Minha Imagem" />. Use a sintaxe de tag
simplificada para elementos vazios.
Faces e Struts
Em breve nas Melhores Livrarias
Desenvolvendo Aplicaes Web com JSP, Servlets, JavaServer Faces,
Hibernate, EJB 3 Persistence e Ajax
Um livro com uma abordagem totalmente indita, contendo exemplos de desenvolvimento que iro
muito alm de apenas ensinar tcnicamente. Com exemplos orientadoa ao desenvolvimento, o livro
aumenta o nvel de dificuldade at as mais complexas aplicaes utilizando Ajax.
Alm disso, voc ter a possibilidade de utilizar tanto a IDE NetBeans 5.5 ou a plataforma Eclipse
WTP 3.2.
Viso geral dos captulos
Ao longo desse livro, voc ter muitos cdigos para desenvolver. A sua grande maioria est na integra,
para que voc mesmo o digite.
Embora seja um livro voltado para o trabalho com cdigos, ainda assim possui uma grande quantidade
de imagens (quase 200 figuras), que ilustram desde o resultado do que voc obter nas suas aplicaes
at mesmo os passos utilizados em uma IDE.
Captulo 1: Como a Web trabalha?
Criar pginas Web sem entender como ela trabalha algo impossvel de se imaginar. Neste captulo
voc conhecer os fundamentos sobre a funcionalidade da Web, passando de uma requisio feita pelo
seu browser ao servidor at os diversos protocolos existentes.
Captulo 2: A linguagem Java
O que Java? Como configurar minha mquina para utilizar aplicaes Java? Posso rodar Java em
outros sistemas operacionais? Essa e outras perguntas sero respondidas atravs deste captulo, onde
voc aprender onde encontrar, a instalar e configurar o Java SE tanto no sistema operacional Windows
como no Linux.
Captulo 3: Fazendo funcionar o Java na Web
A configurao de um container Servlet necessria para que suas pginas Web escritas em Java
rodem em sua mquina. Neste captulo voc aprender onde baixar, instalar e configurar o Apache
Tomcat 5.5, um dos containeres Servlet mais utilizados do mundo.
Captulo 4: Introduo aos Servlets
Servlets, o que isso? Neste captulo voc ser introduzido no aprendizado sobre Servlets, seu ciclo de
vida, sua configurao, seu desenvolvimento, compilao e publicao no Tomcat.
Captulo 5: Escolha seu ambiente de desenvolvimento
Na atualidade, duas IDEs Java vem se destacando no mercado: Eclipse e NetBeans. A pergunta : qual
utilizar? Voc aprender neste captulo a utilizar o bsico de cada IDE, desde onde baixar at a sua
configurao de projetos e criao de aplicaes escritas em Java no desenvolvimento Web.
Captulo 6: A classe HttpServlet
Faces e Struts
Com um aprofundamento na criao de Servlets, voc aprender neste captulo como captar pedidos
via mtodo GET e POST, utilizando links e formulrios para envio de informaes.
Captulo 7: Outros mtodos muito teis da interface HttpServletRequest
Neste captulo voc aprender outros mtodos utilizados na construo de Servlets que pode desde
varrer um conjunto de dados enviados por um formulrio at mesmo recuperar cabealhos do servidor.
Captulo 8: Cookies e Sesses
Gerar cookies em pginas Web algo to comum, extremamente utilizado em sites de comercio
eletrnico e agora ao seu alcance. Neste captulo voc aprender a criar e a recuperar cookies, para
utiliz-los em um controle as visitas feitas em seu site. Alm disso, aprender a criar e gerenciar
sesses, o habilitando para criar sofisticadas reas administrativas que exijam um usurio e senha para
entrar, e que esses dados persistam por toda a aplicao at a sua sada.
Captulo 9: Introduo a JavaServer Pages
A tecnologia JSP (JavaServer Pages) fora criada pela Sun Microsystems para facilitar o
desenvolvimento de pginas Web que exijam um alto grau de design. Mas o que JSP? Esse captulo o
introduzir nessa tecnologia, suas semelhanas e diferenas com Servlets, sua configurao e
publicao no Tomcat. Tambm aprender a criar JSP em sua IDE predileta.
Captulo 10: Comparando JavaServer Pages com Servlets
Aps aprender a criar pginas JSP, provavelmente voc quer gerar pginas com as mesmas
caractersticas criadas nos exemplos feitos com Servlets. Este captulo o mostrar exatamente isso,
possibilitando assim uma melhor compreenso de como migrar de Servlets para JSP.
Captulo 11: Controlando Erros
Erros, uma situao inevitvel quando estamos aprendendo. No poderia ser diferente no
desenvolvimento de aplicaes Web. Mas como entend-los e control-los? Este captulo o ensinar a
entender os erros mais comuns e como contorn-los sem traumas. Voc tambm aprender a tornar seu
erro mais amigvel ao usurio, em caso de falha no seu sistema quando publicado.
Captulo 12: Actions
Actions so tags que afetam o comportamento em JSP e a resposta retornada ao cliente. Durante a
traduo o container substitui uma Action por um cdigo Java que corresponda a seu efeito.
Neste captulo voc aprender sobre as diversas actions encontradas na construo de pginas JSP e o
quanto isso pode facilitar no seu desenvolvimento.
Captulo 13: JavaBeans
JavaBeans so classes que possuem o construtor sem argumentos e mtodos de acesso get e set. Muito
utilizado em construes de aplicaes Java, voc aprender no s a utilizar essas classes, mas
tambm o que elas podem facilitar no desenvolvimento de suas pginas JSP, separando a lgica do
design.
Captulo 14: Fazendo Upload de arquivos
Enviar arquivos para o servidor uma das tarefas mais comuns em sistemas administrativos
construdos para rodar em aplicaes Web. Neste captulo voc desenvolver um JavaBean que
trabalhar com uma biblioteca Open Source para enviar arquivos para o servidor. Aprender tambm
Faces e Struts
como fazer esse upload com segurana, permitindo um determinado tamanho mximo para o arquivo
enviado, bem como tambm a extenso permitida.
Captulo 15: Trabalhando com Banco de Dados
Uma imerso ao uso do banco de dados com aplicaes escritas em Java utilizando pginas JSP
mostrada neste captulo. Voc aprender neste captulo os passos bsicos para trabalhar com um banco
de dados, no caso o MySQL. Configurar seu acesso utilizando uma biblioteca JDBC e criar uma
aplicao contendo desde a incluso at a excluso de dados.
Captulo 16: JavaServer Pages Expression Language
Com linguagem de expresso JSP, EL (JavaServer Pages Expression Language), voc pode melhorar
muito o seu aplicativo, tornando-o mais simples. Este captulo o introduzir no uso de EL, mostrando
os fundamentos, que sero aplicados mais adiante em pginas JSTL e JSF. Alm disso, voc aprender
como desativar essa linguagem de expresso, caso haja necessidade.
Captulo 17: JavaServer Pages Standard Tag Library
Com a biblioteca JSTL (JavaServer Pages Standard Tag Library) voc ter uma facilitao no
desenvolvimento de pginas JSP, trabalhando com tags personalizadas. Programadores JSP
eventualmente usam JSTL para criar pginas rapidamente. Este captulo lhe dar a viso geral de JSTL,
desde seus fundamentos bsicos, passando pela internacionalizao da aplicao at o uso de banco de
dados e XML.
Captulo 18: Entendendo Custom Tags
Este captulo o ensinar a criar tags personalizadas, mostrando como desenvolver aplicaes utilizando
caractersticas que envolvem os frameworks, criando seus prprios componentes.
Captulo 19: Envio de E-mail
Dez entre dez aplicativos criados para a Web enviam e-mail. Enviar e-mail atravs de suas aplicaes
algo vital para a comunicao com os usurios de um site. Nesse captulo voc aprender desde a
instalar e configurar um servidor Open Source de envio de e-mail at o envio com autenticao e
arquivo anexo. Tambm conhecer uma biblioteca mais simples de envio de e-mails, facilitando seu
trabalho no dia-a-dia.
Captulo 20: Model-View-Controller e Data Access Object
Com dois padres de desenvolvimento de aplicaes Java, importantssimos para a elaborao de
pginas Web dinmicas, voc aprender o que significa MVC (Model-View-Controller) e DAO (Data
Access Object) e como aplic-los em seus sistemas.
Captulo 21: JavaServer Faces
Este captulo o ensinar os fundamentos existentes para desenvolver uma aplicao Web com o uso do
framework oficial da Sun Microsystems. apresentada a tecnologia de forma gradual, passando dos
passos bsicos, internacionalizao da aplicao, utilizao de banco de dados com o padro DAO at a
paginao de resultados e utilizao de estilos.
Captulo 22: JavaServer Faces e Hibernate
Como uma extenso ao captulo 21, esse captulo aborda a utilizao da tecnologia JSF com um dos
frameworks mais utilizados como camada de acesso ao banco de dados: Hibernate. Voc aprender
Faces e Struts
nesse captulo o que e como o Hibernate trabalha, dando os primeiros passos na sua utilizao.
Aprender tambm a utilizar sua linguagem, a HQL, e a trabalhar com anotaes, um recurso novo
neste framework.
Captulo 23: JavaServer Faces e a API de persistncia EJB 3
A camada de persistncia recentemente lanada pela Sun em sua nova verso do Java EE tem agitado
muito os desenvolvedores ao redor do mundo.
Neste captulo voc aprender a criar acesso a banco de dados utilizando a API de persistncia EJB3,
conhecendo a linguagem JPQL e aplicando seus desenvolvimentos a uma interface criada pelo
framework JSF. Tambm se aprofundar na utilizao de anotaes, criando inclusive relacionamento
entre objetos para pesquisa em mltiplas tabelas no banco de dados.
Captulo 24: AJAX
Com a exploso do Web 2.0, esse livro no poderia deixar de abordar a construo de aplicaes Web
escritas em Java com a adio de Ajax.
Este captulo o ensinar os fundamentos do Ajax, passando pelo uso de frameworks, incluindo para a
utilizao de JavaServer Faces.
Apndice A: Um pouco sobre Java
Uma introduo linguagem Java no que diz respeito aos seus mais bsicos conceitos, ideal para quem
nunca trabalhou com a linguagem.
Apndice B: Contexto de desenvolvimento Web em Java
Este apndice o mostrar como desenvolver um contexto para sua aplicao Web utilizando o Tomcat.
Apndice C: Trabalhando com Datas
Este apndice introduz a utilizao da classe SimpleDateFormat, dando alguns detalhes, j que sua
utilizao ao longo do livro algo muito comum.
Apndice D: O XHTML
Rodar pginas em um browser no seria possvel se a sua sada no fosse em (X)HTML. Esse apndice
introduz um iniciante no desenvolvimento Web na utilizao das principais tags existentes nessa
linguagem de marcao.
Apndice E: O MySQL
Existem muitos exemplos em que voc acessa vrias vezes o banco de dados. Neste livro, o MySQL foi
escolhido como o servidor de dados que voc acessa. Para isso, uma melhor compreenso de sua
utilizao necessria. Este apndice o ensinar alguns dos principais comandos que voc pode utilizar
no MySQL, caso no o conhea.
Faces e Struts
Bibliografia
Livros
Dominando NetBeans Gonalves, Edson Cincia Moderna 2006
Desenvolvendo Aplicaes Web com JSP, Servlets, JavaServer Faces, Hibernate, EJB 3
Persistence e Ajax - Gonalves, Edson Cincia Moderna 2007
Sites
http://www.netbeans.org
http://www.mysql.com
Faces e Struts
Erratas encontradas neste e-book
Pgina 70:
O seguinte trecho foi relatado pelo leitor Marco, faltando a parte da tag:
<jsp:useBean id="interagindo" class="meupacote.InteragindoBean" />

Ebook JSP Serv JSF Struts

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

Ebook JSP Serv JSF Struts

Enviado por

Direitos autorais:

Formatos disponíveis

Desenvolvendo Web com JSP, Servlet, JSTL, JavaServer

Você também pode gostar