Use o código e tenha 10% de desconto!

Aplicações Java para a web com JSF e JPA

Gilliard Cordeiro

Por que eu devo ler esse livro e como ele está organizado?

Durante muito tempo, uma grande parte das aplicações que eram desenvolvidas possuíam uma mesma característica: serem aplicações Desktop. Com isso, plataformas como o Visual Basic, da Microsoft® e o Delphi, da Borland®, tornaram-se muito famosas e batalhavam pelo grande mercado de desenvolvimento de software que já havia naquela época. Com o passar do tempo, algumas das características que tornaram aquele tipo de aplicação tão interessante, como a performance, começaram a perder peso frente a alguns pontos negativos, por exemplo, em relação à manutenibilidade da mesma. Ou seja, como posso garantir que todo mundo que execute uma aplicação que desenvolvi esteja sempre com a versão mais nova da mesma? Claro que é possível, mas as soluções podem não ser necessariamente simples e diretas.

Atualmente, as aplicações Desktop perderam grande fatia do mercado de software. Agora, quem o domina são as aplicações web, que tentam resolver alguns dos problemas existentes com as aplicações Desktop.

Nas tecnologias que gravitam ao redor da plataforma Java, é possível destacar os frameworks MVC, que auxiliam os desenvolvedores a criarem aplicações web. Frameworks como o JSF (Java Server Faces), facilitam a tarefa de desenvolver aplicação para a web.

Por outro lado, a grande maioria das aplicações existentes precisa, de alguma maneira, guardar as informações coletadas dentro dela em um banco de dados. Poderíamos usar JDBC puro para essa tarefa em nossas aplicações, porém temos disponíveis ferramentas que nos auxiliam a criar aplicações que se comuniquem com o banco de dados. Assim, é possível abstrair várias das complexidades existentes nessa integração, como é o caso da especificação JPA.

Neste livro veremos como criar uma aplicação utilizando JSF e JPA. Faremos isso com uma abordagem que mostra a necessidade de cada item que será introduzido ao leitor, e portanto, motivando-o. A cada capítulo, iremos aprender conceitos que podem fazer evoluir a aplicação criada, olhando mais de perto para questões críticas, como boas práticas, performance e componentização. Vamos saber não apenas como fazer ou o que fazer, mas também o motivo das coisas serem de determinada forma. O objetivo desse livro não é ser uma receita de bolo para o leitor e sim, ser um material que desmistifique as questões e dúvidas que existem na grande maioria das aplicações que são desenvolvidas para a web.

Desenvolvedores sem experiências em desenvolvimento para a Web em Java aproveitarão esse livro de forma que, paralelamente à leitura, já consigam ir implementando seu próprio projeto e colocando em prática os novos conceitos e ideias aprendidas. O objetivo é que, ao final do livro, o leitor saiba como criar uma aplicação nova, desde a parte web, até o back-end com as regras de negócio e a camada de persistência. E que conheça quais as armadilhas em que ele pode cair e como se livrar delas, além de conseguir utilizar as boas práticas tanto do JSF quanto da JPA.

Para o desenvolvedor experiente, o livro contém diversos detalhes e boas práticas que podem fazer a diferença no uso das ferramentas indicadas. Por exemplo, como configurar o cache de segundo nível para a aplicação, ou como otimizar o consumo da sessão do JSF, entre outras situações que serão abordadas no decorrer da leitura.

O livro está estruturado em três partes, cada uma com seu objetivo específico:

Na primeira parte, teremos o primeiro contato com cada ferramenta, ainda sem nos preocuparmos muito com como cada uma funciona internamente. O principal objetivo é tornar familiar o funcionamento geral da JPA e do JSF, mostrando como integrá-los e construindo uma tela de cadastro junto com a camada de persistência.

Na segunda parte, o objetivo é apresentar as ferramentas de forma mais aprofundada, mostrando como funcionam e como usá-las da forma correta. É um conteúdo útil tanto para quem teve o primeiro contato na primeira parte do livro, quando para quem já desenvolve há muito tempo, mas nunca teve a oportunidade de explorar as ferramentas a ponto de saber como elas se comportam em situações específicas.

Na terceira e última parte, veremos como melhorar nossa aplicação em cima do conhecimento adquirido na segunda parte. O foco é principalmente usabilidade e performance. Exploraremos temas que foram vistos na segunda parte, como AJAX no JSF e Lazy Load na JPA, mas com enfoque muito mais específico em tirar o máximo proveito das ferramentas.

Agradecimentos

Podem considerar clichê, mas não há como iniciar qualquer tipo de agradecimento sem primeiro agradecer a Deus, pois sem ele não estaria aqui agradecendo a outras pessoas muito importantes, tanto na minha vida, quanto na escrita deste livro.

Gostaria de agradecer aos meus pais, José Cordeiro de Souza e Cleunice dos Santos Cordeiro, pela criação, pelos valores e pelo incentivo em todos os momentos da minha vida. Desde as tarefas da escola, cafés feitos altas horas da noite para aguentar a madrugada de trabalhos da faculdade e agora os períodos de "entocamento" para escrever este livro.

Ainda na seção família, não poderia deixar de agradecer minha irmã, Giselly Santos Cordeiro, por ser um exemplo de estudos e dedicação em uma época em que eu andava meio preguiçoso.

Um agradecimento muito especial à minha namorada, quase esposa, Dantiele de Freitas Queiróz que tem sido uma verdadeira parceira nesses oito anos que estamos juntos. Isso mesmo, oito anos de namoro :). Agradeço pela companhia nos momentos descontraídos, mas principalmente pela parceria nos momentos de muito trabalho e estudo. São meses sem poder curtir um final de semana tranquilo, sem sair para pescar, ou ficar horas fazendo qualquer outra coisa. Em vez de reclamar, era eu escrevendo em uma escrivaninha e ela estudando em outra.

Agradeço também aos meus sogros, Wanderley e Iraci, pois quando estava na casa deles, além de ficar no meu canto escrevendo, ainda carregava a filha deles comigo. E apesar de toda brincadeira que se faz com sogro e sogra, eles sempre foram paizões comigo.

E não poderia terminar essa lista sem agradecer a dois caras em especial: Paulo Silveira e Adriano Almeida. Primeiramente ao Paulo pela confiança e pelo convite de escrever um livro, algo que eu nunca tinha feito. Admiro essa capacidade dele em transformar conhecimento em algo palpável, primeiro com o GUJ, depois a Caelum e agora a Casa do Código. E também um muito obrigado ao Adriano, que teve o duro trabalho de transformar quilos de trechos de código e explicação técnica em algo leve e prazeroso de ler. Sem ele como editor, em vez de um livro, teria escrito um post gigante de blog.

Sumário

  • Contato inicial
  • 1 Introdução
    • 1.1 A evolução da integração entre Java e Bancos de dados
    • 1.2 Como era a vida com o JDBC?
    • 1.3 Diminuição da impedância por meio do mapeamento
    • 1.4 Bibliotecas ORM e o Hibernate
    • 1.5 Muitos frameworks ORM, como evitar o vendor lock-in?
    • 1.6 O desenvolvimento web com servlets e o padrão MVC
    • 1.7 Tirando HTML do código Java com as JavaServer Pages
    • 1.8 Organize seu código com a separação de responsabilidades
    • 1.9 O MVC e os frameworks
    • 1.10 Por que usar JSF?
    • 1.11 O primeiro contato com o JSF
    • 1.12 Considerações finais
  • 2 Primeiros passos com a JPA
    • 2.1 Definição do modelo
    • 2.2 Configuração básica do persistence.xml
    • 2.3 Escolha o dialeto do banco de dados
    • 2.4 Automatização da criação e evolução das tabelas
    • 2.5 Gravação do primeiro dado no banco de dados
    • 2.6 Consultas simples no banco de dados com a JPA
    • 2.7 Exclusão de dados com a JPA
    • 2.8 Considerações finais
  • 3 Primeiros passos com o JSF
    • 3.1 Onde e como defino telas com o JSF?
    • 3.2 Criação da tela e dos inputs básicos de dados
    • 3.3 commandButton, Managed Beans e a submissão de formulários
    • 3.4 Passe dados da tela para o Managed Bean
    • 3.5 Como receber os parâmetros diretamente no método
    • 3.6 Gravação do automóvel no banco de dados
    • 3.7 Liste os dados com o dataTable
    • 3.8 Mas minha listagem está executando várias consultas no banco...
    • 3.9 Exclusão de dados e o commandLink
    • 3.10 Considerações finais
  • Domine as ferramentas
  • 4 Entendendo a JPA
    • 4.1 O padrão de projetos Data Access Object (DAO)
    • 4.2 JPA não é um DAO genérico, é contextual
    • 4.3 Ciclo de vida de um objeto na JPA
    • 4.4 Considerações finais
  • 5 Como mapear tudo... ou nada!
    • 5.1 Definições de entidade
    • 5.2 Faça atributos não serem persistidos com o @Transient
    • 5.3 Mapeie chaves primárias simples
    • 5.4 Mapeie chaves compostas
    • 5.5 A anotação @Basic
    • 5.6 @Table, @Column e @Temporal
    • 5.7 @Version e lock otimista
    • 5.8 Relacionamentos muitos para um com @ManyToOne
    • 5.9 @OneToOne
    • 5.10 Relacionamentos bidirecionais
    • 5.11 O que tem a ver o dono do relacionamento com a operação em cascata?
    • 5.12 Organize melhor suas entidades e promova reaproveitamento com @Embeddable e @Embedded
    • 5.13 Relacionamentos um para muitos com o @OneToMany e @ManyToOne
    • 5.14 A importância do Lazy Loading, o carregamento preguiçoso
    • 5.15 @Lob
    • 5.16 @ElementCollection
    • 5.17 Relacionamentos muitos para muitos com o @ManyToMany
    • 5.18 Customize as colunas de relacionamentos com @JoinColumn e @JoinColumns
    • 5.19 Configure as tabelas auxiliares com @JoinTable
    • 5.20 Considerações finais
  • 6 Consultas com a JPQL e os problemas comuns na integração com o JSF
    • 6.1 Filtre dados com a Java Persistence Query Language (JPQL)
    • 6.2 Como aplicar funções às consultas
    • 6.3 Onde estão meus joins?
    • 6.4 Execute suas consultas e use parâmetros
    • 6.5 Utilize funções de agregação
    • 6.6 Faça subconsultas com a JPQL
    • 6.7 Agrupamentos e HAVING
    • 6.8 Consultas complexas... resultados complexos?
    • 6.9 Use o Select New e esqueça os arrays de Object
    • 6.10 Organize suas consultas com Named Queries
    • 6.11 Execute as Named Queries
    • 6.12 Relacionamentos Lazy, N+1 Query e Join Fetch
    • 6.13 Evite a LazyInitializationException com o OpenEntityManagerInView
    • 6.14 O problema das N+1 consultas e como resolvê-lo
    • 6.15 Considerações finais
  • 7 Entenda o JSF e crie aplicações web
    • 7.1 Se prepare para um mundo diferente, baseado em componentes
    • 7.2 A web stateless contra a web stateful
    • 7.3 O ciclo de vida das requisições no JSF
    • 7.4 Aja sobre as fases do JSF com os PhaseListeners
    • 7.5 Conheça os componentes do JSF
    • 7.6 A diferença entre Action e ActionListener
    • 7.7 Padronização no carregamento de recursos
    • 7.8 Entenda os conversores nativos, o f:convertDateTime e o f:convertNumber
    • 7.9 Conversores customizados
    • 7.10 Conheça os validadores nativos
    • 7.11 E quando os validadores nativos não fazem o que eu quero?
    • 7.12 Novidade: JSF com GET e bookmarkable URLs
    • 7.13 Regras de navegação
    • 7.14 Entenda os escopos e saiba como e quando trabalhar com cada um
    • 7.15 Considerações finais
  • 8 Validações simplificadas na JPA e no JSF com a Bean Validation
    • 8.1 Trabalhe com os validadores e crie sua própria validação
    • 8.2 Organize grupos de validação
    • 8.3 A integração entre Bean Validation e JPA
    • 8.4 A integração entre Bean Validation e JSF
    • 8.5 Considerações finais
  • Desenvolvendo a fluência
  • 9 Enriquecendo nossa aplicação JSF
    • 9.1 Combos em cascata e commands em dataTable
    • 9.2 Mostre mensagens com h:message e h:messages
    • 9.3 Internacionalizando nossa aplicação
    • 9.4 JSF e AJAX
    • 9.5 Organize o código das telas com templates
    • 9.6 Composite Components: criando nossos próprios componentes a partir de outros
    • 9.7 Criar um jar com componentes customizados
    • 9.8 Considerações finais
  • 10 Truques que podem aumentar a escalabilidade e a performance da sua aplicação
    • 10.1 Utilize o cache de segundo nível da JPA
    • 10.2 Faça cache de consultas
    • 10.3 Colhendo estatísticas da nossa camada de persistência
    • 10.4 Relacionamentos extra-lazy
    • 10.5 Paginação virtual e real de dados
    • 10.6 Utilizando Pool de conexões
    • 10.7 Tornando o JSF mais leve com o uso inteligente de AJAX
    • 10.8 Quando possível, manipule componentes JSF no lado do cliente
    • 10.9 Considerações finais
  • 11 Conclusão
  • 12 Apêndice: iniciando projeto com Eclipse
    • 12.1 Adicionando o Tomcat no Eclipse
    • 12.2 Criando o projeto web
    • 12.3 Baixando os jars do JSF
    • 12.4 Configurando a JPA

Dados do produto

Número de páginas:
346
ISBN:
978-85-66250-01-5
Data publicação:
07/2012

Compartilhe!

Compartilhe no Facebook Compartilhe no Twitter