Curso Persistência com JPA 2 e Hibernate

Sobre o curso

Trabalhe com banco de dados em Java com o maior e melhor framework de persistência Java do mercado. Tire o máximo de proveito do mapeamento objeto-relacional (ORM) e escreva buscas avançadas com JPQL e Criteria. Evite os problemas mais comuns de trabalhar com JPA na Web, melhore a escalabilidade do seu sistema com pool de conexões e cache de segundo nível.

24 horas

MATRICULE-SE
Domine sua ferramenta de mapeamento objeto relacional.

Pré-requisitos obrigatórios
* Dúvidas no pré-requisito entre em contato

Curso de Java e OO e Java para Web; ou possuir conhecimentos na plataforma Java (linguagem, JVM etc). Noções básicas em SQL e banco de dados. Desejável noções básicas de desenvolvimento Web.

Conteúdo do curso
* Grade e conteúdo em constante atualização

  1. Persistência no mundo Java

    1. Persistindo dados com JDBC puro
    2. A motivação da JPA
    3. Existem outras opções para Java?
    4. Leitura recomendada

  2. Definição do projeto

    1. A necessidade de um Bug Tracker
    2. Tecnologias escolhidas
    3. Rabiscando o domínio de um Bug Tracker
    4. Exercícios: Criando o projeto no Eclipse

  3. Mapeamento Objeto Relacional (ORM)

    1. Trabalhando com banco de dados em sistemas orientado a objetos
    2. Modelando as entidades
    3. Configurando JPA com Hibernate
    4. Mapeando os modelos através de anotações
    5. Mapeando chave primária auto gerada
    6. Entendendo a convenção de mapeamento do JPA
    7. Persistindo objetos com JPA
    8. Exercícios: Mapeando os modelos e criando o banco de dados
    9. Exercícios Opcionais: Fugindo da convenção do JPA, melhorando o nome das tabelas e colunas e criação do banco de dados

  4. Organizando a camada de persistência

    1. Encapsulando a criação do EntityManager
    2. Exercícios: Criando o EntityManager através da JPAUtil
    3. Encapsulando a JPA dentro dos DAOs
    4. Buscando todas as entidades do banco
    5. Exercícios: Encapsulando código através do DAO

  5. Contexto de Persistência

    1. Contexto de persistência e ciclo de vida das entidades
    2. O estado Managed
    3. O estado Transient
    4. O estado Detached
    5. O estado Removed
    6. Forçando a sincronização com o banco de dados
    7. Exercícios: Sincronização forçada através do flush
    8. Discussão: Quando eu devo utilizar o flush?

  6. Complementando o modelo

    1. Modelando a entidade Bug
    2. Mapeando enumerações e datas
    3. Relacionando o Usuario com um Bug
    4. Persistindo o novo modelo de Bug
    5. Exercícios: Criando e persistindo o modelo de Bug
    6. Persistindo objetos envolvidos em relacionamentos
    7. Exercícios: Tentando persistir um novo Bug relacionado com um Usuario
    8. Entendendo e evitando o erro TransientPropertyValueException
    9. Exercícios: Persistindo um Bug relacionado com um Usuario
    10. Navegando nos relacionamentos
    11. Atualizando objetos envolvidos em relacionamentos
    12. Criando o DAO de Bug
    13. Exercícios: Criando o DAO de Bug e navegando nos relacionamentos

  7. Operações em cascata

    1. Relacionando o Comentario com um Bug
    2. Tentando persistir um novo Comentario em um Bug
    3. Exercícios: Criando e tentando persistir o modelo de Comentario
    4. Utilizando operações em cascata
    5. Exercícios: Utilizando operações em cascata para persistir um novo Comentario
    6. Tentando remover um Comentario do Bug
    7. Exercícios: Tentando remover um Comentario do Bug
    8. Definindo a identidade de uma entidade
    9. Exercícios: Definindo a identidade e removendo um Comentario do Bug
    10. Para saber mais: Removendo do banco registros orfãos
    11. Discussão: Cuidados com o uso de operações em cascata

  8. Eventos do ciclo de vida da JPA

    1. Callbacks internos para entidades
    2. Exercícios: Disparando callbacks ao persistir um Bug
    3. EntityListener: callbacks externos para entidades
    4. Exercício opcional: Utilizando EntityListeners em vez de callbacks internos
    5. Para saber mais: Configurando EntityListeners globais
    6. Para saber mais: Ordem de execução dos callbacks
    7. Discussão: Até onde eu devo utilizar callbacks e EntityListeners?

  9. Criando queries com JPQL

    1. Entendendo a JPQL
    2. Adicionando filtros na consulta
    3. Exercícios: Contando o número de bugs no banco de dados
    4. Exercícios: Buscando bugs que possuem comentarios
    5. Exercícios: Buscando todos comentarios de determinado bug
    6. Exercícios: Buscando comentarios seguindo alguns critérios
    7. Exercícios: Calculando a quantidade de bugs por mês
    8. Para saber mais: Named Queries
    9. Discussão: Quando usar Named Queries ou JPQL?

  1. Relacionamento bidirecional

    1. Buscando os comentários de um bug
    2. Exercícios: Testando o novo mapeamento
    3. Relacionamento bidirecional
    4. Exercícios: Utilizando o mappedBy no relacionamento bidirecional
    5. Trabalhando de forma orientada a objetos com relacionamento bidirecional
    6. Discussão: Devo sempre mapear um relacionamento bidirecional?

  2. Criando queries com Criteria

    1. Entendendo a motivação da Criteria
    2. Criteria do JPA2 ou Hibernate?
    3. Conhecendo a API da Criteria
    4. Exercícios: Buscando bugs com o uso de filtros
    5. Exercícios: Buscando bugs que possuem comentarios
    6. Exercícios: Utilizando Projections para trazer apenas os dados necessários
    7. Exercícios: Definindo Join e Fetch nas consultas
    8. Discussão: Quando usar JPQL ou Criteria?

  3. Integrando JPA com Spring

    1. Importando o projeto Web
    2. Diminuindo o acomplamento com Injeção de Dependências (DI)
    3. Spring Framework
    4. Gerenciando a JPA com o Spring
    5. Configurando o EntityManagerFactory
    6. Injetando o EntityManager com @PersistenceContext
    7. Exercícios: Configurando o Spring e refatorando os DAOs
    8. Problemas de abrir e fechar transações na mão
    9. Configurando Controle Transacional com Spring e @Transactional
    10. Exercícios: Declarando o controle transacional nos DAOs
    11. Para saber mais: Entendendo a propagação das transações com Spring

  4. Desafios da JPA na Web

    1. Problemas mais comuns
    2. Entendendo o comportamento Lazy nos relacionamentos
    3. O famigerado LazyInitializationException
    4. Resolvendo o problema com o comportamento EAGER
    5. Exercícios: Mudando o relacionamento para trabalhar como EAGER
    6. Os problemas de um mapeamento mal definido
    7. Resolvendo o problema com queries planejadas
    8. Exercícios: Ajustando a consulta para trabalhar com query planejada
    9. Terei que alterar todas as minhas consultas?
    10. Evitando o LazyInitializationException com Open Session In View
    11. Exercícios: Implementando o pattern Open Session In View
    12. Problemas trazidos pelo excesso de Lazy
    13. Entendendo e evitando o problema do Select N+1
    14. Resolvendo com @BatchSize
    15. Para saber mais: FetchMode.SUBSELECT

  5. Gerenciando as conexões com Pool de Conexões

    1. O perigo de não ter controle sobre as conexões criadas
    2. Utilizando o pool de conexões do Hibernate
    3. Exercícios: Configurando o pool de conexões do Hibernate
    4. Utilizando o C3P0 como pool de conexões
    5. Exercício opcional: Configurando o pool de conexões com o C3P0
    6. Para saber mais: Configurações avançadas do C3P0

  6. Melhorando a performance com Cache

    1. Cache de primeiro nível
    2. Exercícios: Testando o cache de primeiro nível
    3. Cache de segundo nível
    4. Configurando Ehcache como cache de segundo nível
    5. Cache de entidades
    6. Exercícios: Configurando e testando o cache de segundo nível
    7. Para saber mais: configuração fina do cache de entidades
    8. Cache de collections
    9. Exercícios: Utilizando cache para as collections
    10. Cache de consultas
    11. Configurando o cache de consultas do Hibernate
    12. Exercícios: Adicionando cache nas consultas

  7. Apêndice - Mais mapeamentos com JPA

    1. Relacionamentos Many to Many
    2. Exercício: Mapeando relacionamentos muitos para muitos
    3. Relacionamentos One to One
    4. Exercícios: Mapeando relacionamentos um para um
    5. Melhorando o mapeamento com Embeddable
    6. Exercícios: Isolando os atributos dentro do Embeddable
    7. Para saber mais: Aproveitando o Embeddable em outras classes
    8. Para saber mais: Mapeando chaves compostas
    9. Para saber mais: Mapeando Herança

Inscrições

Veja as próximas datas do curso e matricule-se!

*Pagamento à vista ou outras formas de pagamento entrar em contato.

Turma Data Período Local
#12 06/Abril a 22/Abril (sábado) Sábados (09h às 17h) TriadWorks Vagas encerradas!
#13 16/Setembro a 30/Setembro (sábado) Sábados (09h às 17h) TriadWorks
#14 11/Novembro a 25/Novembro (sábado) Sábados (09h às 17h) TriadWorks
Novas turmas em breve! Para mais informações, fale com a gente.
Veja outros cursos oferecidos pela TriadWorks