Escolar Documentos
Profissional Documentos
Cultura Documentos
Desenvolvendo Aplicações Web Com NetBeans IDE 6
Desenvolvendo Aplicações Web Com NetBeans IDE 6
AGRADECIMENTOS
Também agradeço o apoio dado pela Editora Ciência Moderna para o desenvol-
vimento desta segunda edição.
A versão 6 desta fantástica IDE não poderia ser diferente de seus lançamentos
anteriores, onde vemos que a intenção é tornar a ferramenta uma plataforma de
desenvolvimento para várias linguagens.
Esta nova versão, além de aproveitar melhor as facilidades incorporadas nas es-
pecificações Java EE 5, conta também com as características que vem mudando
o mundo do desenvolvimento Web, como o framework Rails da linguagem Ruby.
Mais ainda, é possível, através do uso de JRuby, rodar aplicações Ruby on Rails
(RoR) sobre uma Java Virtual Machine, agregando as facilidades do desenvolvi-
mento com RoR, aliados a estabilidade e integração com sistemas Java rodando
sobre os servidores de aplicações. Além do Ruby, a linguagem PHP, tida como plu-
gin adicional na versão 6.0, também ganhou seu lugar na IDE definitivamente na
versão 6.1, ainda em desenvolvimento no momento em que este livro é escrito.
Outra novidade é a incorporação do editor visual ao NetBeans IDE 6.x, tido an-
tes como um pacote separado, para geração de aplicações 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 construção de aplicações Web.
Para este livro, nesta nova edição, cerca de 50% do material foi reescrito e amplia-
do. O leitor agora tem em suas mãos informações que vão desde a construção de
aplicações Web básicas, contendo páginas JSP e Servlets, como também o foco na
utilização de JavaServer Faces, incluindo Facelets. O uso de JPA (Java Persistence
API) e EJB 3 foram adicionados, tendo em vista os leitores que estão aproveitando
as facilidades que ambos incorporam no desenvolvimento de aplicações Web.
VIII ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
O uso de Ruby on Rails foi adicionado, incluindo o JRuby on Rails para programa-
dores Java, focado na versão 2.0.2 do framework. Neste caso, não só um CRUD
é feito através da IDE, mas também há muitas explicações sobre sua arquitetura e
um exemplo com relacionamento.
A grande novidade neste livro está no aprimoramento dos capítulos sobre Visual
Web JavaServer Faces. Para aqueles que desejam trabalhar com esta ferramenta,
fora elaborado em dois capítulos um aplicativo completo, utilizando seus princi-
pais componentes com acesso a dados. E para aqueles que desejam utilizar JPA e
Hibernate com Visual Web JavaServer Faces, um capítulo especial fora dedicado
a este assunto, incluindo o uso de Spring.
Por fim, há no CD-ROM como brinde, diversos Capítulos Extras que contém o
trabalho com Struts, criando um CRUD completo, a utilização do novíssimo plu-
gin iReport for NetBeans, integrando-se a ferramenta e facilitando a criação de
relatórios JasperReports e dois estudos de caso completos, envolvendo o Visual
Web JSF, incluindo o uso de DAO genérico, injeção de dependências com Spring
Framework e a JPA com o Hibernate como provider.
Este livro foi escrito para desenvolvedores com pouca ou nenhuma experiência na
utilização do NetBeans IDE. Embora sejam apresentados alguns conceitos sobre
as tecnologias Java, para a criação de aplicações Web, é de suma importância
que o leitor tenha conhecimento de lógica e da estrutura da linguagem Java. O
mesmo vale para os desenvolvedores que desejam trabalhar com aplicações Ruby
on Rails, ao qual é necessário um prévio conhecimento de Ruby, facilitando assim
sua compreensão.
ANTES DE COMEÇAR
Em algumas partes desse livro você encontrará um símbolo, que o ajudará a en-
tender o código proposto e desenvolvido, mostrado a seguir:
... - Indica que acima ou abaixo contém mais código, mas que não está sendo exi-
bido por não ter sido alterado e que o mesmo pode ser acessado pelo CD-ROM,
em anexo ao livro.
OS SOFTWARES REQUERIDOS
HARDWARE REQUERIDO
Uma boa configuração de hardware se faz necessário para trabalhar com aplica-
ções escritas em Java. Um computador para rodar bem o NetBeans na versão 6.0
deve ter as seguintes configurações para uma confortável utilização, segundo o
autor:
Para a criação deste livro, um Core 2 Duo com 4 MB de cache e 2GB de RAM
fora utilizado.
Todos os códigos dos exemplos criados no livro, bem como a IDE e outros, se
encontram no CD-ROM anexo.
Caso não encontre algum exemplo, entre em contato com o autor pelo site http://
www.integrator.com.br.
Embora este livro esteja completamente focado no NetBeans IDE, ainda assim
você terá ao longo do livro, muitos códigos para desenvolver. Todos os detalhes,
em sua maioria, se encontram na íntegra, para que sejam digitados por você mes-
mo. Em todo caso, dúvidas poderão surgir, o que pode requerer a visão do arqui-
vo em geral. Para este caso, o CD-ROM em anexo possui o projeto com seu nome
proposto em livro para ser analisado.
CAPÍTULO 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, através do
uso de Java Persistence API (JPA).
CAPÍTULO 11: RAILS 2 COM NETBEANS IDE – Cria um estudo de caso usando o NetBe-
ans como ferramenta para desenvolver aplicações Ruby on Rails.
XII ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
CAPÍTULO 12: JRUBY ON RAILS – Recria o projeto do Capítulo 11, adicionando as ca-
racterísticas individuais do JRuby, que roda sobre a Java Virtual Machine, incluin-
do acesso a dados via JDBC e deploy no Application Server GlassFish.
CAPÍTULO 13: TRABALHANDO COM AJAX NO NETBEANS IDE – Utiliza o NetBeans para
trabalhar com AJAX através de plug-ins, integrando frameworks conhecidos como
jMaki, GWT e ICEfaces.
NO CD-ROM
CAPÍTULO EXTRA 1: TRABALHANDO COM TOMCAT 5.5 – Introduz ao uso do Tomcat 5.5
utilizando o NetBeans IDE.
CAPÍTULO EXTRA 2: APLICAÇÕES WEB COM ACESSO A DADOS SEM PADRÃO – Indicado para
iniciantes com baixa experiência em aplicações Web Java, ensina a acessar dados
via JDBC diretamente através de scriptlets sem o padrão DAO.
CAPÍTULO EXTRA 5: Estudo de caso completo com Visual Web JSF – Continua a apli-
cação criada no livro através dos capítulos 7 e 8, criando todos os relacionamentos
e acesso ao banco de dados, incluindo o uso de novos componentes.
CAPÍTULO EXTRA 6: Estudo de caso completo com Visual Web JSF, Spring e Hiberna-
te utilizando JPA – Criação da mesma aplicação gerada através dos capítulos 7, 8 e
Extra 5, criando todos os relacionamentos e acesso ao banco de dados, utilizando
DAO genérico, Spring framework e Hibernate com JPA, incluindo o uso de novos
componentes.
Os pacotes..................................................................................................................... 5
A instalação ................................................................................................................... 6
A desinstalação ............................................................................................................ 1 3
Diretivas ...................................................................................................................... 6 1
O que é MVC?........................................................................................................... 1 4 1
Pool de conexões....................................................................................................... 1 8 6
O aperfeiçoamento.................................................................................................... 1 9 3
Session Bean.............................................................................................................. 2 6 9
Capítulo 8 - Desenvolvendo com Visual Web JSF usando banco de dados ............. 3 1 7
O Hibernate .............................................................................................................. 4 0 2
O Spring .................................................................................................................... 4 0 4
O Log4j ..................................................................................................................... 4 2 4
O que é Ruby?........................................................................................................... 4 4 2
A Camada Modelo..................................................................................................... 4 5 7
O que é JRuby?.......................................................................................................... 4 7 5
AJAX .......................................................................................................................... 4 9 1
Bibliografia ............................................................................................................... 5 7 9
Capítulo Extra 2 – Aplicações Web com acesso a dados sem padrão ............CD-ROM
Capítulo Extra 5 – Estudo de caso completo com Visual Web JSF ...................CD-ROM
Capítulo Extra 6 – Estudo de caso completo com Visual Web JSF, Spring e Hibernate uti-
lizando JPA .....................................................................................................CD-ROM
INTRODUÇÃO:
DESENVOLVIMENTO DE
APLICAÇÕES WEB COM JAVA
CAPÍTULO 1
OBTENDO E INSTALANDO O
NETBEANS IDE 6
O NetBeans é uma IDE criada em Java Swing e portanto, depende da Java Virtual
Machine (JVM) instalada em sua máquina.
Além disso, você verá que há várias opções da IDE, onde cada uma contém mó-
dulos de instalação diferentes para cada necessidade do desenvolvedor.
Neste Capítulo você aprenderá a obter e instalar o NetBeans IDE na versão 6.x.
Assim que você entra no site oficial do NetBeans, há um grande botão escrito
Download NetBeans IDE 6.0.
Dando um clique neste botão, você irá até a página de downloads da IDE.
OBSERVAÇÃO: Você pode notar que existe ao lado do botão Download NetBeans
IDE 6.0 um ícone de uma mídia CD/DVD escrito em seu rótulo Get Free DVD.
Caso você queira, basta pedir o DVD pelo site que eles o enviarão sem custo
algum. O tempo necessário para recebê-lo depende de sua localização.
ATENÇÃO: No momento em que este livro está sendo escrito, ainda não existe
disponível uma versão traduzida em nosso idioma.
OBTENDO E INSTALANDO O NETBEANS IDE 6 ¦ 5
OS PACOTES
Ao clicar no botão Download NetBeans IDE 6.0, você será levado à área de do-
wnload, contendo os diversos pacotes que a IDE atualmente oferece.
Se você for desenvolver para a Web, como é o caso, selecione a opção Web &
Java EE para uma opção enxuta ou All para todas as soluções.
Como pretendemos trabalhar também com Ruby on Rails, a opção All é mais atra-
tiva, embora você possa instalar os pacotes separadamente após a instalação.
6 ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
Sem o assistente, você tem uma listagem dos arquivos compactados no formato
.zip, onde o maior é o All.
A INSTALAÇÃO
Este livro está baseado em um pacote independente da sua escolha, mas focado
no ambiente Web.
NO WINDOWS
A instalação do NetBeans é tranqüila, quando utilizamos assistente, como a maio-
ria dos programas existentes para este sistema operacional. Para o exemplo, a ins-
talação 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 instalação.
OBTENDO E INSTALANDO O NETBEANS IDE 6 ¦ 7
Especifique um diretório vazio dentro do qual será instalado o NetBeans IDE. Esta
instalação da IDE não alterará as configurações de outras instalações do NetBeans,
caso você as tenha. Isso ocorre porque a IDE cria automaticamente um novo dire-
tório de usuário quando é aberto. Para modificar o local da instalação, no campo
Install the NetBeans IDE to digite ou clique no botão Browse e selecione.
Caso você tenha mais de um JDK instalado em sua máquina, este aparecerá em
uma lista, no qual você deverá escolher o compatível com a IDE. No caso somente
poderá ser as versões Java SE 5 ou 6. Clique no botão Next.
ATENÇÃO: Caso mantenha como está, observe que a senha padrão é adminadmin.
10 ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
Se em sua instalação houver também o Tomcat, você pode alterar o seu local de
instalação no campo Install Apache Tomcat to.
OBTENDO E INSTALANDO O NETBEANS IDE 6 ¦ 11
Por fim, veja os itens que serão instalados e clique no botão Install.
12 ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
NO LINUX
A versão para Linux é ligeiramente diferente do Windows. O arquivo vem em
formato binário, com assistente também, o que facilita sua instalação.
Vale lembrar que a versão descrita se trata da versão mais atual no momento em
que este livro está sendo escrito.
OBTENDO E INSTALANDO O NETBEANS IDE 6 ¦ 13
shell# ./netbeans-6.0-linux.bin
A DESINSTALAÇÃO
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 pro-
gramas.
shell# ./uninstall.sh
O mesmo que ocorre com o Windows ocorrerá com o Linux. Confirme no botão
Uninstall para remover a IDE.
CAPÍTULO 2
SERVIDORES DE APLICAÇÕES
E SERVLETS
Deste capítulo em diante você será levado a compreender a IDE com relação ao
desenvolvimento de aplicações escritas para a Web. O seu fundamento criando
e utilizando Servlets, trabalhará com os servidores de aplicações Web para rodar
seus códigos desenvolvidos, monitorará sua aplicação e aprenderá como é distri-
buída para um servidor de produção.
• Desenvolvendo Servlets
CRIANDO UM PROJETO
Como o livro está focado em desenvolvimento Web, o seu primeiro projeto será
feito para construir aplicações Web. Neste caso, mais especificamente para o de-
senvolvimento de um Servlet.
Servlets e JSP, assim como JavaServer Faces são tecnologias desenvolvidas pela Sun
Microsystems para a construção de aplicações 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 botão di-
reito do mouse e selecionar a opção New Project (Ctrl+Shift+N) no menu de
contexto.
Em Project Name você digita o nome do seu projeto. No caso do livro é Des-
vComServlets.
Perceba que o seu projeto gerará um novo diretório, e este é mostrado em Project
Folder.
Na parte inferior da caixa de diálogo você tem como principais pontos o Servi-
dor, que pode ser selecionado em Server. Os servidores possuem características
próprias, embora, no geral, sejam parecidos em suas administrações, desde que
sigam rigorosamente regras impostas pela Sun Microsystems. Um exemplo de ser-
vidores que trabalhem com Java EE na versão 5 é o Sun Java System Application
Server, GlassFish, Geronimo e etc.
Caso você precise trabalhar com a versão 1.4, basta selecionar em Java EE Version
a opção J2EE 1.4.
Outra forma seria clicar no botão Add e adicionar um novo servidor (ou container)
para uma versão inferior a 5.
No caso do livro, vamos utilizar o GlassFish V2 como Server para o primeiro pro-
jeto. E com a versão de Java EE 5 selecionada em Java EE Version.
Em caso de utilizar a versão J2EE 1.4, haverá a opção Set Source Level to ..., onde
você possui o nível dos arquivos desenvolvidos no projeto. Em alguns casos (prin-
cipalmente no uso de annotations) você deve desmarcar esta opção.
A opção Set as Main Project indica qual é o projeto que será compilado toda vez
que você mandar rodar para exibir no browser.
• BARRA DE MENUS: Esta é a barra de menu global, que lhe permite fazer todas
as tarefas gerais. As opções disponíveis em cada menu também mudarão de-
pendendo do que estiver selecionado.
• SOURCE EDITOR: É exatamente o que o seu nome diz: é um painel para editar
documentos. Aqui você escreve seus códigos Java.
Nesta janela você possui diversos atalhos, com o menu de contexto, que podem
ser muito úteis, passando desde a execução de um projeto como até mesmo adi-
cionar novas bibliotecas, criar novos arquivos, alterar seus nomes e etc.
Na construção de uma aplicação Web, você possui diversos elementos. Estes ele-
mentos estão dispostos em forma de diretórios que podem ser expandidos clican-
do em seus nós. O diretório Web Pages representa o diretório principal (raiz) de
uma aplicação Web normal. Dentro deste nó você encontra o diretório WEB-INF,
que contém o arquivo obrigatório web.xml, conhecido como deployment des-
criptor.
No caso de uma aplicação criada para trabalhar com o Tomcat, por exemplo, o
padrão Jakarta entra em ação.
A Apache Jakarta fornece diretrizes de como estruturar suas aplicações 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 aplicação
utilizando a Apache Jakarta para um projeto com o container Servlet Tomcat 6:
SERVIDORES DE APLICAÇÕES E SERVLETS ¦ 23
DESENVOLVENDO SERVLETS
Como você pôde ver, o NetBeans criou na conclusão do projeto, um arquivo JSP
(JavaServer Pages).
O que você vai fazer agora é um Servlet, que receberá de um formulário vindo
deste arquivo criado na conclusão 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 não esteja aparecendo, clique em New File. O atalho para um novo
arquivo é Ctrl + N.
Na última etapa, mantenha como está. Esta etapa existe para que você possa con-
figurar o caminho do seu Servlet na chamada pela URL através de URL Pattern(s).
Se você possui alguma experiência com aplicações Web construídas em Java, sabe
que isto pode ser mudado, assim como o seu Name. Estas informações deverão
ser gravadas no deployment descriptor (Add information to deployment des-
criptor), portanto, mantenha esta opção selecionada. Clique no botão Finish para
completar o assistente.
SERVIDORES DE APLICAÇÕES E SERVLETS ¦ 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 então explicarei melhor como
tudo funciona.
No arquivo index.jsp, você irá adicionar um formulário HTML. Para fazer isso,
você possui duas formas: digitando ou utilizando a janela Palette como auxiliar.
Vou ensinar pela janela Palette para simplificar sua digitação.
Perceba que o NetBeans construiu o formulário, através das tags HTML <form />
no seu código, por entre as tags <body />.
30 ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
• 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 diálogo 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 diálogo clicando no botão OK.
FIGURA 2.17 – CAIXA DE DIÁLOGO INSERT TEXT INPUT COM O CAMPO NOME CONFIGURADO
SERVIDORES DE APLICAÇÕES E SERVLETS ¦ 31
Neste ponto, o NetBeans deve ter criado todo o código necessário do formulário
HTML para enviar seu nome ao Servlet desenvolvido.
Para compilar e rodar, você tem mais do que duas formas, na qual você pode
escolher entre:
FIGURA 2.22 – BOTÃO 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 começar a rodar a sua aplicação, note a janela Output que surgiu logo abaixo
de sua IDE, acima da barra de status. Ela contém três janelas. A primeira é a exibi-
ção da compilação da sua aplicação Java (ferramenta Ant), a segunda é o Java DB
Database Process, que exibe a inicialização do banco de dados derby, embutido
a IDE. O log do servidor de aplicações ou Container Servlet é a terceira a janela,
contendo no caso o nome GlassFish V2, juntamente com botões de controle. Ve-
remos isto com detalhes mais adiante.
FIGURA 2.24 – FORMULÁRIO DE ENVIO E O RESULTADO IMPRESSO PELO SERVLET APÓS RECEBER OS DADOS
Caso você queira adicionar um novo browser, que não esteja na lista, clique no
botão Edit. Na caixa de diálogo Web Browsers clique no botão Add. Digite em
Name o nome referente ao navegador que está adicionando, selecione em Pro-
cess o executável deste browser e coloque em Arguments o argumento necessário
para que a página da sua aplicação seja aberta quando o mesmo for chamado.
Caso haja necessidade de configurar algum Proxy, em Proxy Settings você pode
definir de três formas:
Observe que o Servlet possui a extensão .java. Portanto, Servlets são classes Java,
desenvolvidas de acordo com uma estrutura bem definida e que, quando insta-
ladas junto a um Servidor que implemente um Servidor de Aplicações ou Servlet
Container (um servidor que permita a execução de Servlets), podem tratar requi-
sições recebidas de clientes.
Se você analisar o código, que foi gerado pela IDE, notará que contém dois méto-
dos importantes: doGet( ) e doPost( ). Ambos chamam processRequest( ), onde
você alterou o código para receber os dados vindos do formulário.
Olhando atentamente a classe Servlet criada, notará que ela estende a classe ja-
vax.servlet.http.HttpServlet, uma classe abstrata que estende a javax.servlet.
GenericServlet. A criação 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 então que há dois imports de pacotes nesta classe.
• O elemento <servlet /> indica o nome do Servlet bem como sua classe.
No elemento <servlet-mapping /> você mapeia o Servlet para que seja melhor
acessível no navegador.
38 ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
Como ele possui muitos elementos, estes são separados por botões, pela IDE.
Note que temos inicialmente General, para informações gerais, como o tempo
de duração de uma sessão, Servlets, onde são mapeados os servlets da sua aplica-
ção, Pages que indica o arquivo inicial, quando em produção 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 opção de digitação na construção pelo as-
sistente o URL Pattern(s), lembra?
Pois é, também possuía um nome para o Servlet. Estes são configurações que o
deployment descriptor precisa para saber qual Servlet utilizar, mesmo porque,
colocar o caminho do pacote mais o nome do Servlet não é muito inteligente.
40 ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
O GLASSFISH E O TOMCAT
O GlassFish é um servidor de aplicações Web open source, baseado no Sun Java
System Application Server Platform Edition, sendo 100% compatível com as es-
pecificações Java EE 5 robusto, de padrão aberto, mantido pelo Projeto GlassFish,
parte da comunidade OpenJava EE.
Poderoso, este servidor contém itens que um Servlet Container como o Tomcat
não possui, incluindo suporte a EJB (Enterprise JavaBeans) e JMS (Java Message
Service).
ATENÇÃO: No momento em que este livro é escrito, não havia aplicação Web
administrativa do Tomcat 6.0.14 liberada pela Fundação Apache. Nos extras do
livro, contido no CD-ROM anexo, você encontra um capítulo inteiro ensinando
a trabalhar com a versão Admin do Tomcat 5.5.
http://localhost:8084/manager/html
Ao que surgirá uma caixa de diálogo pedindo o usuário e a senha. Após o preen-
chimento, você entrará no manager.
Com isso, você tem a seguinte compatibilidade quanto aos servidores de aplicação:
• GlassFish V1 e V2
• Tomcat 5.x e 6
• JBoss 4 e 5
Por usar o Monitor HTTP, você pode analisar pedidos HTTP feitos pelo método
GET e POST para uma futura analise. Você também pode editar estes pedidos
armazenados e também pode revê-los, em um replay.
Os pedidos são armazenados até que você encerre a IDE. Você também pode
salva-los de forma que estejam disponíveis em sessões posteriores da IDE.
CAPÍTULO 4
TRABALHANDO COM
BANCO DE DADOS
• Como utilizar o NetBeans IDE para criar e modificar tabelas e instruções SQL;
• A criação de páginas JSP com uso de JSTL para acessar dados via JDBC;
INTRODUÇÃO AO JDBC
JDBC é uma API incluída dentro da linguagem Java para o acesso a banco de
dados. Consiste em um conjunto de classes e interfaces escritas em Java que ofe-
recem uma completa API para a programação com banco de dados, por tanto é
uma solução 100% Java.
JDBC é uma especificação formada por uma coleção de interfaces e classes abs-
tratas, que devem implementar todos os fabricantes de drivers que queiram reali-
zar uma implementação de seu driver 100% Java e compatível com JDBC.
120 ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
Devido ao JDBC ser escrito completamente em Java também passa a ter a vanta-
gem de ser independente de plataforma. Sendo assim, não será necessário escre-
ver um programa para cada tipo de banco de dados, uma mesma aplicação escrita
utilizando JDBC poderá trabalhar com banco de dados como Oracle, Sybase, SQL
Server, MySQL, Firebird, PostgreSQL e etc. Para que isso aconteça, 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 atenção de quem desenvolve em Java.
O driver JDBC escolhido para fazer os exemplos neste livro foi o Connector/J, su-
portado oficialmente pela mantenedora do MySQL. Usando o driver Connector/J,
todos os tipos de aplicações Java podem acessar um banco de dados e seus dados,
desde que seja em MySQL, é claro.
http://www.mysql.com/downloads
INSTALANDO NO WINDOWS
Procure pelo formato executável. O arquivo vem compactado no formato .zip.
Descompacte e instale. A instalação, como não poderia deixar de ser, é feita por
um assistente. Siga os passos até a finalização.
TRABALHANDO COM BANCO DE DADOS ¦ 127
Na caixa de diálogo New JDBC Driver clique no botão 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. Con-
firme a caixa de diálogo clicando no botão OK.
128 ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
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 usuário que você adicionou ao criar o banco de
dados e em Password a senha.
A caixa de diálogo mudará o foco para a aba Advanced, onde no final aparecerá
uma mensagem - Connection established. Isso significa que a conexão foi esta-
belecida com sucesso. Confirme novamente no botão OK.
132 ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
Você deve ter percebido que alguns tipos de dados (em Data type) não existem
como os do MySQL. Por isso, para completar a criação da tabela, você vai colocar
os comandos a seguir, em SQL Command (menu de contexto, Execute Com-
mand):
Nesta janela podemos criar instruções SQL para seleção de dados visualmente,
o que garante uma velocidade maior no desenvolvimento de queries mais com-
plexas.
O QUE É MVC?
MVC é um conceito (paradigma) de desenvolvimento e design que tenta separar
uma aplicação em três partes distintas. Uma parte, a Model, está relacionada ao
trabalho atual que a aplicação administra, outra parte, a View, está relacionada a
exibir os dados ou informações dessa aplicação e a terceira parte, Controller, em
coordenar os dois anteriores exibindo a interface correta ou executando algum
trabalho que a aplicação precisa completar.
A arquitetura MVC foi desenvolvida para ser usada no projeto de interface visual
em Smalltalk.
A separação lógica da aplicação nestas partes assegura que a camada Modelo não
sabe nada praticamente do que é exibido; restringida por representar as partes de
componentes do problema que é resolvido pela aplicação. Igualmente, a camada
de Apresentação só está relacionada a exibir os dados e não com o implementar
lógica de negócios que é controlada pela camada Modelo. O Controlador, como
um gerenciador de tráfego, dirige as apresentações a serem exibidas e com as
devidas mudanças de dados e recuperações vindas da camada Modelo.
O MODEL 1
A primeira arquitetura, conhecida como Model 1, é muito comum no desenvol-
vimento de aplicações Web, chamada de page-centric. Esta arquitetura fornece o
modo mais fácil de reunir uma aplicação Web. Envolve simplesmente a constru-
ção de uma aplicação como um conjunto de páginas JSP.
O MODEL 2
O Model 1, é indicada para uma aplicação pequena, que contém um limitado
número de usuários e possui pouca lógica de negócios, principalmente por ser
simples e efetiva. Porém, em uma aplicação mais complexa, onde a lógica de ne-
gócios não só é mais detalhada, mas a lógica de exibição necessária também é sig-
nificantemente grande, uma arquitetura de desenvolvimento baseada no Modelo
1 fará com que seja um tanto bagunçado o montante de códigos desenvolvidos.
Quando você coloca a lógica de negócios em um modelo simples de desenvol-
vimento, uma repetição de código acaba ocorrendo (isso é muito comum no
desenvolvimento de outras linguagens de programação Web cujos conceitos de
desenvolvimento não estão fortemente agregados). Isso impossibilita uma rápida
manutenção e evidentemente, em um crescimento da aplicação, não haverá uma
possível extensão. E isso porque não estamos contando com o fator de testes.
A seguir você tem uma explicação do que acontece nesse modelo de desenvol-
vimento:
Sempre que você precisa acessar um banco de dados que está mantendo seu mo-
delo de objetos, é melhor empregar o padrão DAO. O Padrão DAO fornece uma
interface independente, no qual você pode usar para persistir objetos de dados.
A idéia é colocar todas as funcionalidades encontradas no desenvolvimento de
acesso e trabalho com dados em um só local, tornando simples sua manutenção.
A FÁBRICA DE CONEXÃO
Você vai começar a construir a classe de conexão, no qual acessará o banco de
dados criado.
O exemplo que será feito é simples, apenas para testar a funcionalidade do DAO,
sem a intenção de obter uma biblioteca de terceiros não suportada nativamente
pelo NetBeans.
JUnit, para quem não conhece, é um framework open source, criado para fazer
testes automatizados, chamados de test cases.
Este framework foi idealizado por Erich Gamma, um dos autores dos populares
padrões de projeto e Kent Beck, pai do XP (Extreme Programming). Para desen-
volvê-lo, usaram o conceito de testes unitários (unit tests) em Java criando uma
ferramenta chamada JUnit, baseada em SUnit, do SmallTalk.
FIGURA 4.30 - SELEÇÃO DA OPÇÃO CREATE JUNIT TESTS NO MENU PRINCIPAL TOOLS
Como o projeto possui duas versões do JUnit, haverá uma pergunta ao criar o
teste unitário, para escolha da versão desejada. Para o exemplo, você vai escolher
o JUnit 4.x
ATRIBUTOS DESCRIÇÃO
type Pode ser time, date ou both. Usado para imprimir somente a hora, data ou ambos.
dateStyle Pode ser usado short, medium, long ou full (ou default). Usado para imprimir a data.
timeStyle Pode ser short, medium, long ou full (ou default). Usado para imprimir a hora.
value Um valor do tipo java.util.Date usado para renderizar à data e à hora.
Para excluir um autor, o Servlet novamente deve ser chamado, enviando dois
comandos: exc e o ID do autor que deseja remover do banco de dados. Para
executar essa ação, a query string cmd=exc&id=ID do autor é transmitida para
o Servlet para que esse execute o determinado.
Outro detalhe é que novamente JSTL é usado aqui para simplificar a formatação
da data de nascimento do autor.
POOL DE CONEXÕES
Quando uma aplicação Web acessa um banco de dados remoto, esse acesso pode
ser feito por uma conexão JDBC, como visto anteriormente. Tipicamente, uma
conexão de JDBC física é estabelecida entre a aplicação cliente e o servidor de
banco de dados por uma conexão TCP/IP.
Quando uma aplicação requerer uma conexão, uma destas conexões físicas é for-
necida a esta aplicação. Em um sistema comum, sem o pool de conexão, quando
a aplicação termina de usar a conexão, este a desconecta, como feito anterior-
mente usando o método close( ). Porém, no caso de uma conexão física, essa é
devolvida somente para o pool de conexões, onde espera o próximo pedido da
aplicação para um novo acesso ao banco de dados.
JAVA EE5:
AVANÇANDO NO
DESENVOLVIMENTO DE
APLICAÇÕES WEB
CAPÍTULO 5
JAVASERVER FACES
O JavaServer Faces utiliza o paradigma MVC para trabalhar com sua apresentação
e navegação de dados. Sua utilização é recomendada pela Sun Microsystems para
o desenvolvimento Web com Java na atualidade.
Inicie a criação de um projeto Web. Digite o nome do seu projeto. Se quiser se-
guir o livro, chame-o de PrimProjJSF. Escolha seu servidor e clique no botão Next
para prosseguir.
Em Servlet URL Mapping você tem por padrão a configuração /faces/*, indican-
do que o acesso às aplicações escritas em JSF serão antecipadas da palavra faces/,
o que teríamos, 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 aplicações
escritas em JavaServer Faces, as páginas conterão a extensão .faces, como o link
de exemplo mostrado a seguir:
http://localhost:8080/PrimProjJSF/pagina.faces
1. commons-beanutils.jar
2. commons-collections.jar
3. commons-digester.jar
4. commons-logging.jar,
1. jsf-api.jar
2. jsf-impl.jar
1. jstl.jar
2. standard.jar
200 ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
O primeiro exemplo terá apenas um campo para o envio de nomes. Este exemplo
contará com uma validação, para o caso do usuário entrar com um valor inválido,
não alfabético, retornando um erro.
Caso retorne o erro, além de manter preenchido o campo digitado, também mos-
trará uma mensagem, solicitando a alteração.
CRIANDO O JAVABEAN
O JavaBean mostrado a seguir será o responsável pela comunicação entre a página
inicial, que o usuário digitará o nome, em um formulário, e a página que resultará
na mensagem de boas vindas, caso esta seja submetida com sucesso.
<body>
<f:view>
Olá <h:outputText value=”#{NomeBean.nome}”/><br />
</f:view>
</body>
</html>
A saída do nome, como resultado positivo, vindo do Bean, é feito pela tag <h:
outputText />.
A página forwardToJSF.jsp poderá ser alterada a seu gosto, embora ela esteja
pronta com um redirecionamento para welcomeJSF.jsp. Rode a aplicação e tente
enviar um texto contendo um caractere numérico. Em seguida, corrija e envie os
dados corretamente, conforme as regras estabelecidas no Bean.
Além disso, o código de acesso ao banco de dados não será necessário refazer,
uma vez que ele será o DAO criado no Capítulo 4 deste livro.
</f:view>
</body>
...
O último link criado pela tag <h:commandLink/> está fora do dataTable, por não
interagir diretamente sobre a mesma, chamando o método novoAutor( ) para
criar um novo cadastro de Autores.
Assim que pego a linha em questão, escolhida na hora do clique sobre o link, o
método editar( ) se responsabiliza de preencher o JavaBean Autor com os valores
captados e envia a String editar para que a navegação entre as páginas ocorram.
CONFIGURANDO A NAVEGAÇÃO
A maior dificuldade neste exemplo será na criação da navegação do aplicativo.
Não que esta complicação seja por causa do que foi feito, mas sim por poder
causar confusão, na construção da navegabilidade das páginas. No arquivo fa-
ces-config.xml o resultado final da navegação necessária da aplicação será como
mostrada a Figura 5.15 a seguir.
236 ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
A seguir você tem a Listagem 5.12 de como deverá ficar sua navegação no for-
mato XML.
Com adição de CSS, você pode ter uma página similar ao da Figura 5.24 a se-
guir:
<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>
…
• Gerando EJB 3;
• A linguagem JPQL;
Na caixa de diálogo Call Enterprise Bean, selecione seu EJB. Confirme a caixa de
diálogo.
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
primária é a Java Persistence Query Language (JPQL). Esta é uma linguagem
de consultas independente de banco de dados e opera no modelo de entidades
lógicas, ao contrário do modelo de dados físico. As consultas também podem ser
expressas em SQL. No caso dos códigos gerados pelos assistentes do NetBeans, a
query criada está na linguagem JPQL.
Perceba que é similar ao SQL que conhecemos. A JPQL usa uma sintaxe similar
à SQL, onde é possível dar ao desenvolvedor experiente com instruções SQL a
vantagem de escrever as queries. A diferença fundamental entre SQL e JPQL está
na seleção de uma tabela, onde a entidade do modelo da aplicação é especificada
ao invés da tabela propriamente dita.
@PersistenceUnit(unitName = “livraria”)
private EntityManagerFactory emf;
Na segunda etapa do assistente, você deve desmarcar a opção Set Source Level to
1.4. Os demais itens serão similares ao já feito até o momento na criação de um
projeto utilizando JavaServer Faces.
Um container servlet como o Tomcat 5.5, por exemplo, também não implementa
a versão Java EE 5 e, portanto, precisa da biblioteca do TopLink Essentials (toplink-
essentials.jar e toplink-essentials-agent.jar).
ATENÇÃO: Caso precise saber como usar JNDI no Tomcat 5.5 com o arquivo per-
sistence.xml, no CD-ROM, pegue o capítulo extra que trata do assunto sobre
esta versão do container Servlet.
CAPÍTULO 7
O VISUAL WEB JAVASERVER
FACES
O Visual Web JavaServer Faces é um editor visual, no estilo WYSIWYG (What You
See Is What You Get), baseado no Java Studio Creator IDE, da Sun Microsystems,
criado para desenvolver páginas JavaServer Faces, como já diz seu nome. Isso sig-
nifica que seu desenvolvimento é baseado em componentes arrastáveis que, com
pouco código, o desenvolvedor pode criar páginas totalmente funcionais. Este
capítulo foi escrito em forma de estudo de caso, desenvolvendo uma aplicação Ja-
vaServer Faces envolvendo o uso de diversos componentes e suas configurações,
focando na etapa visual sem acesso a banco de dados.
• Formulários virtuais;
Na segunda etapa, defina um nome para o seu projeto, em Project Name. Caso
queira fazer com um nome idêntico ao usado no livro, coloque DesComVisu-
alWebApplication. Selecione o GlassFish como servidor e clique no botão Next
para prosseguir.
FIGURA 7.20 – VIRTUAL FORM DOS COMPONENTES QUE ENVOLVEM A SUBMISSÃO DO FORMULÁRIO
Selecione o botão Limpar e crie um formulário virtual também para ele. Chame
de limparForm. Em Submit altere para Yes e confirme.
FIGURA 7.21 – FORMULÁRIOS VIRTUAIS SENDO EXIBIDOS ATRAVÉS DE SHOW VIRTUAL FORMS
CAPÍTULO 8
DESENVOLVENDO COM VISUAL
WEB JSF USANDO BANCO
DE DADOS
Integrar um banco de dados com uma página desenvolvida usando Visual Web
JavaServer Faces é a tarefa mais comum para o desenvolvimento de uma aplica-
ção Web.
Com o direito do mouse sobre o componente Table da sua página, selecione Ta-
ble Layout no menu de contexto e configure como a tabela da página Livros.jsp.
Desde que a palavra Web Service foi pronunciada pela primeira vez ao mundo,
todas as linguagens de programação voltadas para a construção de aplicações
Web começaram a correr em busca de trabalhar com esta forma de serviço.
Neste Capítulo será criado e consumido Web Services através do NetBeans IDE,
onde será visto:
WEB SERVICES
Para que você entenda um Web Service, vamos ilustrar uma situação: imagine
que você esteja criando um site de comércio eletrônico e que deseja implementar
um programa de afiliados. Este afiliado como recompensa receberá uma peque-
na porcentagem da venda ocorrida através de seu vínculo em um produto ou
serviço. Muitos sites de comércio eletrônicos fazem isso, criando uma forma de
vincular seus produtos e serviços a outros sites.
TRABALHANDO COM WEB SERVICES NO NETBEANS IDE ¦ 375
Observe que uma classe chamada MeuPrimeiroWS foi criada. Na janela Pro-
jects, um diretório novo, chamado de Web Services surgiu, abrindo também um
editor visual. Clique no botão Add Operation.
FIGURA 9.14 – CONSUMINDO O WEB SERVICE CRIADO POR UMA PÁGINA JSP
Será bem provável que o Visual Web JavaServer Faces preencha no Design os
dados oriundos do Web Service, como mostra a Figura 9.23.
400 ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
ATENÇÃO: Não esqueça de ter o servidor rodando para que o Web Service se
mantenha funcional.
CAPÍTULO 10
VISUAL WEB JSF COM JPA,
SPRING E HIBERNATE
Usar a Java Persistence API (JPA) com Visual Web JSF, no NetBeans IDE, é um ca-
minho alternativo ao acesso padrão usando JDBC. O Visual Web JSF possui, além
de uma ferramenta visual para desenvolvimento de páginas JSF poderosa, uma
grande flexibilidade, ao qual o desenvolvedor pode adicionar outros frameworks,
como o Spring e o Hibernate para trabalhar em conjunto.
Neste capítulo será apresentado como criar um CRUD usando Visual Web Java-
Server Faces, através do uso da JPA, com Hibernate e Spring 2.5.
• A configurar o Spring para trabalhar com JPA e com o Visual Web JSF;
O HIBERNATE
Hibernate é um projeto audacioso que procura ter uma completa solução 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 lógica do negócio. Sua
simplicidade em configuração, dá ao desenvolvedor algumas regras para que se-
jam seguidas como padrões de desenvolvimento ao escrever sua lógica de negó-
cios 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 aplicação.
VISUAL WEB JSF COM JPA, SPRING E HIBERNATE ¦ 437
DESENVOLVIMENTO
COM LINGUAGENS
DINÂMICAS E AJAX
CAPÍTULO 11
RAILS 2 COM NETBEANS IDE
O NetBeans IDE vem se firmando cada vez mais como uma plataforma de de-
senvolvimento, possibilitando o uso não somente da linguagem Java e sua gama
de frameworks, como também com outras linguagens e seus respectivos fra-
meworks.
Uma das linguagens que foram incorporadas a IDE na versão 6.0 é o Ruby, que
também 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 capítulo, o leitor será introduzido no trabalho com Ruby on Rails na versão
2.0.2, usando o NetBeans IDE, ao qual será apresentado:
• A utilizar o Scaffold;
ruby - -version
Para utilizar o Ruby instalado, caso queira, vá ao menu Tools e clique em Op-
tions.
CRIANDO O PROJETO
Comece por criar um novo projeto na IDE. Selecione Ruby on Rails Application
da categoria Ruby e clique no botão Next.
4
Rake: Comando que realiza tarefas descritas em um arquivo chamado Rakefile
446 ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
Na terceira etapa, dê um Update em Rails, caso esteja usando uma versão antiga.
A caixa de diálogo Gem(s) Update surgirá, neste caso, para fazer a atualização.
Se tudo estiver correto, clique no botão Finish para confirmar.
Observe que o servidor roda na porta 3000. Para acessar a parte da aplicação
gerada, digite o endereço seguinte em seu navegador:
http://localhost:3000/livros
Rails criou o CRUD, sendo que na primeira página você possui uma tabela listan-
do os dados existentes na tabela livros.
A declaração belongs_to diz a Rails que a tabela autores é filha de livros. Isso
significa que não deve haver um autor sem que antes haja um livro existente
associado.
Em Active Record, o objeto parente, o que contém uma coleção de objetos filhos,
usa has_many para declarar sua relação à tabela filho e por sua vez, a tabela filho
usa belongs_to para indicar seu pai.
6
Imagem inspirada no livro Agile Web Development with Rails – second edition – The Pragmatic Bookshelf
CAPÍTULO 12
JRUBY ON RAILS
A máquina virtual Java, Java Virtual Machine (JVM), também possui sua versão da
linguagem Ruby, chamada de JRuby. O NetBeans suporta o trabalho com JRuby
como em Ruby, incluindo também em sua instalação uma versão de JRuby para
desenvolvimento.
Neste capítulo, o leitor aprendera a trabalhar com JRuby em conjunto com Rails
2.0.2, usando o NetBeans IDE 6.x, ao qual será apresentado:
O QUE É JRUBY?
JRuby é a versão Java da linguagem Ruby criada originalmente por Jan Arne Peter-
sen em 2001. Atualmente possui quatro como principais desenvolvedores: Char-
les Nutter, Thomas Enebo, Ola Bini e Nick Sieger. Percebendo a popularidade do
Ruby, devido em grande parte ao impacto do framework Rails, a Sun Microsyste-
ms contratou Thomas Enebo e Charles Nutter para trabalhar com JRuby em tempo
integral, mantendo-o compatível com a versão C do Ruby e conseqüentemente
acompanhando a evolução do Rails em seu uso.
478 ¦ DESENVOLVENDO APLICAÇÕES WEB COM NETBEANS IDE 6
Para instalar um novo Gem, vá a guia New Gems e selecione o que deseja adicio-
nar. Clique no botão Install. A caixa de diálogo Gem Installation Settings surgirá
definindo o nome (Name) e versão (Version). Sempre que estiver usando uma
última versão, por exemplo do Rails, deixe em Version o item Latest selecionado.
Mas se este não for o caso, selecione a versão ao qual deseja usar. Ao confirmar
o item que será instalado, a caixa de diálogo Gem Installation surge mostrando
o status do console enquanto o Gem é baixado e instalado. Ao terminar, o botão
Close é habilitado, para que seja fechada e confirmada a instalação.
JRUBY ON RAILS ¦ 489
O NetBeans possui bons módulos de desenvolvimento AJAX que podem ser in-
corporados à ferramenta, tornando mais rápido e prático seu desenvolvimento.
Além disso, também há empresas que estão investindo no Visual Web JavaServer
Faces, como ICEfaces que possui componentes integrados.
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 inglês e pode ser lido no endereço http://
www.adaptivepath.com/publications/essays/archives/000385.php.
TRABALHANDO COM AJAX NO NETBEANS IDE ¦ 495
https://ajax.dev.java.net/
<a:widget name=”dojo.etable”
service=”LivrosFacade” />
Na janela Projects, expandindo os nós de Web Pages > resources > dojo > eta-
ble, você encontra o arquivo JavaScript component.js, onde reside os métodos
que manipulam este componente.
TRABALHANDO COM AJAX NO NETBEANS IDE ¦ 511
Existem outros componentes que podem ser analisado, onde em suma, trabalham
com formatos JSON e que são muito simples de se adaptar.
BAIXANDO O GWT
O projeto do Google Web Toolkit possui o pacote que é encontrado na página do
framework. Disponível para os sistemas operacionais Linux, Windows e MacOS,
você o encontra no seguinte endereço:
http://code.google.com/webtoolkit/
Neste endereço há o link Download Google Web Toolkit (GWT), que o leva ao
download do framework, que no momento em que este livro é escrito, se encon-
tra na versão 1.4.61. O arquivo vem compactado. Descompacte-o em um local
desejado.
FormPanel é uma classe que gera a tag XHTML <form/> com seus respecti-
vos atributos. O método setAction() determina o valor do atributo action da tag
<form/> e setMethod() o atributo method. Pode-se definir o método de envio
POST através da constante METHOD_POST de FormPanel ou GET através de
METHOD_GET.
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 são a submissão do
formulário, através do método onSubmit, e a conclusão da submissão, através de
onSubmitComplete.
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.
É necessário fazer login para baixá-lo. Para o NetBeans IDE, existem as ferramen-
tas de integração:
Ao descompactar estes arquivos, perceba que há por entre eles um arquivo com
extensão .nbm.
APÊNDICE A
RUBY PARA DESENVOLVEDORES
JAVA
Embora a linguagem Ruby não seja nova, somente há pouco tempo os holofotes
do desenvolvimento Web se voltaram para esta linguagem devido ao reconhe-
cimento de seu framework, chamado de Rails. Além da espantosa velocidade
com que uma aplicação pode ser feita com a dupla, Ruby on Rails, Ruby é uma
linguagem orientada a objetos, possuidora de uma sintaxe amigável 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 Apêndice você conhecerá o básico sobre a linguagem Ruby, focada nos
exemplos com relação 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 adoção por muitos desenvolvedores desta linguagem. Entre seus
principais recursos temos:
• Tratamento de Exceções;
• É uma linguagem orientada a objetos (não 100%), mas melhor que Java e
similar a mãe das linguagens orientadas a objetos SmallTalk. Isso significa que
um número é a extensão de uma classe;
• Não precisa ser compilada após uma alteração. Você a modifica e executa.