Java

EDSON GONALVES
AGRADECIMENTOS
Primeiramente gostaria de agradecer os inmeros e-mails de leitores elogiando a
primeira edio deste livro e tambm os que criticaram, pedindo mais detalhes a
respeito de determinados assuntos.
Tambm agradeo o apoio dado pela Editora Cincia Moderna para o desenvolvimento desta segunda edio.
Um agradecimento especial ao apoio do JUG Leader e Founding Java Champion,
Daniel deOliveira, do DFJUG.
INTRODUO
Mais uma verso e, novamente, o NetBeans amadurece e surpreende com novas
caractersticas que tornam o desenvolvimento mais agradvel e gil.
A verso 6 desta fantstica IDE no poderia ser diferente de seus lanamentos
anteriores, onde vemos que a inteno tornar a ferramenta uma plataforma de
desenvolvimento para vrias linguagens.
Esta nova verso, alm de aproveitar melhor as facilidades incorporadas nas especificaes Java EE 5, conta tambm com as caractersticas que vem mudando
o mundo do desenvolvimento Web, como o framework Rails da linguagem Ruby.
Mais ainda, possvel, atravs do uso de JRuby, rodar aplicaes Ruby on Rails
(RoR) sobre uma Java Virtual Machine, agregando as facilidades do desenvolvimento com RoR, aliados a estabilidade e integrao com sistemas Java rodando
sobre os servidores de aplicaes. Alm do Ruby, a linguagem PHP, tida como plugin adicional na verso 6.0, tambm ganhou seu lugar na IDE definitivamente na
verso 6.1, ainda em desenvolvimento no momento em que este livro escrito.
Com um nmero maior de linguagens e frameworks suportados, o desenvolvedor
pode contar com assistentes que se integram tanto para o desenvolvimento de
aplicaes Java, como tambm na integrao com o poderoso framework Rails
(RoR) para o mesmo principio.
Outra novidade a incorporao do editor visual ao NetBeans IDE 6.x, tido antes como um pacote separado, para gerao de aplicaes Web que utilizam o
framework JavaServer Faces. Seu nome foi rebatizado para Visual Web JavaServer
Faces Applications e mais uma das diversas facilidades que o desenvolvedor Java
conta na construo de aplicaes Web.
Para este livro, nesta nova edio, cerca de 50% do material foi reescrito e ampliado. O leitor agora tem em suas mos informaes que vo desde a construo de
aplicaes Web bsicas, contendo pginas JSP e Servlets, como tambm o foco na
utilizao de JavaServer Faces, incluindo Facelets. O uso de JPA (Java Persistence
API) e EJB 3 foram adicionados, tendo em vista os leitores que esto aproveitando
as facilidades que ambos incorporam no desenvolvimento de aplicaes Web.
VIII
DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6
O uso de Ruby on Rails foi adicionado, incluindo o JRuby on Rails para programadores Java, focado na verso 2.0.2 do framework. Neste caso, no s um CRUD
feito atravs da IDE, mas tambm h muitas explicaes sobre sua arquitetura e
um exemplo com relacionamento.
A grande novidade neste livro est no aprimoramento dos captulos sobre Visual
Web JavaServer Faces. Para aqueles que desejam trabalhar com esta ferramenta,
fora elaborado em dois captulos um aplicativo completo, utilizando seus principais componentes com acesso a dados. E para aqueles que desejam utilizar JPA e
Hibernate com Visual Web JavaServer Faces, um captulo especial fora dedicado
a este assunto, incluindo o uso de Spring.
Por fim, h no CD-ROM como brinde, diversos Captulos Extras que contm o
trabalho com Struts, criando um CRUD completo, a utilizao do novssimo plugin iReport for NetBeans, integrando-se a ferramenta e facilitando a criao de
relatrios JasperReports e dois estudos de caso completos, envolvendo o Visual
Web JSF, incluindo o uso de DAO genrico, injeo de dependncias com Spring
Framework e a JPA com o Hibernate como provider.
QUEM DEVE LER ESTE LIVRO?

Este livro foi escrito para desenvolvedores com pouca ou nenhuma experincia na
utilizao do NetBeans IDE. Embora sejam apresentados alguns conceitos sobre
as tecnologias Java, para a criao de aplicaes Web, de suma importncia
que o leitor tenha conhecimento de lgica e da estrutura da linguagem Java. O
mesmo vale para os desenvolvedores que desejam trabalhar com aplicaes Ruby
on Rails, ao qual necessrio um prvio conhecimento de Ruby, facilitando assim
sua compreenso.
desejvel tambm um conhecimento sobre o desenvolvimento Web com a linguagem Java, tais como pginas JSP ou Servlets, assim como acesso e utilizao de
um banco de dados.
INTRODUO
IX
ANTES DE COMEAR
Em algumas partes desse livro voc encontrar um smbolo, que o ajudar a entender o cdigo proposto e desenvolvido, mostrado a seguir:
... - Indica que acima ou abaixo contm mais cdigo, mas que no est sendo exibido por no ter sido alterado e que o mesmo pode ser acessado pelo CD-ROM,
em anexo ao livro.
OS SOFTWARES REQUERIDOS
Os aplicativos criados nesse livro no exigem software proprietrio. Portanto ao
longo dos captulos voc no s aprender como us-los como tambm onde
encontr-los na Internet, caso precise de uma atualizao.
Esse livro no est focado especialmente em um sistema operacional, portanto a
sua escolha livre nesse ponto.
HARDWARE REQUERIDO
Uma boa configurao de hardware se faz necessrio para trabalhar com aplicaes escritas em Java. Um computador para rodar bem o NetBeans na verso 6.0
deve ter as seguintes configuraes para uma confortvel utilizao, segundo o
autor:
Processador: Pentium 4 ou similar (recomendo um Dual Core ou Core 2 Duo)
Memria: 1 GB de RAM mnimo (recomendo 2GB de RAM)
HD: 10GB de espao livre
Monitor: 17 polegadas ou superior
Alguns testes foram executados em Pentium 4 com 1 GB de memria, no qual

houve certa lentido na inicializao da IDE, mas no a inviabilidade de seu uso.
O maior problema na utilizao da IDE com relao exigncia do Hardware est
no trabalho com o Visual Web JavaServer Faces e com servidores de aplicaes
como o Glassfish.
Para a criao deste livro, um Core 2 Duo com 4 MB de cache e 2GB de RAM
fora utilizado.
CDIGOS DOS EXEMPLOS CRIADOS NO LIVRO
Todos os cdigos dos exemplos criados no livro, bem como a IDE e outros, se
encontram no CD-ROM anexo.
Caso no encontre algum exemplo, entre em contato com o autor pelo site http://
www.integrator.com.br.
VISO GERAL DOS CAPTULOS

Embora este livro esteja completamente focado no NetBeans IDE, ainda assim
voc ter ao longo do livro, muitos cdigos para desenvolver. Todos os detalhes,
em sua maioria, se encontram na ntegra, para que sejam digitados por voc mesmo. Em todo caso, dvidas podero surgir, o que pode requerer a viso do arquivo em geral. Para este caso, o CD-ROM em anexo possui o projeto com seu nome
proposto em livro para ser analisado.
ATENO: Em caso de erro, recomendado a visualizao dos exemplos contidos no CD-ROM anexo ao livro, antes de entrar em contato com o autor.
Com um contedo completamente ilustrado, o livro possui diversas imagens, espalhadas por todos os captulos e sempre com foco em detalhes quando necessrio. Em seu longo, dicas so dadas para uma melhor produtividade do que est
sendo feito, aproveitando melhor os recursos que a IDE tem a oferecer.
PARTE 1: INTRODUO: DESENVOLVIMENTO DE APLICAES WEB COM JAVA

CAPTULO 1: OBTENDO E INSTALANDO O NETBEANS IDE 6 Como obter e instalar a NetBeans IDE na verso 6.x.
CAPTULO 2: SERVIDORES DE APLICAES E SERVLETS Viso geral, uso e aprofundamento
do NetBeans IDE com o desenvolvimento de aplicaes Web escritas em Java, utilizando servidores de aplicaes, monitoramento e distribuio para produo.
INTRODUO
XI
CAPTULO 3: DESENVOLVENDO PGINAS DINMICAS NO NETBEANS - Dedicado ao trabalho

com pginas dinmicas usando Java, envolvendo JSP, JSTL, Custom Tags, as configurao da sua aplicao e o Deployment Descriptor usando o NetBeans IDE.
CAPTULO 4: TRABALHANDO COM BANCO DE DADOS Desenvolvido para o contato inicial com o banco de dados, usando JDBC, em aplicaes Web atravs Servlets
e pginas JSP, utilizando NetBeans IDE. Os padres de desenvolvimento MVC e
DAO so apresentados, integrando o JSP e JSTL com acesso a dados atravs do
MySQL.
PARTE 2: JAVA EE5: AVANANDO NO DESENVOLVIMENTO DE APLICAES WEB

CAPTULO 5: JAVASERVER FACES Viso geral e tcnica do framework JavaServer Faces
trabalhado atravs do NetBeans IDE, com configuraes e acesso a banco de dados e Web 2.0 com Facelets.
CAPTULO 6: EJB 3 E JAVA PERSISTENCE API Apresenta o desenvolvimento de aplicaes Enterprise utilizando o NetBeans.
CAPTULO 7: O VISUAL WEB JAVASERVER FACES A primeira parte de um estudo de caso
detalhado, ensinando o uso do Visual Web JSF atravs do desenvolvimento de
uma aplicao, focando na etapa visual sem acesso a banco de dados.
CAPTULO 8: DESENVOLVENDO NO VISUAL WEB JSF COM BANCO DE DADOS Continuao
do estudo de caso usando Visual Web JSF com acesso a dados, incluindo uma
rea administrativa.
CAPTULO 9: TRABALHANDO COM WEB SERVICES NO NETBEANS IDE Desenvolve e consome Web Services usando o NetBeans IDE, incluindo a integrao com EJB 3,
acesso a dados e o uso de Visual Web JavaServer Faces.
CAPTULO 10: VISUAL WEB JSF COM JPA, SPRING E HIBERNATE Finaliza o trabalho com
Visual Web JSF integrando um CRUD com Spring 2.5 e Hibernate 3, atravs do
uso de Java Persistence API (JPA).
PARTE 3: DESENVOLVIMENTO COM LINGUAGENS DINMICAS E AJAX

CAPTULO 11: RAILS 2 COM NETBEANS IDE Cria um estudo de caso usando o NetBeans como ferramenta para desenvolver aplicaes Ruby on Rails.
XII
CAPTULO 12: JRUBY ON RAILS Recria o projeto do Captulo 11, adicionando as caractersticas individuais do JRuby, que roda sobre a Java Virtual Machine, incluindo acesso a dados via JDBC e deploy no Application Server GlassFish.
CAPTULO 13: TRABALHANDO COM AJAX NO NETBEANS IDE Utiliza o NetBeans para
trabalhar com AJAX atravs de plug-ins, integrando frameworks conhecidos como
jMaki, GWT e ICEfaces.
APNDICE A: Ruby para desenvolvedores Java Explica de forma comparativa a

linguagem Ruby com Java para um suave entendimento.
NO CD-ROM
CAPTULO EXTRA 1: TRABALHANDO
utilizando o NetBeans IDE.
COM
TOMCAT 5.5 Introduz ao uso do Tomcat 5.5
CAPTULO EXTRA 2: APLICAES WEB COM ACESSO A DADOS SEM PADRO Indicado para
iniciantes com baixa experincia em aplicaes Web Java, ensina a acessar dados
via JDBC diretamente atravs de scriptlets sem o padro DAO.
CAPTULO EXTRA 3: STRUTS - Viso geral e tcnica do framework Struts trabalhado
atravs do NetBeans IDE, com configuraes e acesso a banco de dados.
CAPTULO EXTRA 4: DESENVOLVENDO RELATRIOS COM NETBEANS IDE Utilizao do plugin iReport for NetBeans para construir relatrios visualmente na IDE.
CAPTULO EXTRA 5: Estudo de caso completo com Visual Web JSF Continua a aplicao criada no livro atravs dos captulos 7 e 8, criando todos os relacionamentos
e acesso ao banco de dados, incluindo o uso de novos componentes.
CAPTULO EXTRA 6: Estudo de caso completo com Visual Web JSF, Spring e Hibernate utilizando JPA Criao da mesma aplicao gerada atravs dos captulos 7, 8 e
Extra 5, criando todos os relacionamentos e acesso ao banco de dados, utilizando
DAO genrico, Spring framework e Hibernate com JPA, incluindo o uso de novos
componentes.
APNDICE B: O MYSQL Explica o MySQL mais detalhadamente para desenvolvedores que no o conhecem.
SUMRIO
PARTE 1 - INTRODUO: DESENVOLVIMENTO DE APLICAES WEB COM JAVA .................................. 1
Captulo 1 - Obtendo e instalando o NetBeans IDE 6 ................................................. 3

Os pacotes..................................................................................................................... 5
O pacote sem instalador e o JDK requerido ................................................................... 6
A instalao ................................................................................................................... 6
A desinstalao ............................................................................................................ 1 3
Captulo 2 - Servidores de Aplicaes e Servlets ....................................................... 1 5

Criando um projeto ..................................................................................................... 1 6
Viso geral do NetBeans IDE ........................................................................................ 2 0
Explorando seu projeto ................................................................................................ 2 1
Desenvolvendo Servlets ............................................................................................... 2 5
Como alterar o navegador no NetBeans ....................................................................... 3 4
Entendendo como funciona um Servlet........................................................................ 3 6
Servidores de Aplicaes Web ..................................................................................... 3 9
Monitorando transaes HTTP ..................................................................................... 5 1
Distribuindo sua aplicao em arquivos WAR .............................................................. 5 4
Captulo 3 - Desenvolvendo pginas dinmicas no NetBeans ................................... 5 7

Trabalhando com pginas JSP ....................................................................................... 5 7
Um pouco mais sobre o Deployment Descriptor .......................................................... 5 9
A estrutura de JavaServer Pages .................................................................................... 6 1
XIV
Diretivas ...................................................................................................................... 6 1
O controle de erros configurado atravs da IDE ........................................................... 6 3
Recebendo dados de um formulrio com JSP............................................................... 6 8
O auto-completar do editor ......................................................................................... 7 1
Rodando uma pgina ou Servlet como inicial ............................................................... 7 2
Objetos implcitos ....................................................................................................... 7 3
Criando JavaBeans ....................................................................................................... 7 5
Outros atalhos do Editor de Cdigos do NetBeans IDE ................................................. 8 2
Utilizando JSTL em suas pginas .................................................................................. 8 7
Desenvolvendo tags customizadas ............................................................................. 1 1 1
Dinamizando Tag Files ............................................................................................... 1 1 6
Captulo 4 - Trabalhando com Banco de Dados ...................................................... 1 1 9

Introduo ao JDBC ................................................................................................... 1 1 9
MySQL e o JDBC ....................................................................................................... 1 2 0
A instalao e utilizao do MySQL ........................................................................... 1 2 0
Comandos bsicos de utilizao do MySQL ............................................................... 1 2 2
Acessando o banco de dados MySQL ........................................................................ 1 2 2
O comando CREATE .................................................................................................. 1 2 3
O comando USE ....................................................................................................... 1 2 4
Criando tabelas .......................................................................................................... 1 2 4
O comando SHOW ................................................................................................... 1 2 5
Configurando usurios ............................................................................................... 1 2 5
Inserindo um registro ................................................................................................. 1 2 6
SUMRIO
XV
Baixando o driver JDBC ............................................................................................. 1 2 6

Utilizando o driver JDBC no NetBeans ....................................................................... 1 2 7
As APIs JDBC ............................................................................................................. 1 3 4
Os tipos de dados no Java e na SQL........................................................................... 1 3 7
Utilizando o Design Query ........................................................................................ 1 4 0
Utilizando padres de desenvolvimento..................................................................... 1 4 1
O que MVC?........................................................................................................... 1 4 1
O Padro DAO (Data Access Object) ......................................................................... 1 4 5
Pool de conexes....................................................................................................... 1 8 6
O aperfeioamento.................................................................................................... 1 9 3
PARTE 2 - JAVA EE5: AVANANDO NO DESENVOLVIMENTO DE APLICAES WEB............................ 1 9 5
Captulo 5 - JavaServer Faces ................................................................................... 1 9 7

Um projeto JavaServer Faces ...................................................................................... 1 9 8
Conhecendo melhor o JavaServer Faces ..................................................................... 2 1 3
As tags padres de JavaServer Faces ........................................................................... 2 1 5
Criando um exemplo utilizando banco de dados e JSF ............................................... 2 2 2
Personalizando mensagens padro do JavaServer Faces .............................................. 2 3 8
Facelets e Web 2.0 .................................................................................................... 2 4 1
Instalando um plugin com suporte a Facelets ............................................................. 2 4 2
Criando um CRUD nos padres de Facelets ............................................................... 2 4 7
XVI
Captulo 6 - EJB 3 e Java Persistence API ................................................................. 2 5 9

Criando um projeto Java EE 5 .................................................................................... 2 6 0
Seu primeiro EJB 3 ..................................................................................................... 2 6 3
Session Bean.............................................................................................................. 2 6 9
As interfaces EJB ........................................................................................................ 2 7 1
EJB 3 com acesso a dados .......................................................................................... 2 7 2
Utilizando JavaServer Faces para acessar o EJB ........................................................... 2 8 4
Captulo 7 - O Visual Web JavaServer Faces ............................................................ 2 9 1

Criando uma aplicao .............................................................................................. 2 9 3
Definindo o layout da pgina principal ...................................................................... 2 9 6
A pgina de contato ................................................................................................... 3 0 2
Criando a primeira navegao ................................................................................... 3 1 4
Captulo 8 - Desenvolvendo com Visual Web JSF usando banco de dados ............. 3 1 7
O acesso a banco de dados ....................................................................................... 3 1 7
Desenvolvendo uma rea administrativa .................................................................... 3 2 6
O acesso a rea administrativa ................................................................................... 3 4 6
Assegurando o acesso a rea administrativa ................................................................ 3 5 5
Alterando as mensagens da sua aplicao .................................................................. 3 6 2
Adicionando o sistema de pesquisa no site................................................................. 3 6 3
Adicionando Cdigo a SessionBean1 ......................................................................... 3 6 6
Captulo 9 - Trabalhando com Web Services no NetBeans IDE ............................... 3 7 1

Web Services ............................................................................................................. 3 7 1
SUMRIO
XVII
Entendendo a estrutura do documento WSDL ........................................................... 3 8 1

Consumindo o Web Service criado ............................................................................ 3 8 6
Um Web Service mais complexo ............................................................................... 3 9 0
Acessando o Web Service com Visual Web JSF........................................................... 3 9 5
Criando um Data Provider ......................................................................................... 3 9 6
Captulo 10 - Visual Web JSF com JPA, Spring e Hibernate ..................................... 4 0 1

A aplicao que ser construda ................................................................................. 4 0 1
O Hibernate .............................................................................................................. 4 0 2
Onde baixar a ltima verso ...................................................................................... 4 0 3
O Spring .................................................................................................................... 4 0 4
O plugin do Spring Framework para o NetBeans ........................................................ 4 0 5
Criando o projeto Visual Web JSF com Spring Framework .......................................... 4 0 6
Criando o DAO genrico ........................................................................................... 4 1 0
Configurando o Spring atravs de applicationContext.xml .......................................... 4 1 5
Configurando o Spring no deployment descriptor ...................................................... 4 1 7
Criando a classe que controlar o CRUD ................................................................... 4 1 8
Configurando o Spring para trabalhar com JSF ........................................................... 4 1 9
Configurando o arquivo persistence.xml .................................................................... 4 2 2
O Log4j ..................................................................................................................... 4 2 4
Alterando a classe SessionBean1 ................................................................................ 4 2 7
Configurando o componente Table na pgina ............................................................ 4 2 9
Adicionando os mtodos a Page1.java ....................................................................... 4 3 0
XVIII
PARTE 3 - DESENVOLVIMENTO COM LINGUAGENS DINMICAS E AJAX ........................................ 4 3 9
Captulo 11 - Rails 2 com NetBeans IDE ................................................................. 4 4 1

O que Ruby?........................................................................................................... 4 4 2
O que Ruby on Rails?.............................................................................................. 4 4 2
Onde baixar o Ruby .................................................................................................. 4 4 2
Configurando o Ruby no NetBeans IDE 6.0 ............................................................... 4 4 4
Desenvolvendo com Ruby on Rails ........................................................................... 4 4 4
A Camada Modelo..................................................................................................... 4 5 7
A Camada Controle ................................................................................................... 4 6 0
A Camada Apresentao ............................................................................................ 4 6 2
Adicionando relacionamentos .................................................................................... 4 6 3
Mais sobre Ruby on Rails ........................................................................................... 4 7 4
Captulo 12 - JRuby on Rails .................................................................................... 4 7 5

O que JRuby?.......................................................................................................... 4 7 5
Baixando e instalando a ltima verso do JRuby ......................................................... 4 7 6
Configurando o JRuby no NetBeans ........................................................................... 4 7 7
Instalando os Ruby Gems no NetBeans ..................................................................... 4 7 8
Criando um projeto JRuby on Rails ............................................................................ 4 8 1
Colocando sua aplicao Rails no Application Server ................................................. 4 8 4
Captulo 13 - Trabalhando com AJAX no NetBeans IDE .......................................... 4 9 1

AJAX .......................................................................................................................... 4 9 1
Utilizando a tecnologia jMaki..................................................................................... 4 9 5
SUMRIO
XIX
Criando um projeto utilizando jMaki ......................................................................... 4 9 9

Mas o que JSON?.................................................................................................... 5 0 1
Ajax com GWT .......................................................................................................... 5 1 1
Utilizando Ajax com Visual Web JSF .......................................................................... 5 2 5
Outros frameworks AJAX............................................................................................ 5 3 0
Apndice A - Ruby para desenvolvedores Java ....................................................... 5 3 1

Recursos do Ruby ...................................................................................................... 5 3 1
Desenvolvendo com Ruby no NetBeans IDE .............................................................. 5 3 2
Conhecendo o bsico sobre Ruby .............................................................................. 5 3 4
Bibliografia ............................................................................................................... 5 7 9
Captulo Extra 1 Trabalhando com Tomcat 5.5 .............................................CD-ROM
Captulo Extra 2 Aplicaes Web com acesso a dados sem padro ............CD-ROM
Captulo Extra 3 Struts .................................................................................CD-ROM
Captulo Extra 4 Desenvolvendo relatrios com NetBeans IDE ...................CD-ROM
Captulo Extra 5 Estudo de caso completo com Visual Web JSF ...................CD-ROM
Captulo Extra 6 Estudo de caso completo com Visual Web JSF, Spring e Hibernate utilizando JPA .....................................................................................................CD-ROM
Apndice B O MySQL ..................................................................................CD-ROM
PARTE 1
INTRODUO:
DESENVOLVIMENTO DE
APLICAES WEB COM JAVA
CAPTULO 1
OBTENDO E INSTALANDO O
NETBEANS IDE 6
O NetBeans uma IDE criada em Java Swing e portanto, depende da Java Virtual
Machine (JVM) instalada em sua mquina.
Alm disso, voc ver que h vrias opes da IDE, onde cada uma contm mdulos de instalao diferentes para cada necessidade do desenvolvedor.
Neste Captulo voc aprender a obter e instalar o NetBeans IDE na verso 6.x.
OBSERVAO: Apesar de abordar onde obter o NetBeans IDE, o CD-ROM anexo

contm todos os arquivos que esto sendo ilustrados para a instalao.
BAIXANDO O NETBEANS NA INTERNET

Existem dois sites que oficialmente do ao usurio a possibilidade de obter o
NetBeans na verso 6.0. Um o site oficial da prpria IDE, que se encontra no
endereo http://www.netbeans.org. O outro site o oficial do Java, da prpria
Sun Microsystems, criadora da linguagem e principal mantenedora do NetBeans.
O site neste caso http://java.sun.com.
Em ambos os casos, a obteno da IDE est correta.
FIGURA 1.1 SITE OFICIAL DO NETBEANS IDE
Assim que voc entra no site oficial do NetBeans, h um grande boto escrito
Download NetBeans IDE 6.0.
Dando um clique neste boto, voc ir at a pgina de downloads da IDE.
OBSERVAO: Voc pode notar que existe ao lado do boto Download NetBeans
IDE 6.0 um cone de uma mdia CD/DVD escrito em seu rtulo Get Free DVD.
Caso voc queira, basta pedir o DVD pelo site que eles o enviaro sem custo
algum. O tempo necessrio para receb-lo depende de sua localizao.
ATENO: No momento em que este livro est sendo escrito, ainda no existe
disponvel uma verso traduzida em nosso idioma.
OBTENDO E INSTALANDO O NETBEANS IDE 6
OS PACOTES
Ao clicar no boto Download NetBeans IDE 6.0, voc ser levado rea de download, contendo os diversos pacotes que a IDE atualmente oferece.
FIGURA 1.2 NETBEANS PACKS
Se voc for desenvolver para a Web, como o caso, selecione a opo Web &
Java EE para uma opo enxuta ou All para todas as solues.
Como pretendemos trabalhar tambm com Ruby on Rails, a opo All mais atrativa, embora voc possa instalar os pacotes separadamente aps a instalao.
O PACOTE SEM INSTALADOR E O JDK REQUERIDO

Abaixo das opes mostradas anteriormente, voc tem o link para o NetBeans
compactado sem instalador (zip file format) e o link para o JDK requerido (download the JDK here).
FIGURA 1.3 A OPO COMPACTADA SEM ASSISTENTE
Sem o assistente, voc tem uma listagem dos arquivos compactados no formato
.zip, onde o maior o All.
A INSTALAO
Este livro est baseado em um pacote independente da sua escolha, mas focado
no ambiente Web.
O servidor de aplicaes oficialmente suportado pelo NetBeans o GlassFish V2
e o container Web o Tomcat 6, ambos compatveis com a verso Java EE 5.
O JBoss possui suporte a EJB 3, tanto na verso 4 como na 5, mas que deve ser
instalado at o momento separadamente e incluso logo aps (veremos isso mais
adiante).
NO WINDOWS
A instalao do NetBeans tranqila, quando utilizamos assistente, como a maioria dos programas existentes para este sistema operacional. Para o exemplo, a instalao do pacote contendo todos os aplicativos ser usado (All). Assim que baixar
o programa (ou peg-lo no CD em anexo) d um duplo clique sobre o arquivo
que iniciar o processo de instalao.
FIGURA 1.4 INICIO DO ASSISTENTE DE INSTALAO
No boto Customize, marque ou desmarque os itens que no deseja instalar.

Como o Tomcat 6 no est selecionado por padro, caso no o tenha em sua
mquina, selecione-o. Pacotes como C/C++ e Mobility so desnecessrios para
o nosso trabalho. Instale-os apenas se voc for usar. Cada pacote a mais implicar
em maior consumo de memria e portanto uma maior lentido em seu uso em
mquinas menos poderosas.
Confirme a customizao e clique logo aps no boto Next para prosseguir
segunda parte do assistente.
FIGURA 1.5 CUSTOMIZANDO A INSTALAO
No assistente de instalao, leia a licena se no a conhecer e aceite marcando a opo I accept the terms in the license agreement. Para prosseguir, clique em Next.
FIGURA 1.6 TERMOS DE LICENA
Especifique um diretrio vazio dentro do qual ser instalado o NetBeans IDE. Esta
instalao da IDE no alterar as configuraes de outras instalaes do NetBeans,
caso voc as tenha. Isso ocorre porque a IDE cria automaticamente um novo diretrio de usurio quando aberto. Para modificar o local da instalao, no campo
Install the NetBeans IDE to digite ou clique no boto Browse e selecione.
FIGURA 1.7 DETERMINANDO O LOCAL DA INSTALAO E O JDK ENCONTRADO
Caso voc tenha mais de um JDK instalado em sua mquina, este aparecer em
uma lista, no qual voc dever escolher o compatvel com a IDE. No caso somente
poder ser as verses Java SE 5 ou 6. Clique no boto Next.
Na etapa seguinte voc define o local da instalao do GlassFish (Install GlassFish
to), o JDK e o usurio e senhas administrativas. Mais abaixo existe as portas para
rodar o GlassFish em sua mquina.
ATENO: Caso mantenha como est, observe que a senha padro adminadmin.
10
FIGURA 1.8 CONFIGURAO DO GLASSFISH V2
A senha do usurio administrativo ser guardada em um arquivo chamado .asadminpass. Este arquivo se encontra no diretrio do usurio de seu sistema operacional.
Se em sua instalao houver tambm o Tomcat, voc pode alterar o seu local de
instalao no campo Install Apache Tomcat to.
11
FIGURA 1.9 DEFININDO O LOCAL DE INSTALAO PARA O TOMCAT 6
OBSERVAO: O servidor GlassFish e o container Tomcat no tero suas telas

apresentadas caso voc tenha optado por no instal-los.
Por fim, veja os itens que sero instalados e clique no boto Install.
12
FIGURA 1.10 CONFIRMAO PARA A INSTALAO
Aguarde a instalao at o boto Finish.
NO LINUX
A verso para Linux ligeiramente diferente do Windows. O arquivo vem em
formato binrio, com assistente tambm, o que facilita sua instalao.
Para iniciar o processo de instalao, v at o diretrio onde se encontra o arquivo
do qual baixou.
D a permisso necessria para que seja possvel a execuo do arquivo binrio:
shell# chmod +x netbeans-6.0-linux.sh
Vale lembrar que a verso descrita se trata da verso mais atual no momento em
que este livro est sendo escrito.
13
Para iniciar a instalao, execute o comando como demonstrado:

shell# ./netbeans-6.0-linux.bin
FIGURA 1.11 INICIANDO A INSTALAO NO LINUX UBUNTU
As demais instrues so similares ao sistema operacional Windows.
A DESINSTALAO
DESINSTALANDO O NETBEANS NO WINDOWS XP
Para desinstalar a IDE no Windows, v ao menu Iniciar do sistema e selecione
o Painel de controle. D um duplo clique no cone Adicionar ou remover programas.
Selecione o NetBeans IDE 6.0 na lista e clique em Remover.
Surgir o desinstalador do NetBeans. Basta confirmar manter selecionados os servidores adicionados IDE e clicar no boto Uninstall.
14
DESINSTALANDO O NETBEANS NO LINUX

Para desinstalar a IDE no Linux, v ao diretrio de instalao do NetBeans, geralmente netbeans-6.0, atravs do terminal. Digite a seqncia a seguir:
shell# ./uninstall.sh
O mesmo que ocorre com o Windows ocorrer com o Linux. Confirme no boto
Uninstall para remover a IDE.
CAPTULO 2
SERVIDORES DE APLICAES
E SERVLETS
Deste captulo em diante voc ser levado a compreender a IDE com relao ao
desenvolvimento de aplicaes escritas para a Web. O seu fundamento criando
e utilizando Servlets, trabalhar com os servidores de aplicaes Web para rodar
seus cdigos desenvolvidos, monitorar sua aplicao e aprender como distribuda para um servidor de produo.
Os tpicos apresentados neste captulo sero:
Criao de um novo projeto
Viso geral do NetBeans IDE
Explorando seu projeto
Desenvolvendo Servlets
Entendendo como funciona um Servlet
Servidores de Aplicaes Web
Monitorando transaes HTTP
Distribuindo sua aplicao em arquivos WAR
16
CRIANDO UM PROJETO
Como o livro est focado em desenvolvimento Web, o seu primeiro projeto ser
feito para construir aplicaes Web. Neste caso, mais especificamente para o desenvolvimento de um Servlet.
Servlets e JSP, assim como JavaServer Faces so tecnologias desenvolvidas pela Sun
Microsystems para a construo de aplicaes Web.
Para criar seu primeiro projeto Web, v ao menu File e clique em New Project.
Alternativamente, na janela Projects, voc pode dar um clique com o boto direito do mouse e selecionar a opo New Project (Ctrl+Shift+N) no menu de
contexto.
FIGURA 2.1 SELECIONANDO A OPO NEW PROJECT
A caixa de dilogo New Project surgir. O desenvolvimento de projetos para

aplicaes Web se encontra na categoria (Categories) Web. Como a aplicao
trata-se de um desenvolvimento sem informaes anteriores, ou seja, limpo, voc
seleciona Web Application em Projects. Aps selecionar a opo em Projects
clique no boto Next.
SERVIDORES DE APLICAES E SERVLETS
17
FIGURA 2.2 SELEO DO ITEM WEB APPLICATION EM PROJECTS
Na segunda etapa do assistente, voc possui vrias opes para a construo do

seu projeto.
FIGURA 2.3 NOME E LOCALIZAO DO PROJETO
18
Em Project Name voc digita o nome do seu projeto. No caso do livro DesvComServlets.
Em Project Location o NetBeans coloca seus projetos geralmente no diretrio do
usurio do seu sistema operacional. Para mudar a localizao, clique no boto
Browse e selecione ou crie um novo diretrio para salvar seus projetos.
Perceba que o seu projeto gerar um novo diretrio, e este mostrado em Project
Folder.
FIGURA 2.4 DETALHE DO PASSO NAME AND LOCATION
Na parte inferior da caixa de dilogo voc tem como principais pontos o Servidor, que pode ser selecionado em Server. Os servidores possuem caractersticas
prprias, embora, no geral, sejam parecidos em suas administraes, desde que
sigam rigorosamente regras impostas pela Sun Microsystems. Um exemplo de servidores que trabalhem com Java EE na verso 5 o Sun Java System Application
Server, GlassFish, Geronimo e etc.
FIGURA 2.5 DETALHE DO SERVIDOR, VERSO E CAMINHO DO CONTEXTO
19
Caso voc precise trabalhar com a verso 1.4, basta selecionar em Java EE Version
a opo J2EE 1.4.
FIGURA 2.6 SELEO DO JAVA EE VERSION INFERIOR A 5
Outra forma seria clicar no boto Add e adicionar um novo servidor (ou container)
para uma verso inferior a 5.
No caso do livro, vamos utilizar o GlassFish V2 como Server para o primeiro projeto. E com a verso de Java EE 5 selecionada em Java EE Version.
Em Context Path voc possui o nome do contexto de acesso ao projeto, o que na
realidade ser a sua aplicao.
Em caso de utilizar a verso J2EE 1.4, haver a opo Set Source Level to ..., onde
voc possui o nvel dos arquivos desenvolvidos no projeto. Em alguns casos (principalmente no uso de annotations) voc deve desmarcar esta opo.
A opo Set as Main Project indica qual o projeto que ser compilado toda vez
que voc mandar rodar para exibir no browser.
A terceira etapa seria para a seleo de um framework, no qual veremos mais
adiante. Para o momento, apenas clique no boto Finish para completar as configuraes e criar o projeto.
20
VISO GERAL DO NETBEANS IDE

O NetBeans possui muitos menus, ferramentas e janelas que o auxiliam no desenvolvimento de uma aplicao Web. A seguir a Figura 2.7 que demonstra os
principais componentes que existem na IDE quando voc cria um projeto.
FIGURA 2.7 CARACTERSTICAS GERAIS DO NETBEANS IDE 6.0
BARRA DE TTULO: A barra de ttulo sempre exibe o nome do projeto.

BARRA DE MENUS: Esta a barra de menu global, que lhe permite fazer todas
as tarefas gerais. As opes disponveis em cada menu tambm mudaro dependendo do que estiver selecionado.
BARRA DE FERRAMENTAS: Esta a barra de ferramentas global da IDE que tambm lhe permite executar tarefas gerais e tarefas especficas para itens selecionados.
BARRA DE STATUS: Esta linha exibe tipicamente informaes que dependem da
tarefa voc est executando atualmente.
SOURCE EDITOR: exatamente o que o seu nome diz: um painel para editar
documentos. Aqui voc escreve seus cdigos Java.
JANELAS: Mostram grupos de objetos relacionados, propriedades, componentes e at mesmo a sada da execuo de um cdigo Java.
21
EXPLORANDO SEU PROJETO

A janela Projects ser com certeza a que voc mais vai utilizar, aps o Source
Editor.
Nesta janela voc possui diversos atalhos, com o menu de contexto, que podem
ser muito teis, passando desde a execuo de um projeto como at mesmo adicionar novas bibliotecas, criar novos arquivos, alterar seus nomes e etc.
Na construo de uma aplicao Web, voc possui diversos elementos. Estes elementos esto dispostos em forma de diretrios que podem ser expandidos clicando em seus ns. O diretrio Web Pages representa o diretrio principal (raiz) de
uma aplicao Web normal. Dentro deste n voc encontra o diretrio WEB-INF,
que contm o arquivo obrigatrio web.xml, conhecido como deployment descriptor.
Junto a este diretrio, h tambm um arquivo inicial, chamado de index.jsp, que
aberto inicialmente assim que concludo o projeto. Veremos isto mais adiante.
Expandindo o n de Configuration Files voc encontra os arquivos MANIFEST.
MF, sun-web.xml e web.xml. Evidentemente pode haver mais arquivos, pois neste diretrio se encontram todos os arquivos referentes configurao da aplicao
Web que voc est desenvolvendo.
Em Source Packages voc encontra pacotes e classes Java e Servlets, criados no
processo de desenvolvimento da sua aplicao.
Para testes unitrios voc tem Test Packages.
As bibliotecas utilizadas no seu projeto se encontram em Libraries. Em Test Libraries voc adiciona as bibliotecas necessrias para criar os testes necessrios para a
sua aplicao (por padro, j esto contidas as bibliotecas do JUnit 3.8.2 e 4.1).
22
FIGURA 2.8 DIRETRIOS EXPANDIDOS DO PROJETO NA JANELA PROJECTS
Esta estrutura utiliza o padro Java BluePrints.

No caso de uma aplicao criada para trabalhar com o Tomcat, por exemplo, o
padro Jakarta entra em ao.
A Apache Jakarta fornece diretrizes de como estruturar suas aplicaes Web para
assegurar que elas trabalhem corretamente com o servidor Tomcat. Quando voc
cria um projeto na IDE e seleciona o Tomcat, esta estrutura respeitada.
A seguir voc tem a imagem da janela Projects com a estrutura de sua aplicao
utilizando a Apache Jakarta para um projeto com o container Servlet Tomcat 6:
23
FIGURA 2.9 ESTRUTURA DO PROJETO UTILIZADO PELO TOMCAT
Clicando na janela Files, ao lado de Projects, voc v a estrutura do seu projeto

como se encontra no sistema operacional.
FIGURA 2.10 ARQUIVOS ENCONTRADOS EM UM PROJETO NO NETBEANS IDE 6.0
24
A Tabela 2.1 a seguir compara a estrutura de um projeto Web criado no NetBeans

e a estrutura real da aplicao no GlassFish ou Tomcat.
TABELA 2.1 COMPARAO DA APLICAO REAL VERSUS NO NETBEANS

CONTEDO
Pginas Web
REPRESENTAO NA JANELA
PROJECTS
REPRESENTAO NA JANELA
FILES
N Web Pages
NO ARQUIVO WAR
Diretrio web
Na raiz do arquivo
Arquivos Java no com- N Source Packages

pilados, servlets, entre
outros
Diretrio src
Diretrio classes dentro

de WEB-INF
testes unitrios
Diretrio test
N/A
N Test Packages
deployment descriptor N Configuration Files

(web.xml)
Diretrio WEB-INF em Diretrio WEB-INF

web
GlassFish(sun-web.xml)
Diretrio WEB-INF em Diretrio WEB-INF

web
N Configuration Files
Arquivo de configura- N Configuration Files

o do Tomcat e GlassFish V2 ou superior
(context configuration)
(context.xml)
Diretrio META-INF em Diretrio META-INF

web
Bibliotecas
N Libraries
Diretrio lib em web/ Diretrio WEB-INF/lib

WEB-INF
Testes
N Test Libraries
Diretrio test
N/A
Metadata do projeto in- Propriedade do projecluindo script build

to na caixa de dilogo
Project Properties, que
pode ser aberta com
um clique com o direito do mouse sobre
o projeto, selecionando
a opo Properties no
menu de contexto.
ATENO: Nem todos os itens apresentados na Tabela 2.1 aparecem em um

projeto utilizando o Application Server GlassFish.
25
DESENVOLVENDO SERVLETS
Como voc pde ver, o NetBeans criou na concluso do projeto, um arquivo JSP
(JavaServer Pages).
O que voc vai fazer agora um Servlet, que receber de um formulrio vindo
deste arquivo criado na concluso do projeto, para imprimir um determinado
valor, que no seu caso, ser seu nome.
V ao menu File e clique em New File. Alternativamente voc pode clicar com o
direito do mouse e selecionar, no menu de contexto, em New, o item em Servlet.
Caso Servlet no esteja aparecendo, clique em New File. O atalho para um novo
arquivo Ctrl + N.
Na caixa de dilogo New File selecione em Categories o item Web e em File
Types o item Servlet. Clique no boto Next para prosseguir.
FIGURA 2.11 CRIANDO UM SERVLET
26
Na segunda etapa do assistente, em New Servlet, digite MeuPrimeiroServlet em

Class Name. Toda classe Java, assim como Servlets, devem ter um pacote. Como
voc ainda no fez nenhum pacote, digite em Package o nome do seu pacote.
Caso queira seguir o livro, seria br.com.integrator. Perceba que o assistente lhe
mostra a localizao da classe Servlet que ser gerada, em Source Packages, bem
como onde ser criado, em Created File. Clique no boto Next para a terceira e
ltima etapa deste assistente.
FIGURA 2.12 DEFININDO UM NOME E UM PACOTE PARA O SERVLET
Na ltima etapa, mantenha como est. Esta etapa existe para que voc possa configurar o caminho do seu Servlet na chamada pela URL atravs de URL Pattern(s).
Se voc possui alguma experincia com aplicaes Web construdas em Java, sabe
que isto pode ser mudado, assim como o seu Name. Estas informaes devero
ser gravadas no deployment descriptor (Add information to deployment descriptor), portanto, mantenha esta opo selecionada. Clique no boto Finish para
completar o assistente.
27
FIGURA 2.13 LTIMA ETAPA PARA A CRIAO DO SERVLET
Perceba que o NetBeans criou para voc um arquivo, baseado em seu template,
com parte do desenvolvimento de um Servlet.
Vamos alter-lo para que voc o veja funcionando e ento explicarei melhor como
tudo funciona.
No Servlet pr-construdo, altere como mostrado na Listagem 2.1 a seguir, em
destaque:
LISTAGEM 2.1 CDIGO DO ARQUIVO MEUPRIMEIROSERVLET.JAVA
protected void processRequest(HttpServletRequest request,

HttpServletResponse response)
throws ServletException, IOException {
String nome = request.getParameter(nome);
response.setContentType(text/html;charset=ISO-8859-1);
28
PrintWriter out = response.getWriter( );

// /* TODO output your page here
out.println(<html>);
out.println(<head>);
out.println(<title>Meu nome +nome+</title>);
out.println(</head>);
out.println(<body>);
out.println(<h1>Meu nome + nome + </h1>);
out.println(</body>);
out.println(</html>);
// */
out.close( );
}
...
Os demais itens permanecero exatamente como esto.

No arquivo index.jsp, voc ir adicionar um formulrio HTML. Para fazer isso,
voc possui duas formas: digitando ou utilizando a janela Palette como auxiliar.
Vou ensinar pela janela Palette para simplificar sua digitao.
Primeiramente, apague todo o contedo existente por entre as tags HTML
<body> ... </body>.
Mantenha o cursor por entre estas tags. V a janela Palette e d um duplo
clique em Form, na categoria HTML Forms. Alternativamente voc pode arrastar desta janela para o Editor, por entre as tags HTML mencionadas.
29
FIGURA 2.14 O ITEM FORM SELECIONADO
Na caixa de dilogo Insert Form digite em Action o nome do seu Servlet,

que no caso MeuPrimeiroServlet. Selecione em Method o mtodo POST
de envio de dados e em Name voc pode dar um nome ao seu formulrio,
alternativamente. Confirme a caixa de dilogo clicando no boto OK.
FIGURA 2.15 A CAIXA DE DILOGO INSERT FORM COM AS CONFIGURAES PREENCHIDAS
Perceba que o NetBeans construiu o formulrio, atravs das tags HTML <form />
no seu cdigo, por entre as tags <body />.
30
Coloque seu cursor por entre as tags <form> ... </form>. Novamente na
janela Palette, na categoria HTML Forms, d um duplo clique no componente
Text Input.
FIGURA 2.16 COMPONENTE TEXT INPUT SELECIONADO
Na caixa de dilogo Insert Text Input digite nome em Name. Mantenha text
selecionado em Type e coloque 25 para a largura da sua caixa de texto, em
Width. Confirme a caixa de dilogo clicando no boto OK.
FIGURA 2.17 CAIXA DE DILOGO INSERT TEXT INPUT COM O CAMPO NOME CONFIGURADO
31
Resta agora apenas adicionar um boto de envio (submisso) do formulrio.

V janela Palette novamente, e d um duplo clique no componente Button,
ainda na categoria HTML Forms.
FIGURA 2.18 COMPONENTE BUTTON EM DESTAQUE
Na caixa de dilogo Insert Button digite Enviar em Label e mantenha selecionada a opo submit em Type. D um nome ao seu boto em Name e
confirme a caixa de dilogo no boto OK.
FIGURA 2.19 BOTO ENVIAR CONFIGURADO NA CAIXA DE DILOGO INSERT BUTTON
32
Neste ponto, o NetBeans deve ter criado todo o cdigo necessrio do formulrio
HTML para enviar seu nome ao Servlet desenvolvido.
Com o formulrio construdo e o Servlet alterado, vamos compilar e rodar a aplicao criada, de uma s vez.
Para compilar e rodar, voc tem mais do que duas formas, na qual voc pode
escolher entre:
1. Clique no menu Run e selecione Run Main Project.
FIGURA 2.20 RUN MAIN PROJECT DO MENU RUN
2. Com o boto direito do mouse sobre o projeto, na janela Projects selecione

no menu de contexto o item Run. Este modo de rodar seu projeto tambm
muito usado quando queremos um projeto que no seja o padro do compilador e executor.
FIGURA 2.21 DETALHE NA SELEO RUN DO MENU DE CONTEXTO NA JANELA PROJECTS
33
3. A terceira forma clicando sobre o boto Run Main Project, na barra de

ferramentas Build.
FIGURA 2.22 BOTO RUN MAIN PROJECT PRESSIONADO NA BARRA DE FERRAMENTAS BUILD
4. A quarta forma se encontra no atalho F6, que pode ser visto no menu Run
quando voc o abre, em Run Main Project.
Ao comear a rodar a sua aplicao, note a janela Output que surgiu logo abaixo
de sua IDE, acima da barra de status. Ela contm trs janelas. A primeira a exibio da compilao da sua aplicao Java (ferramenta Ant), a segunda o Java DB
Database Process, que exibe a inicializao do banco de dados derby, embutido
a IDE. O log do servidor de aplicaes ou Container Servlet a terceira a janela,
contendo no caso o nome GlassFish V2, juntamente com botes de controle. Veremos isto com detalhes mais adiante.
FIGURA 2.23 SADAS ENCONTRADAS NA EXECUO DE UMA APLICAO WEB
O navegador abrir. O NetBeans usa o navegador padro do seu sistema operacional para abrir a pgina principal, no caso o index.jsp primeiramente. No formulrio, digite seu nome e clique no boto Enviar. O Servlet criado no exemplo,
receber esta informao e a imprimir na tela, gerando um HTML.
34
FIGURA 2.24 FORMULRIO DE ENVIO E O RESULTADO IMPRESSO PELO SERVLET APS RECEBER OS DADOS
COMO ALTERAR O NAVEGADOR NO NETBEANS

Caso voc queira alterar o navegador do NetBeans, v ao menu Tools e clique
em Options.
Na caixa de dilogo Options, em General, voc seleciona em Web Browser o
navegador de sua preferncia para a exibio de suas pginas.
FIGURA 2.25 SELECIONANDO UM NOVO WEB BROWSER COMO PADRO
35
Caso voc queira adicionar um novo browser, que no esteja na lista, clique no
boto Edit. Na caixa de dilogo Web Browsers clique no boto Add. Digite em
Name o nome referente ao navegador que est adicionando, selecione em Process o executvel deste browser e coloque em Arguments o argumento necessrio
para que a pgina da sua aplicao seja aberta quando o mesmo for chamado.
FIGURA 2.26 ADICIONANDO OU REMOVENDO UM WEB BROWSER
Ao preencher todos os itens necessrios clique no boto OK.

Caso haja necessidade de configurar algum Proxy, em Proxy Settings voc pode
definir de trs formas:
No Proxy Sem Proxy.
Use System Proxy Settings O padro. Ele utiliza as configuraes padro
do sistema para a configurao do Proxy.
Manual Proxy Settings Neste caso, voc deve configurar manualmente o
Proxy a ser utilizado.
36
ENTENDENDO COMO FUNCIONA UM SERVLET

Agora que voc j entende como se cria um projeto e um Servlet na IDE, basta
apenas explicar como ele funciona e o que pode ser feito.
Vamos comear pela sua localizao, na IDE. Expanda o n de Source Packages, na janela Projects e voc encontrar um pacote, que no exemplo dado ser
br.com.integrator, ou o nome que voc deu, na gerao do Servlet. Expanda o
n deste pacote e voc ver o Servlet criado.
FIGURA 2.27 O SERVLET CRIADO EM SOURCE PACKAGES
Observe que o Servlet possui a extenso .java. Portanto, Servlets so classes Java,
desenvolvidas de acordo com uma estrutura bem definida e que, quando instaladas junto a um Servidor que implemente um Servidor de Aplicaes ou Servlet
Container (um servidor que permita a execuo de Servlets), podem tratar requisies recebidas de clientes.
Se voc analisar o cdigo, que foi gerado pela IDE, notar que contm dois mtodos importantes: doGet( ) e doPost( ). Ambos chamam processRequest( ), onde
voc alterou o cdigo para receber os dados vindos do formulrio.
Estes mtodos possuem a habilidade de resgatar informaes enviadas pelo usurio tanto pelo mtodo GET, como pelo mtodo POST. Na gerao do formulrio
HTML, voc criou a tag <form/> selecionando em METHOD o item POST, o
que, portanto, resgatado por este Servlet. Embora existam outros protocolos de
envio, POST e GET so os mais usados.
37
Olhando atentamente a classe Servlet criada, notar que ela estende a classe javax.servlet.http.HttpServlet, uma classe abstrata que estende a javax.servlet.
GenericServlet. 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.
Perceba ento que h dois imports de pacotes nesta classe.
A sada de informaes, para serem impressas no HTML de retorno ao usurio,
feito pelo mtodo println, de java.io. PrintWriter. H tambm a importao
desta biblioteca no Servlet criado pela IDE.
Para compilar um Servlet manualmente, voc precisaria incluir no classpath o
arquivo servlet-api.jar, que fica no diretrio lib do Tomcat, o que o NetBeans
faz para voc, atravs do arquivo Ant pr-configurado build.xml (este arquivo
s visvel atravs da janela Files). O Ant uma ferramenta que o NetBeans
usa para rodar comando relacionados ao projeto. Se voc no conhece Ant e
no possui nenhum interesse em conhecer, saiba que este pode ser ignorado em
questo quase que completamente. Ant foi desenvolvido pela Apache Software
Foundation para automatizar rotinas de desenvolvimento como compilar, testar e
empacotar sua aplicao.
Expandindo o n de Configuration Files, na janela Projects, voc encontra o
deployment descriptor, como j foi dito, chamado de web.xml. Este deployment
descriptor usado por Servlets Containers como o Tomcat e servidores de aplicao como o GlassFish. O GlassFish, utilizado no exemplo, utiliza tambm o Sun
Deployment Descriptor, chamado de sun-web.xml.
O arquivo descritor de contexto (Deployment Descriptor) o padro de uma
aplicao Web, segundo a especificao Java Servlet/Java EE, em um arquivo chamado de web.xml.
Em um Deployment Descriptor padro, voc ver as seguintes informaes nele
contidas, que detm as configuraes especificas da aplicao:
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.
38
Como ele possui muitos elementos, estes so separados por botes, pela IDE.
Note que temos inicialmente General, para informaes gerais, como o tempo
de durao de uma sesso, Servlets, onde so mapeados os servlets da sua aplicao, Pages que indica o arquivo inicial, quando em produo no Servidor e XML,
onde voc pode visualizar toda a estrutura do arquivo web.xml.
FIGURA 2.28 O DEPLOYMENT DESCRIPTOR ABERTO PELO NETBEANS
Para compreender um pouco mais sobre os Servlets, vamos mapear um. Quando
voc criou o Servlet, voc tinha como opo de digitao na construo pelo assistente o URL Pattern(s), lembra?
Pois , tambm possua um nome para o Servlet. Estes so configuraes que o
deployment descriptor precisa para saber qual Servlet utilizar, mesmo porque,
colocar o caminho do pacote mais o nome do Servlet no muito inteligente.
40
O GLASSFISH E O TOMCAT
O GlassFish um servidor de aplicaes Web open source, baseado no Sun Java
System Application Server Platform Edition, sendo 100% compatvel com as especificaes Java EE 5 robusto, de padro aberto, mantido pelo Projeto GlassFish,
parte da comunidade OpenJava EE.
Poderoso, este servidor contm itens que um Servlet Container como o Tomcat
no possui, incluindo suporte a EJB (Enterprise JavaBeans) e JMS (Java Message
Service).
O Tomcat tem suas origens no incio da tecnologia Servlet. A Sun Microsystems
criou o primeiro Servlet Container, 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.
A verso Tomcat 6.x a atual e a RI de especificaes Servlet 2.5 e JSP 2.1,
pertencentes ao Java EE 5.
TRABALHANDO COM OS SERVIDORES PELO NETBEANS

Na janela Services, expanda o n do item Servers. Veja os servidores que existem
configurados neste local.
Voc pode iniciar o GlassFish V2 ou o Tomcat, clicando com o direito do mouse
sobre ele e selecionando Start no menu de contexto.
FIGURA 2.30 INICIANDO O GLASSFISH
46
FIGURA 2.37 VISUALIZANDO OS WEB APPLICATIONS PELO ADMIN CONSOLE
Retornando ao NetBeans, com o uso do direito sobre GlassFish, no menu de

contexto, selecione Refresh para refletir a alterao no servidor.
ADMINISTRANDO APLICAES PELO TOMCAT FORA DO NETBEANS

Para acessar o administrador do Tomcat, abaixo da verso 6, Administration Tool,
clique com o direito do mouse sobre o servidor, no NetBeans, janela Services, e
selecione no menu de contexto o item View Admin Console.
ATENO: No momento em que este livro escrito, no havia aplicao Web

administrativa do Tomcat 6.0.14 liberada pela Fundao Apache. Nos extras do
livro, contido no CD-ROM anexo, voc encontra um captulo inteiro ensinando
a trabalhar com a verso Admin do Tomcat 5.5.
Outra maneira de administrar as aplicaes Web atravs do Tomcat pelo Manager. O Manager possui uma estrutura mais simples, pois apenas administra as
aplicaes para o bsico como deploy, undeploy, reload da aplicao e etc.
47
Para isso, no seu browser, seguindo a porta padro, voc digita:

http://localhost:8084/manager/html
Ao que surgir uma caixa de dilogo pedindo o usurio e a senha. Aps o preenchimento, voc entrar no manager.
FIGURA 2.38 ACESSANDO O MANAGER PELO BROWSER
O Manager dividido em duas sesses principais: Applications e Deploy. Atravs de Applications voc pode dar desde Start, Stop e Reload em sua aplicao,
como at mesmo fazer o undeploy, simplesmente com um clique. Ele tambm
exibe as Sesses em execuo na aplicao, alm de poder modificar o tempo de
sesso e expirar com o boto Expire sessions. Ou seja, se houver um navegador
visualizando uma de suas aplicaes, ele conta uma sesso aberta. Clicando em
Path voc abre a aplicao no navegador.
51
Com isso, voc tem a seguinte compatibilidade quanto aos servidores de aplicao:
Sun Java System Application Server
GlassFish V1 e V2
Tomcat 5.x e 6
JBoss 4 e 5
BEA WebLogic Server 9 e 10
IBM WebSphere Application Server V6.0 e 6.1 (NetBeans 6.1)
Sailfin V1 (NetBeans 6.1)
Segundo as recomendaes da equipe do NetBeans.org, o uso de verses do

JBoss, BEA WebLogic ou qualquer outra no seja especificada nesta lista, pode
alterar o funcionamento da IDE de forma imprevisvel, uma vez que as interfaces
externas no so controladas pela equipe do projeto.
MONITORANDO TRANSAES HTTP

O NetBeans fornece um Monitor HTTP embutido para ajud-lo a isolar problemas
com a fluncia de dados de pginas JSP e execuo de Servlets em um servidor
Web. Quando a IDE configurada com um container ou application server, ou
feito um deploy em uma aplicao web com o Monitor HTTP do NetBeans habilitado, este registrar todos os pedidos feitos neste container web. Para cada pedido
HTTP que processado pelo servidor, o Monitor HTTP registra no s o pedido,
mas tambm registros com informaes de estados mantidos no container Web.
Por usar o Monitor HTTP, voc pode analisar pedidos HTTP feitos pelo mtodo
GET e POST para uma futura analise. Voc tambm pode editar estes pedidos
armazenados e tambm pode rev-los, em um replay.
Os pedidos so armazenados at que voc encerre a IDE. Voc tambm pode
salva-los de forma que estejam disponveis em sesses posteriores da IDE.
CAPTULO 4
TRABALHANDO COM
BANCO DE DADOS
O trabalho com banco de dados utilizando o NetBeans se desenvolveu ao longo

das ltimas verses. O usurio pode criar desde suas tabelas como at mesmo
instrues SQL de forma visual. Este captulo tratar do uso de banco de dados em
aplicaes Web com Servlets e pginas JSP, utilizando o NetBeans IDE.
Ao longo deste captulo ser apresentado:
A instalao, configurao e acesso ao banco de dados MySQL;
Como utilizar o NetBeans IDE para criar e modificar tabelas e instrues SQL;
O trabalho com os padres MVC e DAO em suas aplicaes;
A utilizao de refactor do cdigo e do histrico do NetBeans;
Como criar testes usando JUnit;
A criao de pginas JSP com uso de JSTL para acessar dados via JDBC;
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.
120
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, suportado oficialmente pela mantenedora do MySQL. Usando o driver Connector/J,
todos os tipos de aplicaes 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 passos at a finalizao.
TRABALHANDO COM BANCO DE DADOS
127
UTILIZANDO O DRIVER JDBC NO NETBEANS

Na janela Services expanda o n do item Databases. Clique com o direito do
mouse sobre o item Drivers e selecione no menu de contexto o nico item: New
Driver.
FIGURA 4.1 MENU DE CONTEXTO PARA ADIO DE UM NOVO DRIVER
Na caixa de dilogo New JDBC Driver clique no boto Add e selecione no local
onde voc descompactou o arquivo mysql-connector-java-5.1.5-bin.jar.
Ao selecionar, note que os campos Driver Class e Name ficam preenchidos. Confirme a caixa de dilogo clicando no boto OK.
128
FIGURA 4.2 CONFIGURAO DO NOVO DRIVER JDBC
SE CONECTANDO AO BANCO DE DADOS

O NetBeans possibilita a conexo ao banco de dados pela IDE, tornando acessvel
sua manipulao. Na janela Services clique com o direito do mouse sobre o item
Databases e selecione no menu de contexto o item New Connection.
FIGURA 4.3 CRIANDO UMA NOVA CONEXO
Na caixa de dilogo New Database Connection, na aba Basic setting, selecione

em Name o driver do MySQL adicionado. No campo Driver aparecer classe
de conexo.
129
No campo Database URL perceba que por parte j est preenchido. Digite o
restante como mostrado a seguir:
jdbc:mysql://localhost:3306/livraria
No campo User Name use o usurio que voc adicionou ao criar o banco de
dados e em Password a senha.
Marque a opo Remember password se voc desejar manter a senha durante a
execuo do NetBeans. Confirme clicando no boto OK.
FIGURA 4.4 BANCO DE DADOS LIVRARIA CONFIGURADO
A caixa de dilogo mudar o foco para a aba Advanced, onde no final aparecer
uma mensagem - Connection established. Isso significa que a conexo foi estabelecida com sucesso. Confirme novamente no boto OK.
132
FIGURA 4.8 CRIAO DA TABELA LIVROS PELA IDE
Voc deve ter percebido que alguns tipos de dados (em Data type) no existem
como os do MySQL. Por isso, para completar a criao da tabela, voc vai colocar
os comandos a seguir, em SQL Command (menu de contexto, Execute Command):
alter table livros modify id int auto_increment;
Para confirmar a execuo, clique no boto Run SQL (Ctrl+Shift+E).
FIGURA 4.9 EXECUTANDO A INSTRUO PARA MODIFICAR A COLUNA ID
140
UTILIZANDO O DESIGN QUERY

Na sexta verso do NetBeans, o Design Query foi adicionado nativamente a IDE
graas a incorporao do Visual Web JavaServer Faces. Agora, voc pode criar
instrues SQL visuais pelo Design Query antes de adicionar em suas aplicaes.
Para acessar o Design Query, clique com o direito do mouse sobre a tabela livros.
Selecione no menu de contexto o item Design Query.
Nesta janela podemos criar instrues SQL para seleo de dados visualmente,
o que garante uma velocidade maior no desenvolvimento de queries mais complexas.
Mais adiante veremos com mais detalhes o seu uso.
FIGURA 4.12 DESIGN QUERY
141
UTILIZANDO PADRES DE DESENVOLVIMENTO

Em uma pgina JSP o correto conter apenas o mnimo possvel de scriptlets. A
essa forma de desenvolver aplicaes chamamos de Padres de Desenvolvimento
(Design Patterns). Um padro muito praticado no desenvolvimento de aplicaes
Web escritas em Java o Model 2, baseado no paradigma MVC (Model-ViewController). Quanto ao acesso a banco de dados temos um padro popularmente
usado, chamado de DAO (Data Access Object).
O QUE MVC?
MVC um conceito (paradigma) 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 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 controlam 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.
142
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.
O modelo MVC uma forma de desenvolvimento que ajuda na manuteno do
sistema, 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; restringida por representar as partes de
componentes do problema que resolvido pela aplicao. Igualmente, a camada
de Apresentao s est relacionada a exibir os dados e no com o 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.
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:
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 lgica de negcios. Os JavaBeans fornecem as representaes de dados dentro da pgina JSP.
3. Unido junto lgica de negcios da pgina, sero confeccionadas e apresentadas o HTML ao usurio.
4. Como resultado do processo, construdo o HTML final e exibido ao usurio.
143
FIGURA 4.13 - ARQUITETURA MODEL 1
O MODEL 2
O Model 1, indicada para uma aplicao pequena, que contm um limitado
nmero de usurios e possui pouca lgica de negcios, principalmente por ser
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 significantemente grande, uma arquitetura de desenvolvimento baseada no Modelo
1 far com que seja um tanto bagunado o montante de cdigos desenvolvidos.
Quando voc coloca a lgica de negcios em um modelo simples de desenvolvimento, uma repetio de cdigo acaba ocorrendo (isso muito comum no
desenvolvimento de outras linguagens de programao Web cujos conceitos de
desenvolvimento no esto fortemente agregados). Isso impossibilita uma rpida
manuteno e evidentemente, em um crescimento da aplicao, no haver uma
possvel extenso. 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 pginas JSP. Esta arquitetura fora
batizada de Model 2 (Modelo 2), que est baseada em uma adaptao da arquitetura MVC. Nessa implementao, um Servlet usado como um Controlador,
recebendo pedidos do usurio, enquanto efetuando mudanas no Modelo, e fornecendo a Apresentao ao usurio.
144
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 4.14 - ARQUITETURA MODEL 2
A seguir voc tem uma explicao do que acontece nesse modelo de desenvolvimento:
1. Um pedido feito a um Servlet atravs da URL. No pedido h uma indicao do trabalho a ser executado. Por exemplo, na URL voc pode ter algo
como: /Livraria?action=mostrarAutores, 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 camada Modelo que empreende a lgica de negcios exigida.
3. A camada Modelo instruda a fornecer uma lista de objetos de Livros pelo
Controlador. Este, por sua vez, pode acessar algum tipo de camada persistente,
como um banco de dados.
4. Para a camada Controlador proporcionada a lista de objetos de Livros para
serem exibidos na camada de Apresentao. A camada Controlador tambm
determina a apresentao apropriada para fornecer ao usurio. Usando um
145
despachante de pedidos, o Servlet pode fornecer a lista de objetos 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.
O HTML gerado no resultado desse processo fornecido em resposta ao usurio.
Embora esta explicao tcnica possa parecer complexa ou confusa a um iniciante, utilizar o Model 2 para desenvolvimento de simples compreenso e traz
muita vantagem no momento da manuteno.
O PADRO DAO (DATA ACCESS OBJECT)

O padro DAO (Data Access Object) o padro mais utilizado para acesso a dados contidos em um banco de dados.
Sempre que voc precisa acessar um banco de dados que est mantendo seu modelo de objetos, melhor empregar o padro DAO. O Padro DAO fornece uma
interface independente, no qual voc pode usar para persistir objetos de dados.
A idia 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 por todos os seus objetos.
CRIANDO UM PROJETO COM PADRES

Crie um novo projeto no NetBeans IDE. Chame-o de TrabComPadroes. Adicione
as bibliotecas: JDBC MySQL e JSTL.
147
A FBRICA DE CONEXO
Voc vai comear a construir a classe de conexo, no qual acessar o banco de
dados criado.
Com o direito do mouse sobre o projeto, v a New e clique em Java Class. Se
preferir, Ctrl + N e na caixa de dilogo New File selecione Java Classes em Categories e clique em Java Class em File Types.
Digite ConnectionFactory em Class Name e br.com.integrator.util em Package.
Clique no boto Finish para confirmar.
FIGURA 4.17 CRIAO DA CLASSE CONNECTIONFACTORY
165
Observe que ao renomear a classe, o construtor tambm foi renomeado automaticamente, o que altamente recomendvel utilizar sempre esta ferramenta para
tais situaes.
TESTANDO SEU DAO

Uma boa prtica no desenvolvimento testar classes para verificar a assertividade
e conseqentemente evitar erros futuros por falhas ocorridas em etapas preliminares. A classe DAO desenvolvida faz o que chamamos de CRUD (Create Read
Update Delete), ou seja, ela opera em quatro situaes no banco de dados.
Estas operaes devem ser testadas para saber se esto corretamente funcionais
ou se h pequenas falhas no percebidas pelo desenvolvedor.
O exemplo que ser feito simples, apenas para testar a funcionalidade do DAO,
sem a inteno de obter uma biblioteca de terceiros no suportada nativamente
pelo NetBeans.
Quando voc cria um projeto, automaticamente o NetBeans adiciona em sua
rvore um diretrio chamado de Test Libraries contendo duas bibliotecas: JUnit
3.x e JUnit 4.x. A biblioteca mais moderna possui suporte a annotations (Java SE
5 ou superior e Java EE 5).
JUnit, para quem no conhece, um framework open source, criado para fazer
testes automatizados, chamados de test cases.
Este framework foi idealizado por Erich Gamma, um dos autores dos populares
padres de projeto e Kent Beck, pai do XP (Extreme Programming). Para desenvolv-lo, usaram o conceito de testes unitrios (unit tests) em Java criando uma
ferramenta chamada JUnit, baseada em SUnit, do SmallTalk.
Para iniciar a criao da classe de testes, selecione a classe AutorDAOImp e v
at o menu Tools e clique no item Create JUnit Tests (Ctrl+Shif+U). O mesmo
pode ser feito com o direito do mouse sobre a classe, na janela Projects, e no
menu de contexto selecionar o item Tools e clicar em Create JUnit Tests.
166
FIGURA 4.30 - SELEO DA OPO CREATE JUNIT TESTS NO MENU PRINCIPAL TOOLS
Como o projeto possui duas verses do JUnit, haver uma pergunta ao criar o
teste unitrio, para escolha da verso desejada. Para o exemplo, voc vai escolher
o JUnit 4.x
FIGURA 4.31 SELECIONANDO A VERSO DO JUNIT A SER USADA
O NetBeans mantm em Test Libraries apenas a verso escolhida, removendo

a anterior. Outra caixa de dilogo surgir, Create Tests, onde no campo Class
Name haver o nome da classe e o pacote que ser criado. Se desejar, pode alter-los (o que para o caso seria desperdcio de tempo). Em Location mostrado o
local onde ser criada a classe, que na janela Projects ficar em Test Packages.
182
FIGURA 4.35 EXIBIO DOS AUTORES CADASTRADOS
A Tabela 4.4 a seguir demonstra seus atributos:
TABELA 4.4 - 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 data e hora.
Para excluir um autor, o Servlet novamente deve ser chamado, enviando dois
comandos: exc e o ID do autor que deseja remover do banco de dados. Para
executar essa ao, a query string cmd=exc&id=ID do autor transmitida para
o Servlet para que esse execute o determinado.
CADASTRANDO NOVOS AUTORES

Aproveitando o DAO, voc vai criar um formulrio (Listagem 4.15) que ir cadastrar os dados do novo autor que deseja armazenar:
186
Outro detalhe que novamente JSTL usado aqui para simplificar a formatao
da data de nascimento do autor.
FIGURA 4.36 FORMULRIO DE ATUALIZAO PREENCHIDO
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 fornecida a esta 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 POOL DE CONEXES

No NetBeans IDE, voc pode tambm configurar Pool de conexes. Para o exemplo, voc vai configurar um no GlassFish.
PARTE 2
JAVA EE5:
AVANANDO NO
DESENVOLVIMENTO DE
APLICAES
WEB
CAPTULO 5
JAVASERVER FACES
JavaServer Faces um framework desenvolvido pela Sun Microsystems, e parte

integrante da tecnologia do mundo de Java EE.
O framework JavaServer Faces foi desenhado para facilitar o desenvolvimento de
aplicaes Web atravs de componentes de interface de usurio (GUI) e conecta
estes componentes a objetos de negcios.
O JavaServer Faces utiliza o paradigma MVC para trabalhar com sua apresentao
e navegao de dados. Sua utilizao recomendada pela Sun Microsystems para
o desenvolvimento Web com Java na atualidade.
Neste captulo ser apresentado:
Os princpios de JavaServer Faces no NetBeans IDE;
Como desenvolver aplicaes JSF com acesso a banco de dados;
Como validar erros e criar navegao por entre as pginas;
A alterao das mensagens padres de JSF.
198
UM PROJETO JAVASERVER FACES

Para que voc se acostume com o desenvolvimento de pginas JSF, seu primeiro
exemplo ser pequeno e simples. Com este exemplo, voc vai aprender a base caracterstica do desenvolvimento de JavaServer Faces utilizando o NetBeans IDE.
Inicie a criao de um projeto Web. Digite o nome do seu projeto. Se quiser seguir o livro, chame-o de PrimProjJSF. Escolha seu servidor e clique no boto Next
para prosseguir.
Na terceira etapa, marque a opo JavaServer Faces em Select the frameworks
you want to use in your web application.
FIGURA 5.1 CONFIGURANDO A TERCEIRA ETAPA DO ASSISTENTE DE CRIAO
Em Servlet URL Mapping voc tem por padro a configurao /faces/*, indicando que o acesso s aplicaes escritas em JSF sero antecipadas da palavra faces/,
o que teramos, por exemplo, um link como o mostrado a seguir:
JAVASERVER FACES
199
http://localhost:8080/PrimProjJSF/faces/pagina.jsp
Para este caso, voc vai mudar para *.faces, ou seja, no acesso a suas aplicaes
escritas em JavaServer Faces, as pginas contero a extenso .faces, como o link
de exemplo mostrado a seguir:
http://localhost:8080/PrimProjJSF/pagina.faces
Ao terminar a configurao, basta clicar no boto Finish. O NetBeans IDE cria
duas pginas JSP (forwardToJSF.jsp e welcomeJSF.jsp), onde a segunda contm um
pequeno trecho de JavaServer Faces.
Se voc estiver usando o Tomcat, expandindo o n de Libraries voc ver que o
NetBeans IDE colocou todas as bibliotecas necessrias para o desenvolvimento de
JSF. No caso do GlassFish, tais bibliotecas j esto embutidas no servidor, o que
no ser necessrio esta adio.
Em uma aplicao que utilize o framework JavaServer Faces na verso 1.2, h a
necessidade de oito arquivos do tipo JAR (bibliotecas) para que sejam acessados
pelo servidor ou pela aplicao Web:
Quatro JARs Commons:
1. commons-beanutils.jar
2. commons-collections.jar
3. commons-digester.jar
4. commons-logging.jar,
Dois JARs JSF:
1. jsf-api.jar
2. jsf-impl.jar
Dois JARs JSTL:
1. jstl.jar
2. standard.jar
200
Em uma um ambiente de produo, estas bibliotecas devem estar disponveis em

sua aplicao no diretrio lib, encontrado em WEB-INF, caso o servidor no as
disponibilize nativamente.
OBSERVAO: O JavaServer Faces atualmente est na verso 1.2, suportado apenas pelos servidores Java EE 5. Se o usurio tiver disponvel um Servlet Container como o Tomcat verso 5.5, que implementa Java EE 1.4 (J2EE 1.4), ser
necessria a configurao do JavaServer Faces n a verso 1.1 (anterior a atual).
TRABALHANDO COM JAVASERVER FACES

Assim que configurado, voc apenas precisa criar um exemplo para comear a
entender como funciona o JavaServer Faces.
O primeiro exemplo ter apenas um campo para o envio de nomes. Este exemplo
contar com uma validao, para o caso do usurio entrar com um valor invlido,
no alfabtico, retornando um erro.
Caso retorne o erro, alm de manter preenchido o campo digitado, tambm mostrar uma mensagem, solicitando a alterao.
CRIANDO O JAVABEAN
O JavaBean mostrado a seguir ser o responsvel pela comunicao entre a pgina
inicial, que o usurio digitar o nome, em um formulrio, e a pgina que resultar
na mensagem de boas vindas, caso esta seja submetida com sucesso.
No NetBeans IDE, crie uma nova classe e chame-a de NomeBean. Coloque no
pacote br.com.integrator e clique no boto Finish para confirmar.
JAVASERVER FACES
213
<body>
<f:view>
Ol <h:outputText value=#{NomeBean.nome}/><br />
</f:view>
</body>
</html>
A sada do nome, como resultado positivo, vindo do Bean, feito pela tag <h:
outputText />.
A pgina forwardToJSF.jsp poder ser alterada a seu gosto, embora ela esteja
pronta com um redirecionamento para welcomeJSF.jsp. Rode a aplicao e tente
enviar um texto contendo um caractere numrico. Em seguida, corrija e envie os
dados corretamente, conforme as regras estabelecidas no Bean.
FIGURA 5.10 ERRO APRESENTADO PELO ENVIO INCORRETO DE DADOS
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 parte 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.
222
CRIANDO UM EXEMPLO UTILIZANDO BANCO DE DADOS E JSF

A idia neste exemplo demonstrar as principais caractersticas encontradas em
uma pgina JavaServer Faces acessando um banco de dados. Este exemplo acessar o banco de dados MySQL, executando o famoso CRUD (Create, Read, Update
and Delete).
Alm disso, o cdigo de acesso ao banco de dados no ser necessrio refazer,
uma vez que ele ser o DAO criado no Captulo 4 deste livro.
Crie um novo projeto web. Se desejar, chame-o de UtilJSFComDAO. No se esquea de selecionar o framework JavaServer Faces na terceira etapa do assistente.
Quanto ao Servlet URL Mapping, voc pode alterar ou manter como est. No
caso do livro, alterei para *.jsf.
Adicione a biblioteca JDBC do MySQL ao projeto. Do projeto que utiliza o padro
DAO, feito no captulo anterior, copie as classes e seus respectivos pacotes.
O BEAN DE COMUNICAO COM AS PGINAS JSF

Para a comunicao com as pginas JavaServer Faces que sero construdas, um
bean ser construdo, um controlador com o intuito de se comunicar com as classes j existentes.
Para desenvolver este controlador, crie uma classe chamada de AutorController
em um pacote chamado de br.com.integrator.controller. Altere esta classe como
mostrado na Listagem 5.7 a seguir.
LISTAGEM 5.7 ALTERAO EM AUTORCONTROLLER.JAVA

...
public class AutoresController {
private Autor autor;
private DataModel model;
JAVASERVER FACES
231
value=Cadastrar novo Autor/>

</h:form>
</f:view>
</body>
...
O datagrid desenvolvido utiliza a tag JSF <h:dataTable/>, que recebe todos os

dados existentes na tabela autores do banco de dados atravs do mtodo getTodos( ), da classe AutorController, no atributo value. Com a tag <h:commandLink/> voc pode chamar os mtodos editar( ) ou excluir( ).
A tag JSF <f:convertDateTime/>, adicionada a tag JSF <h:outputText/> responsvel por renderizar corretamente a formatao da data, trazida do banco de
dados.
O ltimo link criado pela tag <h:commandLink/> est fora do dataTable, por no
interagir diretamente sobre a mesma, chamando o mtodo novoAutor( ) para
criar um novo cadastro de Autores.
O resultado desta pgina ser como mostrado na Figura 5.13 a seguir:
FIGURA 5.13 JAVASERVER FACES DATATABLE RENDERIZADO COM OS DADOS
JAVASERVER FACES
235
O resultado a pgina com o formulrio similar ao mostrado na Figura 5.14 a

seguir:
FIGURA 5.14 FORMULRIO DE CADASTRO E ATUALIZAO DE DADOS
ATUALIZANDO UM AUTOR CADASTRADO

Na pgina onde contm todos os autores cadastrados existe na primeira coluna
o ID do autor com um link. Este link, gerado pela tag JSF <h:commandLink/>
contm a chamada ao mtodo editar( ) da classe AutorController. Este mtodo,
na sua classe de origem, chama outro mtodo, o getAutorFromEditOrDelete( ),
responsvel pela captura da linha em questo no DataModel. Essa linha pega
pelo mtodo getRowData( ), explicado anteriormente.
Assim que pego a linha em questo, escolhida na hora do clique sobre o link, o
mtodo editar( ) se responsabiliza de preencher o JavaBean Autor com os valores
captados e envia a String editar para que a navegao entre as pginas ocorram.
CONFIGURANDO A NAVEGAO
A maior dificuldade neste exemplo ser na criao da navegao do aplicativo.
No que esta complicao seja por causa do que foi feito, mas sim por poder
causar confuso, na construo da navegabilidade das pginas. No arquivo faces-config.xml o resultado final da navegao necessria da aplicao ser como
mostrada a Figura 5.15 a seguir.
236
FIGURA 5.15 NAVEGAO FINAL CONFIGURADA EM FACES-CONFIG.XML
A seguir voc tem a Listagem 5.12 de como dever ficar sua navegao no formato XML.
LISTAGEM 5.12 RESULTADO FINAL DA NAVEGAO EM FACES-CONFIG.XML

...

<navigation-rule>
<from-view-id>/mostrarAutores.jsp</from-view-id>
<navigation-case>
<from-outcome>novo</from-outcome>
<to-view-id>/formAutor.jsp</to-view-id>
</navigation-case>
<navigation-case>
<from-outcome>editar</from-outcome>
<to-view-id>/formAutor.jsp</to-view-id>
</navigation-case>
JAVASERVER FACES
253
Com adio de CSS, voc pode ter uma pgina similar ao da Figura 5.24 a seguir:
FIGURA 5.24 FORMULRIO UTILIZANDO FACELETS COM FORMATAO CSS
EXIBINDO OS AUTORES COM FACELETS

Crie uma nova pgina Facelets, em Facelets Template Client. Chame-a de mostrarAutores.xhtml e selecione em Template, clicando no boto Browse, o arquivo template.xhml. Marque <ui:composition> em Generated Root Tag e clique
no boto Finish.
Adicione em <ui:composition/> as chamadas as bibliotecas JavaServer Faces. Altere os demais itens como mostrado na Listagem 5.19 a seguir:
LISTAGEM 5.19 ALTERAES NO ARQUIVO MOSTRARAUTORES.XHTML
<ui:define name=titulo>
Autores Cadastrados
</ui:define>
<ui:define name=conteudo>
<div id=autores>
<h:dataTable value=#{autorC.todos}
JAVASERVER FACES
</f:facet>
<h:outputText
value=#{item.nascimento}>
<f:convertDateTime pattern=dd/MM/yyyy />
</h:outputText>
</h:column>
<h:column>
<f:facet name=header>
<h:outputText value=Excluir Autor/>
</f:facet>
<h:commandLink
action=#{autorC.excluir}
value=Excluir/>
</h:column>
</h:dataTable>
</div>
</ui:define>
O resultado poder ser algo similar a Figura 5.25 a seguir:
FIGURA 5.25 PGINA MOSTRARAUTORES.XHTML FORMATADA COM CSS
255
CAPTULO 6
EJB 3 E JAVA PERSISTENCE API
Enterprise JavaBeans, ou somente EJB, uma das peas-chaves da plataforma Java

EE, com uma arquitetura de componentes para aplicaes de negcios distribudos, que roda em um servidor de aplicaes. Definido pela Sun Microsystems,
as aplicaes escritas usando a arquitetura EJB so escalonveis, portteis, transacionais e seguras. Alm disso, garantem alta disponibilidade e neutralidade do
tipo de cliente.
Com a especificao do EJB3, na introduo da JPA (Java Persistence API), ficou
muito popular o uso de JPQL, Java Persistence Query Language, onde o mapeamento de objeto/relacional foi padronizado na plataforma Java.
Neste Captulo ser apresentado as facilidades do NetBeans IDE no desenvolvimento com EJB 3, utilizando seus assistentes atravs de exemplos.
Os seguintes tpicos sero apresentados:
Desenvolvimento de aplicaes Enterprise;
Gerando EJB 3;
Como funciona a API de persistncia do Java EE 5 (JPA);
O significado das anotaes;
A linguagem JPQL;
Acessando EJB atravs de pginas JavaServer Faces.
260
CRIANDO UM PROJETO JAVA EE 5

O desenvolvimento de um projeto de Enterprise Application roda em torno do
servidor de aplicaes GlassFish. Embora o JBoss, no momento em que escrevo
este livro, possua suporte oficialmente ao EJB 3, o GlassFish o mais indicado para
uso com a IDE. Inicie criando um novo projeto no NetBeans. Na caixa de dilogo
New Project, v em Enterprise, em Categories e selecione Enterprise Application, em Projects. Clique em Next para prosseguir.
FIGURA 6.1 INICIANDO UM PROJETO ENTERPRISE APPLICATION
Na segunda etapa, chame o projeto de EALivraria. O servidor ser o GlassFish

(por implementar o Java EE 5). Observe que esto selecionadas duas opes: Create EJB Module e Create Web Application Module.
Clique no boto Finish para terminar.
261
FIGURA 6.2 DEFINIO DO NOME E SERVIDOR DO PROJETO
O resultado ao final do assistente a criao de uma estrutura de trs projetos:

EALivraria-ejb, que gerar o EJB-JAR; o EALivraria-war, que gera o WAR e o EALivraria que gera o EAR.
FIGURA 6.3 RESULTADO FINAL DO PROJETO GERADO PELO NETBEANS
266
ACESSANDO SEU EJB

Clique com o direito do mouse sobre EALivraria-war e no menu de contexto selecione Servlet, em New. Chame este Servlet de AcessaEJB e coloque um pacote
(br.com.integrator.web).
Aps a criao do Servlet, clique com o direito do mouse dentro no Editor, e
selecione no menu de contexto o item Call Enterprise Bean, em Enterprise Resources.
FIGURA 6.7 CHAMANDO UM ENTERPRISE BEAN PELO MENU DE CONTEXTO
Na caixa de dilogo Call Enterprise Bean, selecione seu EJB. Confirme a caixa de
dilogo.
FIGURA 6.8 INVOCANDO SEU EJB
280
CRIANDO A SESSION BEAN

O segundo passo a proceder na construo do EJB com acesso a dados ser criar
uma Session Faade para se comunicar com a Entity Bean desenvolvida.
Crie um novo arquivo e selecione a categoria Persistence e o tipo Session Beans
For Entity Classes. Clique no boto Next para prosseguir.
FIGURA 6.15 SELEO DE SESSION BEANS FOR ENTITY CLASSES
No segundo passo, selecione a entidade Autor, clicando no boto Add. Clique

no boto Next.
283
A JAVA PERSISTENCE QL
A Java Persistence API (JPA) suporta duas linguagens de consultas (queries) para
recuperar entidades e outros dados persistentes do banco de dados. A linguagem
primria a Java Persistence Query Language (JPQL). Esta uma linguagem
de consultas independente de banco de dados e opera no modelo de entidades
lgicas, ao contrrio do modelo de dados fsico. As consultas tambm podem ser
expressas em SQL. No caso dos cdigos gerados pelos assistentes do NetBeans, a
query criada est na linguagem JPQL.
Observando atentamente a query gerada, no mtodo findAll() do CRUD, voc
ver:
select object(o) from Autor as o
Perceba que similar ao SQL que conhecemos. A JPQL usa uma sintaxe similar
SQL, onde possvel dar ao desenvolvedor experiente com instrues SQL a
vantagem de escrever as queries. A diferena fundamental entre SQL e JPQL est
na seleo de uma tabela, onde a entidade do modelo da aplicao especificada
ao invs da tabela propriamente dita.
OBSERVAO: Na utilizao de um container Servlet, como o Tomcat, a criao

de instncia do gerenciador da persistncia feita pela classe abstrata EntityManagerFactory. Essa classe criada pela anotao @PersistenceUnit, que l
as configuraes existentes no arquivo de configurao persistence.xml.
@PersistenceUnit(unitName = livraria)
private EntityManagerFactory emf;
evidente que algumas das vantagens existentes em um EJB 3 sero perdidas,
mas em um contexto geral, utilizar EJB 3 Persistence (JPA) similar.
284
UTILIZANDO JAVASERVER FACES PARA ACESSAR O EJB

Para utilizar o JavaServer Faces para acessar o EJB criado com acesso a banco de
dados, o projeto precisa ter as configuraes de JavaServer Faces.
Clique com o direito do mouse sobre o projeto EALivraria-war e selecione no
menu de contexto o item Properties. Na caixa de dilogo Project Properties,
selecione Frameworks em Categories. Em Used Frameworks, clique no boto
Add. Selecione JavaServer Faces e confirme tudo.
FIGURA 6.18 ADIO DO FRAMEWORK JAVASERVER FACES
Abra o projeto UtilJSFComDAO, criado no Captulo 5, e copie todas as pginas

JSP para EALivraria-war. Copie tambm o arquivo faces-config.xml e o pacote
br.com.integrator.controller com a classe AutorController.
289
RODANDO O EJB 3 PERSISTENCE EM UM CONTAINER J2EE 1.4

Para fazer isso com o NetBeans IDE, crie um projeto normalmente. Escolha as
opes padro para gerar um projeto Web, incluindo seu container J2EE 1.4.
Na segunda etapa do assistente, voc deve desmarcar a opo Set Source Level to
1.4. Os demais itens sero similares ao j feito at o momento na criao de um
projeto utilizando JavaServer Faces.
O arquivo persistence.xml ligeiramente diferente, pois no possui uma integrao completa, como ocorre com GlassFish.
Um container servlet como o Tomcat 5.5, por exemplo, tambm no implementa
a verso Java EE 5 e, portanto, precisa da biblioteca do TopLink Essentials (toplinkessentials.jar e toplink-essentials-agent.jar).
ATENO: Caso precise saber como usar JNDI no Tomcat 5.5 com o arquivo persistence.xml, no CD-ROM, pegue o captulo extra que trata do assunto sobre
esta verso do container Servlet.
CAPTULO 7
O VISUAL WEB JAVASERVER
FACES
O Visual Web JavaServer Faces um editor visual, no estilo WYSIWYG (What You
See Is What You Get), baseado no Java Studio Creator IDE, da Sun Microsystems,
criado para desenvolver pginas JavaServer Faces, como j diz seu nome. Isso significa que seu desenvolvimento baseado em componentes arrastveis que, com
pouco cdigo, o desenvolvedor pode criar pginas totalmente funcionais. Este
captulo foi escrito em forma de estudo de caso, desenvolvendo uma aplicao JavaServer Faces envolvendo o uso de diversos componentes e suas configuraes,
focando na etapa visual sem acesso a banco de dados.
Ao longo deste captulo ser apresentado:
Os componentes principais e suas configuraes;
A comunicao entre componentes;
A gerao de navegao por entre pginas atravs da ligao de componentes;
Como alterar ou mesmo criar novos estilos CSS para o aplicativo;
Envio de e-mail com componente;
Formulrios virtuais;
UM PROJETO COM VISUAL WEB JAVASERVER FACES

Inicie a criao de um novo projeto pelo menu de contexto ou tecle Ctrl + Shift
+ N. Na caixa de dilogo New Project, v em Web, nas categorias, e selecione
Web Application, em Projects. Clique em Next para prosseguir.
292
Na segunda etapa, defina um nome para o seu projeto, em Project Name. Caso
queira fazer com um nome idntico ao usado no livro, coloque DesComVisualWebApplication. Selecione o GlassFish como servidor e clique no boto Next
para prosseguir.
Na terceira etapa, em Frameworks, selecione Visual Web JavaServer Faces. Altere o pacote da aplicao, em Default Java Package para o exemplo fora
utilizado br.com.integrator. Altere para *.faces no campo Servlet URL Mapping.
Clique no boto Finish para completar o assistente.
FIGURA 7.1 SELEO E CONFIGURAO DO VISUAL WEB JAVASERVER FACES
VISO GERAL DO VISUAL WEB JAVASERVER FACES

Ao finalizar a criao do projeto, o NetBeans IDE abrir as janelas necessrias para
o trabalho com a ferramenta Visual Web JavaServer Faces.
O VISUAL WEB JAVASERVER FACES
295
FIGURA 7.4 EXEMPLO DA PGINA INICIAL
ADICIONANDO UM TTULO E COR DE FUNDO A PGINA

Com um clique no editor visual (Design) da pgina, voc pode alterar suas propriedades. Na janela Properties, altere a cor de fundo (Background) para as cores
RGB 232,231,207.
O ttulo adicionado a pgina pela propriedade Title. Digite Aplicaes com
Visual Web JSF.
FIGURA 7.5 PROPRIEDADES DA PGINA
312
Na caixa de dilogo Configure Virtual Forms, observe que todos os componentes

selecionados que pertencero ao seu formulrio virtual estaro listados logo abaixo do ttulo. Clique no boto New. Aparecer uma linha contendo uma cor, um
nome e mais dois itens. Em Name altere para enviarForm. Nos itens Participate e
Submit altere para Yes, pois os mesmos participaro da submisso do formulrio.
Confirme clicando no boto Apply. Clique no boto OK para fechar a caixa de
dilogo.
FIGURA 7.20 VIRTUAL FORM DOS COMPONENTES QUE ENVOLVEM A SUBMISSO DO FORMULRIO
Selecione o boto Limpar e crie um formulrio virtual tambm para ele. Chame
de limparForm. Em Submit altere para Yes e confirme.
FIGURA 7.21 FORMULRIOS VIRTUAIS SENDO EXIBIDOS ATRAVS DE SHOW VIRTUAL FORMS
CAPTULO 8
DESENVOLVENDO COM VISUAL
WEB JSF USANDO BANCO
DE DADOS
Integrar um banco de dados com uma pgina desenvolvida usando Visual Web
JavaServer Faces a tarefa mais comum para o desenvolvimento de uma aplicao Web.
Este captulo continua o estudo de caso iniciado no captulo anterior, adicionando
a interatividade com banco de dados.
Alm de completar o desenvolvimento da aplicao, ser mostrado:
Como criar formulrios conectados a banco de dados gerando CRUDs;
O upload de arquivos integrado a um formulrio;
A criao de consultas SQL complexas pelo editor;
A configurao para paginao de dados;
A adio de pesquisa ao sistema;
A gerao de segurana atravs de sesso para navegar na rea administrativa.
O ACESSO A BANCO DE DADOS

O banco de dados utilizado ser o livraria, o mesmo usado ao longo do livro. O
princpio para acesso a dados usando Visual Web JSF muito similar aos demais j
utilizados, uma vez que voc deve ter uma conexo criada na IDE para integrao
direta com os componentes.
DESENVOLVENDO COM VISUAL WEB JSF USANDO BANCO DE DADOS
319
FIGURA 8.1 VINCULANDO A TABELA AO COMPONENTE TABLE
COMPREENDENDO COMO OS DADOS SO ACESSADOS

Observe na janela Navigator que agora h um componente chamado livrosDataProvider e em SessionBean1, livrosRowSet.
FIGURA 8.2 NOVOS COMPONENTES NA PGINA LIVROS
Todos os componentes da seo Data Provider, encontrados na janela Palette,

implementam a interface bsica DataProvider, que fornece um caminho consistente para acesso a dados em um objeto FieldKeys usando campos chaves que
correspondem aos seus nomes de propriedades. Com a interface TableDataProvider, podemos usar o conceito de acesso baseado em cursor (usando a linha em
curso) e acesso aleatrio (especificado por voc atravs de FieldKey ou RowKey).
No caso, livrosDataProvider um CachedRowSetDataProvider, que implementa
ambas as interfaces.
DESENVOLVENDO COM VISUAL WEB JSF USANDO BANCO DE DADOS
345
FIGURA 8.16 RESULTADO FINAL DA PGINA LIVRO.JSP
CONFIGURANDO O TAMANHO DO ARQUIVO PARA UPLOAD

Quando adicionado a uma pgina o componente File Upload, automaticamente se tem as configuraes de seu filtro em web.xml. O filtro, no caso, utiliza a
classe com.sun.webui.jsf.util.UploadFilter. Em sua configurao, temos o parmetro maxSize que determina o tamanho mximo permitido do arquivo que ser
feito upload. A biblioteca usada para upload de arquivos a commons-fileupload-1.0.jar, que pode ser encontrada em Projects, em Libraries.
CRIANDO UM CADASTRO DE AUTORES

Crie uma pgina chamada Autor e execute os passos relacionados para a gerao
de um sistema de cadastro de autores. Como diferena, no haver um upload de
imagens (a menos que queira adicionar uma foto, o que implica na alterao da
tabela como ocorreu com livros).
364
Com o direito do mouse sobre o componente Table da sua pgina, selecione Table Layout no menu de contexto e configure como a tabela da pgina Livros.jsp.
Na guia Options digite em Title o texto Resultados da pesquisa realizada e em
Empty Data Message digite No h livros encontrados na pesquisa. Confirme
as alteraes clicando em Apply.
FIGURA 8.35 APARNCIA FINAL DA PGINA DE PESQUISAS
Na janela Outline expanda SessionBean1 e d um duplo clique no componente

livrosPesqRowSet.
Clique com o direito do mouse sobre a coluna titulo e selecione no menu de
contexto o nico item Add Query Criteria.
CAPTULO 9
TRABALHANDO COM WEB
SERVICES NO NETBEANS IDE
Desde que a palavra Web Service foi pronunciada pela primeira vez ao mundo,
todas as linguagens de programao voltadas para a construo de aplicaes
Web comearam a correr em busca de trabalhar com esta forma de servio.
Alguns padres foram estabelecidos e isto facilitou o desenvolvimento de rotinas
aplicveis a IDEs, como o NetBeans.
Neste Captulo ser criado e consumido Web Services atravs do NetBeans IDE,
onde ser visto:
Como criar e consumir um Web Services simples;
Como alter-lo de forma eficiente e visual;
A integrao com EJB 3 e acesso a banco de dados;
Como consumir com Visual Web JavaServer Faces.
WEB SERVICES
Para que voc entenda um Web Service, vamos ilustrar uma situao: imagine
que voc esteja criando um site de comrcio eletrnico e que deseja implementar
um programa de afiliados. Este afiliado como recompensa receber uma pequena porcentagem da venda ocorrida atravs de seu vnculo em um produto ou
servio. Muitos sites de comrcio eletrnicos fazem isso, criando uma forma de
vincular seus produtos e servios a outros sites.
TRABALHANDO COM WEB SERVICES NO NETBEANS IDE
375
FIGURA 9.1 CRIANDO UM NOVO WEB SERVICE
Na segunda etapa do assistente, digite MeuPrimeiroWS em Web Service Name.

Em Package coloque o nome do seu pacote (no caso do livro: br.com.integrator).
Clique no boto Finish para terminar.
FIGURA 9.2 DETERMINANDO O NOME E PACOTE DO WEB SERVICE
376
Observe que uma classe chamada MeuPrimeiroWS foi criada. Na janela Projects, um diretrio novo, chamado de Web Services surgiu, abrindo tambm um
editor visual. Clique no boto Add Operation.
FIGURA 9.3 EDIO DO WEB SERVICE VISUAL DO NETBEANS IDE
Na caixa de dilogo Add Operation, digite no campo Name o nome do mtodo

a ser criado, o que no caso ser seuNome. Em Return Type determinado o tipo
do mtodo, onde no exemplo ser java.lang.String. Clique no boto Add, logo
abaixo, na guia Parameters. Ao surgir uma linha, defina o nome, em Name, da
varivel parmetro ao qual o mtodo receber. No caso, fora colocado nome. Em
Type mantenha java.lang.String. Clique no boto OK para confirmar esta caixa
de dilogo.
390
Do cdigo gerado automaticamente pela IDE, fora acrescentado uma requisio

de um campo, para o uso de um formulrio logo abaixo e uma condio que evita
a chamada do servio Web antes de submetido um valor. Ao submeter o nome, o
Web Service o receber e retornar com a string devida.
O resultado similar ao visto na Figura 9.14 mostrada a seguir, aps envio:
FIGURA 9.14 CONSUMINDO O WEB SERVICE CRIADO POR UMA PGINA JSP
UM WEB SERVICE MAIS COMPLEXO

Criar e consumir um Web Service usando o NetBeans simples, uma vez que ele
se prope a gerar o cdigo bruto de seu desenvolvimento.
O exemplo anterior tratou de trabalhar com apenas uma informao retornada.
Neste exemplo agora, voc far um acesso a um banco de dados e uma pesquisa,
onde o retorno da pesquisa ser feita pelo Web Service, ao qual ser consumido
por sua aplicao Web.
CRIANDO O PROJETO ENTERPRISE APPLICATION E O ENTITY BEAN

Crie um projeto Enterprise Application e o chame de WSComBancoDados. Clique com o direito do mouse sobre o EJB (WSComBancoDados-ejb), v em New
e clique no item Entity Classes from Database. Em Database Tables, escolha em
Data Source o JNDI criado do banco de dados livraria. Selecione a tabela livros,
em Available Tables, clicando em seguida no boto Add. Clique no boto Next
para prosseguir.
TRABALHANDO COM WEB SERVICES NO NETBEANS IDE
399
FIGURA 9.22 UTILIZANDO O DATA PROVIDER CRIADO
Ser bem provvel que o Visual Web JavaServer Faces preencha no Design os
dados oriundos do Web Service, como mostra a Figura 9.23.
400
FIGURA 9.23 TABLE PREENCHIDO COM DADOS ORIUNDOS DO WEB SERVICE
ATENO: No esquea de ter o servidor rodando para que o Web Service se

mantenha funcional.
CAPTULO 10
VISUAL WEB JSF COM JPA,
SPRING E HIBERNATE
Usar a Java Persistence API (JPA) com Visual Web JSF, no NetBeans IDE, um caminho alternativo ao acesso padro usando JDBC. O Visual Web JSF possui, alm
de uma ferramenta visual para desenvolvimento de pginas JSF poderosa, uma
grande flexibilidade, ao qual o desenvolvedor pode adicionar outros frameworks,
como o Spring e o Hibernate para trabalhar em conjunto.
Neste captulo ser apresentado como criar um CRUD usando Visual Web JavaServer Faces, atravs do uso da JPA, com Hibernate e Spring 2.5.
Ao longo do captulo o leitor aprender:
A instalar e configurar o plugin do Spring Framework;
A criar um DAO genrico;
A configurar o arquivo de persistncia para trabalhar com Hibernate;
A configurar o Spring para trabalhar com JPA e com o Visual Web JSF;
A APLICAO QUE SER CONSTRUDA

Para o exemplo proposto, ser feita uma aplicao contendo uma pgina somente, seguindo a aparncia similar utilizada no cadastro de autores do Captulo 8,
na rea administrativa. A Figura 10.1 exibe a aparncia proposta e seus respectivos componentes.
402
FIGURA 10.1 EXEMPLO DA APARNCIA DA PGINA
O HIBERNATE
Hibernate um projeto audacioso que procura ter uma completa soluo para
o problema de gerenciamento de dados persistentes em Java. O Hibernate um
framework que se relaciona com o banco de dados, onde este relacionamento
conhecido como mapeamento objeto/relacional (ORM) para Java, deixando o
desenvolvedor livre para se concentrar em problemas da lgica do negcio. Sua
simplicidade em configurao, d ao desenvolvedor algumas regras para que sejam seguidas como padres de desenvolvimento ao escrever sua lgica de negcios e suas classes persistentes. De resto, o Hibernate se integra suavemente ao
seu sistema se comunicando com o banco de dados como se fosse diretamente
feito por sua aplicao.
VISUAL WEB JSF COM JPA, SPRING E HIBERNATE
437
FIGURA 10.15 EXIBIO DO PROJETO EM EXECUO NO NAVEGADOR
ATENO: No Captulo Extra 6, encontrado no CD-ROM anexo ao livro, h um

projeto completo, como estudo de caso, usando o Spring Framework e Hibernate com JPA, o mesmo criado ao longo dos Captulos 7, 8 e Extra 5, mas com
as tcnicas para utilizar o poder destes frameworks em seus componentes.
PARTE 3
DESENVOLVIMENTO
COM LINGUAGENS
DINMICAS E
AJAX
CAPTULO 11
RAILS 2 COM NETBEANS IDE
O NetBeans IDE vem se firmando cada vez mais como uma plataforma de desenvolvimento, possibilitando o uso no somente da linguagem Java e sua gama
de frameworks, como tambm com outras linguagens e seus respectivos frameworks.
Uma das linguagens que foram incorporadas a IDE na verso 6.0 o Ruby, que
tambm possui um popular framework, chamado de Rails.
Para desenvolvimento com Ruby on Rails, o NetBeans tem se tornado uma das
mais indicadas ferramentas do mercado.
Neste captulo, o leitor ser introduzido no trabalho com Ruby on Rails na verso
2.0.2, usando o NetBeans IDE, ao qual ser apresentado:
O que Ruby on Rails e o que este framework muda no desenvolvimento
de aplicaes;
Como criar um projeto e configurar o Ruby e Rails;
A compreenso da estrutura do framework Rails;
O ActiveRecord e o que este facilita no trabalho com banco de dados;
A utilizar o Scaffold;
A trabalhar com relacionamentos;
A conhecer o console Rails atravs do NetBeans IDE;
444
VISUALIZANDO A VERSO DO RUBY NO TERMINAL

Aps a instalao, abra o terminal ou prompt de comando e digite a seqncia a
seguir, sem espao entre os hfens:
ruby - -version
CONFIGURANDO O RUBY NO NETBEANS IDE 6.0

Como j foi dito anteriormente, no NetBeans IDE 6.0, j existe embebido em seu
pacote de instalao o JRuby, que compatvel com o Ruby compilado em C.
Para utilizar o Ruby instalado, caso queira, v ao menu Tools e clique em Options.
Na caixa de dilogo Options, clique em Ruby. Na guia Platform, em Ruby Interpreter, clique no boto Browse e selecione o interpretador que ser usado em
suas aplicaes Ruby on Rails. Se for o Ruby, selecione o executvel a ser usado.
DESENVOLVENDO COM RUBY ON RAILS

O exemplo que ser apresentado envolver o uso de banco de dados ensinando
a criar um CRUD completo.
NOTA: O uso imediato de banco de dados acontecer em parte devido a extrema facilidade em lidar com Rails, principalmente para um programador Java,
que j possui experincia com as complicaes que a linguagem costuma trazer.
445
CRIANDO O PROJETO
Comece por criar um novo projeto na IDE. Selecione Ruby on Rails Application
da categoria Ruby e clique no boto Next.
FIGURA 11.1 CRIANDO UM PROJETO RUBY ON RAILS
A segunda etapa para definio do nome do projeto. Para o livro o projeto

fora chamado de LivrariaRails. O banco de dados ser o mysql, claro. Se estiver
usando o JRuby, h tambm a opo de ter acesso ao banco de dados via JDBC
e adicionar o Rake4 para criar arquivos WAR. Como este exemplo visa trabalhar
diretamente com o Ruby na verso C, estas caractersticas sero ignoradas. Clique
no boto Next para prosseguir.
Rake: Comando que realiza tarefas descritas em um arquivo chamado Rakefile
446
FIGURA 11.2 ESCOLHA DO NOME DO PROJETO
NOTA: Na criao do projeto h tambm a possibilidade de mudar o interpretador Ruby. Clique em Change e depois de um alerta, a caixa de dilogo Options
ser aberta para modificao.
Na terceira etapa, d um Update em Rails, caso esteja usando uma verso antiga.
A caixa de dilogo Gem(s) Update surgir, neste caso, para fazer a atualizao.
Se tudo estiver correto, clique no boto Finish para confirmar.
Observe que h uma sada na janela Output, mostrando o trabalho executado
por Rails para gerar a rvore de seus componentes.
ATENO: provvel que seja necessrio fazer a atualizao o RubyGems. Entre
no terminal ou prompt de comando e digite:
gem update --system
455
FIGURA 11.9 PGINA WELCOME PADRO DO RAILS
Observe que o servidor roda na porta 3000. Para acessar a parte da aplicao
gerada, digite o endereo seguinte em seu navegador:
http://localhost:3000/livros
Rails criou o CRUD, sendo que na primeira pgina voc possui uma tabela listando os dados existentes na tabela livros.
FIGURA 11.10 LISTAGEM INICIAL DA TABELA LIVROS
458
O mtodo validates_presence_of um validador do Rails que verifica se um

campo est vazio. J validates_numericality_of valida entrada numrica nos
campos. Com validates_uniqueness_of o Rails valida o campo para garantir a
entrada de um nome nico. Muito comum para usurios de um sistema, neste
caso fora utilizado para validar o ttulo de cada livro cadastrado.
FIGURA 11.12 VALIDAES EM AO
O mtodo error_messages_for recebe todas as mensagens de erro geradas na

validao e cria o HTML para exibi-las, usando uma folha de estilo. O padro
para o estilo usado neste caso o scaffold.css, encontrado no diretrio Public >
stylesheets de seu projeto.
466
LISTAGEM 11.10 - ALTERAO NO MODEL AUTOR

class Autor < ActiveRecord::Base
belongs_to :livros
end
A declarao belongs_to diz a Rails que a tabela autores filha de livros. Isso
significa que no deve haver um autor sem que antes haja um livro existente
associado.
SOBRE O RELACIONAMENTO USADO

O relacionamento usado para este exemplo foi o conhecido um-para-muitos,
que pode ser melhor entendido na Figura 11.14 mostrada a seguir:
FIGURA 11.14 RELACIONAMENTO ONE-TO-MANY DO ACTIVE RECORD DE RAILS6
Em Active Record, o objeto parente, o que contm uma coleo de objetos filhos,
usa has_many para declarar sua relao tabela filho e por sua vez, a tabela filho
usa belongs_to para indicar seu pai.
NOTA: O relacionamento no est levando em conta uma modelagem mais
correta para o caso.
Imagem inspirada no livro Agile Web Development with Rails second edition The Pragmatic Bookshelf
CAPTULO 12
JRUBY ON RAILS
A mquina virtual Java, Java Virtual Machine (JVM), tambm possui sua verso da
linguagem Ruby, chamada de JRuby. O NetBeans suporta o trabalho com JRuby
como em Ruby, incluindo tambm em sua instalao uma verso de JRuby para
desenvolvimento.
Neste captulo, o leitor aprendera a trabalhar com JRuby em conjunto com Rails
2.0.2, usando o NetBeans IDE 6.x, ao qual ser apresentado:
Como configurar o JRuby;
Como fazer um projeto e configurar o JRuby e Rails;
A configurar, instalar e desinstalar Ruby Gems;
Como configurar o JDBC para trabalhar com JRuby;
A criar arquivos WAR para fazer deploy em um Application Server;
O QUE JRUBY?
JRuby a verso Java da linguagem Ruby criada originalmente por Jan Arne Petersen em 2001. Atualmente possui quatro como principais desenvolvedores: Charles Nutter, Thomas Enebo, Ola Bini e Nick Sieger. Percebendo a popularidade do
Ruby, devido em grande parte ao impacto do framework Rails, a Sun Microsystems contratou Thomas Enebo e Charles Nutter para trabalhar com JRuby em tempo
integral, mantendo-o compatvel com a verso C do Ruby e conseqentemente
acompanhando a evoluo do Rails em seu uso.
478
No NetBeans IDE 6.1, os interpretadores para Ruby e JRuby sero configurados

separadamente, atravs do menu Tools em Ruby Platforms.
FIGURA 12.1 OS INTERPRETADORES RUBY E JRUBY CONFIGURADOS NO NETBEANS IDE 6.1
INSTALANDO OS RUBY GEMS
NO
NETBEANS
Indo ao menu Tools, no item Ruby Gems, temos acesso aos Gems instalados do
Ruby (Installed), os que precisam ser atualizados (Updated) e os novos que podem
ser adicionados (New Gems). Ao lado de cada guia h o nmero correspondente
de cada uma das opes que podem e muitas vezes devem ser feitas como operaes necessrias para a gerao de uma aplicao Rails.
Para instalar um novo Gem, v a guia New Gems e selecione o que deseja adicionar. Clique no boto Install. A caixa de dilogo Gem Installation Settings surgir
definindo o nome (Name) e verso (Version). Sempre que estiver usando uma
ltima verso, por exemplo do Rails, deixe em Version o item Latest selecionado.
Mas se este no for o caso, selecione a verso ao qual deseja usar. Ao confirmar
o item que ser instalado, a caixa de dilogo Gem Installation surge mostrando
o status do console enquanto o Gem baixado e instalado. Ao terminar, o boto
Close habilitado, para que seja fechada e confirmada a instalao.
JRUBY ON RAILS
489
ADICIONANDO O ARQUIVO WAR NO GLASSFISH

Inicie o GlassFish no NetBeans atravs da janela Services. Com o direito sobre o
GlassFish, selecione View Admin Console. Entre no administrador do GlassFish e
faa o deploy do arquivo WAR, em Applications > Web Applications e clique no
boto Deploy e suba o arquivo WAR gerado.
FIGURA 12.14 DEPLOY DO PROJETO JRUBY ON RAILS CRIADO NO NETBEANS
Para executar a aplicao, dentro do prprio administrador do GlassFish h um

link Launch. Clique nele para que seja aberta a aplicao. Caso tenha configurado
o arquivo routes.rb e retirado o index.html, voc ver imediatamente os livros
cadastrados. Do contrrio, adicione livros em seu final, na barra de endereos.
FIGURA 12.15 APLICAO EXECUTANDO NO GLASSFISH
CAPTULO 13
TRABALHANDO COM AJAX
NO NETBEANS IDE
O NetBeans possui bons mdulos de desenvolvimento AJAX que podem ser incorporados ferramenta, tornando mais rpido e prtico seu desenvolvimento.
Alm disso, tambm h empresas que esto investindo no Visual Web JavaServer
Faces, como ICEfaces que possui componentes integrados.
Neste captulo ser apresentado:
A origem do AJAX e seu significado
Como o AJAX trabalha
Como criar um projeto AJAX no NetBeans IDE
A instalar novos mdulos (plug-ins)
O framework jMaki e seus componentes
O uso de GWT integrado ao NetBeans
A utilizar o banco de dados com AJAX
A integrar o ICEfaces ao Visual Web JSF
AJAX
O termo AJAX surgiu em fevereiro 2005, por Jesse James Garrett de Adaptive Path,
LLC, onde publicou um artigo on-line intitulado, Ajax: A New Approach to Web
Applications. O artigo se encontra em ingls e pode ser lido no endereo http://
www.adaptivepath.com/publications/essays/archives/000385.php.
TRABALHANDO COM AJAX NO NETBEANS IDE
495
UTILIZANDO A TECNOLOGIA JMAKI

O JMaki um framework que oferece uma srie dos melhores componentes de
vrios outros frameworks Ajax para projetos com este fim. Na lista de frameworks
usados temos: Dojo, Scriptaculous, Yahoo UI Widgets, Spry, DHTML Goodies, e
Google, permitindo ao desenvolvedor Java, trabalhar como se estivesse usando
uma tag do JSTL ou JSF. Tambm possui suporte a outras tecnologias alm de
Java.
Voc pode encontrar este framework no endereo:
https://ajax.dev.java.net/
FIGURA 13.2 PGINA PRINCIPAL DO PROJETO
O framework jMaki possui uma srie de componentes, ao qual a seguir esto

listados como organizados:
CLIENT SIDE COMPONENTS

JMAKI
LAYOUTS: jMaki Layouts fornece um padro baseado em pontos iniciais para

crias suas aplicaes Web usando HTML e CSS.
510
OBSERVAO: Existe um conjunto de classes no endereo http://www.json.org/

java para desenvolver o formato JSON utilizando Java. O NetBeans IDE 6.0
possui em suas bibliotecas o JSON para que voc possa adicionar em seus projetos.
Uma biblioteca Java tambm pode ser encontrada no endereo http://json-lib.
sourceforge.net/.
Na sua pgina, altere seu componente como mostrado a seguir:

<a:widget name=dojo.etable
service=LivrosFacade />
O resultado pode ser visto na Figura 13.11 a seguir:
FIGURA 13.11 EXIBIO DA TABELA RENDERIZADA COM OS DADOS DO SERVLET
Na janela Projects, expandindo os ns de Web Pages > resources > dojo > etable, voc encontra o arquivo JavaScript component.js, onde reside os mtodos
que manipulam este componente.
511
Existem outros componentes que podem ser analisado, onde em suma, trabalham
com formatos JSON e que so muito simples de se adaptar.
AJAX COM GWT

O Google Web Toolkit, ou simplesmente GWT, um framework Ajax que facilita o desenvolvimento por esconder do programador a implementao de cdigo JavaScript. O GWT abstrai o JavaScript a partir de uma biblioteca de classes
Java, disponibilizando diversos componentes widgets (componentes visuais). Estes
componentes so usados pela prpria Google, desenvolvedora do framework, em
aplicaes j consagradas como GMail e Google Maps.
BAIXANDO O GWT
O projeto do Google Web Toolkit possui o pacote que encontrado na pgina do
framework. Disponvel para os sistemas operacionais Linux, Windows e MacOS,
voc o encontra no seguinte endereo:
http://code.google.com/webtoolkit/
Neste endereo h o link Download Google Web Toolkit (GWT), que o leva ao
download do framework, que no momento em que este livro escrito, se encontra na verso 1.4.61. O arquivo vem compactado. Descompacte-o em um local
desejado.
INSTALANDO O PLUGIN GWT NO NETBEANS

V ao menu Tools e clique em Plugins. Na guia Available Plugins, da caixa de
dilogo Plugins, selecione o item GWT4NB. Este plugin possibilita integrar o NetBeans ao GWT de forma simples, integrando a suas aplicaes Web. Clique no
boto Install.
522
FormPanel uma classe que gera a tag XHTML <form/> com seus respectivos atributos. O mtodo setAction() determina o valor do atributo action da tag
<form/> e setMethod() o atributo method. Pode-se definir o mtodo de envio
POST atravs da constante METHOD_POST de FormPanel ou GET atravs de
METHOD_GET.
O FormPanel uma subclasse de SimplePanel, o que significa que este componente pode conter somente um widget ou painel. A menos que seu formulrio
possua somente um controle, necessrio colocar os demais componentes em
um painel e depois adicion-lo ao FormPanel. Para simplificar seu desenvolvimento, foi usado no exemplo um VerticalPanel, onde o resultado visto na Figura
13.18.
OS EVENTOS DE FORMPANEL
O FormPanel permite registrar um ouvinte de eventos, permitindo escrever um
manipulador que os codifique. Os dois eventos para o ouvinte so a submisso do
formulrio, atravs do mtodo onSubmit, e a concluso da submisso, atravs de
onSubmitComplete.
No exemplo, somente onSubmit fora utilizado para definir se um dos campos de
entrada possui algum valor. Se este estiver vazio, aparece um alerta, seguido do foco
no campo (setFocus(true)) e cancelamento da submisso (setCancelled(true)).
FIGURA 13.18 FORMULRIO GERADO POR FORMPANEL
525
UTILIZANDO AJAX COM VISUAL WEB JSF

O Visual Web JavaServer Faces possui tambm seus prprios componentes Ajax.
O que atualmente possui constante atualizao o projeto ICEfaces.
O PROJETO ICEFACES
O projeto Open Source ICEfaces mantido pela empresa ICEsoft Technologies
Inc., que contribui constantemente com a comunidade e que atualmente o que
possui mais componentes Ajax integrados com o Visual Web JSF.
Para obter este framework, v ao site http://www.icefaces.org e clique em Download.
FIGURA 13.21 BANNER DE ENTRADA DO PROJETO ICEFACES
necessrio fazer login para baix-lo. Para o NetBeans IDE, existem as ferramentas de integrao:
ICEFACES-NETBEANS6-IDE-V3.0.0.1.ZIP - que se integra ao NetBeans.
ICEFACES-1.6.2-LIBS-NETBEANS6.ZIP as bibliotecas do ICEFaces.
Ao descompactar estes arquivos, perceba que h por entre eles um arquivo com
extenso .nbm.
APNDICE A
RUBY PARA DESENVOLVEDORES
JAVA
Embora a linguagem Ruby no seja nova, somente h pouco tempo os holofotes

do desenvolvimento Web se voltaram para esta linguagem devido ao reconhecimento de seu framework, chamado de Rails. Alm da espantosa velocidade
com que uma aplicao pode ser feita com a dupla, Ruby on Rails, Ruby uma
linguagem orientada a objetos, possuidora de uma sintaxe amigvel e simples. O
conjunto destes elementos trouxe ao desenvolvedor a abertura de um mundo de
novas possibilidades, onde a simplicidade a palavra de ordem.
Neste Apndice voc conhecer o bsico sobre a linguagem Ruby, focada nos
exemplos com relao a Java, em conjunto com o NetBeans IDE.
RECURSOS DO RUBY
O Ruby possui muitos recursos similares a muitas linguagens, inclusive a Java, o
que explica sua adoo por muitos desenvolvedores desta linguagem. Entre seus
principais recursos temos:
Tratamento de Excees;
uma linguagem orientada a objetos (no 100%), mas melhor que Java e
similar a me das linguagens orientadas a objetos SmallTalk. Isso significa que
um nmero a extenso de uma classe;
No precisa ser compilada aps uma alterao. Voc a modifica e executa.
Closures (funes criadas dentro de outras funes, que referenciam o ambiente da funo externa mesmo depois de ter sado de escopo) e com bindings de variveis;

Java

Enviado por

Dados do documento

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

Java

Enviado por

Direitos autorais:

Formatos disponíveis

EDSON GONALVES

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

QUEM DEVE LER ESTE LIVRO?

Alguns testes foram executados em Pentium 4 com 1 GB de memria, no qual

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

VISO GERAL DOS CAPTULOS

PARTE 1: INTRODUO: DESENVOLVIMENTO DE APLICAES WEB COM JAVA

CAPTULO 3: DESENVOLVENDO PGINAS DINMICAS NO NETBEANS - Dedicado ao trabalho

PARTE 2: JAVA EE5: AVANANDO NO DESENVOLVIMENTO DE APLICAES WEB

PARTE 3: DESENVOLVIMENTO COM LINGUAGENS DINMICAS E AJAX

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

APNDICE A: Ruby para desenvolvedores Java Explica de forma comparativa a

TOMCAT 5.5 Introduz ao uso do Tomcat 5.5

Captulo 1 - Obtendo e instalando o NetBeans IDE 6 ................................................. 3

Captulo 2 - Servidores de Aplicaes e Servlets ....................................................... 1 5

Captulo 3 - Desenvolvendo pginas dinmicas no NetBeans ................................... 5 7

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

Captulo 4 - Trabalhando com Banco de Dados ...................................................... 1 1 9

Baixando o driver JDBC ............................................................................................. 1 2 6

PARTE 2 - JAVA EE5: AVANANDO NO DESENVOLVIMENTO DE APLICAES WEB............................ 1 9 5

Captulo 5 - JavaServer Faces ................................................................................... 1 9 7

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

Captulo 6 - EJB 3 e Java Persistence API ................................................................. 2 5 9

Captulo 7 - O Visual Web JavaServer Faces ............................................................ 2 9 1

Captulo 9 - Trabalhando com Web Services no NetBeans IDE ............................... 3 7 1

Entendendo a estrutura do documento WSDL ........................................................... 3 8 1

Captulo 10 - Visual Web JSF com JPA, Spring e Hibernate ..................................... 4 0 1

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

PARTE 3 - DESENVOLVIMENTO COM LINGUAGENS DINMICAS E AJAX ........................................ 4 3 9

Captulo 11 - Rails 2 com NetBeans IDE ................................................................. 4 4 1

Captulo 12 - JRuby on Rails .................................................................................... 4 7 5

Captulo 13 - Trabalhando com AJAX no NetBeans IDE .......................................... 4 9 1

Criando um projeto utilizando jMaki ......................................................................... 4 9 9

Apndice A - Ruby para desenvolvedores Java ....................................................... 5 3 1

Captulo Extra 1 Trabalhando com Tomcat 5.5 .............................................CD-ROM

Captulo Extra 3 Struts .................................................................................CD-ROM

Captulo Extra 4 Desenvolvendo relatrios com NetBeans IDE ...................CD-ROM

Apndice B O MySQL ..................................................................................CD-ROM

OBSERVAO: Apesar de abordar onde obter o NetBeans IDE, o CD-ROM anexo

BAIXANDO O NETBEANS NA INTERNET

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

FIGURA 1.1 SITE OFICIAL DO NETBEANS IDE

OBTENDO E INSTALANDO O NETBEANS IDE 6

FIGURA 1.2 NETBEANS PACKS

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

O PACOTE SEM INSTALADOR E O JDK REQUERIDO

FIGURA 1.3 A OPO COMPACTADA SEM ASSISTENTE

OBTENDO E INSTALANDO O NETBEANS IDE 6

FIGURA 1.4 INICIO DO ASSISTENTE DE INSTALAO

No boto Customize, marque ou desmarque os itens que no deseja instalar.

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

FIGURA 1.5 CUSTOMIZANDO A INSTALAO

FIGURA 1.6 TERMOS DE LICENA

OBTENDO E INSTALANDO O NETBEANS IDE 6

FIGURA 1.7 DETERMINANDO O LOCAL DA INSTALAO E O JDK ENCONTRADO

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

FIGURA 1.8 CONFIGURAO DO GLASSFISH V2

OBTENDO E INSTALANDO O NETBEANS IDE 6

FIGURA 1.9 DEFININDO O LOCAL DE INSTALAO PARA O TOMCAT 6

OBSERVAO: O servidor GlassFish e o container Tomcat no tero suas telas

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

FIGURA 1.10 CONFIRMAO PARA A INSTALAO

Aguarde a instalao at o boto Finish.

OBTENDO E INSTALANDO O NETBEANS IDE 6