Desenvolvendo Aplicacoes Web Com NetBeans IDE 6

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 plu, gin 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 confi, gurao 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 N Web Pages REPRESENTAO NA JANELA FILES Diretrio web Diretrio src NO ARQUIVO WAR Na raiz do arquivo Diretrio classes dentro de WEB-INF N/A
Arquivos Java no com- N Source Packages pilados, servlets, entre outros testes unitrios N Test Packages deployment descriptor N Configuration Files (web.xml) GlassFish(sun-web.xml) N Configuration Files
Diretrio test
Diretrio WEB-INF em Diretrio WEB-INF web Diretrio WEB-INF em Diretrio WEB-INF web Diretrio META-INF em Diretrio META-INF web
Arquivo de configura- N Configuration Files o do Tomcat e GlassFish V2 ou superior (context configuration) (context.xml) Bibliotecas Testes N Libraries N Test Libraries
Diretrio lib em web/ Diretrio WEB-INF/lib WEB-INF 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 type dateStyle timeStyle value DESCRIO Pode ser time, date ou both. Usado para imprimir somente a hora, data ou ambos. Pode ser usado short, medium, long ou full (ou default). Usado para imprimir a data. Pode ser short, medium, long ou full (ou default). Usado para imprimir a hora. 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
255
</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
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.
EJB 3 E JAVA PERSISTENCE API
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.
RAILS 2 COM NETBEANS IDE
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
RAILS 2 COM NETBEANS IDE
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;

Desenvolvendo Aplicacoes Web Com NetBeans IDE 6

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Desenvolvendo Aplicacoes Web Com NetBeans IDE 6

Uploaded by

Copyright:

Available Formats

EDSON GONALVES

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

NO CD-ROM CAPTULO EXTRA 1: TRABALHANDO utilizando o NetBeans IDE.

TOMCAT 5.5 Introduz ao uso do Tomcat 5.5

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

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

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

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

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

INTRODUO: DESENVOLVIMENTO DE APLICAES WEB COM JAVA

CAPTULO 1 OBTENDO E INSTALANDO O NETBEANS IDE 6

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

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

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

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.

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

DESINSTALANDO O NETBEANS NO LINUX

CAPTULO 2 SERVIDORES DE APLICAES E SERVLETS

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

FIGURA 2.1 SELECIONANDO A OPO NEW PROJECT

SERVIDORES DE APLICAES E SERVLETS

FIGURA 2.2 SELEO DO ITEM WEB APPLICATION EM PROJECTS

FIGURA 2.3 NOME E LOCALIZAO DO PROJETO

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

FIGURA 2.4 DETALHE DO PASSO NAME AND LOCATION

FIGURA 2.5 DETALHE DO SERVIDOR, VERSO E CAMINHO DO CONTEXTO

SERVIDORES DE APLICAES E SERVLETS

FIGURA 2.6 SELEO DO JAVA EE VERSION INFERIOR A 5

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

VISO GERAL DO NETBEANS IDE

FIGURA 2.7 CARACTERSTICAS GERAIS DO NETBEANS IDE 6.0

SERVIDORES DE APLICAES E SERVLETS

EXPLORANDO SEU PROJETO

DESENVOLVENDO APLICAES WEB COM NETBEANS IDE 6

FIGURA 2.8 DIRETRIOS EXPANDIDOS DO PROJETO NA JANELA PROJECTS