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

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

Gilliard Cordeiro
Capa

JSF e JPA

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

  • 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 através 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 - Nos próximos capítulos
  • 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 - O que mais vem pela frente?
  • 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 direto 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 - O primeiro CRUD integrado
  • 4 - Entendendo a JPA
    • 4.1 - O padrão de projetos Data Access Object, ou DAO
    • 4.2 - JPA não é um DAO genérico, é contextual
    • 4.3 - Ciclo de vida de um objeto na JPA
    • 4.4 - A JPA vai mais além do que um simples executar de SQLs
  • 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 - Conclusão
  • 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 nas 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 sub-consultas 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 - Foi bastante, mas não acabou...
  • 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 - Fase 1 - Criar ou restaurar a árvore de componentes da tela (Restore View)
    • 7.5 - Fase 2 - Aplicar valores da requisição na árvore de componentes (Apply Request Values)
    • 7.6 - Fase 3 - Converter e Validar (Validate)
    • 7.7 - Fase 4 - Atualizar o modelo (Update Model)
    • 7.8 - Fase 5 - Invocar ação da aplicação (Invoke Application)
    • 7.9 - Fase 6 - Renderizar a resposta (Render Response)
    • 7.10 - Aja sobre as fases do JSF com os PhaseListeners
    • 7.11 - Conheça os componentes do JSF
    • 7.12 - h:form
    • 7.13 - h:inputText e h:inputTextarea
    • 7.14 - h:inputSecret
    • 7.15 - h:inputHidden
    • 7.16 - h:selectOneMenu, f:selectItem e f:selectItems
    • 7.17 - h:selectOneRadio
    • 7.18 - h:selectOneListbox
    • 7.19 - h:selectManyMenu e h:selectManyListbox
    • 7.20 - h:selectManyCheckbox
    • 7.21 - h:selectBooleanCheckbox
    • 7.22 - Novidade do JSF 2.2: h:inputFile
    • 7.23 - h:panelGrid
    • 7.24 - h:panelGroup
    • 7.25 - h:outputText
    • 7.26 - h:outputLabel
    • 7.27 - h:outputFormat
    • 7.28 - h:outputScript e h:outputStylesheet
    • 7.29 - h:graphicImage
    • 7.30 - h:dataTable
    • 7.31 - ui:repeat
    • 7.32 - h:commandButton e h:commandLink
    • 7.33 - A diferença entre Action e ActionListener
    • 7.34 - Padronização no carregamento de recursos
    • 7.35 - Entenda os conversores nativos, o f:convertDateTime e o f:convertNumber
    • 7.36 - Conversores customizados
    • 7.37 - Conheça os validadores nativos
    • 7.38 - E quando os validadores nativos não fazem o que eu quero? Crie seus validadores
    • 7.39 - Novidade: JSF com GET e bookmarkable URLs
    • 7.40 - h:button e h:link
    • 7.41 - Regras de navegação
    • 7.42 - Entenda os escopos e saiba como e quando trabalhar com cada um
    • 7.43 - A curva de aprendizado do JSF
  • 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
  • 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
  • 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 uso inteligente de AJAX
    • 10.8 - Quando possível, manipule componentes JSF no lado do cliente
    • 10.9 - Considerações finais sobre otimizações
  • 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:
    329
    ISBN:
    978-85-66250-01-5
    Data publicação:
    07/2012

    Compartilhe!

    Compartilhe no Facebook Compartilhe no Twitter