Aller au contenu principal

MODULE 2 - Premiers Pas avec Spring Boot

Objectifs du Module​

Ce module vous permettra de:

  • Maîtriser l'utilisation de Spring Initializr pour créer des projets
  • Comprendre la structure d'un projet Spring Boot
  • Configurer votre environnement de développement (Visual Studio Code)
  • Créer votre première application REST
  • Utiliser les annotations de base de Spring Boot

Contenu du Module​

Théorie​

Chapitre 1: Spring Initializr​

  • Qu'est-ce que Spring Initializr
  • Configuration du projet (Maven, Java, Spring Boot)
  • Métadonnées et paramètres
  • Gestion des dépendances et starters
  • Génération et import du projet
  • Alternatives (CLI, API, IDE)

Chapitre 2: Structure d'un Projet Spring Boot​

  • Arborescence complète d'un projet
  • Rôle du fichier pom.xml
  • Organisation des packages (Controller, Service, Repository, Model)
  • Répertoires resources (static, templates)
  • Configuration avec application.properties/yml
  • Conventions de nommage

Chapitre 3: Configuration​

  • Fichiers application.properties et application.yml
  • Propriétés Spring Boot communes
  • Configuration de la base de données
  • Configuration des logs
  • Propriétés personnalisées avec @Value et @ConfigurationProperties
  • Gestion des profiles (dev, test, prod)
  • Variables d'environnement et sécurité

Chapitre 4: Annotations de Base​

  • @SpringBootApplication et ses composantes
  • Annotations de stéréotype: @Component, @Service, @Repository
  • @RestController vs @Controller
  • Annotations de mapping HTTP: @GetMapping, @PostMapping, @PutMapping, @DeleteMapping
  • @RequestParam, @PathVariable, @RequestBody
  • Injection de dépendances avec @Autowired

Chapitre 5: Introduction aux Repositories​

  • Qu'est-ce qu'un Repository Spring Data JPA
  • Les 4 méthodes de base héritées de JpaRepository
  • Conventions de nommage simples: findBy, And, Or
  • Créer une entité JPA
  • Architecture complète Controller → Service → Repository
  • Exemples pratiques avec l'entité User
  • Note: Contenu simplifié pour débutants. Les concepts avancés (jointures, JPQL, @Query) seront vus au Module 6

Travaux Pratiques​

TP2.1: Application Greeting avec VS Code​

Objectif: Créer votre première application Spring Boot REST

Contenu:

  • Configuration de Spring Initializr
  • Import du projet dans Visual Studio Code
  • Création d'un contrôleur REST simple
  • Test et débogage
  • Résolution de problèmes courants

Durée estimée: 2-3 heures

Prérequis: JDK 17+, Maven, VS Code avec extensions Java

Niveau: Débutant

TP2.2: Base de Données H2 - Mémoire et Persistance​

Objectif: Maîtriser H2 en mode mémoire et en mode fichier persistant

Contenu:

  • Partie 1: H2 en mémoire (données temporaires)
  • Partie 2: H2 persistante (données sur disque)
  • Partie 3: Gestion avancée avec renommage de fichiers
  • Différences entre les modes
  • Configuration de schema.sql et data.sql
  • Console H2
  • 4 exercices pratiques
  • Utilisation des 4 méthodes JPA de base (findById, findAll, save, deleteById)

Durée estimée: 3-4 heures

Prérequis: TP2.1 complété, Chapitre 5 (Repositories) lu

Niveau: Débutant

📚 Note Importante: Restructuration Pédagogique​

Où sont TP3 et TP4?​

Si vous cherchez les TPs avancés, ils ont été déplacés vers les modules appropriés pour une meilleure progression pédagogique:

TP3.1: Architecture CRUD → MODULE 3​

  • Nouveau nom: TP3.1 du Module 3
  • Raison: Utilise des concepts avancés (Validation, ResponseEntity, Gestion d'erreurs)
  • Prérequis ajoutés:
    • Chapitre 1: Service Layer en détail
    • Chapitre 2: Validation des données
    • Chapitre 3: Gestion des erreurs HTTP
    • Chapitre 4: Architecture 3 couches professionnelle

TP4.1: PostgreSQL → MODULE 4​

  • Nouveau nom: TP4.1 du Module 4
  • Raison: Utilise des concepts de production (PostgreSQL, Lombok, Jakarta, DDL strategies)
  • Prérequis ajoutés:
    • Chapitre 1: PostgreSQL - Installation et configuration
    • Chapitre 2: Jakarta vs Javax Persistence
    • Chapitre 3: Hibernate et stratégies DDL
    • Chapitre 4: Lombok

Pourquoi Ce Changement?​

Analyse pédagogique:

TP3 (anciennement ici): 60% de concepts non enseignés
TP4 (anciennement ici): 80% de concepts non enseignés

Impact positif:

  • ✅ Chaque TP a maintenant TOUTE la théorie nécessaire AVANT de le commencer
  • ✅ Moins de frustration et de confusion
  • ✅ Apprentissage plus progressif et efficace
  • ✅ Meilleure préparation pour la production

Progression Recommandée​

MODULE 2 (Bases)
├── 5 Chapitres théoriques
└── 2 TPs pratiques (TP2.1, TP2.2)
    ↓
MODULE 3 (Architecture Robuste)
├── 4 Chapitres théoriques
└── 1 TP (Architecture CRUD) ← Ancien TP3 du Module 2
    ↓
MODULE 4 (Production)
├── 4 Chapitres théoriques
└── 1 TP (PostgreSQL) ← Ancien TP4 du Module 2

Prérequis Techniques​

Avant de commencer ce module, assurez-vous d'avoir:

Logiciels Requis​

  1. JDK 17 ou supérieur

  2. Visual Studio Code

  3. Extensions VS Code:

    • Extension Pack for Java (Microsoft)
    • Spring Boot Extension Pack (VMware)
    • Maven for Java (Microsoft)

  4. Maven 3.9+

Vérification de l'Installation​

# Vérifier Java
java -version

# Vérifier Maven
mvn -version

Durée Estimée​

Théorie: 6-8 heures (5 chapitres)
Pratique: 5-7 heures (TP2.1, TP2.2)
Total: 11-15 heures (2-3 séances de 4-6 heures)

Note: Le Module 2 a été simplifié pour se concentrer sur les fondamentaux. Les TPs avancés (CRUD Architecture, PostgreSQL) sont maintenant dans les Modules 3 et 4 avec la théorie appropriée.

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 un projet Spring Boot avec Spring Initializr
  • ✅ Configurer Visual Studio Code pour le développement Java/Spring
  • ✅ Créer et tester un contrôleur REST simple
  • ✅ Comprendre la structure d'un projet Spring Boot
  • ✅ Configurer application.properties et application.yml
  • ✅ Utiliser les annotations de base (@RestController, @Service, @Repository)
  • ✅ Créer des entités JPA simples
  • ✅ Utiliser les 4 méthodes CRUD de base (findById, findAll, save, deleteById)
  • ✅ Créer des méthodes de recherche simples (findBy, And, Or)
  • ✅ Travailler avec H2 en mode mémoire et persistant

Ce que vous N'êtes PAS encore censé maîtriser (c'est dans les modules suivants):

  • ❌ Architecture 3 couches complète (Module 3)
  • ❌ Validation avancée (Module 3)
  • ❌ Gestion des erreurs HTTP (Module 3)
  • ❌ PostgreSQL en production (Module 4)
  • ❌ Lombok (Module 4)
  • ❌ Jointures JPA (Module 6)

Prochaines Étapes​

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

  • Module 3: Architecture en Couches et CRUD Complet

    • Service Layer approfondi
    • Validation des données (@Valid, @NotNull, @Size, etc.)
    • Gestion des erreurs HTTP (ResponseEntity, codes de statut)
    • Architecture 3 couches professionnelle
    • TP3.1: CRUD Architecture (déplacé pour meilleure progression)

  • Module 4: Bases de Données en Production

    • PostgreSQL - Installation et configuration
    • Jakarta vs Javax Persistence
    • Hibernate et DDL strategies
    • Lombok pour réduire le code
    • TP4.1: Migration PostgreSQL (déplacé pour meilleure progression)

  • Module 5: Spring Core - IoC et DI avancé

  • Module 6: Spring Data JPA Avancé (Jointures, JPQL, Optimisation)

📚 Pourquoi Cette Réorganisation?​

Ancienne structure:

  • Module 2 contenait 4 TPs dont 2 trop avancés
  • TP3.1 et TP4.1 utilisaient des concepts non enseignés
  • Frustration des étudiants

Nouvelle structure:

  • ✅ Module 2: Bases uniquement (TP2.1, TP2.2)
  • ✅ Module 3: CRUD avec théorie complète (TP3.1)
  • ✅ Module 4: Production avec théorie complète (TP4.1)

💡 Résultat: Chaque TP a maintenant TOUTE la théorie nécessaire AVANT de le commencer!

Commencer avec le TP2.1