Saltar al contenido principal

MÓDULO 6 - Spring Data JPA Avanzado

¡Bienvenido al Módulo 6! 🎯​

En el Módulo 2, aprendió los fundamentos de Spring Data JPA: los 4 métodos CRUD (save, findById, findAll, deleteById) y 3 palabras clave simples (findBy, And, Or).

¡Ahora está listo para ir más allá!

Este módulo le enseña los conceptos avanzados de JPA para crear consultas complejas y gestionar relaciones entre entidades.

🎓 Objetivos de Aprendizaje​

Al final de este módulo, usted será capaz de:

  1. ✅ Utilizar las 15+ palabras clave de Spring Data JPA
  2. ✅ Crear consultas personalizadas con @Query
  3. ✅ Gestionar relaciones (@OneToMany, @ManyToOne, @ManyToMany)
  4. ✅ Utilizar paginación y ordenamiento
  5. ✅ Optimizar el rendimiento de las consultas

📚 Prerrequisitos​

Antes de comenzar este módulo, debe haber:

  • ✅ Completado los Módulos 1 a 4
  • ✅ Dominado los fundamentos de JPA (Módulo 2, Capítulo 5)
  • ✅ Comprendido los repositories (JpaRepository)

Si no tiene estos prerrequisitos, regrese al Módulo 2.

🗺️ Plan del Módulo​

Parte Teórica (4 capítulos)​

Capítulo 1: Convenciones de Nomenclatura Avanzadas​

Duración: 1h

Contenido:

  • Las 15+ palabras clave de Spring Data JPA
  • Between, LessThan, GreaterThan
  • Like, StartingWith, EndingWith, Containing
  • In, NotIn, IsNull, IsNotNull
  • True, False, IgnoreCase
  • Ejemplos prácticos para cada palabra clave

¿Por qué es importante? Crear consultas complejas sin escribir SQL

Capítulo 2: Relaciones entre Entidades​

Duración: 1h30

Contenido:

  • @OneToOne (1-1)
  • @OneToMany y @ManyToOne (1-N)
  • @ManyToMany (N-N)
  • Fetch types (LAZY vs EAGER)
  • Operaciones en cascada
  • Relaciones bidireccionales

¿Por qué es importante? Modelar datos reales complejos

Capítulo 3: Consultas Personalizadas con @Query​

Duración: 1h

Contenido:

  • Sintaxis JPQL
  • @Query con JPQL
  • @Query con SQL nativo
  • Parámetros nombrados con @Param
  • Named queries
  • Consultas dinámicas

¿Por qué es importante? Ir más allá de las convenciones de nomenclatura

Capítulo 4: Paginación y Rendimiento​

Duración: 1h

Contenido:

  • Pageable y Page<T>
  • Sort y ordenamiento multi-criterio
  • Problema N+1
  • Fetch strategies
  • Proyecciones
  • Optimización de consultas

¿Por qué es importante? Crear aplicaciones de alto rendimiento

Parte Práctica (3 TPs)​

TP6.1: Convenciones Avanzadas​

Duración: 2h

Objetivo: Dominar las 15+ palabras clave

Usted va a crear:

  • Entidad Product con muchos campos
  • 20 métodos de repository usando las palabras clave
  • Pruebas para cada método

TP6.2: Relaciones Employee-Department​

Duración: 2h

Objetivo: Gestionar las relaciones entre entidades

Usted va a crear:

  • Entidades Employee y Department (OneToMany/ManyToOne)
  • CRUD completo con relaciones
  • Operaciones en cascada
  • Pruebas de las relaciones

TP6.3: Ejercicio Airport-Flight-Passenger​

Duración: 2h30

Objetivo: Evaluación completa

Usted va a:

  • Modelar 3 entidades relacionadas
  • Implementar 20 consultas (Fácil, Medio, Difícil)
  • Solucionario proporcionado
  • Auto-corrección

📊 Duración Total​

TipoDuración
Teoría4h30 (4 capítulos)
Práctica6h30 (3 TPs)
Total11h (~3-4 sesiones)

🎯 Lo Que Va a Aprender​

Antes del Módulo 6​

// Usted sabía hacer esto:
public interface ProductRepository extends JpaRepository<Product, Long> {
    List<Product> findByName(String name);
    List<Product> findByNameAndPrice(String name, Double price);
}

Limitado a: Consultas simples con And y Or

Después del Módulo 6​

// Usted sabrá hacer todo esto:
public interface ProductRepository extends JpaRepository<Product, Long> {
    
    // Comparaciones
    List<Product> findByPriceBetween(Double min, Double max);
    List<Product> findByPriceLessThan(Double maxPrice);
    List<Product> findByPriceGreaterThanEqual(Double minPrice);
    
    // Búsqueda textual
    List<Product> findByNameContaining(String keyword);
    List<Product> findByNameStartingWith(String prefix);
    List<Product> findByDescriptionLike(String pattern);
    
    // Listas y nulos
    List<Product> findByCategoryIn(List<String> categories);
    List<Product> findByDiscountIsNull();
    List<Product> findByActiveTrue();
    
    // Ordenamiento y paginación
    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();
}

Usted dominará: Consultas complejas, relaciones, rendimiento

🚀 Por Qué Este Módulo Es Importante​

1. Consultas Reales en Producción​

En la empresa, usted NO hará solo findAll(). Necesitará:

// Encontrar los pedidos de un cliente en los últimos 30 días
List<Order> findByCustomerIdAndOrderDateAfter(Long customerId, LocalDate date);

// Productos sin stock en una categoría
List<Product> findByCategoryAndStockLessThan(String category, Integer minStock);

// Empleados de un departamento con salario en un rango
List<Employee> findByDepartmentAndSalaryBetween(Department dept, Double min, Double max);

¡Este módulo le prepara para la realidad!

2. Rendimiento de las Aplicaciones​

Problema común: El Problema N+1

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

Solución que aprenderá:

// ✅ Buena práctica - ¡Solo 1 consulta!
@Query("SELECT d FROM Department d JOIN FETCH d.employees")
List<Department> findAllWithEmployees();

¡Este módulo le enseña a escribir código eficiente!

3. Modelado de Datos Complejos​

Caso real: E-commerce

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

Usted aprenderá a:

  • Modelar estas relaciones
  • Gestionar las cascadas (¿eliminar un Customer → sus Orders?)
  • Optimizar las consultas
  • Gestionar datos huérfanos

🗺️ Progresión en la Formación​

Módulo 2: Fundamentos JPA (4 métodos, 3 palabras clave simples)
          ↓
Módulo 6: ← USTED ESTÁ AQUÍ - JPA Avanzado
          (15+ palabras clave, relaciones, @Query, rendimiento)
          ↓
Proyectos: Aplicaciones completas con BDD complejas

Módulo 6 = ¡Convertirse en experto en Spring Data JPA!

📖 Cómo Abordar Este Módulo​

Método Recomendado​

  1. Lea los capítulos en orden

    • Capítulo 1: Convenciones (15+ palabras clave)
    • Capítulo 2: Relaciones (OneToMany, ManyToOne, etc.)
    • Capítulo 3: @Query (JPQL, SQL nativo)
    • Capítulo 4: Rendimiento (paginación, optimización)

  2. Realice los TPs progresivamente

    • TP6.1: Practique las convenciones (2h)
    • TP6.2: Practique las relaciones (2h)
    • TP6.3: Evaluación completa (2h30)

  3. Pruebe todo el código

    • No copie, escriba el código
    • Pruebe cada consulta
    • Comprenda los resultados

Tiempo Recomendado​

Opción Intensiva (1 fin de semana):

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

Opción Progresiva (3 sesiones):

  • Sesión 1: Capítulos 1-2 + TP6.1
  • Sesión 2: Capítulo 3 + TP6.2
  • Sesión 3: Capítulo 4 + TP6.3

✅ Autoevaluación​

Antes de comenzar, pruebe sus conocimientos:

  1. ¿Sabe crear un método findByPriceBetween? ☐ Sí ☐ No
  2. ¿Conoce @OneToMany y @ManyToOne? ☐ Sí ☐ No
  3. ¿Sabe utilizar @Query? ☐ Sí ☐ No
  4. ¿Comprende el problema N+1? ☐ Sí ☐ No
  5. ¿Sabe paginar resultados? ☐ Sí ☐ No

Si respondió "No" a 2 preguntas o más → ¡Este módulo es ESENCIAL para usted!

Después del módulo, repita esta prueba. ¡Debe responder "Sí" en todas!

🎯 Próximo Paso​

¿Listo para convertirse en experto en Spring Data JPA?

➡️ Comenzar con el Capítulo 1: Convenciones de Nomenclatura Avanzadas

⬅️ Volver al Plan de Curso