Pular para o conteúdo principal

MÓDULO 6 - Spring Data JPA Avançado

Bem-vindo ao Módulo 6! 🎯​

No Módulo 2, você aprendeu o básico do Spring Data JPA: os 4 métodos CRUD (save, findById, findAll, deleteById) e 3 palavras-chave simples (findBy, And, Or).

Agora, você está pronto para ir além!

Este módulo ensina os conceitos avançados de JPA para criar consultas complexas e gerenciar relações entre entidades.

🎓 Objetivos de Aprendizagem​

Ao final deste módulo, você será capaz de:

  1. ✅ Utilizar as 15+ palavras-chave do Spring Data JPA
  2. ✅ Criar consultas personalizadas com @Query
  3. ✅ Gerenciar relações (@OneToMany, @ManyToOne, @ManyToMany)
  4. ✅ Utilizar paginação e ordenação
  5. ✅ Otimizar a performance das consultas

📚 Pré-requisitos​

Antes de começar este módulo, você deve ter:

  • ✅ Completado os Módulos 1 a 4
  • ✅ Dominado o básico de JPA (Módulo 2, Capítulo 5)
  • ✅ Compreendido os repositórios (JpaRepository)

Se estes pré-requisitos não foram cumpridos, volte ao Módulo 2!

🗺️ Plano do Módulo​

Parte Teórica (4 capítulos)​

Capítulo 1: Convenções de Nomeação Avançadas​

Duração: 1h

Conteúdo:

  • As 15+ palavras-chave do Spring Data JPA
  • Between, LessThan, GreaterThan
  • Like, StartingWith, EndingWith, Containing
  • In, NotIn, IsNull, IsNotNull
  • True, False, IgnoreCase
  • Exemplos práticos para cada palavra-chave

Por que é importante? Criar consultas complexas sem escrever SQL

Capítulo 2: Relações entre Entidades​

Duração: 1h30

Conteúdo:

  • @OneToOne (1-1)
  • @OneToMany e @ManyToOne (1-N)
  • @ManyToMany (N-N)
  • Tipos de fetch (LAZY vs EAGER)
  • Operações de cascade
  • Relações bidirecionais

Por que é importante? Modelar dados reais complexos

Capítulo 3: Consultas Personalizadas com @Query​

Duração: 1h

Conteúdo:

  • Sintaxe JPQL
  • @Query com JPQL
  • @Query com SQL nativo
  • Parâmetros nomeados com @Param
  • Named queries
  • Consultas dinâmicas

Por que é importante? Ir além das convenções de nomeação

Capítulo 4: Paginação e Performance​

Duração: 1h

Conteúdo:

  • Pageable e Page<T>
  • Sort e ordenação multi-critérios
  • Problema N+1
  • Estratégias de fetch
  • Projeções
  • Otimização de consultas

Por que é importante? Criar aplicações performáticas

Parte Prática (3 TPs)​

TP6.1: Convenções Avançadas​

Duração: 2h

Objetivo: Dominar as 15+ palavras-chave

Você vai criar:

  • Entidade Product com vários campos
  • 20 métodos de repository usando as palavras-chave
  • Testes para cada método

TP6.2: Relações Employee-Department​

Duração: 2h

Objetivo: Gerenciar relações entre entidades

Você vai criar:

  • Entidades Employee e Department (OneToMany/ManyToOne)
  • CRUD completo com relações
  • Operações de cascade
  • Testes das relações

TP6.3: Exercício Airport-Flight-Passenger​

Duração: 2h30

Objetivo: Avaliação completa

Você vai:

  • Modelar 3 entidades relacionadas
  • Implementar 20 consultas (Fácil, Médio, Difícil)
  • Gabarito fornecido
  • Auto-correção

📊 Duração Total​

TipoDuração
Teoria4h30 (4 capítulos)
Prática6h30 (3 TPs)
Total11h (~3-4 sessões)

🎯 O Que Você Vai Aprender​

Antes do Módulo 6​

// Você sabia fazer isso:
public interface ProductRepository extends JpaRepository<Product, Long> {
    List<Product> findByName(String name);
    List<Product> findByNameAndPrice(String name, Double price);
}

Limitado a: Consultas simples com And e Or

Depois do Módulo 6​

// Você saberá fazer tudo isso:
public interface ProductRepository extends JpaRepository<Product, Long> {
    
    // Comparações
    List<Product> findByPriceBetween(Double min, Double max);
    List<Product> findByPriceLessThan(Double maxPrice);
    List<Product> findByPriceGreaterThanEqual(Double minPrice);
    
    // Busca textual
    List<Product> findByNameContaining(String keyword);
    List<Product> findByNameStartingWith(String prefix);
    List<Product> findByDescriptionLike(String pattern);
    
    // Listas e nulls
    List<Product> findByCategoryIn(List<String> categories);
    List<Product> findByDiscountIsNull();
    List<Product> findByActiveTrue();
    
    // Ordenação e paginação
    Page<Product> findByCategory(String category, Pageable pageable);
    
    // Consultas personalizadas
    @Query("SELECT p FROM Product p WHERE p.price < :maxPrice")
    List<Product> findCheapProducts(@Param("maxPrice") Double maxPrice);
    
    // SQL nativo
    @Query(value = "SELECT * FROM products WHERE stock < 10", nativeQuery = true)
    List<Product> findLowStock();
}

Você dominará: Consultas complexas, relações, performance!

🚀 Por Que Este Módulo É Importante​

1. Consultas Reais em Produção​

No mercado, você NÃO fará apenas findAll(). Você vai precisar de:

// Encontrar os pedidos de um cliente nos últimos 30 dias
List<Order> findByCustomerIdAndOrderDateAfter(Long customerId, LocalDate date);

// Produtos fora de estoque em uma categoria
List<Product> findByCategoryAndStockLessThan(String category, Integer minStock);

// Funcionários de um departamento com salário em uma faixa
List<Employee> findByDepartmentAndSalaryBetween(Department dept, Double min, Double max);

Este módulo te prepara para a realidade!

2. Performance das Aplicações​

Problema comum: O Problema N+1

// ❌ Má prática - N+1 consultas!
List<Department> departments = departmentRepo.findAll();  // 1 consulta
for (Department dept : departments) {
    List<Employee> employees = dept.getEmployees();  // N consultas!
    // ...
}

Solução que você vai aprender:

// ✅ Boa prática - 1 única consulta!
@Query("SELECT d FROM Department d JOIN FETCH d.employees")
List<Department> findAllWithEmployees();

Este módulo te ensina a escrever código performático!

3. Modelagem de Dados Complexos​

Caso real: E-commerce

Customer ──< Order >── Product
              │
              └──> Payment

Você vai aprender a:

  • Modelar essas relações
  • Gerenciar cascatas (excluir um Customer → seus Orders?)
  • Otimizar as consultas
  • Gerenciar dados órfãos

🗺️ Progressão na Formação​

Módulo 2: Bases JPA (4 métodos, 3 palavras-chave simples)
          ↓
Módulo 6: ← VOCÊ ESTÁ AQUI - JPA Avançado
          (15+ palavras-chave, relações, @Query, performance)
          ↓
Projetos: Aplicações completas com bancos de dados complexos

Módulo 6 = Tornar-se expert em Spring Data JPA!

📖 Como Abordar Este Módulo​

Método Recomendado​

  1. Leia os capítulos na ordem

    • Capítulo 1: Convenções (15+ palavras-chave)
    • Capítulo 2: Relações (OneToMany, ManyToOne, etc.)
    • Capítulo 3: @Query (JPQL, SQL nativo)
    • Capítulo 4: Performance (paginação, otimização)

  2. Faça os TPs progressivamente

    • TP6.1: Pratique as convenções (2h)
    • TP6.2: Pratique as relações (2h)
    • TP6.3: Avaliação completa (2h30)

  3. Teste todo o código

    • Não copie, digite o código
    • Teste cada consulta
    • Entenda os resultados

Tempo Recomendado​

Opção Intensiva (1 final de semana):

  • Sábado: Capítulos 1-2 + TP6.1
  • Domingo: Capítulos 3-4 + TP6.2 + TP6.3

Opção Progressiva (3 sessões):

  • Sessão 1: Capítulos 1-2 + TP6.1
  • Sessão 2: Capítulo 3 + TP6.2
  • Sessão 3: Capítulo 4 + TP6.3

✅ Autoavaliação​

Antes de começar, teste seus conhecimentos:

  1. Você sabe criar um método findByPriceBetween? ☐ Sim ☐ Não
  2. Você conhece @OneToMany e @ManyToOne? ☐ Sim ☐ Não
  3. Você sabe usar @Query? ☐ Sim ☐ Não
  4. Você entende o problema N+1? ☐ Sim ☐ Não
  5. Você sabe paginar resultados? ☐ Sim ☐ Não

Se você respondeu "Não" para 2 ou mais perguntas → Este módulo é ESSENCIAL para você!

Após o módulo, refaça este teste. Você deverá responder "Sim" para todas!

🎯 Próximo Passo​

Pronto para se tornar expert em Spring Data JPA?

➡️ Comece pelo Capítulo 1: Convenções de Nomeação Avançadas

⬅️ Voltar ao Plano de Curso