3775815-Dominando-JavaServer-Faces-e-Facelets-utilizando-Spring-2-5-Hibernate-e-JPA

Prévia do material em texto

EDSON GONÇALVES
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
http://www.integrator.com.br
http://www.integrator.com.br
AGRADECIMENTOS
Primeiramente quero agradecer à minha família, pelo apoio e compreensão da 
minha ausência, que de certa forma tornou-se uma rotina.
Agradeço o apoio da Editora Ciência Moderna, em especial ao editor Paulo André 
P. Marques, pelo incentivo e crédito em mais este livro.
Um agradecimento especial a todos aqueles que me ajudaram na conclusão desta 
obra, opinando, lendo e criticando certos pontos para uma melhor elaboração 
dos textos. Embora não pareça, demoraria mais que os sete meses necessários a 
sua conclusão.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
INTRODUÇÃO
Trabalhar em aplicações Web utilizando tecnologia Java não é uma tarefa fácil. 
Entretanto, ao redor do mundo, muitos desenvolvedores já criaram diversas bi-
bliotecas que auxiliam nessa tarefa, gerando o que chamamos de frameworks.
No geral, um framework é um conjunto de bibliotecas com práticas gerais encap-
suladas que, juntas, criam uma forma mais simples de desenvolver alguma tarefa. 
Dentre os diversos frameworks existentes para a criação de aplicações Web, te-
mos o JavaServer Faces. 
JavaServer Faces é o framework oficial da especificação Java EE e é desenhado 
para o desenvolvimento de aplicações Web baseado em componentes (compo-
nent based). Na prática, desenvolver com esse framework torna fácil o trabalho 
na construção de aplicações através de componentes de interface com o usuário 
(GUI), e sua capacidade de conectar esses componentes a objetos de negócios é 
relativamente fácil.
Este livro, embora pequeno, foi elaborado pensando no desenvolvedor iniciante 
em JavaServer Faces, que deseja aprender a integrar suas aplicações com tecnolo-
gias conhecidas, como o Spring Framework, Hibernate e JPA, usando um exemplo 
completo, embora pequeno, de um site fictício de comércio eletrônico.
QUEM DEVE LER ESTE LIVRO?
Este livro foi escrito para desenvolvedores com experiência em desenvolvimento 
Web utilizando a linguagem Java, mas que não possuem muito conhecimento 
sobre o framework JavaServer Faces. 
Além disso, embora sejam apresentados os conceitos fundamentais sobre as fer-
ramentas de desenvolvimento aplicadas no decorrer do livro, é muito importante 
que o usuário já tenha tido um contato inicial com as mesmas. 
É desejável também um conhecimento sobre o acesso e utilização de um banco 
de dados. 
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
VI � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA6
ANTES DE COMEÇAR
Em algumas partes deste 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 código, mas que não está sendo exibido 
por não ter sido alterado ou por ser importações, e o mesmo pode ser acessado 
pelo CD-ROM, anexo ao livro.
OS SOFTWARES REQUERIDOS
Os aplicativos criados neste livro não exigem software proprietário. Portanto, ao 
longo dos capítulos, você não só aprenderá como usá-los, mas também onde en-
contrá-los na Internet, caso precise de uma atualização.
Esse livro não está focado especialmente em um sistema operacional, já que a 
linguagem Java é multiplataforma.
HARDWARE REQUERIDO
Uma boa configuração de hardware se faz necessária para trabalhar com aplica-
ções escritas em Java. Um computador para rodar bem o Eclipse IDE ou NetBeans 
IDE deve ter as seguintes configurações para uma confortável utilização, segundo 
o autor:
Processador: Pentium 4 ou similar (recomendo um Dual Core ou Core 2 
Duo)
Memória: 1 GB de RAM mínimo (recomendo 2GB de RAM)
HD: 10GB de espaço livre
Monitor: 17 polegadas ou superior
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
INTRODUÇÃO � VII
CÓDIGOS DOS EXEMPLOS CRIADOS NO LIVRO
Todos os códigos dos exemplos criados no livro, bem como as IDEs 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.
VISÃO GERAL DOS CAPÍTULOS
Com um conteúdo completamente ilustrado, o livro possui diversas imagens es-
palhadas por todos os capítulos, sempre focando em detalhes quando necessário. 
Ao longo do livro, são dadas dicas para uma melhor compreensão do que está 
sendo feito, sempre com informações técnicas. 
Para uma melhor compreensão, aqui você tem uma sinopse dos capítulos encon-
trados no decorrer do livro.
PARTE 1 – AMBIENTES DE TRABALHO, JAVASERVER FACES E FACELETS
Composta por três capítulos, essa parte introduz o iniciante nos ambientes de 
trabalho envolvidos no decorrer do livro. Além de possuir informações de teor 
prático e técnico para o início com o desenvolvimento com JavaServer Faces e 
Facelets, será mostrado onde encontrar e como instalar e configurar o Eclipse IDE 
ou NetBeans IDE, incluindo plug-ins.
PARTE 2 – DESENVOLVENDO O SITE E-COMMERCE
Composta por oito capítulos, essa parte trabalha do início ao fim com o desenvol-
vimento da aplicação foco do livro. Em seu longo, diversos tópicos serão aborda-
dos, entre eles:
• A configuração da JPA em conjunto com o Hibernate;
• Como mapear as entidades que serão utilizadas;
• A integração com o Spring Framework e suas anotações;
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
http://www.integrator.com.br
VIII � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA6
• Geração de DAOs genéricos para minimizar a quantidade de códigos no 
desenvolvimento;
• Criação de testes unitários com JUnit em conjunto com o Spring Framework 
e anotações;
• Segurança na aplicação com Filtros Servlet e JSF PhaseListener;
• A utilização de plug-ins Eclipse como JBoss Tools, Hibernate Tools, Projeto 
Dali JPA Tools e Spring IDE;
• O trabalho com Hibernate e Spring Framework através do NetBeans IDE;
• O envio de e-mails utilizando os recursos do Spring Framework;
• O desenvolvimento de um relatório JasperReports com iReport utilizando 
objetos;
 
ATENÇÃO: Em caso de erro, recomendo a visualização dos exemplos contidos 
no CD-ROM anexo ao livro, antes de entrar em contato com o autor.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
SUMÁRIO
PARTE 1 - AMBIENTES DE TRABALHO, JAVASERVER FACES E FACELETS ...............................................1
 
 Capítulo 1 - Preparando seu ambiente de trabalho ...................................................3
 O Eclipse IDE .....................................................................................................3
 Obtendo e instalando o Eclipse IDE .............................................................4
 O plug-in JBoss Tools ....................................................................................4
 Iniciando na plataforma Eclipse ....................................................................5
 O plug-in Spring IDE ....................................................................................6
 O NetBeans IDE .................................................................................................8
 Obtendo e instalando o NetBeans IDE .........................................................8
 Resumo ..............................................................................................................9
 Capítulo 2 - O JavaServer Faces ..............................................................................11
 Baixando o JavaServer Faces .............................................................................11
 As bibliotecas do JavaServer Faces ....................................................................12
 JavaServer Faces no NetBeans IDE ....................................................................13
 JavaServer Faces no Eclipse IDE ........................................................................15As bibliotecas JavaServer Faces no projeto do NetBeans IDE .......................18
 Adicionando o JavaServer Faces ao projeto no Eclipse IDE ..........................19
 Um primeiro contato com JavaServer Faces ......................................................23
 Alterando os projetos das ferramentas .........................................................27
 Distribuindo sua aplicação em um arquivo WAR ..............................................39
 Como subir sua aplicação no servidor .........................................................39
 Conhecendo melhor o JavaServer Faces ...........................................................40
 As tags padrões de JavaServer Faces ..................................................................42
 JSF Tags HTML ...........................................................................................43
 JSF Tags Core .............................................................................................46
 Ciclo de Vida do JSF .........................................................................................48
 Resumo ............................................................................................................51
 Capítulo 3 - Facelets ...............................................................................................53
 Como o Facelets trabalha? ................................................................................53
 Onde baixar o Facelets .....................................................................................54
 Desenvolvendo com Facelets ...........................................................................55
 O plug-in com suporte a Facelets no NetBeans IDE ....................................55
 Criando um projeto simples com Facelets ...................................................55
 A API do Facelets ........................................................................................71
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
X � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA6
 Segurança no acesso aos arquivos .xhtml ....................................................72
 Resumo ............................................................................................................75
PARTE 2 - DESENVOLVENDO O SITE E-COMMERCE ....................................................................77
 
 Capítulo 4 - JPA com Hibernate .............................................................................79
 O modelo de dados .........................................................................................79
 MySQL e o JDBC ........................................................................................80
 O comando CREATE ...................................................................................84
 O comando USE .......................................................................................85
 Criando tabelas ..........................................................................................85
 O comando SHOW ....................................................................................86
 Configurando usuários ................................................................................86
 Confirmando o novo usuário ......................................................................87
 No CD-ROM ..............................................................................................87
 Baixando o driver JDBC ..............................................................................88
 O Hibernate .....................................................................................................88
 Baixando o Hibernate .................................................................................88
 O Hibernate no CD-ROM ..........................................................................89
 Modelando a aplicação ....................................................................................89
 Criando o projeto .......................................................................................89
 Adicionando as bibliotecas do Hibernate ao projeto ...................................90
 Adicionando a biblioteca JDBC ao projeto do Eclipse IDE ...........................92
 Criando as entidades persistentes ...............................................................93
 O conceito da API de persistência ............................................................101
 Java Annotations, o que é isso? .................................................................102
 A API de persistência ................................................................................103
 Entendendo os arquivos criados ................................................................104
 O relacionamento ....................................................................................105
 O arquivo persistence.xml ........................................................................108
 Modelando a aplicação com ferramentas automatizadas ................................114
 Criando entidades com Hibernate Tools .........................................................114
 Criando entidades com Dali JPA Tools ............................................................121
 Criando entidades com o NetBeans IDE .........................................................127
 Os detalhes ....................................................................................................130
 Resumo ..........................................................................................................130
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
SUMÁRIO � XI
 Capítulo 5 - O Spring com a JPA e Testes unitários ................................................131
 O Spring ........................................................................................................132
 Onde baixar a última versão .....................................................................132
 Adicionando o suporte ao Spring Framework em seu projeto ....................133
 Criando o DAO genérico ................................................................................135
 O Spring atuando no DAO .......................................................................141
 A simplicidade para estender a outros DAOs ...........................................144
 Configurando o Spring através de applicationContext.xml .........................145
 Criando testes unitários ............................................................................151
 O Log4j ....................................................................................................161
 Pronto para a próxima etapa ..........................................................................165
 Resumo ..........................................................................................................165
 Capítulo 6 - A área administrativa – Parte 1 ..........................................................167
 Criando o projeto Web ..................................................................................167
 Adicionando a biblioteca do Apache Trinidad ...........................................168
 Adicionando as bibliotecas para upload de arquivos .................................169
 Adicionando as bibliotecas e o projeto com os DAOs ...............................170
 Configurando o Apache MyFaces Trinidad no projeto ...............................172
 Configurando o Spring Framework ............................................................177
 A classe bean de controle de categorias ....................................................182
 A classe bean de produtos ........................................................................187
 Criando a página modelo daárea administrativa .......................................198
 Criando as páginas para as Categorias .......................................................202
 Criando as páginas para os Produtos .........................................................207
 Resumo ..........................................................................................................214
 Capítulo 7 - As páginas do lado cliente .................................................................215
 Criando o bean de controle da loja ................................................................215
 Adicionando a classe no Managed Bean ...................................................221
 O template das páginas ............................................................................221
 A página principal do site .........................................................................229
 O que é EL? ..............................................................................................234
 A página detalhes do produto ...................................................................237
 A página de resultados da pesquisa ...........................................................240
 A página de produtos da categoria ............................................................243
 Resumo ..........................................................................................................246
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
XII � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA6
 Capítulo 8 - O carrinho de compras .....................................................................247
 Os beans para o carrinho ...............................................................................248
 Controlando o carrinho ............................................................................253
 A página do carrinho ................................................................................258
 Configurando o Managed Bean e a navegação ..........................................264
 Resumo ..........................................................................................................266
 Capítulo 9 - Finalizando a compra ........................................................................267
 Controlando a entrada do usuário ..................................................................267
 Configurando a classe ..............................................................................278
 Criando as páginas ...................................................................................278
 Criando a navegação ...............................................................................291
 Criando o Filtro ........................................................................................292
 Registrando o Filtro no Deployment Descriptor .........................................294
 Criando o Filtro pelo NetBeans .................................................................295
 Validando a entrada de dados ..................................................................295
 Validando a entrada do número do cartão ................................................295
 Configurando o validador .........................................................................298
 Aplicando o validador ...............................................................................299
 Validando pelo Bean ................................................................................300
 Resumo ..........................................................................................................302
 Capítulo 10 - Enviando e-mail pelo site ................................................................303
 Configurando o projeto para envio de e-mail ............................................303
 Criando o bean para enviar o e-mail de contato .......................................305
 Configurando o bean ContatoController ...................................................309
 Criando o contato no site .........................................................................310
 A navegação das páginas do contato .........................................................313
 Criando um e-mail de confirmação ao pedido efetuado ...........................314
 Resumo ..........................................................................................................316
 Capítulo 11 - A área administrativa – Parte 2 ........................................................317
 Criando a consulta ....................................................................................317
 A página que trabalhará com a consulta ....................................................320
 Paginação de resultados ............................................................................324
 Paginando os resultados ............................................................................329
 Criando a navegação para a página ..........................................................333
 Adicionando um relatório ...............................................................................334
 O iReport .................................................................................................335
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
SUMÁRIO � XIII
 Criando o relatório ...................................................................................336
 Chamando o relatório através da aplicação ...............................................347
 As bibliotecas do JasperReports .................................................................353
 Trabalhando com PhaseListener para o login administrativo ......................354
 Resumo ..........................................................................................................366
 Bibliografia ...........................................................................................................367
 Livros Nacionais .............................................................................................367
 Livros Internacionais .......................................................................................367
 Sites..... ..........................................................................................................368
 Acesso para pesquisa ......................................................................................368
 Tutoriais .........................................................................................................368
 Apêndice A: Pool de Conexões .............................................................CD-ROM
 Apêndice B: O MySQL ..........................................................................CD-ROM
 Apêndice C: Suporte a Facelets no NetBeans ........................................CD-ROM
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
PARTE 1
AMBIENTES DE TRABALHO, 
JAVASERVER FACES E 
FACELETS
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
O trabalho com desenvolvimento Web em Java é penoso sem um bom ambiente 
de desenvolvimento. Entretanto, há duas ferramentas muito conhecidas no desen-
volvimento Java que serão abordadas para a utilização ao longo do livro: Eclipse 
IDE com plug-ins e NetBeans IDE. Este capítulo está baseado na instalação e con-
figuração de ambos os ambientes. 
O ECLIPSE IDE
O Eclipse IDE, chamado por muitos de Plataforma Eclipse, é considerada por uma 
grande maioria de desenvolvedores Java como a melhor ferramenta para desen-
volvimento dessa linguagem. 
Desenvolvido inicialmente pela IBM e liberado o código fonte para a comuni-
dade, criando a fundação Eclipse (Eclipse Foundation), sua grande vantagem, na 
atualidade, está no uso de seus assistentes de código e grande gama de plug-ins, 
podendose adaptar a qualquer situação de desenvolvimento. 
Até o momento em que esse livro está sendo escrito, a versão atual e estável do 
Eclipse é a 3.3.
PREPARANDO SEU AMBIENTE 
DE TRABALHO
CAPÍTULO 1
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
8 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
O NETBEANS IDE
O NetBeans IDE é uma ferramenta criada em Java Swing e com várias opções em 
pacotes para que você baixe a versão que melhor se encaixa em seu trabalho; 
cada uma contém módulos de instalação diferentes para cada necessidade do 
desenvolvedor. 
OBTENDO E INSTALANDO O NETBEANS IDE 
O site oficial do NetBeans IDE se encontra no endereço http://www.netbeans.
org. Assim que você entra no site oficial do NetBeans, há um grande botão escrito 
Download NetBeans IDE.
Dando um clique nesse botão, você irá até a página de downloads da IDE. En-
quanto este livro é escrito, o NetBeans IDE se encontra na versão 6.0 como estável 
e 6.1 como desenvolvimento. Para o livro, será adotada a versão 6.1.
FIGURA 1.7 – DOWNLOAD DO PACOTE NECESSÁRIO PARA O DESENVOLVIMENTO COM APLICAÇÕES WEB
A instalação do NetBeans IDE é tranqüila, quando utilizamos assistente, tanto no 
sistema operacional Windows como em Linux, basta executar o arquivo baixado.
No Linux, apenas dê a permissão necessária para que seja possível a execução do 
arquivo binário:
shell# chmod +x netbeans-6.1rc1-javaee-linux.sh
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
JavaServer Faces é o framework de aplicações Web Java oficial da Sun Microsyste-
ms. Esse framework foi desenhado para simplificar o desenvolvimento de aplica-
ções Web, através do conceito baseado em componentes (component based). 
Na prática, a autilização de JavaServer Faces torna fácil o desenvolvimento através 
de componentes de interface de usuário (GUI), possibilitando a conexão desses 
componentes a objetos de negócios de forma simplificada. 
Neste capítulo, você aprenderá a criar e configurar um projeto utilizando JavaSer-
ver Faces, além de compreender o básico necessário trabalhar com o framework. 
BAIXANDO O JAVASERVER FACES
Para trabalhar com o JavaServer Faces, primeiramente será preciso configurar os 
arquivos e a estrutura necessária.
O contêiner Servlet usado para este livro será o Tomcat 6 que, por padrão, não 
possui suporte direto ao JavaServer Faces, ou seja, não contém as bibliotecas ne-
cessárias para o desenvolvimento com o mesmo. 
Para baixar o JSF, faça download no endereço http://java.sun.com/j2ee/javaser-
verfaces/download.html. Como você irá trabalhar com JavaServer Faces voltado 
para um contêiner compatível com a tecnologia Java EE 5, você deverá baixar a 
versão JSF 1.2, a utilizada nesse livro. Ao baixar o arquivo, simplesmente descom-
pacte em um diretório de sua escolha.
O JAVASERVER FACES
CAPÍTULO 2
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
O JAVASERVER FACES � 13
Para torná-los disponíveis em sua aplicação é simples: basta colocar esses arquivos 
listados no diretório lib, encontrado em WEB-INF de sua aplicação Web.
Porém, como vamos utilizar um ambiente de trabalho baseado em IDE, será mais 
fácil essa configuração.
JAVASERVER FACES NO NETBEANS IDE
O NetBeans IDE já possui configurado por padrão as bibliotecas necessárias para 
desenvolver uma aplicação JavaServer Faces.
Para criar um projeto com JavaServer Faces, vá ao menu File e clique no item New 
Project. Na caixa de diálogo New Project selecione o item Web em Categories 
e Web Application em Projects. Clique no botão Next.
Na segunda etapa você define o nome do projeto, em Project Name e a localiza-
ção, em Project Location. Digite TrabComJSF e clique no botão Next.
FIGURA 2.1 – NOME DO PROJETO E LOCAL
Na terceira etapa você seleciona o Apache Tomcat em Server. Clique no botão 
Next.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
14 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
FIGURA 2.2 – SELEÇÃO DO SERVLET CONTAINER APACHE TOMCAT 6.0.16
A última etapa é onde você escolhe o framework JavaServer Faces. Em Servlet 
URL Mapping digite *.jsf e clique no botão Finish para concluir.
FIGURA 2.3 – SELEÇÃO DO FRAMEWORK JAVASERVER FACES E CONFIGURAÇÃO INICIAL
O NetBeans IDE abrirá automaticamente uma página em JSF criada pelo assisten-
te através do template existente.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
O JAVASERVER FACES � 15
JAVASERVER FACES NO ECLIPSE IDE
O Eclipse IDE possui mais opções de criação de páginas com o framework Java-
Server Faces devido a utilização do plug-in JBoss Tools.
Vá ao menu File em New e selecione Project. Na caixa de diálogo New Project 
expanda JBoss Tools Web > JSF e selecione JSF Project. Clique no botão Next 
para prosseguir.
FIGURA 2.4 – SELEÇÃO DE JSF PROJECT DO PLUG-IN JBOSS TOOLS
Na próxima etapa digite TrabComJSF no campo Project Name, selecione JSF 1.2 
em JSF Environment e altere para o item JSFKickStartWithoutLibs em Template 
(isso fará com que o projeto possua de início algumas páginas em JSF). Clique no 
botão Next para prosseguir.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
16 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
FIGURA 2.5 – DETERMINANDO O NOME, VERSÃO E TEMPLATE DO PROJETO JSF
Na terceira etapa será necessário adicionar um servidor ao Eclipse IDE. Clique 
no botão New, em Runtime. Na caixa de diálogo New Server Runtime expanda 
Apache e selecione Apache Tomcat v6.0. Clique no botão Next para prosseguir.
FIGURA 2.6 – SELEÇÃO DO APACHE TOMCAT 6
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
O JAVASERVER FACES � 23
FIGURA 2.16 – CONFIRMAÇÃO DO JAR DE DEPENDÊNCIA DO PROJETO
UM PRIMEIRO CONTATO COM JAVASERVER FACES
Se você não tem base de conhecimento no JavaServer Faces, aqui será a sua linha 
de partida. O projeto JavaServer Faces de ambas as ferramentas, Eclipse e NetBe-
ans, já contém funcionalidades e essas podem ser testadas imediatamente. Porém, 
vamos estudá-los através de alterações específicas para que você compreenda o 
que está acontecendo.
AS PÁGINAS INICIAIS DOS PROJETOS
O JavaServer Faces não é iniciado imediatamente pelo contêiner Servlet, como 
o Tomcat, o que significa que precisamos de uma página inicial que redirecione 
para a página JSF.
É esse o papel da página index.jsp, no projeto criado pelo Eclipse IDE e forwar-
dToJSF.jsp, criada no projeto do NetBeans IDE. Essas páginas são encontradas na 
view Package e na janela Projects do Eclipse e NetBeans respectivamente.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
24 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
Em ambas as situações, você tem a tag JSP <jsp:forward /> e a página para a 
qual irá direcionar no atributo page.
Na configuração de ambas as páginas a serem redirecionadas, nos projetos das 
respectivas IDEs, a extensão .jsf será utilizada nas páginas JSF dos projetos (confi-
gurada pelo web.xml).
FIGURA 2.17 – O PROJETO JSF NO ECLIPSE IDE E NO NETBEANS IDE
O DIRETÓRIO WEB-INF
No diretório WEB-INF você encontra o arquivo web.xml (deployment descriptor) 
padrão, com a adição da configuração JSF e outro arquivo, chamado de faces-
config.xml. No NetBeans, você também pode acessar esses arquivos através do 
diretório Configuration Files.
Em ambas as ferramentas, a edição dos arquivos podem ser tanto visuais como 
pelo XML.
LISTAGEM 2.1 – O ARQUIVO WEB.XML
…
<!-- Faces Servlet -->
 <servlet>
 <servlet-name>Faces Servlet</servlet-name>
 <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
O JAVASERVER FACES � 27
FIGURA 2.19 – PÁGINA GERADA COM RESULTADO APÓS SUBMISSÃO
No NetBeans IDE,o projeto de exemplo é bem mais simples. Basta ir ao menu 
Run e clicar em Run Main Project. O resultado é uma simples página com o texto 
JavaServer Faces renderizado pelo componente que possui.
FIGURA 2.20 – RESULTADO DA PÁGINA JSF RENDERIZADA
ALTERANDO OS PROJETOS DAS FERRAMENTAS
O projeto criado inicialmente em cada uma das ferramentas, através de templa-
tes, possui o objetivo nobre de dar um “primeiro empurrão” para seu desenvol-
vimento com as mesmas. Porém, por utilizar assistentes, é evidente que você não 
aprenderá sobre o funcionamento do JSF, e nem é a idéia desses exemplos ensinar 
o framework. Portanto, para melhor compreender o JSF, você vai alterar o projeto 
gerado.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
O JAVASERVER FACES � 35
Primeiramente, você tem um elemento chamado de <managed-bean />, que 
configura o nome do bean que será acessado pelas páginas JSF e, o nome da 
classe utilizada do exemplo, chamada de Controle. Por fim, esse bean, que irá 
controlar as páginas, possui um escopo, configurado no caso como session.
No elemento <navigation-rule />, você tem um sub-elemento chamado de 
<from-view-id/>, que determina a página de partida na sua aplicação.
O elemento <navigation-case /> determina qual a página deverá ser exibida, partin-
do da configurada em <from-view-id/>. Caso receba uma mensagem, seja de suces-
so ou de falha, o elemento <from-outcome /> é acionado, verificando-se a palavra 
existente entre esse elemento. A página que será exibida é determinada através do 
elemento <to-view-id />, que indica a navegação para onde o browser irá.
FIGURA 2.25 – REPRESENTAÇÃO VISUAL DO ARQUIVO FACES-CONFIG.XML PELO ECLIPSE E NETBEANS
O FORMULÁRIO 
Para que essas regras funcionem, primeiro você tem que criar a página que sub-
meterá os dados digitados. Essa página também será responsável por mostrar um 
erro, caso ocorra, ao usuário. 
• Para criar no Eclipse IDE, com o direito do mouse sobre o projeto, selecione 
no menu de contexto o item New > JSP File. Na caixa de diálogo New File 
JSP, digite trabComJSF no campo Name e selecione o item JSFBasePage, em 
Template. Clique em Finish para completar. O Eclipse IDE, através do plug-in 
JBoss Tools, adicionará a base da página com as diretivas taglibs configuradas 
para o JSF.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
40 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
No Tomcat, você pode configurar da forma como a Listagem 2.7 mostra:
LISTAGEM 2.7 – ARQUIVO CONTEXT.XML NO TOMCAT
<?xml version=”1.0” encoding=”UTF-8”?>
<Context path=”/ProjECommerce”>
 <Resource auth=”Container” 
 driverClassName=”com.mysql.jdbc.Driver” 
 maxActive=”20” maxIdle=”10” maxWait=”-1” 
 name=”jdbc/dataSource” 
 password=”integrator” 
 type=”javax.sql.DataSource” 
 url=”jdbc:mysql://localhost:3306/ecommerce” 
 username=”edson”/>
</Context>
As configurações nele propostas são utilizadas tanto para a criação do contexto do 
projeto, através do atributo path do elemento <Context/>, como também para a 
conexão com um banco de dados, visto no elemento <Resource/>. 
ATENÇÃO: Informações adicionais de como trabalhar com pool de conexões 
são mostradas no Apêndice A contido no CD-ROM anexo ao livro.
CONHECENDO MELHOR O JAVASERVER FACES
Agora que você já fez sua primeira aplicação em JSF, é mais fácil de entender 
os serviços que o framework oferece ao desenvolvedor. Como você pôde ver, 
o framework JSF é responsável por interagir com o usuário (cliente), e fornece 
ferramentas para criar uma apresentação visual, a aplicação lógica e a lógica de 
negócios de uma aplicação Web. Porém, o escopo de JSF é restringido à camada 
de apresentação. A persistência de banco de dados e outras conexões de back-
end estão fora do escopo de JSF.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
JavaServer Faces é muito bom para desenvolver aplicações Web, porém, ainda 
assim, exige-se do desenvolvedor o conhecimento das tags JSF, o que atrapalha o 
designer de páginas em sua construção. A saída seria utilizar um sistema de tem-
plates simples que não exigisse mudanças no uso de (X)HTML e se integrasse ao 
framework sem maiores alterações.
Para esse caso, temos Facelets, um framework de templates JavaServer Faces, ba-
seado em alguns princípios simples, que transforma tags (X)HTML em páginas JSF, 
sem a necessidade de utilização total de suas tags. 
Nesse capítulo você aprenderá a trabalhar com Facelets através das IDEs, criando 
um pequeno projeto de exemplo.
COMO O FACELETS TRABALHA?
O Facelets trabalha criando uma árvore de objetos UIComponent e interliga o 
conteúdo completamente com as requisições processadas pelo ciclo de vida JSF. 
Através dessa ligação com JSF, o Facelets incorpora numerosas características ami-
gáveis ao desenvolvedor. Isso torna possível o trabalho com templates, importan-
tíssimo para uma reutilização de layouts no desenvolvimento de páginas Web e 
até o uso de HTML com injeção de atributos que se transformam em componen-
tes JSF. 
FACELETS
CAPÍTULO 3
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
54 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
Graças ao Facelets, podemos ter como vantagens sobre a construção de páginas JSF:
• Criação de uma árvore de objetos UIComponent e conteúdo entrelaçado 
completamente com o processo de ciclo de vida do JavaServer Faces;
• É mais rápido, pois não utiliza o engine do JSP para transformar em Servlets;
• Suporte a templates reutilizáveis, aumentando a produtividade na criação de 
numerosas páginas, criando uma base padrão;
• Integração com os processos Faces e com as tags (X)HTML (usa diretamente o 
XHTML como tecnologia view do JSF) como membros da árvore de componentes. 
Isso possibilita a injeção de componentes JSF com um simples atributo jsfc;
• Erros mais amigáveis e com maior precisão;
• Eliminação de tags JSF como <f:view/> e <f:subview/>.
Graças a essas integrações, as aplicações podem ser escritas para serem visualiza-
das em uma interface CSS.
NOTA: Os layouts que trabalham com CSS é um novo paradigma em torno do 
desenvolvimento de páginas Web, tornando-as mais leves e com o uso intensi-
vo de folhas de estilos (CSS), menos tabelas e seguindo as especificações W3C, 
não se prendendo a somente um browser.
ONDE BAIXAR O FACELETS
Você pode baixar o Facelets no endereço oficial https://facelets.dev.java.net/.
Na parte inferior do site, há o link downloadable from here. O arquivo necessário 
para trabalhar com Facelets é jsf-facelets.jar. Porém, dentro do arquivo compac-
tado, você possui outros arquivos no diretório lib, que também são importantes 
ao seu funcionamento.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
62 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
 </navigation-case>
 </navigation-rule>
 <navigation-rule>
 <from-view-id>/cadastrados.xhtml</from-view-id>
 <navigation-case>
 <from-outcome>cadastro</from-outcome>
 <to-view-id>/cadastro.xhtml</to-view-id>
 </navigation-case>
 </navigation-rule>
...
A página cadastrados.xhtml será exibida quando houver a string cadastrados. E 
cadastro.xhtml será exibida quando houver a string cadastro.
FIGURA 3.3 – NAVEGAÇÃO DAS PÁGINAS
O ARQUIVO WEB.XML
Para ter uma aplicação Web utilizando Facelets funcionando, é necessário tam-
bém adicionar alguns elementos no arquivo web.xml.
A principal informação adicionada no deployment descriptor para trabalhar com 
Facelets é mostrado na Listagem 3.4 a seguir:
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
FACELETS � 71
FIGURA 3.6 – RESULTADO FINAL DAS PÁGINAS FACELETS RENDERIZADAS 
A API DO FACELETS
A API do Facelets, contido no pacote com.sun.facelets, consiste de três classes 
abstratas ( Facelet, FaceletFactory eFaceletContext) e duas interfaces (Facele-
tHandler e TemplateClient). Cada uma das três classes abstratas expõem os mé-
todos de uma classe implementada padrão, contida no pacote com.sun.facelets.
impl. A DefaultFacelet é a que deriva de Facelet; DefaultFaceletFactory deriva 
de FaceletFactory e DefaultFaceletContext deriva de FaceletContext. Em con-
traste, a interface FaceletHandler é implementada por mais de trinta classes ma-
nipuladoras. Basicamente, isto ocorre porque a instância de Handler é específica 
para o componente que está manipulando. A interface TemplateClient é imple-
mentada por CompositionHandler e DecorateHandler. 
A API DO FACELETS EM AÇÃO
Para melhor compreender o Facelets, é importante saber como ocorre à interação 
com os componentes requisitados do JSF no processo de ciclo de vida.
FaceletViewHandler integra Facelets dentro do framework Faces e invoca a API 
de Facelets para construir e renderizar a árvore UIComponent. A ViewHandler 
é chamada nas duas fases do ciclo de vida de JSF: a Restaurar a Apresentação e 
Renderizar a Resposta.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
PARTE 2
DESENVOLVENDO O 
SITE E-COMMERCE
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
Por anos a persistência de dados foi um tópico problemático por entre os desen-
volvedores Java. A palavra portabilidade era algo fora de alcance, principalmente 
porque um banco de dados, em muitos casos, tem um dialeto próprio. Eis que 
surgem os ORMs que tentam fechar o buraco existente na construção de aplica-
ções que exijam portabilidade total. Dentre os mais famosos, temos o Hibernate, 
que se tornou referência no meio do desenvolvimento.
Porém, com o Java EE 5, através da especificação do EJB3, na introdução da JPA 
(Java Persistence API), ficou muito popular o uso de JP-QL, Java Persistence Query 
Language, onde o mapeamento de objeto/relacional foi padronizado na platafor-
ma Java. Com isso, o ORM Hibernate passou a ser um provedor de persistência 
que, se for necessário, pode ser substituído por outro sem que ocorram mudan-
ças na comunicação entre a aplicação e o ORM. 
Neste capítulo, você aprenderá a mapear suas entidades persistentes utilizando a 
JPA integrando com o Hibernate.
O MODELO DE DADOS
Para construir a aplicação Web e-commerce, teremos cinco simples tabelas ini-
cialmente. Do ponto de vista administrativo da aplicação, haverá uma área fecha-
da, que será gerenciada cadastrando-se categorias e produtos (armazenando os 
dados nas tabelas de mesmo nome). 
JPA COM HIBERNATE
CAPÍTULO 4
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
80 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
No site, para o público em geral, teremos os produtos sendo exibidos e suas res-
pectivas categorias, ao qual poderemos visualizar um ou vários desses produtos, 
assim como filtrá-los por sua categoria (resumidamente falando). Assim que cria-
do o carrinho de compras, no fechamento do pedido, um usuário se cadastrará 
(tabela usuários) para então, fechar o pedido (esse usuário deverá estar logado). 
O código do usuário e dados de pagamento são armazenados na tabela pedidos. 
A quantidade comprada, bem como os produtos adquiridos são armazenados na 
tabela itens_pedido. Um pedido, como já sabe, deve ter diversos produtos adqui-
ridos. Isso significa que, na prática, o carrinho de compras será todo armazenado, 
no fechamento, na tabela itens_pedido. A Figura 4.1 ilustra as tabelas e o banco 
de dados do sistema.
FIGURA 4.1 – MODELO DE DADOS
MYSQL E O JDBC
Sendo um dos sistemas de gerenciamento de bancos de dados mais usados do 
mundo, pertencente a Sun Microsystems, sua velocidade e capacidade de ser 
multiplataforma só poderiam chamar a atenção de quem desenvolve em Java.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
JPA COM HIBERNATE � 91
FIGURA 4.4 – A BIBLIOTECA DE USUÁRIO HIBERNATE CONFIGURADA NO ECLIPSE IDE
NOTA: Com a biblioteca Hibernate criada, você não precisará repetir os pas-
sos novamente para criar uma biblioteca de usuário, a menos que mude de 
Workspace.
Com o direito do mouse no projeto, selecione o item Properties no menu de 
contexto. Em Java Build Path selecione a guia Libraries. Clique no botão Add Li-
brary. Na caixa de dialogo Add Library selecione User Library e clique em Next. 
Selecione Hibernate e clique no botão OK.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
92 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
ADICIONANDO A BIBLIOTECA JDBC AO PROJETO DO ECLIPSE IDE
Repita os mesmos passos que foram necessários para criar e adicionar a biblioteca 
do Hibernate, porém adicionando nesse caso a biblioteca JDBC do MySQL.
NO NETBEANS IDE
No NetBeans IDE, vá ao menu Tools>Libraries. Na caixa de diálogo Library 
Manager clique no botão New Library. No diálogo New Library digite Hibernate 
em Library Name e confirme. Selecione, assim como no Eclipse IDE, todos os 
arquivos JARs existentes do Hibernate, no diretório de mesmo nome, encontrado 
no CD-ROM.
FIGURA 4.5 - A BIBLIOTECA HIBERNATE CONFIGURADA NO NETBEANS IDE
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
JPA COM HIBERNATE � 93
Com o direito do mouse em Libraries, no seu projeto, através da janela Projects, 
selecione o item Add Library no menu de contexto. Na caixa de diálogo Add 
Library selecione o item Hibernate e MySQL JDBC Driver (com Ctrl) e clique no 
botão Add Library. 
CRIANDO AS ENTIDADES PERSISTENTES
As classes mostradas a seguir serão criadas dentro de um pacote chamado de 
br.com.integrator.entities.
FIGURA 4.6 – AS ENTIDADES NO PROJETO MODEL DO ECLIPSE E NETBEANS
Crie uma nova classe Java e a chame conforme mostrado nas Listagens a seguir. 
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
104 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
ENTENDENDO OS ARQUIVOS CRIADOS
Cada objeto de entidade persistente possui diversas anotações. Cada anotação 
tem um significado na JPA, como você já viu em @Table, @Id e @Column, já 
citado anteriormente.
Mas existem outras anotações, que estão listadas na Tabela 4.1 a seguir:
 
TABELA 4.1 - ANOTAÇÕES MAIS COMUNS DA JPA
ANOTAÇÃO DESCRIÇÃO
@Entity A entidade. Indica que essa classe é uma entidade (entity bean), que nada mais é 
do que um POJO, representando um objeto de negócio. Sem a defi nição de um 
parâmetro adicional, é assumido que o valor padrão será o nome da classe.
@Table Mapeia o nome da tabela. Caso não seja utilizado o parâmetro name, o valor 
padrão assumido é o nome da classe.
@Id O identifi cador da entidade. Normalmente se refere à chave primária da tabela 
relacional.
@GeneratedValue Defi ne que terá seus identifi cadores automaticamente gerados. Isso é chamado 
de geração de id e é especifi cado por essa anotação.
@Column Mapeia o nome da coluna existente na tabela relacional. É importante frisar que 
o Hibernate assume os atributos da classe como os mesmos nomes dos campos 
da tabela existente no banco de dados. A utilização dessa anotação com o atributo 
name se faz necessário nesse caso, uma vez que existem campos de nomes dife-
rentes no modelo relacional com relação à classe.
@Temporal São tipos baseados em informações armazenadas relativas ao tempo. A lista de 
tipos temporais incluem três tipos java.sql e dois tipos java.util: java.sql.Date, 
java.sql.Time, java.sql.Timestamp, java.util.Date e java.util.Calendar.
O uso dessa anotação inclui um atributo chamado de TemporalType com um 
valor enumerado. Esses valores são: DATE, TIME e TIMESTAMP para repre-
sentar os tipos de java.sql.
@Lob Um termo de banco de dados comum para campos que armazenam grandes 
quantidades de dados (ou até mesmo objetos baseados em bytes), conhecidos 
como Binary Large Object - ou LOB, abreviado.Essa anotação atua com esse 
propósito, que são vistos em campos do tipo TEXT, BLOB e outros existentes 
no MySQL.
@OneToMany Defi ne uma relação de “um-para-muitos” do utilizado em banco de dados rela-
cional. Possui um atributo chamado mappedBy para defi nir o atributo da outra 
Entidade no qual é referenciado.
@ManyToOne Defi ne uma relação de “muitos-para-um” do utilizado em banco de dados rela-
cional. 
@JoinColumn São usadas para especifi car a coluna que contém a chave estrangeira de cada 
relacionamento, os conhecidos Inner Joins de um relacionamento SQL.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
JPA COM HIBERNATE � 113
FIGURA 4.9 – CONFIGURAÇÃO FINAL PARA A CRIAÇÃO DO ARQUIVO PERSISTENCE.XML NO NETBEANS IDE
A Figura 4.10 exibe o arquivo persistence.xml criado em cada uma das IDEs.
FIGURA 4.10 – O ARQUIVO PERSISTENCE.XML CRIADO NO ECLIPSE E NETBEANS
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
JPA COM HIBERNATE � 115
FIGURA 4.11 – SELEÇÃO DO HIBERNATE CONSOLE CONFIGURATION
4. Na segunda etapa, selecione JPA em Type e digite ecommerce em Persis-
tence unit. Clique na guia Classpath e adicione a biblioteca JDBC do MySQL 
através do botão Add External JARS;
5. Finalize o assistente clicando no botão Finish.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
JPA COM HIBERNATE � 121
CRIANDO ENTIDADES COM DALI JPA TOOLS
O projeto Dali JPA Tools é um dos diversos plug-ins fornecidos pela Fundação 
Eclipse, que vem já instalado na versão do Eclipse utilizada neste livro. 
Essa ferramenta possui suporte a JPA, contendo views que auxiliam no mapea-
mento entre propriedades e colunas, geração de relacionamentos, além de forne-
cer ferramentas para a geração do modelo relacional a partir das entidades.
Para criar um projeto com Dali JPA Tools no Eclipse IDE, vá ao menu File>New 
e clique em Other. Selecione na caixa de diálogo New o item JPA>JPA Project. 
Clique em Next para prosseguir. Chame o projeto de Model3 e clique no botão 
Next até a última etapa. Siga os passos a seguir para configurar corretamente o 
projeto JPA:
1. Na última etapa, clique no link Add connection.
2. Surgirá a caixa de diálogo New Connection Profile. Selecione Generic 
JDBC Connection. Caso esteja utilizando um banco de dados listado nessa 
parte, selecione-o. Clique em Next para prosseguir.
FIGURA 4.19 – CRIANDO UM NOVO PERFIL DE CONEXÃO 
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
128 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
Na coluna Available Tables aparecem as tabelas do banco de dados. Clique em 
Add All para adicionar todas as tabelas que o NetBeans consegue trabalhar. Assim 
como no Eclipse IDE, através do plug-in Dali JPA Tools, o NetBeans não consegue 
criar uma entidade a partir de uma tabela sem chave primária. Clique no botão 
Next para prosseguir. 
FIGURA 4.28 – SELEÇÃO DAS TABELAS NO BANCO DE DADOS
Na última etapa do assistente, temos a criação das entidades a partir das tabelas. 
Clique no botão Create Persistence Unit para gerar um arquivo persistence.xml. 
Na caixa de diálogo Create Persistence Unit digite ecommece em Persistence 
Unit Name e confirme no botão Create.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
O Spring Framework é uma das diversas soluções criadas pela comunidade Java, 
com o objetivo de amenizar a complexidade de que a plataforma traz para o de-
senvolvimento, principalmente no de aplicações Web. Com o intuito de combater 
os antigos EJBs, que antes da versão 3, eram complexos de se trabalhar, o Spring 
se popularizou rapidamente entre os desenvolvedores Java por ser adaptável a 
bibliotecas e padrões existentes.
Mesmo com o lançamento do EJB 3, muitas aplicações Web são pequenas, não 
exigindo um servidor de aplicações web completo, rodando em contêineres Ser-
vlet. Por sua vez, os contêineres Servlets possuem limitações impostas, como o 
trabalho com EJB, e outras situações que, através do Spring, podem ser supridas 
facilmente.
Como uma de suas características marcantes, o Spring fornece injeção de depen-
dências e uma fácil integração com outros frameworks como o Hibernate, a JPA e 
também com o JSF, possibilitando que seu código se torne mais fácil de gerir.
Neste capítulo, você utilizará o Spring com anotações para trabalhar em conjunto 
com a JPA, criando um DAO genérico para a aplicação e-commerce, trabalhando 
com injeções de dependências, e fará os testes unitários com as anotações ofere-
cidas pelo Spring. Por fim, aprenderá a configurar um arquivo Log4j para melhor 
visualizar a saída executada pelo Hibernate para depuração.
O SPRING COM A JPA 
E TESTES UNITÁRIOS
CAPÍTULO 5
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
O SPRING COM A JPA E TESTES UNITÁRIOS � 147
FIGURA 5.5 – SELEÇÃO DE UMA OPÇÃO EM CREATE A NEW SPRING BEAN DEFINITION FILE
Coloque na perspectiva Java EE através do menu Window > Open Perspective 
> Other. 
Clique com o direito do mouse sobre o projeto e selecione o item Properties. 
Na caixa de diálogo Properties for Model, selecione Spring > Beans Support e 
clique no botão Add. Selecione o arquivo applicationContext.xml do projeto e 
confirme. 
No NetBeans IDE, com o direito do mouse sobre Source Packages, selecione 
no menu de contexto o item New> Other. Na caixa de diálogo New File, vá até 
Other>Spring XML Configuration File e clique em Next. Na segunda etapa, di-
gite applicationContext (diferente do Eclipse IDE, não há necessidade de colocar 
a extensão) e clique no botão Next.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
148 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
Na última etapa do assistente, em Spring namespaces, selecione a opção tx – 
http://www.springframework.org/schema/tx-2.5.xsd e clique no botão Finish.
FIGURA 5.6 – SELEÇÃO DE UMA OPÇÃO EM SPRING NAMESPACES
No arquivo applicationContext.xml adicione as linhas mostradas a seguir, na 
Listagem 5.5.
OBSERVAÇÃO: Os editores das IDEs, para o arquivo XML de configuração do 
Spring, funcionam perfeitamente com o atalho Ctrl + Space nas definições 
das classes no bean.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
158 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
JUnit é projetado para testar seu código e é composto por métodos assertivos que 
podem testar várias condições. É possível construir testes com JUnit usando os 
seguintes métodos:
• assertEquals(a, b) - Testa se a é igual b. (a e b são valores primitivos ou tem 
que ter um método equals para propósitos de comparação).
• assertFalse(a) - Testa se a é false, onde a é um valor booleano.
• assertNotNull(a) - Testa se a é not null, onde a é um objeto qualquer ou null.
• assertNotSame(a, b) - Testa se ambos, a e b, não se referem a um objeto idêntico.
• assertNull(a) - Testa se a é null, onde a é um objeto qualquer ou null.
• assertSame(a, b) - Testa se a e b se referem a um objeto idêntico.
• assertTrue(a) - Testa se a é true, onde a é um valor booleano.
FIGURA 5.11 – RESULTADOS DO TESTE UNITÁRIO REALIZADO NO ECLIPSE IDE E NO NETBEANS IDE
OUTRAS CLASSES DE TESTES UNITÁRIOS
Você pode fazer outras classes para testes unitários. Porém, um caso importante 
para testes unitários é o de pedidos. Podemos criar um teste simulando um car-
rinho de compras com um usuário existente de modo a salvar essas informações 
nas tabelas pedidos e itens_pedido, que representam o armazenamento da com-
pra efetuada pelo cliente. 
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
A primeira parte da área administrativa do site será composta pelas páginas que 
farão o cadastro, alteração, exclusão e visualização de produtos e categorias, ao 
qual estarão disponíveis nas páginasdo site e-commerce. 
Neste capítulo você aprendará a trabalhar com os DAOs criados para cadastrar 
produtos e categorias, adicionará e configurará o Apache MyFaces Trinidad, com 
o intuito de trabalhar com upload de arquivos, além de conhecer as anotações do 
Spring 2.5 para integração com o JavaServer Faces 1.2.
CRIANDO O PROJETO WEB
O projeto Web que será criado é o que você utilizará até o final deste livro. Ele 
deve ser capacitado para trabalhar com JSF e Facelets, além de incorporar as bi-
bliotecas do Apache Trinidad. O projeto se chamará ProjEcommerce. 
No Eclipse IDE, crie um projeto JSF Project (JBoss Tools Web>JSF>JSF Project). 
Na segunda etapa, digite o nome do projeto no campo Project Name e selecione 
JSF 1.2 with Facelets em JSF Environment. Mantenha a opção FaceletsBlankWi-
thoutLibs em Template. Finalize o assistente quando terminar.
A ÁREA ADMINISTRATIVA – PARTE 1
CAPÍTULO 6
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
168 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
FIGURA 6.1 – PROJETO JSF COM FACELETS NO ECLIPSE IDE SEM TEMPLATE
No NetBeans IDE, crie um projeto Web Application (Web>Web Application). 
Na segunda etapa, digite ProjEcommerce e clique em Next. Deixe em Server 
selecionado o Apache Tomcat 6.0.16 e vá até a última etapa.
Na etapa Frameworks, selecione JavaServer Faces e altere na guia Configuration 
para *.jsf no campo Servlet URL Mapping.
ADICIONANDO A BIBLIOTECA DO APACHE TRINIDAD
O Apache MyFaces Trinidad é um conjunto de componentes personalizados que 
trabalham com o JavaServer Faces, estendendo características não suportadas 
pelo framework. 
Para baixar o Apache Trinidad, entre no endereço: 
http://myfaces.apache.org/trinidad/index.html
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
A ÁREA ADMINISTRATIVA – PARTE 1 � 177
FIGURA 6.7 – AS PALETAS DO APACHE TRINIDAD ADICIONADAS AO ECLIPSE
NOTA: É possível personalizar ainda mais, porém foge do escopo do livro.
CONFIGURANDO O SPRING FRAMEWORK
No Eclipse IDE, clique com o direito do mouse sobre o projeto e selecione no 
menu de contexto o item Spring Tools>Add Spring Project Nature.
Crie um arquivo applicationContext.xml do Spring, como já mostrado anterior-
mente no Capítulo 5, na IDE que está utilizando.
Selecione a opção tx – http://www.springframework.org/schema/tx e context – 
http://www.springframework.org/schema/context. Conclua pelo botão Finish.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
A ÁREA ADMINISTRATIVA – PARTE 1 � 207
A Listagem 6.11 exibe o componente JSF <h:dataTable/>, que gera a tag (X)HTML 
<table/> preenchida, carregando todos os dados encontrados no método getTo-
dos() da classe CategoriaController. Para isso, foi configurado o atributo value 
chamando esse método. O atributo var possui um valor, chamado de item, que 
será distribuído por cada coluna da tabela, colocando o nome do campo que será 
exibido.
No componente <h:dataTable/>, cada coluna é representada por <h:colu-
mn />, que gera a tag (X)HTML <tr/>. As tags <th> são geradas por <f:facet 
name=”header”> e as tags <td/> pela simples adição do componente que vai 
ser usado, que no caso é <h:outputText/> e também <h:commandLink/>.
Há duas tags <h:commandLink/>, uma responsável por chamar o formulário 
para edição, através do método editar(), de CategoriaController, e o outro para 
excluir, chamando excluir() da mesma classe. 
ATENÇÃO: Um detalhe importante é que a exclusão não possui confirmação; 
portanto, cuidado.
CRIANDO AS PÁGINAS PARA OS PRODUTOS
A página de formulário de produtos é muito parecida com a de categorias, porém, 
essa possui mais tags JSF e uma tag do Apache Trinidad para renderizar o campo 
file. A Listagem 6.12 exibe o formulário.
FIGURA 6.11 – O CADASTRO DE PRODUTOS
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
A ÁREA ADMINISTRATIVA – PARTE 1 � 211
de quantos caracteres são permitidos no campo. 
Para o campo de cadastro de preço, foi adicionada a tag <f:convertNumber />, 
que converte o valor digitado para o número conforme a localização do browser 
do sistema. Observe que foram usados dois atributos: groupingUsed, com o valor 
booleano true, indicando que será permitido o uso de digitos de grupo e, ma-
xFractionDigits, com o valor 2, indicando o número máximo de casas decimais. 
Caso ocorra um erro nessa conversão, você exibe a mensagem com o atributo 
converterMessage da tag ao qual ela está validando.
Para o upload de arquivos, a tag do Apache MyFaces Trinidad utilizada é <tr:
inputFile/> Essa tag possui o atributo value como as demais, onde você deter-
mina o atributo da classe ProdutoController para ser utilizada. Mas lembre-se, o 
tipo desse atributo, para esse componente, na classe, deve ser org.apache.myfa-
ces.trinidad.model.UploadedFile.
FIGURA 6.12 – A EXIBIÇÃO DOS PRODUTOS CADASTRADOS
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
A capacidade de navegar pelos bens e serviços de um site e-commerce é um dos 
requisitos básicos para os sites Web em uma empresa B2C. As características que 
serão implantadas serão à base da funcionalidade inicial de um site do tipo.
Neste capítulo, você vai criar a classe responsável por gerenciar o front-end do site, 
além de desenvolver o design utilizando Facelets com técnicas de layout CSS.
CRIANDO O BEAN DE CONTROLE DA LOJA
Para trabalhar com a loja, você deverá criar uma classe separada. Isso porque na 
loja, o JavaServer Faces, junto ao Facelets, terá sua navegação via método GET. 
Essa característica é importante para que seja possível guardar o endereço de 
um determinado produto e também para ser identificado facilmente através de 
buscadores3.
Crie uma classe chamada de LojaController no pacote br.com.integrator.con-
troller e altere-a como mostrado na Listagem 7.1 a seguir.
AS PÁGINAS DO LADO CLIENTE
CAPÍTULO 7
3 Atualmente, o trabalho com a URL e a navegação por GET tem passado por transformações. Recomendo a leitura 
a respeito de REST.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
Edson
Cross-Out
Edson
Rectangle
222 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
Para construir o layout, antes, faça os seguintes passos:
1. Pegue no CD-ROM, anexo ao livro, os diretórios imagens/site e css, conti-
dos no projeto-fonte;
2. Coloque-os na raiz da sua aplicação: WebContent no Eclipse ou Web Pa-
ges no NetBeans.
NOTA: A criação dos estilos do site está fora do escopo pretendido por este 
livro.
FIGURA 7.1 – O LAYOUT DA PÁGINA FINAL EM FUNCIONAMENTO
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
Um dos principais pontos de um site de comércio eletrônico é o seu carrinho de 
compras. Os usuários de um site de comércio eletrônico podem construir seus 
pedidos nessa área, selecionando e adicionando vários produtos em seus pedidos. 
Há também quem o chame de cesta de compras, cesta ou apenas carrinho. Em 
inglês, costumamos ver esse processo sendo descrito como “shopping bag”, “sho-
pping cart” ou somente “cart”. 
Embora não importe como você o chame, o que mais importa seja a origem de 
seu nome, que surgiu devido à similaridade do processo que faríamos se estivés-
semos em um mercado ou loja, onde colocamos vários produtos em uma cesta, 
sacola ou carrinho.
Neste capítulo, você vai criar um carrinho de compras no site de comércio ele-
trônico, podendo visualizar os produtos, editar a quantidade e excluir, além de 
calcular o total do pedido.
O CARRINHO DE COMPRAS
CAPÍTULO 8
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
258 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
A PÁGINA DO CARRINHO
Você vai criar uma página similar ao mostrado na Figura 8.1, onde haverá uma 
tabela com os itens adicionados.
FIGURA 8.1 – O CARRINHODE COMPRAS CRIADO
Crie uma página chamada de carrinho.xhtml e altere como mostrado na Lista-
gem 8.4 a seguir.
LISTAGEM 8.4 – A PÁGINA CARRINHO.XHTML
...
<ui:composition template=”template/template.xhtml”>
 
 <ui:define name=”titulo”>
 Carrinho de compras
 </ui:define>
 <ui:define name=”conteudo”>
 <div id=”cart”>
 <c:choose>
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
Quando o usuário termina de escolher tudo que deseja comprar, inicia o processo 
de pagamento. Esse processo é feito através da entrada em uma área especial, 
com um nome de usuário único e uma senha. Porém, para que isso ocorra, esse 
mesmo usuário deve estar devidamente cadastrado no site, evitando assim frau-
des. Neste capítulo, você vai definir a segurança para a entrada na área de usuá-
rio, incluindo o formulário para seu cadastro e login, para que esse possa realizar 
a finalização da compra.
CONTROLANDO A ENTRADA DO USUÁRIO
A entrada do usuário é controlada por uma classe que será responsável pela verifi-
cação do cadastro, sua respectiva entrada ou pelo cadastro de um novo usuário.
Para início, você vai criar a classe UsuarioController no pacote br.com.integra-
tor.controller, conforme mostra a Listagem 9.1:
LISTAGEM 9.1 – A CLASSE USUARIOCONTROLLER
…
@Controller(“usuarioController”)
@Scope(“session”)
public class UsuarioController {
FINALIZANDO A COMPRA
CAPÍTULO 9
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
280 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
 id=”enviar” value=”Logar”/>
 <input jsfc=”h:commandButton” type=”submit” 
 action=”#{usuarioController.novoUsuario}” 
 immediate=”true”
 id=”novo” value=”Novo Usuário”/> 
 </fieldset> 
 </div>
 
 </ui:define>
</ui:composition>
…
Embora o formulário para entrar na área de usuário seja igual a qualquer outro 
feito até o momento no livro, há uma pequena mudança para exibir as mensagens 
globais do formulário. 
<span jsfc=”h:messages” globalOnly=”true”></span>
 
Enquanto cada campo possui uma mensagem personalizada, a tag JSF <h:messa-
ges/> exibe todas as mensagens lançadas pelo formulário, inclusive as que perten-
cem aos campos obrigatórios. Para forçar a exibição de apenas mensagens globais, 
e não locais, utilize o atributo globalOnly= “true”.
FIGURA 9.1 – A PÁGINA PARA SE LOGAR NA ÁREA DO USUÁRIO
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
284 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
 id=”confirmar” value=”Confirmar”/>
 
 </fieldset> 
 </div> 
 
 </ui:define>
</ui:composition>
…
Observe que na página do formulário, o campo de cadastro de e-mail está com 
o atributo readonly contendo uma expressão EL, que verifica se não é vazio o 
atributo email de Usuario, acessado por usuarioController. Se for, ele não per-
mite preencher esse campo. Lembre-se da explicação da classe UsuarioController 
(Listagem 9.1), quando você estiver logado, significa que o formulário será para 
atualização, porém, não há uma verificação na classe para determinar se o e-mail 
não está sendo duplicado com outro usuário.
FIGURA 9.2 – O FORMULÁRIO CADASTRANDO UM NOVO USUÁRIO
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
300 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
Com a tag JSF <f:validator/> você configura o validador, chamando-o pela ID 
configurada no arquivo faces-config.xml, utilizando o atributo validatorId.
FIGURA 9.5 – A MENSAGEM PADRÃO CRIADA NO VALIDADOR ENTRANDO EM AÇÃO 
Se você não gostar da mensagem padrão criada no validador, pode alterá-la dire-
tamente na tag JSF, com o atributo validatorMessage.
<h:inputText id=”ccNumero” 
value=”#{usuarioController.pedido.ccNumero}”
required=”true”
validatorMessage=”Formato: 9999-9999-9999-9999,com ‘-’ ou espaço”>
VALIDANDO PELO BEAN
Uma forma muito simples de fazer a validação de entrada de dados, em um cam-
po de forma personalizada, é através de um JavaBean. Por exemplo, você pode 
validar a entrada de e-mails nos campos definidos para o registro e para o login, 
evitando problemas de digitação. 
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
Em qualquer site de comércio eletrônico, os usuários podem se comunicar com 
a empresa por e-mail, através de uma área de contato, assim como, também, 
podem receber informações por e-mail, como em uma mala-direta (e-mail ma-
rketing), até a confirmação de um pedido efetuado.
Neste capítulo você aprenderá a enviar e-mail de forma simples, utilizando um 
dos recursos do Spring Framework.
CONFIGURANDO O PROJETO PARA ENVIO DE E-MAIL
Antes de começar, você vai precisar de duas bibliotecas para envio de e-mail: 
mail.jar e activation.jar.
Baixe o JavaMail no endereço http://java.sun.com/products/javamail/index.
html. Sua versão está em 1.4.1 no momento em que o livro é escrito.
Baixe também o JavaBeans Activation Framework, que se encontra, no momen-
to em que o livro é escrito, na versão 1.1.
Crie uma biblioteca de usuário chamada Mail em seu Eclipse IDE ou NetBeans 
IDE. Descompacte e pegue os arquivos mail.jar e activation.jar e adicione na 
biblioteca criada. 
ENVIANDO E-MAIL PELO SITE
CAPÍTULO 10
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
312 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
 </fieldset> 
 </div>
</ui:define>
…
FIGURA 10.3 – A PÁGINA DE CONTATO RENDERIZADA
Crie outra página chamada de enviado.xhtml e coloque em seu conteúdo um 
texto para informar o usuário do envio.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
Muitos usuários fazem compras diariamente em um site de comércio eletrônico, 
gerando uma grande quantidade de informações a serem geridas. 
Na segunda parte da área administrativa, você adicionará uma pesquisa pelos 
pedidos realizados no site através de datas, marcando assim um período a ser vi-
sualizado, criando uma query JP-QL mais complexa. Em seguida, fará um relatório 
usando JasperReports com o iReport, com a finalidade de utilizar os objetos dessa 
consulta e gerar um PDF formatado para impressão.
Por fim, você irá garantir a entrada na área administrativa para somente pessoas 
autorizadas, trabalhando com PhaseListener do JavaServer Faces para controlar a 
sessão.
CRIANDO A CONSULTA
Como a aplicação possui a parte de finalização de pedidos na classe Usuario-
Controller, será essa que você usará para criar a consulta de pedidos para o 
administrador.
A ÁREA ADMINISTRATIVA – PARTE 2
CAPÍTULO 11
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
334 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
Altere no template também, adicionando um link que chama essa página, como 
mostra o trecho a seguir:
<li>
<a jsfc=”h:commandLink” 
 action=”mostrarCompras” immediate=”true”> 
 Exibir Compras
</a>
</li> 
FIGURA 11.1 – A PÁGINA DE EXIBIÇÃO DE COMPRAS COM PAGINAÇÃO
ADICIONANDO UM RELATÓRIO
Para concluir as funcionalidades do administrador, é interessante adicionar a 
capacidade de gerar relatórios. Existem diversos programas que trabalham com 
relatórios em Java: na comunidade Open Source temos o JasperReports e sua 
ferramenta visual iReport, da empresa JasperSoft, e o Eclipse Birt, da fundação 
Eclipse.
Criar relatórios em Java é um assunto que exige um livro4 e a idéia aqui é apren-
der a exibir um relatório simples, com os resultados vindos da pesquisa criada na 
página que exibe as compras efetuadas. O relatório será gerado em JasperReports, 
por ser o mais popular, sendo que você usará o iReport para desenhá-lo visual-
mente. 
4 Recomendo a leitura do livroDominando Relatórios JasperReports com iReport, de minha autoria
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
A ÁREA ADMINISTRATIVA – PARTE 2 � 339
FIGURA 11.3 – A JANELA DO IREPORT EM UM RELATÓRIO VAZIO NO LINUX
Cada um destes painéis, espalhados ao redor de seu relatório, possuem caracte-
rísticas e propriedades de certos elementos que, também, podem ser acessíveis 
de outra forma. Esses painéis, numerados na Figura 11.3, são explicados na lista 
a seguir:
(1) File – Exibe os relatórios abertos. O acesso é feito com um duplo clique 
sobre o relatório que deseja exibir na janela. O ícone apresentado, ao lado do 
nome do relatório, nesse painel, também indica modificação no arquivo. Caso 
esteja com dois riscos, é porque houve alteração e não foi salvo. Alternativa-
mente, você pode acessar outro relatório aberto através do menu Window.
(2) Document structure – Exibe os parâmetros, campos da tabela da sua 
query, variáveis pré-definidas e criadas, além das bands do relatório.
(3) Properties – Exibe a propriedade de acordo com o elemento selecionado 
em sua estrutura (Estrutura do documento). As propriedades, de cada ele-
mento do relatório, também podem ser acessíveis facilmente com o botão 
direito do mouse sobre o mesmo, selecionando o item Properties no menu 
de contexto.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
354 � DOMINANDO JAVASERVER FACES E FACELETS UTILIZANDO SPRING 2.5, HIBERNATE E JPA
FIGURA 11.10 – RELATÓRIO COM SAÍDA NO NAVEGADOR DENTRO DO ECLIPSE IDE
TRABALHANDO COM PHASELISTENER PARA O LOGIN ADMINISTRATIVO
No site já criado, você utilizou um filtro para impedir a entrada de pessoas não 
autorizadas na área do usuário, necessitando de um login. Porém, como já foi dito 
naquele capítulo, há mais de uma forma para se fazer isso. A segunda forma que 
será mostrada utilizará o próprio recurso do JavaServer Faces, através do uso de 
PhaseListener. A idéia original foi de Aaron L. Bartell em uma lista de e-mails de 
desenvolvedores JSF e que está sendo adaptada agora para o administrador do 
e-commerce.
Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação