Aller au contenu principal

MODULE 3 - Architecture en Couches et CRUD Complet

Objectifs du Module​

Ce module vous permettra de:

  • Maîtriser l'architecture à 3 couches (Controller, Service, Repository)
  • Comprendre le rôle et l'importance de la couche Service
  • Implémenter la validation des données avec Bean Validation
  • Gérer les erreurs HTTP professionnellement avec ResponseEntity
  • Créer une API REST complète et robuste

Contenu du Module​

Théorie​

Chapitre 1: La Couche Service en Détail​

  • Rôle et responsabilités de la couche Service
  • Séparation des préoccupations
  • Logique métier vs accès aux données
  • Injection de dépendances
  • Architecture complète Controller → Service → Repository

Chapitre 2: Validation des Données​

  • Introduction à Bean Validation (JSR 380)
  • Annotations de validation:
    • @NotNull, @NotEmpty, @NotBlank
    • @Size, @Min, @Max
    • @Email, @Pattern
    • @Past, @Future
  • @Valid dans les contrôleurs
  • Messages d'erreur personnalisés
  • Groupes de validation
  • Validation personnalisée

Chapitre 3: Gestion des Erreurs HTTP​

  • Comprendre ResponseEntity
  • Codes de statut HTTP (200, 201, 204, 400, 404, 500)
  • Gestion des exceptions
  • @ExceptionHandler
  • @ControllerAdvice pour gestion globale
  • Création de réponses d'erreur personnalisées
  • Meilleures pratiques

Chapitre 4: Architecture 3 Couches Professionnelle​

  • Vue d'ensemble de l'architecture
  • Flux de données complet
  • Conventions de nommage
  • Organisation des packages
  • DTOs vs Entités (introduction)
  • Meilleures pratiques professionnelles

Travaux Pratiques​

TP3.1: Architecture CRUD Complète​

Objectif: Créer une API REST complète avec validation et gestion d'erreurs

Contenu:

  • Architecture à 3 couches (Controller, Service, Repository)
  • Entité Product avec validation
  • Opérations CRUD complètes
  • Validation des données d'entrée
  • Gestion professionnelle des erreurs (404, 400, 500)
  • ResponseEntity pour toutes les réponses
  • Tests avec Postman

Durée estimée: 4-6 heures

Prérequis:

  • Module 2 complété (TP2.1 et TP2.2)
  • Tous les chapitres du Module 3 lus

Niveau: Intermédiaire

TP3.2: CRUD Autonome (Défi)​

Objectif: Même énoncé que le TP3.1 mais sans aucun code fourni — à réaliser seul

Contenu:

  • Même application de gestion des étudiants
  • Consignes claires : quoi faire, quels endpoints, quels codes HTTP
  • Aucun détail technique, aucun code fourni
  • 5 exercices bonus (recherche, stats, pagination, erreurs, PostgreSQL)
  • Questions de révision et critères d'évaluation

Durée estimée: 2-3 heures

Prérequis: Avoir compris les concepts du Module 3

Niveau: Intermédiaire-Avancé (autonomie requise)

Prérequis​

Connaissances Requises​

Avant de commencer ce module, vous devez maîtriser:

✅ Création de projets Spring Boot avec Spring Initializr
✅ Structure d'un projet Spring Boot
✅ Configuration (application.properties / application.yml)
✅ Annotations de base (@RestController, @Service, @Repository)
✅ Annotations de mapping HTTP (@GetMapping, @PostMapping, etc.)
✅ JPA et repositories (findById, findAll, save, deleteById)
✅ Méthodes dérivées simples (findBy, And, Or)
✅ H2 en mode mémoire et persistant

Si vous n'êtes pas à l'aise avec ces concepts, retournez au Module 2.

Durée Estimée​

Théorie: 8-10 heures (4 chapitres)
Pratique: 4-6 heures (1 TP complet)
Total: 12-16 heures (2-3 séances de 4-6 heures)

Ressources Supplémentaires​

Documentation Officielle​

Tutoriels Recommandés​

Critères de Réussite​

À la fin de ce module, vous devriez être capable de:

  • ✅ Créer une architecture à 3 couches professionnelle
  • ✅ Implémenter la validation des données avec Bean Validation
  • ✅ Gérer les erreurs HTTP avec ResponseEntity
  • ✅ Utiliser les bons codes de statut HTTP
  • ✅ Implémenter toutes les opérations CRUD
  • ✅ Séparer correctement la logique métier de l'accès aux données
  • ✅ Créer une API REST robuste et professionnelle

Prochaines Étapes​

Une fois ce module complété, vous serez prêt pour:

  • Module 4: Bases de Données en Production (PostgreSQL, Jakarta/Javax, Hibernate, Lombok)
  • Module 5: Spring Core - IoC et DI avancé
  • Module 6: Spring Data JPA Avancé (Jointures, JPQL, Optimisation)

Pourquoi Ce Module Est Important​

Avant Module 3​

❌ Code fragile (pas de validation)
❌ Gestion d'erreurs basique
❌ Logique métier dans le contrôleur
❌ Difficile à tester
❌ Non professionnel

Après Module 3​

✅ Code robuste (validation complète)
✅ Gestion d'erreurs professionnelle
✅ Séparation claire des responsabilités
✅ Facilement testable
✅ Production-ready

Commencer avec le Chapitre 1