Your SlideShare is downloading. ×
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Dominando Jsf E Facelets Utilizando Spring 2.5, Hibernate E Jpa

12,205

Published on

Published in: Education
0 Comments
6 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
12,205
On Slideshare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
1,377
Comments
0
Likes
6
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. EDSON GONÇALVES Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 2. 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
  • 3. 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
  • 4. 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
  • 5. 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
  • 6. 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
  • 7. 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 Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 8. 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
  • 9. 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
  • 10. 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
  • 11. 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
  • 12. 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
  • 13. 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. Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 14. 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
  • 15. 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. Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 16. 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
  • 17. 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
  • 18. 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
  • 19. 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
  • 20. 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
  • 21. 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
  • 22. 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
  • 23. 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
  • 24. 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
  • 25. 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. Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 26. 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
  • 27. 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
  • 28. 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. Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 29. PARTE 2 DESENVOLVENDO O SITE E-COMMERCE Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 30. 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). Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 31. 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
  • 32. 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
  • 33. 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
  • 34. 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
  • 35. 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 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. Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 36. 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
  • 37. 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
  • 38. 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
  • 39. 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
  • 40. 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. Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 41. 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
  • 42. 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
  • 43. 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
  • 44. 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. Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 45. 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
  • 46. 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
  • 47. 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
  • 48. 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
  • 49. 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. Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 50. 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
  • 51. 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. Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 52. 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 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> Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 53. 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 { Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 54. 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
  • 55. 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
  • 56. 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
  • 57. 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. Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 58. 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
  • 59. 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. Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 60. 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 livro Dominando Relatórios JasperReports com iReport, de minha autoria Visite o site www.integrator.com.br e veja um vídeo demonstrativo da aplicação
  • 61. 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
  • 62. 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

×