Aller au contenu principal

MODULE 6 - Spring Data JPA Avancé

Bienvenue au Module 6! 🎯​

Dans le Module 2, vous avez appris les bases de Spring Data JPA: les 4 méthodes CRUD (save, findById, findAll, deleteById) et 3 mots-clés simples (findBy, And, Or).

Maintenant, vous êtes prêts pour aller plus loin!

Ce module vous apprend les concepts avancés de JPA pour créer des requêtes complexes et gérer des relations entre entités.

🎓 Objectifs d'Apprentissage​

À la fin de ce module, vous serez capable de:

  1. ✅ Utiliser les 15+ mots-clés de Spring Data JPA
  2. ✅ Créer des requêtes personnalisées avec @Query
  3. ✅ Gérer les relations (@OneToMany, @ManyToOne, @ManyToMany)
  4. ✅ Utiliser la pagination et le tri
  5. ✅ Optimiser les performances des requêtes

📚 Prérequis​

Avant de commencer ce module, vous devez avoir:

  • ✅ Complété les Modules 1 à 4
  • ✅ Maîtrisé les bases de JPA (Module 2, Chapitre 5)
  • ✅ Compris les repositories (JpaRepository)

Si ces prérequis ne sont pas acquis, retournez au Module 2!

🗺️ Plan du Module​

Partie Théorique (4 chapitres)​

Chapitre 1: Conventions de Nommage Avancées​

Durée: 1h

Contenu:

  • Les 15+ mots-clés de Spring Data JPA
  • Between, LessThan, GreaterThan
  • Like, StartingWith, EndingWith, Containing
  • In, NotIn, IsNull, IsNotNull
  • True, False, IgnoreCase
  • Exemples pratiques pour chaque mot-clé

Pourquoi important? Créer des requêtes complexes sans écrire de SQL

Chapitre 2: Relations entre Entités​

Durée: 1h30

Contenu:

  • @OneToOne (1-1)
  • @OneToMany et @ManyToOne (1-N)
  • @ManyToMany (N-N)
  • Fetch types (LAZY vs EAGER)
  • Cascade operations
  • Relations bidirectionnelles

Pourquoi important? Modéliser des données réelles complexes

Chapitre 3: Requêtes Personnalisées avec @Query​

Durée: 1h

Contenu:

  • Syntaxe JPQL
  • @Query avec JPQL
  • @Query avec SQL natif
  • Paramètres nommés avec @Param
  • Named queries
  • Requêtes dynamiques

Pourquoi important? Aller au-delà des conventions de nommage

Chapitre 4: Pagination et Performance​

Durée: 1h

Contenu:

  • Pageable et Page<T>
  • Sort et tri multi-critères
  • Problème N+1
  • Fetch strategies
  • Projections
  • Query optimization

Pourquoi important? Créer des applications performantes

Partie Pratique (3 TPs)​

TP6.1: Conventions Avancées​

Durée: 2h

Objectif: Maîtriser les 15+ mots-clés

Vous allez créer:

  • Entité Product avec de nombreux champs
  • 20 méthodes de repository utilisant les mots-clés
  • Tests pour chaque méthode

TP6.2: Relations Employee-Department​

Durée: 2h

Objectif: Gérer les relations entre entités

Vous allez créer:

  • Entités Employee et Department (OneToMany/ManyToOne)
  • CRUD complet avec relations
  • Opérations cascade
  • Tests des relations

TP6.3: Exercice Airport-Flight-Passenger​

Durée: 2h30

Objectif: Évaluation complète

Vous allez:

  • Modéliser 3 entités liées
  • Implémenter 20 requêtes (Facile, Moyen, Difficile)
  • Solutionnaire fourni
  • Auto-correction

📊 Durée Totale​

TypeDurée
Théorie4h30 (4 chapitres)
Pratique6h30 (3 TPs)
Total11h (~3-4 séances)

🎯 Ce Que Vous Allez Apprendre​

Avant le Module 6​

// Vous saviez faire ça:
public interface ProductRepository extends JpaRepository<Product, Long> {
    List<Product> findByName(String name);
    List<Product> findByNameAndPrice(String name, Double price);
}

Limité à: Requêtes simples avec And et Or

Après le Module 6​

// Vous saurez faire tout ça:
public interface ProductRepository extends JpaRepository<Product, Long> {
    
    // Comparaisons
    List<Product> findByPriceBetween(Double min, Double max);
    List<Product> findByPriceLessThan(Double maxPrice);
    List<Product> findByPriceGreaterThanEqual(Double minPrice);
    
    // Recherche textuelle
    List<Product> findByNameContaining(String keyword);
    List<Product> findByNameStartingWith(String prefix);
    List<Product> findByDescriptionLike(String pattern);
    
    // Listes et nulls
    List<Product> findByCategoryIn(List<String> categories);
    List<Product> findByDiscountIsNull();
    List<Product> findByActiveTrue();
    
    // Tri et pagination
    Page<Product> findByCategory(String category, Pageable pageable);
    
    // Requêtes personnalisées
    @Query("SELECT p FROM Product p WHERE p.price < :maxPrice")
    List<Product> findCheapProducts(@Param("maxPrice") Double maxPrice);
    
    // SQL natif
    @Query(value = "SELECT * FROM products WHERE stock < 10", nativeQuery = true)
    List<Product> findLowStock();
}

Vous maîtriserez: Requêtes complexes, relations, performance!

🚀 Pourquoi Ce Module Est Important​

1. Requêtes Réelles en Production​

En entreprise, vous ne ferez PAS que des findAll(). Vous aurez besoin de:

// Trouver les commandes d'un client sur les 30 derniers jours
List<Order> findByCustomerIdAndOrderDateAfter(Long customerId, LocalDate date);

// Produits en rupture de stock dans une catégorie
List<Product> findByCategoryAndStockLessThan(String category, Integer minStock);

// Employés d'un département avec salaire dans une fourchette
List<Employee> findByDepartmentAndSalaryBetween(Department dept, Double min, Double max);

Ce module vous prépare pour la réalité!

2. Performance des Applications​

Problème courant: Le Problème N+1

// ❌ Mauvaise pratique - N+1 requêtes!
List<Department> departments = departmentRepo.findAll();  // 1 requête
for (Department dept : departments) {
    List<Employee> employees = dept.getEmployees();  // N requêtes!
    // ...
}

Solution que vous apprendrez:

// ✅ Bonne pratique - 1 seule requête!
@Query("SELECT d FROM Department d JOIN FETCH d.employees")
List<Department> findAllWithEmployees();

Ce module vous apprend à écrire du code performant!

3. Modélisation de Données Complexes​

Cas réel: E-commerce

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

Vous apprendrez à:

  • Modéliser ces relations
  • Gérer les cascades (supprimer un Customer → ses Orders?)
  • Optimiser les requêtes
  • Gérer les données orphelines

🗺️ Progression dans la Formation​

Module 2: Bases JPA (4 méthodes, 3 mots-clés simples)
          ↓
Module 6: ← VOUS ÊTES ICI - JPA Avancé
          (15+ mots-clés, relations, @Query, performance)
          ↓
Projets: Applications complètes avec BDD complexes

Module 6 = Devenir expert en Spring Data JPA!

📖 Comment Aborder Ce Module​

Méthode Recommandée​

  1. Lisez les chapitres dans l'ordre

    • Chapitre 1: Conventions (15+ mots-clés)
    • Chapitre 2: Relations (OneToMany, ManyToOne, etc.)
    • Chapitre 3: @Query (JPQL, SQL natif)
    • Chapitre 4: Performance (pagination, optimisation)

  2. Faites les TPs progressivement

    • TP6.1: Pratiquez les conventions (2h)
    • TP6.2: Pratiquez les relations (2h)
    • TP6.3: Évaluation complète (2h30)

  3. Testez tout le code

    • Ne copiez pas, tapez le code
    • Testez chaque requête
    • Comprenez les résultats

Temps Recommandé​

Option Intensive (1 week-end):

  • Samedi: Chapitres 1-2 + TP6.1
  • Dimanche: Chapitres 3-4 + TP6.2 + TP6.3

Option Progressive (3 séances):

  • Séance 1: Chapitres 1-2 + TP6.1
  • Séance 2: Chapitre 3 + TP6.2
  • Séance 3: Chapitre 4 + TP6.3

✅ Auto-Évaluation​

Avant de commencer, testez vos connaissances:

  1. Savez-vous créer une méthode findByPriceBetween? ☐ Oui ☐ Non
  2. Connaissez-vous @OneToMany et @ManyToOne? ☐ Oui ☐ Non
  3. Savez-vous utiliser @Query? ☐ Oui ☐ Non
  4. Comprenez-vous le problème N+1? ☐ Oui ☐ Non
  5. Savez-vous paginer des résultats? ☐ Oui ☐ Non

Si vous avez répondu "Non" à 2 questions ou plus → Ce module est ESSENTIEL pour vous!

Après le module, refaites ce test. Vous devrez répondre "Oui" partout!

🎯 Prochaine Étape​

Prêt à devenir expert en Spring Data JPA?

➡️ Commencer avec le Chapitre 1: Conventions de Nommage Avancées

⬅️ Retour au Plan de Cours