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.
develop
regles.md
rebase
la page du cours sur Git, GitLab et GitFlow…
À retenir :
main
feature/*
release/*
hotfix/*
git status
git switch develop && git pull && git switch -c feature/classement
git add . && git commit -m "feat: ajout du classement"
git push -u origin feature/classement
git fetch origin && git rebase origin/develop
Merge ou rebase :
merge
git push --force-with-lease
--force
feature/bonus-score
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).
origin
<URL>
https://gitlab.example.com/formation/retrogame.git
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 :
feat
fix
docs
docs: règle de bonus
refactor
test
chore
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.
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.
feature/<sujet>
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"
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.
-u
--set-upstream
git push
git pull
Dans GitLab (partie interface web, pas de commande git !) :
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
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
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 »)
git add regles.md
git rebase --continue
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
git log --oneline --graph --all --decorate
Historique attendu (linéaire grâce au rebase) :
Ce sont deux outils de niveaux différents, souvent confondus car on les utilise dans le même flux de travail.
git rebase develop
Avant (histoire divergente) :
Après git rebase develop depuis feature :
feature
git merge
git rebase
push --force-with-lease
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.
git remote add origin <URL>
git add
--force-with-lease
Détails secondaires :
master
--continue
--abort
printf
echo
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 :
La page de cours
int points = 1200
final
static final
new
static
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; } }
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
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.
ajouterPoints()
setPoints()
private
protected
public
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.
@Getter
@Setter
@RequiredArgsConstructor
@ToString
@Data
equals
hashCode
toString
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.
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.
public int points
Joueur
SCORE_MAX
getPseudo()
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é.
bonus > SCORE_MAX - points
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.
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.
record
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.
int score
Points
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.
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 !
int
Niveau
« Le joueur gagne 100 points bonus » se lit dans le code :
score.ajouter(Bonus.DE_BASE) // plutôt que : score = score + 100
Partie
Manche
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 ».
Points(150)
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.
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 !
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.
s -> s.points() >= 1000
filter
map
sorted
toList()
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.
List
Set
equals/hashCode
Map<K,V>
À 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.
scores
Map<String,Integer>
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.
toMap
(a,b) -> Math.max(a,b)
Page sur Spring Boot et configuration pom.xml pour Maven
Pour le projet RetroGame :
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
packaging=pom
<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.
<parent>
<artifactId>
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 :
retrogame-domaine
retrogame-web
jar
Score
mvn clean verify mvn -pl retrogame-web -am test mvn dependency:tree
Corrigé de la dépendance dans retrogame-web/pom.xml :
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.
-pl
-am
Page de cours sur les tests Unitaires et d’Intégration
Page du cours sur MockMVC et autres
@SpringBootTest
Écrire un test qui vérifie l’ajout de points et un test qui vérifie le rejet d’un bonus négatif.
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)); } }
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.
GET /api/bonjour
Bonjour RetroGame
@WebMvcTest
@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.
org.springframework.beans.factory.annotation.Autowired
org.springframework.test.web.servlet.MockMvc
org.springframework.boot.webmvc.test.autoconfigure.WebMvcTest
org.junit.jupiter.api.Test
MockMvcRequestBuilders.get
MockMvcResultMatchers.*
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.
Page du cours sur Spring Boot
application.properties
application.yml
@Component
@Service
@Repository
@Bean
@Configuration
# 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(); } }
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.
retrogame.bonus=250
appliquer(1000)
1250
Corrigé : remplacer bonus: 100 par bonus: 250. Test Java simple avec new BonusService(250) ; test Spring possible avec @SpringBootTest et @Autowired BonusService.
bonus: 100
bonus: 250
new BonusService(250)
@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.
@Value
Page du cours sur Spring Batch
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.
Job
Step
ItemReader
READ
ItemProcessor
ItemWriter
WRITE
JobRepository
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.
processor
null
abc
filterCount
skipCount
SkipListener
;
FlatFileItemReader
ScoreCsv(String pseudo, String jeu, int points, LocalDate datePartie)
readCount
writeCount
readSkipCount
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.
JobLauncher
COMPLETED
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.
StepBuilder
Page du cours sur 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 :
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 :
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>
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.
classement.html
jeux.html
entete(titre)
pied
th:replace
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.
scope="col"
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.
domaine
Classement
Catalogue de jeux
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.
record Partie
Clock
Page du cours sur l’Architecture Hexagonale
Exemple de 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.
EnregistrerScoreUseCase
ScoreRepositoryPort
// 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); } }
Créer un adaptateur ScoreRepositoryMemoire qui stocke les scores dans une List, puis tester EnregistrerScoreService sans démarrer Spring.
ScoreRepositoryMemoire
EnregistrerScoreService
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.
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. »
feature/top5
Reader
Processor
Writer
É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.
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