Escolar Documentos
Profissional Documentos
Cultura Documentos
Java
Java
AGRADECIMENTOS
Primeiramente gostaria de agradecer os inmeros e-mails de leitores elogiando a primeira edio deste livro e tambm os que criticaram, pedindo mais detalhes a respeito de determinados assuntos. Tambm agradeo o apoio dado pela Editora Cincia Moderna para o desenvolvimento desta segunda edio. Um agradecimento especial ao apoio do JUG Leader e Founding Java Champion, Daniel deOliveira, do DFJUG.
INTRODUO
Mais uma verso e, novamente, o NetBeans amadurece e surpreende com novas caractersticas que tornam o desenvolvimento mais agradvel e gil. A verso 6 desta fantstica IDE no poderia ser diferente de seus lanamentos anteriores, onde vemos que a inteno tornar a ferramenta uma plataforma de desenvolvimento para vrias linguagens. Esta nova verso, alm de aproveitar melhor as facilidades incorporadas nas especificaes Java EE 5, conta tambm com as caractersticas que vem mudando o mundo do desenvolvimento Web, como o framework Rails da linguagem Ruby. Mais ainda, possvel, atravs do uso de JRuby, rodar aplicaes Ruby on Rails (RoR) sobre uma Java Virtual Machine, agregando as facilidades do desenvolvimento com RoR, aliados a estabilidade e integrao com sistemas Java rodando sobre os servidores de aplicaes. Alm do Ruby, a linguagem PHP , tida como plugin adicional na verso 6.0, tambm ganhou seu lugar na IDE definitivamente na verso 6.1, ainda em desenvolvimento no momento em que este livro escrito. Com um nmero maior de linguagens e frameworks suportados, o desenvolvedor pode contar com assistentes que se integram tanto para o desenvolvimento de aplicaes Java, como tambm na integrao com o poderoso framework Rails (RoR) para o mesmo principio. Outra novidade a incorporao do editor visual ao NetBeans IDE 6.x, tido antes como um pacote separado, para gerao de aplicaes Web que utilizam o framework JavaServer Faces. Seu nome foi rebatizado para Visual Web JavaServer Faces Applications e mais uma das diversas facilidades que o desenvolvedor Java conta na construo de aplicaes Web. Para este livro, nesta nova edio, cerca de 50% do material foi reescrito e ampliado. O leitor agora tem em suas mos informaes que vo desde a construo de aplicaes Web bsicas, contendo pginas JSP e Servlets, como tambm o foco na utilizao de JavaServer Faces, incluindo Facelets. O uso de JPA (Java Persistence API) e EJB 3 foram adicionados, tendo em vista os leitores que esto aproveitando as facilidades que ambos incorporam no desenvolvimento de aplicaes Web.
VIII
O uso de Ruby on Rails foi adicionado, incluindo o JRuby on Rails para programadores Java, focado na verso 2.0.2 do framework. Neste caso, no s um CRUD feito atravs da IDE, mas tambm h muitas explicaes sobre sua arquitetura e um exemplo com relacionamento. A grande novidade neste livro est no aprimoramento dos captulos sobre Visual Web JavaServer Faces. Para aqueles que desejam trabalhar com esta ferramenta, fora elaborado em dois captulos um aplicativo completo, utilizando seus principais componentes com acesso a dados. E para aqueles que desejam utilizar JPA e Hibernate com Visual Web JavaServer Faces, um captulo especial fora dedicado a este assunto, incluindo o uso de Spring. Por fim, h no CD-ROM como brinde, diversos Captulos Extras que contm o trabalho com Struts, criando um CRUD completo, a utilizao do novssimo plugin iReport for NetBeans, integrando-se a ferramenta e facilitando a criao de relatrios JasperReports e dois estudos de caso completos, envolvendo o Visual Web JSF, incluindo o uso de DAO genrico, injeo de dependncias com Spring Framework e a JPA com o Hibernate como provider.
QUEM DEVE LER ESTE LIVRO? Este livro foi escrito para desenvolvedores com pouca ou nenhuma experincia na utilizao do NetBeans IDE. Embora sejam apresentados alguns conceitos sobre as tecnologias Java, para a criao de aplicaes Web, de suma importncia que o leitor tenha conhecimento de lgica e da estrutura da linguagem Java. O mesmo vale para os desenvolvedores que desejam trabalhar com aplicaes Ruby on Rails, ao qual necessrio um prvio conhecimento de Ruby, facilitando assim sua compreenso. desejvel tambm um conhecimento sobre o desenvolvimento Web com a linguagem Java, tais como pginas JSP ou Servlets, assim como acesso e utilizao de um banco de dados.
INTRODUO
IX
ANTES DE COMEAR Em algumas partes desse livro voc encontrar um smbolo, que o ajudar a entender o cdigo proposto e desenvolvido, mostrado a seguir: ... - Indica que acima ou abaixo contm mais cdigo, mas que no est sendo exibido por no ter sido alterado e que o mesmo pode ser acessado pelo CD-ROM, em anexo ao livro.
OS SOFTWARES REQUERIDOS Os aplicativos criados nesse livro no exigem software proprietrio. Portanto ao longo dos captulos voc no s aprender como us-los como tambm onde encontr-los na Internet, caso precise de uma atualizao. Esse livro no est focado especialmente em um sistema operacional, portanto a sua escolha livre nesse ponto.
HARDWARE REQUERIDO Uma boa configurao de hardware se faz necessrio para trabalhar com aplicaes escritas em Java. Um computador para rodar bem o NetBeans na verso 6.0 deve ter as seguintes configuraes para uma confortvel utilizao, segundo o autor: Processador: Pentium 4 ou similar (recomendo um Dual Core ou Core 2 Duo) Memria: 1 GB de RAM mnimo (recomendo 2GB de RAM) HD: 10GB de espao livre Monitor: 17 polegadas ou superior
Alguns testes foram executados em Pentium 4 com 1 GB de memria, no qual houve certa lentido na inicializao da IDE, mas no a inviabilidade de seu uso. O maior problema na utilizao da IDE com relao exigncia do Hardware est no trabalho com o Visual Web JavaServer Faces e com servidores de aplicaes como o Glassfish.
Para a criao deste livro, um Core 2 Duo com 4 MB de cache e 2GB de RAM fora utilizado. CDIGOS DOS EXEMPLOS CRIADOS NO LIVRO Todos os cdigos dos exemplos criados no livro, bem como a IDE e outros, se encontram no CD-ROM anexo. Caso no encontre algum exemplo, entre em contato com o autor pelo site http:// www.integrator.com.br.
VISO GERAL DOS CAPTULOS Embora este livro esteja completamente focado no NetBeans IDE, ainda assim voc ter ao longo do livro, muitos cdigos para desenvolver. Todos os detalhes, em sua maioria, se encontram na ntegra, para que sejam digitados por voc mesmo. Em todo caso, dvidas podero surgir, o que pode requerer a viso do arquivo em geral. Para este caso, o CD-ROM em anexo possui o projeto com seu nome proposto em livro para ser analisado.
ATENO: Em caso de erro, recomendado a visualizao dos exemplos contidos no CD-ROM anexo ao livro, antes de entrar em contato com o autor. Com um contedo completamente ilustrado, o livro possui diversas imagens, espalhadas por todos os captulos e sempre com foco em detalhes quando necessrio. Em seu longo, dicas so dadas para uma melhor produtividade do que est sendo feito, aproveitando melhor os recursos que a IDE tem a oferecer.
PARTE 1: INTRODUO: DESENVOLVIMENTO DE APLICAES WEB COM JAVA CAPTULO 1: OBTENDO E INSTALANDO O NETBEANS IDE 6 Como obter e instalar a NetBeans IDE na verso 6.x. CAPTULO 2: SERVIDORES DE APLICAES E SERVLETS Viso geral, uso e aprofundamento do NetBeans IDE com o desenvolvimento de aplicaes Web escritas em Java, utilizando servidores de aplicaes, monitoramento e distribuio para produo.
INTRODUO
XI
CAPTULO 3: DESENVOLVENDO PGINAS DINMICAS NO NETBEANS - Dedicado ao trabalho com pginas dinmicas usando Java, envolvendo JSP , JSTL, Custom Tags, as configurao da sua aplicao e o Deployment Descriptor usando o NetBeans IDE. CAPTULO 4: TRABALHANDO COM BANCO DE DADOS Desenvolvido para o contato inicial com o banco de dados, usando JDBC, em aplicaes Web atravs Servlets e pginas JSP , utilizando NetBeans IDE. Os padres de desenvolvimento MVC e DAO so apresentados, integrando o JSP e JSTL com acesso a dados atravs do MySQL.
PARTE 2: JAVA EE5: AVANANDO NO DESENVOLVIMENTO DE APLICAES WEB CAPTULO 5: JAVASERVER FACES Viso geral e tcnica do framework JavaServer Faces trabalhado atravs do NetBeans IDE, com configuraes e acesso a banco de dados e Web 2.0 com Facelets. CAPTULO 6: EJB 3 E JAVA PERSISTENCE API Apresenta o desenvolvimento de aplicaes Enterprise utilizando o NetBeans. CAPTULO 7: O VISUAL WEB JAVASERVER FACES A primeira parte de um estudo de caso detalhado, ensinando o uso do Visual Web JSF atravs do desenvolvimento de uma aplicao, focando na etapa visual sem acesso a banco de dados. CAPTULO 8: DESENVOLVENDO NO VISUAL WEB JSF COM BANCO DE DADOS Continuao do estudo de caso usando Visual Web JSF com acesso a dados, incluindo uma rea administrativa. CAPTULO 9: TRABALHANDO COM WEB SERVICES NO NETBEANS IDE Desenvolve e consome Web Services usando o NetBeans IDE, incluindo a integrao com EJB 3, acesso a dados e o uso de Visual Web JavaServer Faces. CAPTULO 10: VISUAL WEB JSF COM JPA, SPRING E HIBERNATE Finaliza o trabalho com Visual Web JSF integrando um CRUD com Spring 2.5 e Hibernate 3, atravs do uso de Java Persistence API (JPA).
PARTE 3: DESENVOLVIMENTO COM LINGUAGENS DINMICAS E AJAX CAPTULO 11: RAILS 2 COM NETBEANS IDE Cria um estudo de caso usando o NetBeans como ferramenta para desenvolver aplicaes Ruby on Rails.
XII
CAPTULO 12: JRUBY ON RAILS Recria o projeto do Captulo 11, adicionando as caractersticas individuais do JRuby, que roda sobre a Java Virtual Machine, incluindo acesso a dados via JDBC e deploy no Application Server GlassFish. CAPTULO 13: TRABALHANDO COM AJAX NO NETBEANS IDE Utiliza o NetBeans para trabalhar com AJAX atravs de plug-ins, integrando frameworks conhecidos como jMaki, GWT e ICEfaces.
APNDICE A: Ruby para desenvolvedores Java Explica de forma comparativa a linguagem Ruby com Java para um suave entendimento.
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
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
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 2 Aplicaes Web com acesso a dados sem padro ............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
PARTE 1
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.
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.
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.
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.
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.
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.
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.
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.
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
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
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
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
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
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.
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.
17
Na segunda etapa do assistente, voc possui vrias opes para a construo do seu 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.
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.
19
Caso voc precise trabalhar com a verso 1.4, basta selecionar em Java EE Version a opo J2EE 1.4.
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
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
22
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
Clicando na janela Files, ao lado de Projects, voc v a estrutura do seu projeto como se encontra no sistema operacional.
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
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.
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.
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
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
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.
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.
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.
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.
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.
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.
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.
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
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.
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
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.
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.
46
Retornando ao NetBeans, com o uso do direito sobre GlassFish, no menu de contexto, selecione Refresh para refletir a alterao no servidor.
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.
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.
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.
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.
127
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
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.
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
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).
140
141
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
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.
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.
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.
165
Observe que ao renomear a classe, o construtor tambm foi renomeado automaticamente, o que altamente recomendvel utilizar sempre esta ferramenta para tais situaes.
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
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
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.
186
Outro detalhe que novamente JSTL usado aqui para simplificar a formatao da data de nascimento do autor.
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.
PARTE 2
WEB
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
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).
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
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.
222
LISTAGEM 5.7 ALTERAO EM AUTORCONTROLLER.JAVA ... public class AutoresController { private Autor autor; private DataModel model;
JAVASERVER FACES
231
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:
JAVASERVER FACES
235
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
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 ... <!-- Cria um novo cadastro ou edita, atraves de mostrarAutores.jsp --> <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:
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>
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
Na segunda etapa, chame o projeto de EALivraria. O servidor ser o GlassFish (por implementar o Java EE 5). Observe que esto selecionadas duas opes: Create EJB Module e Create Web Application Module. Clique no boto Finish para terminar.
261
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.
266
Na caixa de dilogo Call Enterprise Bean, selecione seu EJB. Confirme a caixa de dilogo.
280
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
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
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.
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;
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.
295
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
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.
319
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.
345
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.
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.
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.
375
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.
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.
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
399
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
ATENO: No esquea de ter o servidor rodando para que o Web Service se mantenha funcional.
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;
402
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.
437
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
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
NOTA: O uso imediato de banco de dados acontecer em parte devido a extrema facilidade em lidar com Rails, principalmente para um programador Java, que j possui experincia com as complicaes que a linguagem costuma trazer.
445
CRIANDO O PROJETO
Comece por criar um novo projeto na IDE. Selecione Ruby on Rails Application da categoria Ruby e clique no boto Next.
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.
446
NOTA: Na criao do projeto h tambm a possibilidade de mudar o interpretador Ruby. Clique em Change e depois de um alerta, a caixa de dilogo Options ser aberta para modificao.
Na terceira etapa, d um Update em Rails, caso esteja usando uma verso antiga. A caixa de dilogo Gem(s) Update surgir, neste caso, para fazer a atualizao. Se tudo estiver correto, clique no boto Finish para confirmar. Observe que h uma sada na janela Output, mostrando o trabalho executado por Rails para gerar a rvore de seus componentes. ATENO: provvel que seja necessrio fazer a atualizao o RubyGems. Entre no terminal ou prompt de comando e digite: gem update --system
455
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.
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.
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.
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
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.
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
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.
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.
495
O framework jMaki possui uma srie de componentes, ao qual a seguir esto listados como organizados:
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 />
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.
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.
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)).
525
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.
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.
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;