Aller au contenu

Révisions pratiques Java 17, Git-flow et Spring Boot 4

Méthode : lire l’essentiel (5 à 10 minutes), réaliser le TP sans regarder le corrigé (15 à 45 minutes), comparer et expliquer oralement. Les exemples sont volontairement courts et indépendants pour que tu puisses te remettre à niveau. Certains extraits sont des fragments à intégrer, pas des applications complètes même si l’objectif est de réaliser l’application RetroGame.

J’ai ajouté des schémas permettant de faciliter les révisions. L’ordre des concepts et TP est purement indicatif pour les 3 jours en fonction de ce que tu m’as envoyé par mail.

Sommaire


1. Git et Git-flow

Cycle simplifié de travail avec Git-flow

la page du cours sur Git, GitLab et GitFlow…

À retenir :

Opération Commande ou action
Voir l’état git status
Créer une branche depuis develop git switch develop && git pull && git switch -c feature/classement
Enregistrer git add . && git commit -m "feat: ajout du classement"
Publier git push -u origin feature/classement
Proposer une fusion Créer une Merge Request vers develop dans GitLab
Revoir Lire le diff, commenter, demander des corrections, vérifier la CI
Fusionner Cliquer sur Merge après validation ; supprimer la branche si souhaité
Actualiser sa branche git fetch origin && git rebase origin/develop

Merge ou rebase :

TP 1 — Une fonctionnalité complète

  1. Créer un dépôt local et une branche develop
  2. créer feature/bonus-score.
  3. Ajouter un fichier regles.md expliquant : « 100 points bonus au-delà de 10 000 points ».
  4. Faire un commit, puis pousser vers un dépôt distant GitLab existant pour la formation.
  5. Créer une Merge Request, demander une revue, corriger une remarque, puis fusionner vers la branche develop.
  6. Sur une autre branche personnelle, simuler une mise à jour de develop et tester rebase.

Objectif : créer une fonctionnalité dans une branche dédiée, la faire relire via une Merge Request GitLab, la fusionner dans develop, puis comprendre rebase en pratique.

Convention : le dépôt distant GitLab de la formation s’appelle origin. Remplacer <URL> par l’URL habituelle pour la formation (ex : https://gitlab.example.com/formation/retrogame.git).


Étape 1 — Dépôt local et branche develop

mkdir retrogame && cd retrogame
git init -b main                 # dépôt local, branche initiale nommée main
echo "# RetroGame" > README.md
git add README.md
git commit -m "chore: initialisation du dépôt"  # un chore est une tâche sans impact fonctionnel, c'est une convention

git switch -c develop            # crée develop et bascule dessus
git remote add origin <URL>      # déclare le dépôt distant avec l'url à préciser
git push -u origin develop        # publie develop : cible des futures MR

Petit tableau de rappel de quelques conventions :

Type Usage
feat nouvelle fonctionnalité
fix correction de bug
docs documentation uniquement (ton docs: règle de bonus en fait partie)
refactor remaniement sans changement de comportement
test ajout/modification de tests
chore tâches d’entretien sans lien avec le code métier

Pourquoi pousser develop tout de suite ?

Une Merge Request GitLab relie 2 branches du distant. Si develop n’existe pas sur origin, GitLab ne proposera pas de la choisir comme cible.


Étape 2 — Branche de fonctionnalité

git switch -c feature/bonus-score   # créée depuis develop

La convention de nommage feature/<sujet> permet de repérer le rôle de la branche d’un coup d’œil.


Étape 3 — Le fichier regles.md

printf "Bonus : 100 points au-delà de 10 000 points.\n" > regles.md
git add regles.md
git commit -m "docs: règle de bonus à 10 000 points"

Étape 4 — Pousser vers le distant

git push -u origin feature/bonus-score

L’option -u ( --set-upstream) lie la branche locale à sa branche distante : les prochains git push / git pull fonctionneront sans argument. C’est pratique.


Étape 5 — Merge Request, revue, correction, fusion

Dans GitLab (partie interface web, pas de commande git !) :

  1. Créer la MR : dépôt > Merge requests > New merge request > source feature/bonus-score, cible develop > remplir titre et description > Create.
  2. Demander une revue : dans la MR, Reviewers > ajouter un relecteur. GitLab le notifie.
  3. Le relecteur commente, par exemple : « Préciser que le bonus ne s’applique qu’une fois par partie. »
  4. Corriger la remarque localement (la MR se met à jour automatiquement au push) :
printf "Bonus : 100 points au-delà de 10 000 points, une seule fois par partie.\n" > regles.md
git add regles.md
git commit -m "docs: bonus unique par partie (suite revue)"
git push
  1. Fusionner : le/la relecteur/relectrice approuve (Approve), puis on clique sur Merge dans la MR.
  2. Synchroniser le dépôt local avec la fusion effectuée sur GitLab :
git switch develop
git pull                                        # récupère le commit de fusion
git branch -d feature/bonus-score               # la branche est fusionnée, on la supprime
git push origin --delete feature/bonus-score   # (facultatif) nettoyage distant

Étape 6 — Tester rebase sur une branche personnelle

Scénario simulé : pendant que tu travailles sur ta branche, develop a avancé (un camarade a fusionné sa MR).

# Branche personnelle créée depuis develop
git switch -c perso/test-rebase

# Simuler la mise à jour de develop par quelqu'un d'autre
# (une MR d'un camarade a corrigé la formulation dans regles.md)
git switch develop
printf "Bonus : 100 points au-delà de 10 000 points, une seule fois par manche.\n" > regles.md
git commit -am "docs: « partie » remplacé par « manche » (MR d'un camarade)"
git push

# Sur la branche personnelle, modifier la même ligne de regles.md
git switch perso/test-rebase
printf "Bonus : 200 points au-delà de 10 000 points, une seule fois par partie.\n" > regles.md
git commit -am "docs: bonus passé à 200 points"

# Rejouer ta branche AU-DESSUS du nouveau develop
git rebase develop

Deux issues possibles :

A. Pas de conflit : Git « détache » ton commit et le rejoue par-dessus le nouveau develop. L’historique devient linéaire.

B. Conflit (c’est le cas ici : les deux commits modifient la même ligne de regles.md) :

# Git marque le conflit dans regles.md :
# <<<<<<< HEAD        (version de develop : « une seule fois par manche »)
# =======
# >>>>>>> commit     (ta version : « bonus 200 ... par partie »)
  1. Ouvrir regles.md, garder la version souhaitée, supprimer les marqueurs.
  2. git add regles.md
  3. git rebase --continue
  4. Pour tout annuler et revenir à l’état d’avant le rebase : git rebase --abort

Point crucial après un rebase : les commits ont été réécrits (nouveaux identifiants). Si la branche était déjà poussée, un simple git push sera rejeté. Il faut :

git push --force-with-lease      # jamais --force brut : --force-with-lease refuse d'écraser le travail d'un autre

Vérification finale

git log --oneline --graph --all --decorate

Historique attendu (linéaire grâce au rebase) :

rebase


Merge Request contre Rebase : Différence

Ce sont deux outils de niveaux différents, souvent confondus car on les utilise dans le même flux de travail.

La Merge Request (MR) : une demande, un processus d’équipe

Le rebase : une réécriture locale de l’historique

Avant (histoire divergente) :

avant histoire divergente

Après git rebase develop depuis feature :

avant histoire divergente

Comparaison

Aspect Merge (via MR) Rebase
Nature Processus GitLab / commande git merge Commande git rebase
Historique Non linéaire (commit de fusion, losange) Linéaire (commits rejoués)
Réécrit les commits ? Non, ils sont conservés tels quels Oui, nouveaux identifiants
Utilisation typique Intégrer une branche relue dans develop Se mettre à jour : git rebase develop avant de pousser
Risque Aucun (opération additive) Conflits à résoudre ; push --force-with-lease si déjà poussé
Règle d’or Relecture obligatoire avant fusion Ne jamais rebase une branche publique partagée

Le flux typique qui combine les deux

git switch feature/bonus-score
git fetch origin
git rebase origin/develop    # 1) rejouer ma branche au-dessus du develop à jour
# résoudre les conflits éventuels
git push --force-with-lease  # 2) mettre à jour ma MR ouverte
# 3) GitLab : la MR est relue puis fusionnée dans develop

En résumé :

Le rebase prépare et nettoie ta branche avant l’intégration alors que la Merge Request est le processus d’équipe qui décide de l’intégration.


TP avec corrigé minimaliste incomplet

Étape du TP Couvert par le corrigé minimaliste Ce qui manque
1. Dépôt + develop Partiellement develop n’est jamais poussée sur origin : GitLab ne pourra pas créer de MR vers une branche inexistante sur le distant
4. Pousser Partiellement git remote add origin <URL> absent (le commentaire l’évoque mais la commande n’y est pas)
5. MR + revue + correction + fusion Non Aucune étape concrète : ni la création de la MR (source/cible), ni le commit de correction de remarque, ni la fusion, ni le git pull de develop après fusion
6. Rebase Non, entièrement absent C’est le cœur pédagogique de la fin du TP : simulation de mise à jour de develop, git rebase develop, résolution de conflit (git add + git rebase --continue), git rebase --abort, et le besoin de --force-with-lease si la branche était poussée

Détails secondaires :

Ce TP corrigé couvre les étapes 1 à 4 « au minimum syndical » et s’arrête avant les 2 étapes qui font tout l’intérêt du TP (la MR de bout en bout et le rebase). Les étapes 5 et 6 sont ajoutées dans le script complet ci-dessous, qui reprend et prolonge le corrigé minimaliste.

Voici le corrigé complet dans un seul script (étapes 1 à 6) :

# ============ Étape 1 : dépôt local + branche develop ============
mkdir retrogame && cd retrogame
git init -b main
echo "# RetroGame" > README.md
git add README.md
git commit -m "chore: initialisation du dépôt"
git switch -c develop
git remote add origin <URL>       # URL du dépôt GitLab de la formation
git push -u origin develop         # obligatoire : cible des futures MR

# ============ Étape 2 : branche de fonctionnalité ============
git switch -c feature/bonus-score

# ============ Étape 3 : règle de bonus ============
printf "Bonus : 100 points au-delà de 10 000 points.\n" > regles.md
git add regles.md
git commit -m "docs: règle de bonus à 10 000 points"

# ============ Étape 4 : pousser vers le distant ============
git push -u origin feature/bonus-score

# ============ Étape 5 : MR, revue, correction, fusion ============
# (1) GitLab : Merge requests > New merge request
#     source : feature/bonus-score   ->   cible : develop
# (2) Reviewers : ajouter un relecteur (il est notifié)
# (3) Le relecteur commente : « préciser que le bonus est unique par partie »
printf "Bonus : 100 points au-delà de 10 000 points, une seule fois par partie.\n" > regles.md
git add regles.md
git commit -m "docs: bonus unique par partie (suite revue)"
git push                          # la MR ouverte se met à jour automatiquement
# (4) Le relecteur approuve, puis on clique sur Merge dans GitLab
# (5) Synchroniser le local avec la fusion faite sur GitLab :
git switch develop
git pull
git branch -d feature/bonus-score              # branche fusionnée -> nettoyage
git push origin --delete feature/bonus-score    # nettoyage côté distant aussi

# ============ Étape 6 : tester rebase sur une branche personnelle ============
git switch -c perso/test-rebase

# Simuler la mise à jour de develop par un camarade
# (sa MR fusionnée corrige la même ligne de regles.md)
git switch develop
printf "Bonus : 100 points au-delà de 10 000 points, une seule fois par manche.\n" > regles.md
git commit -am "docs: « partie » remplacé par « manche » (MR d'un camarade)"
git push

# De retour sur la branche personnelle, modifier la même ligne
git switch perso/test-rebase
printf "Bonus : 200 points au-delà de 10 000 points, une seule fois par partie.\n" > regles.md
git commit -am "docs: bonus passé à 200 points"

# Rejouer la branche AU-DESSUS du develop mis à jour
git rebase develop
# -> CONFLIT sur regles.md. Résolution :
#    1. éditer regles.md : garder la version voulue,
#       supprimer les marqueurs <<<<<<< ======= >>>>>>>
#    2. git add regles.md
#    3. git rebase --continue     (ou git rebase --abort pour tout annuler)
git push --force-with-lease       # commits réécrits -> push forcé sécurisé

# ============ Vérification ============
git log --oneline --graph --all --decorate

Rappels pour l’étape 6 :


2. POO : variables, constantes, classes et instances

Classe et instances Java

La page de cours

public class Joueur {
    public static final int SCORE_MAX = 1_000_000;
    private final String pseudo;
    private int points;

    public Joueur(String pseudo) {
        if (pseudo == null || pseudo.isBlank()) {
            throw new IllegalArgumentException("Pseudo obligatoire");
        }
        this.pseudo = pseudo;
    }

    public void ajouterPoints(int bonus) {
        if (bonus < 0 || bonus > SCORE_MAX - points) {
            throw new IllegalArgumentException("Bonus invalide");
        }
        points += bonus;
    }

    public String getPseudo() { return pseudo; }
    public int getPoints() { return points; }
}

TP 2 — Créer des joueurs

Créer 2 instances, ajouter 1 200 points à la première, afficher leurs pseudos et leurs scores. Tester un pseudo vide et un bonus négatif.

Corrigé :

Joueur alice = new Joueur("Alice");
Joueur samir = new Joueur("Samir");
alice.ajouterPoints(1200);
System.out.println(alice.getPseudo() + " : " + alice.getPoints());
System.out.println(samir.getPseudo() + " : " + samir.getPoints());
// new Joueur("");        // IllegalArgumentException
// alice.ajouterPoints(-1); // IllegalArgumentException

3. Encapsulation, visibilité, Lombok

utilisation de Lombok

Encapsulation : garder l’état privé et proposer des opérations qui garantissent les règles métier. Un setter n’est pas obligatoire : ajouterPoints() est préférable à setPoints() si les points ne doivent jamais diminuer.

Visibilité Même classe Même package Sous-classe autre package Partout
private Oui Non Non Non
sans modificateur Oui Oui Non Non
protected Oui Oui Oui (règles d’accès) Non
public Oui Oui Oui Oui

Lombok génère du code à la compilation : @Getter, @Setter, @RequiredArgsConstructor, @ToString. Il réduit le code répétitif, mais n’est pas une excuse pour rendre toutes les propriétés modifiables. Prudence avec @Data sur les entités JPA : equals, hashCode et toString peuvent interagir dangereusement avec les relations et proxys Hibernate.

import lombok.Getter;

@Getter
public class Jeu {
    private final String titre;
    public Jeu(String titre) { this.titre = titre; }
}

Maven Lombok (extrait) :

<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <optional>true</optional>
</dependency>

Dans Spring Boot 4, utiliser la gestion des versions du parent/BOM. Configurer le traitement d’annotations dans l’IDE et, si nécessaire, dans le compilateur Maven.

TP 3 — Protéger l’état

Expliquer pourquoi public int points est risqué. Modifier Joueur pour interdire un score dépassant SCORE_MAX. Réécrire getPseudo() avec Lombok, sans ajouter @Setter.

Corrigé : la méthode ajouterPoints() du TP 2 vérifie bonus > SCORE_MAX - points. Ajouter @Getter sur la classe et supprimer le getter manuel si Lombok est correctement configuré.


Les Value Objects

La confusion est fréquente : les value objects sont aussi des objets du domaine ! La vraie distinction n’est pas « métier vs technique », mais identité vs valeur. Par conséquent, à ne pas confondre avec des Entity.


Distinction fondamentale

Une entité a une identité. 2 entités avec les mêmes valeurs restent deux choses différentes. Un joueur change de pseudo, de score, d’adresse : c’est toujours LE même joueur, identifiable par son id.

Un value object n’a pas d’identité. Il n’est défini que par ses valeurs. 2 value objects avec les mêmes valeurs sont interchangeables, indiscernables.

// ENTITÉ : définie par son identité
public class Joueur {
    private final UUID id;      // <- l'identité
    private String pseudo;      // mutable : le pseudo peut changer,
    private int score;          // c'est toujours le même joueur
}

// VALUE OBJECT : défini par ses valeurs, sans identité
public record Points(int valeur) {
    public Points {
        if (valeur < 0) throw new IllegalArgumentException();
    }
    public Points ajouter(Points autre) {
        return new Points(valeur + autre.valeur);  // immuable : on renvoie un nouveau
    }
}

Les record Java sont parfaits pour les value objects : immuables par construction, avec equals/hashCode basés sur les valeurs.


Ce que le value object apporte concrètement

1. La validation au bon endroit, une seule fois

Sans value object, int score traîne partout et chacun doit se souvenir que « le score ne peut pas être négatif ». Avec Points, il est impossible de créer un score invalide : le type le garantit. Le compilateur fait le travail à notre place.

2. L’immutabilité, donc la sécurité

Un value object ne change jamais. On le remplace. Plus de bugs du genre « j’ai passé mon objet à une méthode et elle l’a modifié en douce ». Partager un value object entre plusieurs objets ne présente aucun risque.

3. Du typage qui parle métier
public void enregistrer(int score, int niveau);        // int partout, inversion facile
public void enregistrer(Points score, Niveau niveau);  // impossible d'inverser : le compilateur refuse

Donc : 2 int sont interchangeables par erreur alors que nos Points et Niveau ne le sont pas !

4. Vocabulaire du domaine

« Le joueur gagne 100 points bonus » se lit dans le code :

score.ajouter(Bonus.DE_BASE)   // plutôt que : score = score + 100

Piège : quand utiliser quoi ?

Question Entité Value object
Deux instances identiques doivent-elles être distinguées ? Oui => entité Non, interchangeables → VO
L’objet va-t-il changer au cours de sa vie ? Oui (mutable) Non (immuable, on remplace)
A-t-il un cycle de vie propre ? Oui (créé, modifié, supprimé) Non, il vit via l’entité qui le porte
Exemples RetroGame Joueur, Partie, Manche Points, Pseudo, Adresse, PeriodeDeJeu

Test rapide : si on peut remplacer l’objet par un autre strictement identique sans que rien ne change dans le domaine, c’est un value object. Un Points(150) vaut exactement un autre Points(150) ; un joueur ne vaut jamais « un autre joueur identique ».


L’intérêt par rapport à l’entité

Ce ne sont pas des concurrents : l’entité est le squelette (qui porte l’identité et le cycle de vie), les value objects sont la chair (ils portent les règles et les invariants sur les données). Un domaine bien modélisé utilise beaucoup de value objects, justement parce qu’ils rendent les règles explicites et les erreurs impossibles dès la compilation.


Règle d’or du DDD

Par défaut, préfère le value object. : On ne crée une entité que si on a une vraie raison d’identifier l’objet indépendamment de ses valeurs !

4. Streams et expressions lambda

Les Streams avec Java

La page du cours sur les Streams et Lambda…

Lambda : fonction anonyme courte, par exemple s -> s.points() >= 1000. Stream : pipeline de transformation ; les opérations intermédiaires (filter, map, sorted) sont généralement paresseuses ; toList() déclenche l’exécution et produit une liste non modifiable en Java 17.

record Score(String pseudo, int points) {}

List<Score> scores = List.of(
    new Score("Alice", 1200),
    new Score("Samir", 800),
    new Score("Zoé", 1500)
);

List<String> meilleurs = scores.stream()
    .filter(s -> s.points() >= 1000)
    .sorted(Comparator.comparingInt(Score::points).reversed())
    .map(Score::pseudo)
    .toList();
// [Zoé, Alice]

Collections : List conserve un ordre et accepte les doublons ; Set garantit l’unicité selon equals/hashCode ; Map<K,V> associe une clé à une valeur.

TP 4 — Classement

À partir de scores, calculer (1) les pseudos ayant au moins 1 000 points, (2) la somme des points, (3) un Map<String,Integer> pseudo → points.

Corrigé :

List<String> pseudos = scores.stream()
    .filter(s -> s.points() >= 1000)
    .map(Score::pseudo)
    .toList();
int total = scores.stream().mapToInt(Score::points).sum();
Map<String, Integer> parPseudo = scores.stream()
    .collect(Collectors.toMap(Score::pseudo, Score::points));

Attention : toMap échoue en cas de clés dupliquées sans fonction de fusion ; fournir par exemple (a,b) -> Math.max(a,b) si les pseudos peuvent apparaître plusieurs fois.


5. Maven et projets multimodules

Maven

Page sur Spring Boot et configuration pom.xml pour Maven

Pour le projet RetroGame :

Dépendances d'un projet Maven multimodule

Maven gère le cycle de construction, les dépendances et les modules. pom.xml décrit un projet. Un projet multimodule contient un POM agrégateur (packaging=pom) et des modules enfants ; l’agrégation (<modules>) n’est pas une dépendance Java entre modules.

<!-- pom.xml racine -->
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>fr.formation</groupId>
  <artifactId>retrogame-parent</artifactId>
  <version>1.0.0</version>
  <packaging>pom</packaging>
  <modules>
    <module>retrogame-domaine</module>
    <module>retrogame-web</module>
  </modules>
</project>

Chaque module enfant déclare un <parent> pointant vers ce POM, son propre <artifactId> et, si nécessaire, ses dépendances. Un module web peut dépendre du domaine sans que le domaine dépende de Spring.

TP 5 — Comprendre la construction

Créer deux modules retrogame-domaine et retrogame-web (packaging jar), ajouter une classe Score au domaine, puis déclarer la dépendance du web vers le domaine. Lancer :

mvn clean verify
mvn -pl retrogame-web -am test
mvn dependency:tree

Corrigé de la dépendance dans retrogame-web/pom.xml :

<dependency>
  <groupId>fr.formation</groupId>
  <artifactId>retrogame-domaine</artifactId>
  <version>${project.version}</version>
</dependency>

Point de contrôle : -pl sélectionne un module et -am construit ses dépendances du même réacteur Maven.


6. Tests unitaires et tests d’intégration

JUnit 5

Page de cours sur les tests Unitaires et d’Intégration

Page du cours sur MockMVC et autres

TP 6A — JUnit 5

Écrire un test qui vérifie l’ajout de points et un test qui vérifie le rejet d’un bonus négatif.

Corrigé :

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

class JoueurTest {
    @Test
    void ajouteDesPoints() {
        Joueur joueur = new Joueur("Alice");
        joueur.ajouterPoints(1200);
        assertEquals(1200, joueur.getPoints());
    }

    @Test
    void refuseUnBonusNegatif() {
        Joueur joueur = new Joueur("Alice");
        assertThrows(IllegalArgumentException.class,
            () -> joueur.ajouterPoints(-5));
    }
}

TP 6B — Test HTTP avec MockMvc

Créer un contrôleur GET /api/bonjour renvoyant Bonjour RetroGame, puis vérifier le statut HTTP et le corps. Ici @WebMvcTest est un test de tranche MVC, pas un test d’intégration complet avec PostgreSQL.

Corrigé :

@RestController
class BonjourController {
    @GetMapping("/api/bonjour")
    String bonjour() { return "Bonjour RetroGame"; }
}
@WebMvcTest(BonjourController.class)
class BonjourControllerTest {
    @Autowired MockMvc mvc;

    @Test
    void repondBonjour() throws Exception {
        mvc.perform(get("/api/bonjour"))
            .andExpect(status().isOk())
            .andExpect(content().string("Bonjour RetroGame"));
    }
}

Imports à ajouter : org.springframework.beans.factory.annotation.Autowired, org.springframework.test.web.servlet.MockMvc, org.springframework.boot.webmvc.test.autoconfigure.WebMvcTest (Spring Boot 4), org.junit.jupiter.api.Test, et les imports statiques MockMvcRequestBuilders.get, MockMvcResultMatchers.*. Les packages des annotations de test ont évolué entre Boot 3 et Boot 4 : ne pas recopier automatiquement les anciens imports.

Vrai test d’intégration à réaliser ensuite : @SpringBootTest + PostgreSQL de test (idéalement Testcontainers), insertion d’un score via le service puis lecture via le repository. Utiliser une base isolée ; ne jamais exécuter ce test sur la base de travail de l’apprenant.


7. Spring Boot 4 : configuration, @Component et @Bean

Spring Boot 4

Page du cours sur Spring Boot

# src/main/resources/application.yml
retrogame:
  bonus: 100
spring:
  application:
    name: retrogame
@Component
public class BonusService {
    private final int bonus;

    public BonusService(@Value("${retrogame.bonus:0}") int bonus) {
        this.bonus = bonus;
    }
    public int appliquer(int score) { return score + bonus; }
}
@Configuration
class ReglesConfiguration {
    @Bean
    Clock horloge() { return Clock.systemDefaultZone(); }
}

TP 7 — Configuration externe

Créer retrogame.bonus=250 en YAML, injecter la valeur, puis tester que appliquer(1000) donne 1250. Expliquer la différence entre @Component et @Bean.

Corrigé : remplacer bonus: 100 par bonus: 250. Test Java simple avec new BonusService(250) ; test Spring possible avec @SpringBootTest et @Autowired BonusService.

Compatibilité Boot 4 : vérifier le POM de démarrage et les starters de la version 4.x utilisée ; plusieurs starters et packages d’auto-configuration ont évolué depuis Boot 3. Le code @Component, @Bean, @Value reste conceptuellement identique.


8. Spring Batch : importation de scores

Spring Batch

Page du cours sur Spring Batch

Pipeline Spring Batch avec rejets

Pour un développeur COBOL, le parallèle est direct : lecture séquentielle → contrôle → transformation → écriture → bilan. Spring Batch ajoute le suivi d’exécution, la reprise, les transactions et le traitement par chunks.

Composant Rôle Équivalent conceptuel COBOL
Job Traitement complet Programme batch
Step Étape du traitement Paragraphe de traitement
ItemReader Lecture des enregistrements READ
ItemProcessor Validation / transformation Contrôles métier
ItemWriter Écriture des résultats WRITE / SQL
JobRepository Métadonnées d’exécution Journal / suivi d’exploitation

Exemple de fichier :

pseudo;jeu;points;datePartie
Alice;Pac-Man;1200;2026-10-12
Samir;Tetris;-50;2026-10-13
Zoé;Pac-Man;abc;2026-10-14
Lina;Tetris;1800;2026-10-15

Trois issues différentes : un score négatif peut être filtré (processor retourne null) ; abc peut provoquer une erreur de lecture ; un doublon en base peut produire un rejet d’écriture. filterCount et skipCount sont distincts. Un SkipListener ne reçoit pas les éléments simplement filtrés.

TP 8 — Définir les règles

  1. Lire un CSV ; avec FlatFileItemReader.
  2. Convertir les lignes en ScoreCsv(String pseudo, String jeu, int points, LocalDate datePartie).
  3. Filtrer les points négatifs et les dates futures dans le processor.
  4. Écrire les scores valides via un writer JPA ou JDBC.
  5. Afficher readCount, writeCount, filterCount, readSkipCount et writeSkipCount.

Corrigé du processor (fragment) :

record ScoreCsv(String pseudo, String jeu, int points, LocalDate datePartie) {}

ItemProcessor<ScoreCsv, ScoreCsv> processor = score -> {
    if (score.points() < 0 || score.datePartie().isAfter(LocalDate.now())) {
        return null; // filtré, pas « skipped »
    }
    return score;
};

Corrigé du comptage (fragment) :

StepExecution step = jobExecution.getStepExecutions().iterator().next();
System.out.printf("lus=%d, écrits=%d, filtrés=%d, skips lecture=%d, skips écriture=%d%n",
    step.getReadCount(), step.getWriteCount(), step.getFilterCount(),
    step.getReadSkipCount(), step.getWriteSkipCount());

Point de vigilance : abc ne sera ignoré que si le step est configuré en mode fault tolerant avec une politique de skip ciblée ; sinon le job échouera. Pour une date invalide, employer un parseur strict. Le JobLauncher peut être synchrone ou asynchrone selon sa configuration. Ne pas considérer le statut COMPLETED comme la preuve qu’aucune ligne n’a été rejetée.

Configuration d’un step en Boot 4 : utiliser les API Spring Batch compatibles avec la version effective (Spring Batch 6 avec Spring Boot 4) et adapter les signatures de StepBuilder et des lecteurs/writers aux dépendances du projet. Les fragments ci-dessus illustrent les responsabilités, pas un job prêt à lancer.


9. Thymeleaf et fragments réutilisables

Thymeleaf

Page du cours sur Thymeleaf

Cycle MVC et rendu Thymeleaf

Un fragment évite de recopier un en-tête, une navigation ou un pied de page. Le rendu est côté serveur ; aucun JavaScript n’est nécessaire pour afficher un classement ou soumettre un formulaire classique.

templates/fragments/layout.html :

<!DOCTYPE html>
<html lang="fr" xmlns:th="http://www.thymeleaf.org">
<body>
<header th:fragment="entete(titre)">
  <h1 th:text="${titre}">RetroGame</h1>
  <nav aria-label="Navigation principale"><a th:href="@{/}">Accueil</a></nav>
</header>
<footer th:fragment="pied">© RetroGame — TP Java</footer>
</body>
</html>

templates/accueil.html :

<!DOCTYPE html>
<html lang="fr" xmlns:th="http://www.thymeleaf.org">
<head><meta charset="UTF-8"><title>Classement</title></head>
<body>
  <div th:replace="~{fragments/layout :: entete('Classement RetroGame')}"></div>
  <main>
    <form th:action="@{/importer}" method="post">
      <button type="submit">Importer les scores</button>
    </form>
    <p th:if="${message}" th:text="${message}" role="status"></p>
  </main>
  <div th:replace="~{fragments/layout :: pied}"></div>
</body>
</html>

TP 9 — Réutiliser un en-tête

Créer classement.html et jeux.html, toutes deux utilisant entete(titre) et pied. Le contrôleur doit ajouter les données au modèle et retourner le nom du template. Corrigé : reprendre les deux expressions th:replace ci-dessus et changer seulement le titre passé en argument.

Accessibilité : conserver une hiérarchie de titres cohérente, les libellés des formulaires, les en-têtes de tableaux (scope="col") et les messages d’état. Une page peut fonctionner sans JavaScript tout en étant interactive grâce aux formulaires HTML.


10. DDD : concevoir autour du métier

DDD

Concepts DDD appliqués à RetroGame

DDD (Domain-Driven Design) consiste à construire le logiciel à partir d’une compréhension partagée du métier. Ce n’est ni un framework ni l’obligation de créer une classe domaine pour chaque table SQL.

TP 10 — Modéliser une partie

Règles : une partie possède un joueur, un jeu, une date et des points ; les points ne sont jamais négatifs ; la date ne peut pas être future. Identifier l’entité et les value objects. Écrire une première règle en Java pur.

Corrigé minimal :

public record Points(int valeur) {
    public Points {
        if (valeur < 0) throw new IllegalArgumentException("Points négatifs");
    }
}

public record Partie(String pseudo, String jeu, Points points, LocalDate date) {
    public Partie {
        if (pseudo == null || pseudo.isBlank()) throw new IllegalArgumentException("Pseudo vide");
        if (jeu == null || jeu.isBlank()) throw new IllegalArgumentException("Jeu vide");
        Objects.requireNonNull(points);
        Objects.requireNonNull(date);
        if (date.isAfter(LocalDate.now())) throw new IllegalArgumentException("Date future");
    }
}

Nuance : ce record Partie est un modèle simplifié d’exercice. Dans un vrai DDD, une partie dotée d’une identité persistante et d’un cycle de vie sera souvent une classe entité plutôt qu’un value object record. Une règle dépendante de l’heure gagne à recevoir une Clock injectée pour rester testable.


11. Architecture hexagonale

Architecture hexagonale

Page du cours sur l’Architecture Hexagonale

Exemple de Ports et adaptateurs de RetroGame :

Ports et adaptateurs de RetroGame

Objectif : isoler les règles métier des technologies. Le cœur ne dépend ni de Spring MVC, ni de JPA, ni de PostgreSQL. Les dépendances de code pointent vers l’intérieur.

// Cœur : aucune annotation Spring
public interface EnregistrerScoreUseCase {
    void enregistrer(String pseudo, String jeu, int points);
}

public interface ScoreRepositoryPort {
    void sauvegarder(String pseudo, String jeu, int points);
}

public final class EnregistrerScoreService implements EnregistrerScoreUseCase {
    private final ScoreRepositoryPort repository;

    public EnregistrerScoreService(ScoreRepositoryPort repository) {
        this.repository = repository;
    }

    @Override
    public void enregistrer(String pseudo, String jeu, int points) {
        if (points < 0) throw new IllegalArgumentException("Score négatif");
        repository.sauvegarder(pseudo, jeu, points);
    }
}

TP 11 — Remplacer PostgreSQL par une mémoire

Créer un adaptateur ScoreRepositoryMemoire qui stocke les scores dans une List, puis tester EnregistrerScoreService sans démarrer Spring.

Corrigé :

public final class ScoreRepositoryMemoire implements ScoreRepositoryPort {
    private final List<String> lignes = new ArrayList<>();

    @Override
    public void sauvegarder(String pseudo, String jeu, int points) {
        lignes.add(pseudo + ";" + jeu + ";" + points);
    }

    public List<String> lignes() { return List.copyOf(lignes); }
}
@Test
void enregistreSansBase() {
    var repository = new ScoreRepositoryMemoire();
    var service = new EnregistrerScoreService(repository);
    service.enregistrer("Alice", "Tetris", 1500);
    assertEquals(1, repository.lignes().size());
}

Lien avec DDD : DDD répond surtout à « quel est le modèle métier ? » ; l’hexagonal répond surtout à « comment empêcher les détails techniques de contaminer le métier ? ». Ils sont complémentaires, pas synonymes.


12. Évaluation finale et aide-mémoire

Défi de synthèse

Demande métier : « Un joueur peut importer des scores CSV, les scores négatifs sont rejetés, le classement affiche les 5 meilleurs résultats. »

  1. Créer feature/top5 depuis develop, faire un commit et préparer une MR.
  2. Écrire une règle Java testable refusant les points négatifs.
  3. Utiliser un Stream pour obtenir les cinq meilleurs scores.
  4. Configurer le nombre de résultats via application.yml.
  5. Afficher le classement dans Thymeleaf avec un fragment d’en-tête.
  6. Expliquer où se trouvent Reader, Processor, Writer et les compteurs du batch.
  7. Dessiner le port entrant et le port sortant si l’application passe en hexagonal.

Éléments de corrigé :

List<Score> top5 = scores.stream()
    .filter(s -> s.points() >= 0)
    .sorted(Comparator.comparingInt(Score::points).reversed())
    .limit(5)
    .toList();
retrogame:
  classement:
    limite: 5

Critères de réussite : code compilable, au moins un test passant, historique Git lisible, pas de logique métier dans le contrôleur, pas de SQL dans le domaine, explication correcte des filtres vs skips du batch.

Aide-mémoire

Notion Question à se poser
final Peut-on réaffecter cette variable ?
Encapsulation Qui a le droit de modifier cet état ?
@Component Spring doit-il découvrir cette classe ?
@Bean Dois-je fabriquer/configurer explicitement cet objet ?
Stream Quelle suite de filtres et transformations ?
Test unitaire Puis-je tester sans Spring ni base ?
Test d’intégration Quels composants réels collaborent ?
Spring Batch Quelle ligne est lue, filtrée, écrite ou ignorée ?
DDD Quels mots et règles appartiennent au métier ?
Hexagonal Le domaine dépend-il d’un détail technique ?
Git rebase Vais-je réécrire un historique déjà partagé ?

Commandes utiles

java -version
mvn -version
mvn clean test
mvn clean verify
git status
git log --oneline --graph --all
git diff
git fetch origin

**Note : ** Les TP sont indépendants pour faciliter ta révision. Pour un projet Spring Boot 4 réellement exécutable, fixer la version 4.x, les starters compatibles et les dépendances Spring Batch correspondantes avant de fusionner tous les exemples. Si tu préfères, tu peux aussi réaliser le Projet RetroGame complet