Article

Garder un module autonome : repérer les dépendances qui compliquent les changements

Un module perd son autonomie quand ses règles et ses données se dispersent. Voici les signes à examiner et les moyens de garder des frontières compréhensibles.

Ajouter une remise réservée à une campagne semblait une petite modification du panier. Elle demande pourtant de changer trois modules : le panier, les commandes et la facturation. Pour comprendre la règle de remise, il faut suivre des appels dans toute l’application. Dans ce cas, ces changements révèlent que les responsabilités se sont dispersées entre les modules ; repérer les dépendances qui les dispersent permet de corriger le découpage avant que chaque évolution devienne aussi coûteuse.

Dans une boutique fictive, ce changement fait apparaître trois signaux : un cycle entre deux modules, un mot qui n’a pas le même sens des deux côtés, et des règles éloignées des données qu’elles protègent. Un quatrième signal ne se voit que dans l’historique des changements. La dernière section porte sur les contrôles automatiques et sur ce qu’ils ne peuvent pas juger.

Une remise qui touche trois modules

Dans cette boutique, chaque module regroupe le code, les données et les règles d’une partie du métier : le panier, les commandes, la facturation. Les autres modules ne devraient passer que par son interface publique. Dans le graphe du code, un module dépend d’un autre quand il utilise son code : si le second change, le premier peut devoir changer aussi.

La remise de campagne touche d’abord le panier, qui calcule les remises. Elle touche aussi les commandes, qui rappellent le panier pour relire les remises au moment de commander, et la facturation, qui recalcule elle-même la remise à partir des lignes du panier. Commençons par les deux premiers modules : leur relation se lit directement dans le graphe des dépendances.

Le panier et les commandes dépendent l’un de l’autre

Le panier importe les classes internes des commandes pour connaître leur format. Les commandes rappellent le panier pour relire les remises. Chacun dépend donc de l’autre : c’est un cycle. Robert C. Martin en décrivait le coût en 1996 : des paquets liés par un cycle doivent être livrés ensemble et deviennent, en pratique, un seul grand paquet. Ici, aucun des deux modules ne peut changer sa règle de remise ou son format de commande sans vérifier l’autre.

Le cycle révèle aussi une question que personne n’a tranchée. Le client modifie encore son panier pendant que la commande se construit : quel prix cette commande doit-elle conserver ? Pour le panier, le prix est une estimation qui change à chaque ligne ajoutée ou à chaque nouvelle remise. Pour la commande, c’est le prix que le client a accepté, et il ne doit plus bouger. Le mot est le même, mais les règles d’évolution diffèrent. Le cycle signale donc une décision mal placée, pas seulement deux imports gênants.

Un même mot recouvre deux besoins

Un mot qui prend un sens différent selon le module s’appelle un polysème. Le cas le plus connu est le « client » : celui de l’inscription possède des identifiants de connexion, celui de la facturation une adresse et des informations de paiement. Martin Fowler cite « Customer » parmi ces mots, qui reviennent dans toute grande organisation.

Cette différence n’est pas un défaut en soi : elle peut justifier des modèles distincts. Le problème apparaît lorsqu’une classe commune tente de répondre à tous les usages et change pour des raisons sans rapport entre elles. Définissez alors ce que chaque module entend par ce terme. Des noms plus précis, comme « prix estimé » et « prix accepté », ou des contrats limités évitent de partager tout le modèle.

Supprimer le cycle sans déplacer les mêmes appels ailleurs

Pour la boutique, la correction consiste à faire du prix accepté un objet à part entière, qu’un code de coordination, le parcours d’achat, transmet d’un module à l’autre :

Avant
panier → commandes.interne.Commande
commandes → panier.interne.CalculRemise

Après
parcoursAchat → panier.api.PreparerAchat
parcoursAchat → commandes.api.CreerCommande
commandes → contratAchat.OffreAcceptee
panier → contratAchat.OffreAcceptee

Le panier prépare une offre identifiée contenant les lignes, le prix accepté et une limite de validité. Le parcours d’achat transmet cette offre à la création de commande. La commande vérifie que cette offre peut encore être engagée, puis conserve ses conditions ; elle ne relit plus un panier mutable pour recalculer silencieusement son prix. Le panier et les commandes dépendent désormais d’un contrat commun, et plus l’un de l’autre. C’est l’un des deux moyens que Martin propose pour casser un cycle : placer ce dont les deux paquets dépendent dans un nouveau paquet. Le sens de chaque dépendance devient explicite : le parcours connaît les deux modules, qui ne se connaissent plus.

Ce contrat n’est acceptable que si ses champs ont le même sens pour les deux modules. Le dossier « contratAchat » ne doit pas devenir l’endroit où toutes leurs classes internes finissent par être partagées. Il faut également définir qui émet l’offre et qui garantit son engagement : déplacer le montant dans un objet ne le rend pas fiable.

Reprenons alors la remise de campagne. Son calcul change dans le panier, responsable de l’offre. La commande continue à vérifier et à conserver l’offre acceptée selon le contrat, sans modification. Si la nouvelle règle impose aussi de vérifier un quota global au moment de commander, elle dépasse cette simple transformation : l’autorité qui protège le quota doit participer à la décision, et la commande change légitimement. Le test d’un changement réel montre ainsi jusqu’où va le découpage.

Un événement peut sembler une autre façon de casser le cycle. Il convient lorsque le destinataire doit réagir à un fait déjà accepté ; il ne remplace pas une réponse nécessaire avant d’engager l’achat. Choisir un échange asynchrone uniquement pour retirer un cycle du dessin laisserait la même dépendance métier, avec un délai et des cas de reprise supplémentaires.

Les règles sont éloignées des données qu’elles protègent

Reste le troisième module touché par la campagne. La facturation lit les lignes du panier et recalcule la remise pour l’imprimer, et d’autres modules modifient directement les quantités du panier. Le panier conserve les données, mais ce sont ses voisins qui appliquent ses règles. Chacun doit alors connaître les mêmes règles, avec le risque de les appliquer différemment : la facture peut afficher une remise que la commande n’a jamais acceptée. Martin Fowler appelle modèle anémique un modèle dont les objets portent des données mais presque aucun comportement.

Ce qui compte est d’identifier le responsable de chaque décision. Ici, le panier calcule l’offre, la commande conserve l’offre acceptée, et la facture reprend les montants de cette offre au lieu de les recalculer. Le regroupement des règles peut passer par des objets métier ou par des fonctions dédiées. Un style de programmation fonctionnel, ou une séparation entre données et traitements, ne suffit pas à diagnostiquer un problème d’architecture : le signal est la dispersion d’une même règle entre plusieurs modules.

Si une opération demande sans cesse tous les objets internes d’un voisin, examinez la frontière. Un contrat plus adapté peut suffire ; parfois, déplacer la responsabilité et ses données est plus simple.

Un module change pour trop de raisons

Les trois signaux précédents sont apparus en suivant un seul changement. Le dernier se lit dans l’historique. Un module qui gère à la fois les stocks, les factures et les notifications peut devenir difficile à modifier. Pour le vérifier, regardez ses changements récents : concernent-ils un même besoin ou plusieurs sujets indépendants ? Dans Granularity, Robert C. Martin demande aussi de réunir les classes susceptibles de changer pour les mêmes raisons : c’est son principe de fermeture commune. À l’inverse, un module qui change pour trois raisons sans rapport réunit ce qui devrait être séparé.

La taille du code donne un indice, mais ne tranche pas seule. Un module volumineux peut rester cohérent ; un petit module peut concentrer des dépendances problématiques.

Un composant utilisé partout mérite aussi un examen. Une bibliothèque stable peut remplir ce rôle correctement. Un module métier qui change souvent et oblige tous ses consommateurs à suivre devient plus préoccupant. Son nom ne tranche pas davantage. Le core domain du DDD, la conception pilotée par le domaine, désigne ce qui apporte une valeur distinctive à l’activité ; il n’est pas défini par le nombre de dépendances qui pointent vers lui, et un dossier nommé « core » peut ne contenir que des utilitaires. Examinez les responsabilités, leur stabilité et les changements qu’elles imposent aux autres.

Le schéma suivant rassemble les quatre signaux : un mot à plusieurs sens, ou polysème ; une dépendance cyclique entre deux modules ; des règles dispersées hors du module qui garde les données, le module dit « anémique » ; et un module qui change pour trop de raisons, dit « obèse ».

Quatre signaux : sens différents du prix, dépendance cyclique Panier–Commandes, règles du panier dispersées et responsabilités sans rapport regroupées.
Quatre signaux à examiner dans le contexte des changements : aucun ne constitue à lui seul un diagnostic.

Vérifier la frontière sans lui demander de juger le métier

Une fois la frontière corrigée, il reste à l’empêcher de se dégrader. Le langage, les modules de compilation et la visibilité des types peuvent interdire certains accès. ArchUnit analyse les dépendances du code Java et permet de formuler une règle telle que celle-ci : les commandes ne dépendent d’aucune classe interne du panier. Cet extrait illustre la règle ; les imports, le chargement des classes et son intégration au test dépendent du projet.

noClasses()
  .that().resideInAPackage("..commandes..")
  .should().dependOnClassesThat()
  .resideInAPackage("..panier.interne..");

Un appel réintroduit vers panier.interne.CalculRemise doit faire échouer ce contrôle. Une lecture directe de la table du panier par une chaîne SQL, en revanche, peut échapper à une règle sur les dépendances entre classes. Un message dont le destinataire comprend « prix accepté » autrement que son émetteur passe également ce test. La frontière doit donc être contrôlée dans le stockage et dans le sens des contrats, en complément du graphe de code.

Les deux vérifications méritent d’être gardées : la règle automatique protège une interdiction précise, et un changement métier, comme la remise de campagne, teste si les responsabilités ont réellement gagné en autonomie. Après la correction, cette remise ne modifie plus que le panier ; un quota global, par exemple, ferait participer les commandes, parce qu’il concerne leur décision. Dans un monolithe modulaire, ces déplacements restent possibles sans introduire de déploiement séparé. Extraire un service avant d’avoir clarifié l’offre ferait seulement traverser le réseau au cycle initial.

Sources

Explorer

Sur le même sujet

Choisis dans l’index d’après les étiquettes de cet article — les plus proches d’abord, hors de sa série. Rien n’est écrit à la main : un article publié demain avec les mêmes étiquettes y prendra place.

Concevoir une panne qui reste locale

Concevoir une panne qui reste locale

Une panne peut se propager par les dépendances et les opérations de reprise. Répartir les charges en groupes autonomes permet de limiter son impact.

Laisser un commentaire

Elle n'est jamais affichée ni publiée. Elle sert à regrouper vos commentaires et, si vous vous inscrivez un jour avec elle, à vous les rendre.

Votre commentaire sera relu avant d'être publié.