
Inès a lu votre diagnostic. Sa réponse tient en deux phrases :
D’accord sur l’ordre. Mais je ne veux pas d’un correctif d’arrondi : je veux que ce bug ne puisse plus exister.
De son côté, Samuel a précisé son calendrier : la première stagiaire arrive dans deux mois, et ses congés devront être gérés par Hamac dès son arrivée.
RemplacerMath.ceilparMath.floorprendrait une minute. Mais la règle resterait copiée dans deux méthodes, au milieu de l’accès aux données et des notifications. La règle des stages devrait être ajoutée dans ces mêmes méthodes, avec les mêmes risques de divergence. Pour satisfaire Inès, il faut changer l’organisation du code, pas seulement une ligne.
Pourquoi une organisation d’ensemble ?
Les principes que vous avez utilisés dans votre diagnostic, comme la responsabilité unique, s’appliquent à une classe ou à une méthode. Ils vous disent qu’approveen fait trop, mais pas où ranger ce que vous allez en sortir. Une application a aussi besoin d’une organisation d’ensemble, partagée par toute l’équipe : où placer les règles métier ? Qui reçoit les requêtes ? Qui décide de ce qui est affiché ?
C’est précisément ce qui a manqué à Hamac. Sans organisation convenue, chacun des trois développeurs successifs a placé son code à l’endroit le plus pratique sur le moment. Et l’endroit le plus pratique, dans une application web, c’est presque toujours le contrôleur : c’est là qu’arrive la requête.
Deux organisations complémentaires répondent à ces questions. Elles sont souvent confondues, et c’est la source de nombreux malentendus en entretien comme en revue de code : le pattern MVC, qui organise la présentation, et le découpage en couches, qui organise le reste de l’application.
Le pattern MVC, pour Model-View-Controller, distingue trois rôles dans la façon dont une application répond à un utilisateur :
le contrôleur reçoit une action de l’utilisateur et décide de la réponse ;
le modèle contient les données à présenter ;
la vue met ces données en forme.
Dans Hamac, vous le voyez à l’œuvre dans les pages web. Ouvrezsrc/main/java/com/hamac/controller/PageController.java:
@Controller
class PageController {
@GetMapping("/")
String leaveRequests(Model model) {
model.addAttribute("today", LocalDate.now());
return "leave-requests";
}
}L’annotation@Controllerindique à Spring que cette classe reçoit des requêtes et renvoie des pages. La méthode place dans l’objetModelles données dont la page a besoin, puis renvoie le nom d’un template. Thymeleaf combine alors le fichiersrc/main/resources/templates/leave-requests.html, la vue, avec ces données pour produire la page HTML :
<p>Données au <span th:text="${today}">01/01/2026</span></p>Rôle MVC | Dans les pages de Hamac |
Contrôleur |
|
Modèle | L’objet |
Vue | Le template |
EtLeaveController? Il est annoté@RestController: c’est aussi un contrôleur, mais il ne renvoie pas de page. Sa réponse est écrite directement dans le corps HTTP, en texte ou en JSON. Il n’y a donc pas de vue côté serveur : ce sont les pages et leur JavaScript qui présenteront ces données, quand vous les brancherez sur l’API au chapitre 6.
Pour ranger les règles métier, on utilise un autre découpage : l’organisation en couches. L’application se divise en trois couches qui s’appellent dans un seul sens :
le contrôleur reçoit la requête et traduit le résultat en réponse HTTP ;
le service applique les règles métier, comme « une demande n’est approuvée que si le solde la couvre » ;
le repository lit et enregistre les entités. Dans Hamac, ce sont les interfacesEmployeeRepositoryetLeaveRequestRepository, dont Spring Data JPA fournit l’implémentation.
MVC et les couches ne s’opposent pas : le contrôleur MVC et celui des couches sont la même classe. MVC décrit ce qui se passe entre ce contrôleur et l’utilisateur ; les couches décrivent ce qui se passe derrière lui.
Pourquoi insister sur le sens des appels ? Parce qu’il détermine ce que chaque couche peut ignorer. Le contrôleur connaît le service, mais le service ne sait rien de HTTP : il ne manipule ni requête, ni statut, niModel. Le jour où Samuel demandera un recalcul automatique des soldes chaque fin de mois, une tâche planifiée pourra appeler le même service, sans passer par l’API et sans dupliquer la règle.
Retenez ce test simple : un contrôleur bien organisé ne contient ni règle métier, ni accès direct aux données. Il orchestre. Si vous pouvez lire une règle RH dans votre contrôleur, elle n’est pas au bon endroit.
Si je déplace tout le contenu du contrôleur dans un service, celui-ci ne va-t-il pas devenir à son tour une classe qui fait tout ?
C’est un risque réel. Un service qui reçoit tout le code d’un contrôleur trop gros devient simplement un service trop gros. La couche service indique où placer les règles métier, mais pas comment les découper. C’est le rôle des principes SOLID, que vous allez appliquer dans la suite de ce chapitre.
SOLID regroupe cinq principes de conception objet. Vous en connaissez déjà le premier, la responsabilité unique. Les quatre autres prolongent les mécanismes vus dans le cours sur les design patterns : contrats, polymorphisme, composition et injection.
Chacun se traduit par une question à poser sur le code de Hamac :
Principe | Ce qu’il impose | La question à poser dans Hamac |
S — Responsabilité unique | Une classe n’a qu’une raison de changer. | Où vit la règle de calcul des droits ? |
O — Ouvert/fermé | On ajoute un comportement sans modifier le code existant. | Que faut-il modifier pour ajouter les stages ? |
L — Substitution de Liskov | Toute implémentation d’un contrat peut en remplacer une autre. | Le service peut-il faire confiance à n’importe quelle politique de calcul ? |
I — Ségrégation des interfaces | On ne dépend que des méthodes dont on a besoin. | De quoi le traitement des congés a-t-il besoin pour lire un salarié ? |
D — Inversion des dépendances | Le métier dépend d’abstractions, pas de détails techniques. | Qui crée les collaborateurs du service ? |
Plutôt que de les étudier un par un, de façon abstraite, vous allez les rencontrer dans l’ordre où le refactoring de Hamac les fait apparaître. Toutes les nouvelles classes de ce chapitre se placent dans un packagecom.hamac.service.
Le premier refactoring traite la cause du bug. Le calcul des droits change pour une seule raison, l’évolution des règles RH décidées par Samuel : il mérite donc sa propre place, hors du contrôleur.
Commencez par remplacer les chaînes"CDI","CDD"et"Alternance"par une énumération. La base continue de stocker ces codes : l’énumération se charge de les traduire.
public enum ContractType {
PERMANENT("CDI"),
FIXED_TERM("CDD"),
APPRENTICESHIP("Alternance");
private final String code;
ContractType(String code) {
this.code = code;
}
public static ContractType fromCode(String code) {
return Arrays.stream(values())
.filter(type -> type.code.equals(code))
.findFirst()
.orElseThrow(() -> new IllegalArgumentException("Unknown contract type: " + code));
}
}Remarquez le comportement face à un code inconnu. Le starter attribuait silencieusement zéro jour, ce qui transformait une faute de frappe en bug métier.fromCodelève une exception : un type de contrat inconnu est une erreur de données, et il vaut mieux qu’elle soit visible immédiatement plutôt que découverte par un salarié privé de congés.
Définissez ensuite le contrat d’une politique de calcul :
public interface LeaveEntitlementPolicy {
boolean supports(ContractType type);
double computeEntitlement(Employee employee, LocalDate today);
}La méthodesupportspermet à chaque politique de dire à quel type de contrat elle s’applique : vous verrez son intérêt dans un instant. La date du jour, elle, est passée en paramètre plutôt que lue avecLocalDate.now()à l’intérieur du calcul. Ce détail a une conséquence importante. Un calcul qui lit lui-même la date du jour donne un résultat différent chaque mois : un test qui vérifie « 14,56 jours » passerait aujourd’hui et échouerait le mois prochain. En recevant la date, la politique devient prévisible : pour un même salarié et une même date, elle renvoie toujours le même résultat.
Chaque type de contrat devient une politique concrète. Voici celle des CDD, qui reprend le calcul confirmé par Samuel, celui des mois complets :
public final class FixedTermContractPolicy implements LeaveEntitlementPolicy {
private static final double DAYS_PER_FULL_MONTH = 2.08;
private static final long DAYS_PER_MONTH = 30;
@Override
public boolean supports(ContractType type) {
return type == ContractType.FIXED_TERM;
}
@Override
public double computeEntitlement(Employee employee, LocalDate today) {
var daysSinceHire = ChronoUnit.DAYS.between(employee.getHireDate(), today);
var fullMonths = Math.floorDiv(daysSinceHire, DAYS_PER_MONTH);
return fullMonths * DAYS_PER_FULL_MONTH;
}
}Comparez avec le starter :detmsont devenusfullMonthsetDAYS_PER_FULL_MONTH. Le nom de la variable dit maintenant ce que Samuel vous a confirmé : on compte des mois complets. EtMath.floorDivremplace la division entière, qui arrondissait sans le dire : l’arrondi au mois inférieur est désormais écrit noir sur blanc. Un développeur tenté d’utiliserMath.ceilverrait immédiatement la contradiction.
La division par 30, elle, reste une approximation du mois. Vous la conservez telle quelle : un refactoring ne change pas la règle, il la range. Si l’entreprise décide un jour de compter les mois calendaires, il n’y aura plus qu’une seule classe à modifier.
Le principe ouvert/fermé, ou OCP pour Open/Closed Principle, demande qu’un module soit ouvert à l’extension mais fermé à la modification. Autrement dit, ajouter un comportement ne devrait pas obliger à modifier du code déjà écrit et testé.
Avec l’if/elsedu starter, ajouter les stages imposait de modifier deux méthodes qui fonctionnaient, au risque de les casser. Avec des politiques séparées, il faut maintenant un endroit unique qui trouve la politique d’un type de contrat :
public final class LeavePolicyResolver {
private final List<LeaveEntitlementPolicy> policies;
public LeavePolicyResolver(List<LeaveEntitlementPolicy> policies) {
this.policies = List.copyOf(policies);
}
public LeaveEntitlementPolicy policyFor(ContractType type) {
return policies.stream()
.filter(policy -> policy.supports(type))
.findFirst()
.orElseThrow(() -> new IllegalStateException("No leave policy for " + type));
}
}Le résolveur reçoit la liste des politiques disponibles et demande à chacune si elle s’applique au type de contrat. Il ne connaît aucune politique concrète. Pour ajouter les stages, il suffira de créer une nouvelle politique et de l’ajouter à cette liste : le service et les politiques existantes ne changeront pas. Ce choix d’une liste et desupportsn’est pas anodin : au chapitre 4, c’est exactement la forme que Spring sait remplir automatiquement.
OCP n’est pas pour autant une interdiction absolue de modifier du code. L’énumérationContractTypeet la liste des politiques recevront chacune une ligne de plus. Mais ces modifications se limitent à une déclaration et à un point d’assemblage, sans aucune règle métier : elles ne peuvent pas casser le calcul des CDI.
Java propose une alternative à Strategy, que vous croiserez souvent dans du code récent : leswitchexhaustif. Sur une énumération, une expressionswitchsans branchedefaultne compile que si chaque constante est traitée :
double entitlement = switch (type) {
case PERMANENT -> 25;
case FIXED_TERM -> Math.floorDiv(daysSinceHire, 30) * 2.08;
case APPRENTICESHIP -> 25 + 5;
};Ajoutez une constanteINTERNSHIPàContractType, et le compilateur signale chaqueswitchqui l’a oubliée. Le même mécanisme existe avec une interfacesealed, qui liste ses implémentations autorisées, et unswitchpar pattern matching sur ces implémentations. C’est une vraie garantie : impossible d’oublier un cas.
Alors, comment choisir ? Posez-vous deux questions :
Question | Plutôt un switch exhaustif | Plutôt Strategy |
La liste des cas est-elle fermée ? | Oui : elle change rarement, et chaque ajout doit être vérifié partout | Non : de nouveaux cas arrivent, parfois ajoutés par d’autres équipes |
Chaque cas porte-t-il une vraie règle ? | Non : une ligne par cas suffit | Oui : chaque règle a ses paramètres, ses cas limites et ses tests |
Dans Hamac, les types de contrat évoluent déjà, avec les stages, et chaque règle va s’étoffer : le taux des CDD, par exemple, ne restera pas écrit en dur bien longtemps. Strategy est donc le bon choix pour le calcul des droits. Mais vous utiliserez leswitchexhaustif dans ce même chapitre, pour traduire le résultat d’une approbation en réponse HTTP : là, la liste des cas est fermée, et chaque cas tient en une ligne.
Le principe de substitution de Liskov, ou LSP, demande que toute implémentation d’un contrat puisse remplacer une autre sans surprendre le code qui l’utilise.
Ce principe prend tout son sens avec le résolveur. Le service ne sait pas quelle politique il reçoit : il appellecomputeEntitlementet fait confiance au résultat. Cette confiance n’est justifiée que si toutes les politiques respectent le même contrat.
Imaginez une politique des stages qui lancerait uneUnsupportedOperationExceptionpour une stagiaire arrivée depuis moins d’un mois, ou qui renverrait-1pour signifier « pas de congés ». Le service calculerait alors un solde absurde, ou planterait, sans que rien dans son code ne le laisse prévoir. Pour l’éviter, chaque politique doit respecter le même contrat implicite : renvoyer un nombre de jours positif ou nul pour tout salarié valide. Si un salarié n’a encore acquis aucun droit, sa politique renvoie0.
Vous voyez la différence avec les exceptions defromCodeet du résolveur :0signifie « ce salarié n’a pas de droits », alors que ces exceptions signifient « ce type de contrat n’existe pas » ou « personne n’a prévu de règle pour lui ». Le premier cas est une situation métier normale, les autres sont des erreurs.
Le principe de ségrégation des interfaces, ou ISP, recommande des interfaces ciblées plutôt qu’une interface qui fait tout.
OuvrezEmployeeRepository. Dans le starter, elle étendJpaRepository<Employee, Long>, et hérite ainsi d’une vingtaine de méthodes :findAll,count,deleteById,deleteAll… Le traitement des congés n’en utilise que deux : lire un salarié et l’enregistrer. Le reste n’est pas seulement inutile, il est risqué : rien n’empêche un développeur pressé d’appelerdeleteAll()depuis le service.
Spring Data propose une interface de base vide,Repository, qui ne fait que marquer l’interface comme repository. Vous y déclarez seulement les méthodes dont vous avez besoin :
public interface EmployeeRepository extends Repository<Employee, Long> {
Optional<Employee> findById(Long id);
Employee save(Employee employee);
}Spring Data génère toujours l’implémentation, à partir des méthodes déclarées. Comme leurs signatures sont identiques à celles deJpaRepository, le code qui les appelle ne change pas. En revanche,deleteAll()n’existe plus : le compilateur refuse désormais ce que l’application n’a pas besoin de faire. Vous verrez au chapitre 4 comment Spring Data produit ces implémentations.LeaveRequestRepositoryattendra ce chapitre pour être réduite de la même façon : le service utilise encore sonfindAll(), que vous corrigerez à ce moment-là.
Le même raisonnement s’applique au notificateur.NotificationServicepropose plusieurs méthodes : notifier un salarié, envoyer un récapitulatif hebdomadaire aux managers, renvoyer les notifications en échec. Le traitement des congés n’a besoin que de la première. Définissez donc une interface limitée à ce besoin, queNotificationServiceimplémente sans autre modification :
public interface LeaveNotifier {
void notify(Employee employee, String message);
}Le bénéfice apparaîtra dans les tests : le jour où vous remplacerez le notificateur par un faux, celui-ci n’aura qu’une méthode à écrire, et non trois.
N’en concluez pas qu’il faut découper chaque interface en méthodes isolées par précaution. ISP s’applique quand un client utilise une partie seulement d’une interface plus large, comme ici. Une interface dont tous les clients utilisent toutes les méthodes n’a pas besoin d’être découpée.
Le principe d’inversion des dépendances, ou DIP, demande que le code métier dépende d’abstractions, et non de détails techniques.
Le nouveauLeaveServicene crée plus rien lui-même. Il reçoit ses collaborateurs par son constructeur, et les conserve dans des champsfinal: les deux repositories, le résolveur de politiques et unLeaveNotifier. Les règles métier ne savent plus comment une notification est envoyée, ni quelle classe calcule les droits d’un CDD. C’est ce qui rendra possibles les tests isolés que vous ne pouviez pas écrire au chapitre précédent.
Pourquoi ne pas cacher aussi les repositories derrière des interfaces écrites à la main ?
Ils sont déjà des interfaces.EmployeeRepositoryne dit rien de la base utilisée : Spring Data JPA en fournit l’implémentation, que la base soit H2 ou PostgreSQL. Ajouter une couche par-dessus dupliquerait ce qu’ils font déjà, sans bénéfice pour Hamac.
En attendant le prochain chapitre, quelqu’un doit bien créer ces objets et les assembler. Pour l’instant, ce sera le constructeur du contrôleur, qui reçoit déjà les repositories de Spring. Ce n’est pas idéal, puisque le contrôleur connaîtra toutes les classes concrètes, mais c’est une étape provisoire et assumée. Vous refactorez une chose à la fois, et la création des objets sera confiée à Spring dans le prochain chapitre.
Un refactoring modifie l’organisation du code sans changer son comportement observable. C’est cette contrainte qui le rend sûr : si les tests passent avant et après, rien n’a changé pour les utilisateurs.
Le réflexe le plus risqué consiste à tout réécrire d’un coup, puis à lancer les tests à la fin. Si l’un d’eux échoue, vous ne savez pas laquelle de vos vingt modifications l’a cassé. Avancez donc par petites étapes, et relancez./mvnw testaprès chacune :
Écrivez d’abord un test qui reproduit le bug. Il échoue sur le starter : c’est normal, il prouve que le problème existe. Quand il passera, vous saurez que le bug est corrigé, et il empêchera ce bug de revenir.
Extrayez les politiques, le résolveur et l’énumérationContractType.
RéduisezEmployeeRepositoryaux méthodes utilisées, et créezLeaveNotifier.
Créez le service et déplacez-y la logique degetBalanceet d’approve.
Allégez le contrôleur : il appelle le service et traduit son résultat en réponse HTTP.
Vérifiez que tous les tests passent, y compris celui du bug.
Les réponses de l’API ne changent pas : mêmes routes, mêmes messages. Seule la valeur du solde des CDD est corrigée. Ce choix peut sembler frustrant, puisque vous savez déjà que ces routes sont mal conçues. Mais les tests existants s’appuient sur elles : les modifier maintenant mélangerait deux changements, et un test en échec ne vous dirait plus lequel est en cause.
Pour la même raison, le filtrage aprèsfindAll()attendra le chapitre 4.

Inès vous laisse jusqu’à vendredi pour proposer votre refactoring. Elle le relira avec une exigence : en dehors du solde des CDD, le comportement de l’API ne doit pas changer.
Partez de votreDIAGNOSTIC.mdet suivez les étapes ci-dessus :
DansLeaveApprovalTests, sur le modèle des tests existants, ajoutez un test qui vérifie que le solde affiché pour Leïla Haddad (salariée n° 4) vaut environ 4,56 jours. Vérifiez qu’il échoue.
Dans un packagecom.hamac.service, créez l’énumérationContractType.
CréezLeaveEntitlementPolicyet ses trois implémentations :PermanentContractPolicy,FixedTermContractPolicyetApprenticeshipPolicy.
CréezLeavePolicyResolveretLeaveNotifier, puis faites implémenterLeaveNotifierparNotificationService.
Faites étendreRepository<Employee, Long>àEmployeeRepository, en déclarant seulement les méthodes utilisées.
CréezLeaveService, avec une méthodegetBalanceet une méthodeapprove.
AllégezLeaveControlleret assemblez les objets dans son constructeur.
Ajoutez un test unitaire pourFixedTermContractPolicy, sans Spring ni base de données.
Point de contrôle :./mvnw testse termine parBUILD SUCCESS, y compris avec les deux nouveaux tests. Le solde affiché pour Leïla Haddad est le même que celui utilisé à l’approbation. Enregistrez votre travail avec Git.
MVC organise la présentation : le contrôleur reçoit la requête, place les données dans leModelet choisit la vue qui les met en forme. LeModelde Spring n’est pas le modèle métier.
L’organisation en couches (contrôleur, service, repository) range le reste de l’application. Un contrôleur bien organisé ne contient ni règle métier, ni accès direct aux données.
OCP permet d’ajouter un comportement sans modifier le code déjà testé ; LSP garantit que chaque implémentation respecte le même contrat. ISP conduit à des interfaces ciblées, y compris pour les repositories ; DIP fait dépendre le code métier d’abstractions plutôt que de détails techniques.
Strategy convient quand la liste des cas est ouverte et que chaque cas porte une vraie règle ; unswitchexhaustif convient quand la liste est fermée, car le compilateur signale le cas oublié.
Rassembler une règle en un seul endroit supprime la cause d’une divergence, pas seulement son symptôme. Un refactoring sûr y parvient par petites étapes vérifiées par les tests, en traitant un problème à la fois.
Le bug de Leïla est corrigé, et la règle de calcul n’existe plus qu’à un seul endroit. Mais les objets de Hamac sont encore assemblés à la main dans le contrôleur. Dans le prochain chapitre, vous allez confier ce travail à Spring : déclarer vos classes comme beans, les injecter par constructeur, accéder correctement aux données avec Spring Data JPA et sortir du code les paramètres des règles RH.