Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa

EDSON GONÇALVES

Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação

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.


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.


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


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;


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.


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 ........................................................................15
As 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


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


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


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


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


PARTE 1

AMBIENTES DE TRABALHO,
JAVASERVER FACES E
FACELETS

CAPÍTULO 1

PREPARANDO SEU AMBIENTE
DE TRABALHO
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,
podendo se 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.


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


CAPÍTULO 2

O JAVASERVER FACES
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 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.



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.



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.



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



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.


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
…

<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>


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.



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.



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.


CAPÍTULO 3

FACELETS
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.



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.



</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:


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 e FaceletContext) 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.


PARTE 2

DESENVOLVENDO O
SITE E-COMMERCE


CAPÍTULO 4

JPA COM HIBERNATE
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).



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.


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.



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



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.



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 definiçã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 identificador da entidade. Normalmente se refere à chave primária da tabela
relacional.
@GeneratedValue Define que terá seus identificadores automaticamente gerados. Isso é chamado
de geração de id e é especificado 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 Define uma relação de “um-para-muitos” do utilizado em banco de dados rela-
cional. Possui um atributo chamado mappedBy para definir o atributo da outra
Entidade no qual é referenciado.
@ManyToOne Define uma relação de “muitos-para-um” do utilizado em banco de dados rela-
cional.
@JoinColumn São usadas para especificar a coluna que contém a chave estrangeira de cada
relacionamento, os conhecidos Inner Joins de um relacionamento SQL.



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



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.



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



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.


CAPÍTULO 5

O SPRING COM A JPA
E TESTES UNITÁRIOS
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 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.



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.



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.


CAPÍTULO 6

A ÁREA ADMINISTRATIVA – PARTE 1
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áginas do 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.



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


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.



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



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


CAPÍTULO 7

AS PÁGINAS DO LADO CLIENTE
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.

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.



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


CAPÍTULO 8

O CARRINHO DE COMPRAS
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.



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 CARRINHO DE 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>


CAPÍTULO 9

FINALIZANDO A COMPRA
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 {



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



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



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.


CAPÍTULO 10

ENVIANDO E-MAIL PELO SITE
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.



</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.


CAPÍTULO 11

A ÁREA ADMINISTRATIVA – PARTE 2
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.



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 livro Dominando Relatórios JasperReports com iReport, de minha autoria



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.



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.


Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa

Último

Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa