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.
Article
Pour changer de fournisseur de courriels sans modifier la facturation, isolez son code dans la messagerie derrière un contrat d’envoi stable.
Vous remplacez le fournisseur de courriels, et c’est le code de facturation qu’il faut modifier : la facturation appelait directement la bibliothèque du fournisseur, et un détail d’envoi est entré dans le mauvais module. Pour que ce remplacement ne touche que le code d’envoi, la facturation et la messagerie doivent passer par un contrat d’envoi stable, c’est-à-dire la description de ce que l’envoi accepte et promet, sans rien dire du fournisseur. Reste à décider lequel des deux modules connaît l’autre, donc lequel dépend de l’autre. Si une dépendance existe déjà entre eux, elle impose ce sens. Sinon, le choix est arbitraire, mais il engage : le module qui connaît l’autre s’adapte à son contrat et change quand ce contrat change, et une dépendance ajoutée ensuite en sens inverse, directement ou par d’autres modules, ferait dépendre chacun de l’autre. Une seconde décision ne dépend pas de ce sens : quel module reprend un courriel dont l’envoi a échoué.
Après avoir défini la dépendance et le contrat, l’article fait passer ce même remplacement par les quatre façons de répartir la connaissance entre la facturation et la messagerie, puis par une exigence nouvelle qui risque de créer une boucle.
Dans l’exemple, un module de facturation crée une facture après une vente : il calcule les montants, applique les règles de taxe et enregistre le résultat. Un autre module, la messagerie, prévient le client par courriel en passant par un fournisseur externe. Les deux participent au même service rendu, mais leurs raisons de changer sont différentes : une nouvelle règle de calcul d’un côté, un nouveau fournisseur de courriels de l’autre.
Un module dépend d’un autre lorsqu’il a besoin de connaître une partie de son fonctionnement pour faire son travail. Cette connaissance peut être le nom d’une opération, les données attendues ou le sens d’un message. Quand ce fonctionnement change, le module qui le connaît risque donc de devoir changer aussi. Martin Fowler ramène le couplage à ce critère : deux modules sont couplés si modifier l’un oblige à modifier l’autre (Reducing Coupling, 2001).
Dans un schéma, la flèche part du module qui utilise cette connaissance vers celui qui la fournit, selon la convention des diagrammes UML que suit Robert C. Martin (Granularity, 1996). La notation « A connaît B » signifie donc que A dépend de B.
Cette relation apparaît dans plusieurs échanges courants :
Le sens de circulation des données peut donc différer du sens de la dépendance. Quand la facturation publie « facture créée », c’est la messagerie qui doit en connaître la signification : elle connaît la facturation, qui peut ignorer quels modules reçoivent l’événement. Fowler décrit cette asymétrie : un événement définit une interface à laquelle le module qui écoute se conforme, et le module qui le produit ne connaît pas ses destinataires (Reducing Coupling, 2001). Recevoir un événement suppose de connaître son contrat, c’est-à-dire le nom de l’événement et ses données. Ici, ce contrat est fourni par la facturation : la messagerie dépend donc d’elle.
Un contrat décrit ce qu’un module accepte et promet en retour. Par exemple : les informations nécessaires pour envoyer une facture, le résultat de l’envoi et les erreurs possibles. Il permet à deux modules de travailler ensemble sans partager leur code interne.
Le problème du début vient de l’absence d’un contrat d’envoi indépendant du fournisseur. La facturation appelle directement la bibliothèque du fournisseur et manipule ses options. Le nouveau fournisseur renvoie un identifiant d’acceptation là où l’ancien renvoyait un simple oui ou non : le code de facturation doit changer, alors qu’aucune règle de facturation n’a bougé. Si ces options restaient dans le module d’envoi, la modification y resterait localisée.
Cette séparation guide le découpage proposé par David Parnas en 1972 : identifier les décisions susceptibles de changer, puis les cacher derrière les interfaces des modules. Le choix du fournisseur de courriels est précisément une décision que la facturation n’a pas besoin de connaître. Reste à savoir qui définit le contrat qui la cache : l’un des deux modules, ou un tiers.
Pour que la facturation et la messagerie travaillent ensemble, deux décisions sont à prendre, et aucune ne commande l’autre. La première fixe le sens du couplage, c’est-à-dire quel module connaît l’autre. Quatre formes existent : la facturation connaît la messagerie, la messagerie connaît la facturation, un troisième module les connaît toutes deux, ou toutes deux connaissent un contrat publié par un tiers. Rien dans l’échange lui-même n’impose l’une plutôt que l’autre, et le choix est en ce sens arbitraire. Il engage pourtant : le module qui connaît l’autre s’adapte à son contrat et change quand ce contrat change. Il engage aussi les liaisons suivantes : quand une dépendance existe déjà entre les deux modules pour une autre opération, la nouvelle doit aller dans le même sens, sinon chacun dépendrait de l’autre.
La seconde décision attribue la responsabilité de l’échange : quel module constate un refus, suit l’envoi et reprend un courriel perdu. Dans chacune des quatre formes, elle peut se placer d’un côté ou de l’autre, quel que soit le sens retenu, selon que l’échange passe par une commande, une requête ou un événement. Par exemple, si la facturation connaît la messagerie, sa commande d’envoi peut retourner un résultat, accepté ou refusé, et la facturation reprend alors l’envoi après un échec ; elle peut aussi confier l’envoi à la messagerie, qui le reprend elle-même.
Le défaut à éviter est une responsabilité que personne ne porte : chaque organisation doit nommer le module qui détecte un envoi perdu et celui qui le reprend, et le sens du couplage ne règle pas cette question. Une autre mise en garde porte sur le sens des messages, et elle vaut même quand la responsabilité est bien attribuée. Fowler appelle commande « passive-agressive » un événement par lequel l’émetteur attend en réalité une action du destinataire, au lieu d’exprimer cette intention par une commande (What do you mean by “Event-Driven”?, 2017). Si la facturation compte sur l’envoi du courriel, publier seulement « facture créée » masque cette attente : elle doit apparaître comme une demande, par exemple une commande adressée à la messagerie.
Dans la suite, A désigne la facturation et B la messagerie. La forme la plus simple est un appel direct : la facturation appelle le module de messagerie, dont le contrat ne parle que de l’envoi d’une facture, avec le destinataire, le document et le résultat. Le fournisseur reste caché dans le code interne de la messagerie, qui n’a pas besoin de savoir qui l’appelle. Cette organisation est souvent suffisante, par exemple quand la facturation demande à un module de taxes le montant applicable.
Elle devient gênante si le contrat de la messagerie change souvent ou expose des détails que la facturation devrait pouvoir ignorer : la stabilité utile porte sur le contrat. L’appel direct garde sa place lorsqu’il exprime clairement la responsabilité et que son contrat convient ; ajouter un intermédiaire sans changement à isoler peut compliquer le code sans faciliter son évolution.
Quand la facturation garde la responsabilité de l’envoi, elle n’a pas pour autant à mêler l’envoi externe à sa transaction. Si la facture est enregistrée dans une transaction locale, une intention d’envoi peut être conservée dans cette même transaction ; l’appel au fournisseur intervient après sa validation (Richardson, Transactional outbox). La facturation garde ainsi la trace de ce qu’elle doit obtenir.
Cette trace ne suffit pas à éviter un double envoi : le fournisseur peut avoir accepté le courriel sans que sa réponse arrive, ou juste avant que le traitement s’arrête sans avoir noté l’acceptation. Avant de relancer, la facturation distingue donc un résultat connu, acceptation ou refus, d’un résultat incertain, qu’elle vérifie d’abord. Chaque tentative transmet au fournisseur la même clé, propre à cette notification, et cette clé n’évite le doublon que si le fournisseur s’engage réellement à la reconnaître. L’article sur les reprises de requêtes sans doublon détaille ce contrat.
Le résultat « pris en charge » dit seulement que le fournisseur a accepté de transporter le courriel, pas qu’il l’a livré. Si la livraison doit être suivie, le contrat doit aussi en fournir le moyen.
La facturation publie un événement lorsque la facture est créée ; la messagerie s’y abonne, prépare le courriel et choisit le fournisseur. La flèche de dépendance va de la messagerie vers la facturation : la messagerie connaît le contenu et la signification de l’événement, la facturation ignore tout de l’envoi. Si le contrat de l’événement change, les abonnés peuvent devoir s’adapter.
L’événement ajoute des questions de livraison et de suivi des échecs, qui reviennent à la messagerie quand elle porte la réaction. Le message peut être perdu, reçu deux fois ou traité avec retard. Si l’annonce de la facture F42 arrive deux fois, la messagerie doit la reconnaître : elle note les annonces déjà traitées (Richardson, Idempotent Consumer) et tire de F42 une clé de notification stable. Le numéro de facture suffit tant qu’une facture ne donne lieu qu’à un seul courriel ; plusieurs destinataires demanderaient une clé plus précise. Cette trace locale ne couvre pas le cas où le fournisseur a accepté le courriel sans que la messagerie l’ait appris : la messagerie lui transmet donc la clé, et vérifie un résultat incertain avant toute relance, comme le fait la facturation quand elle porte l’envoi. Si le courriel n’arrive pas, la messagerie doit pouvoir le détecter et le relancer. Retourner une flèche sans attribuer ces responsabilités ne suffit pas à séparer les modules.
La responsabilité peut aussi rester à la facturation sans changer le couplage. La facturation inscrit alors dans son propre contrat les notifications qu’elle attend, chacune avec sa clé : une file « à notifier » que la messagerie interroge. L’intention y est écrite comme une demande, et non présentée comme un simple fait. La messagerie prend F42, envoie le courriel, puis confirme l’envoi par une commande adressée à la facturation ; une confirmation reçue deux fois ne change rien. La facturation repère les notifications dont la confirmation tarde et les remet dans la file. L’absence de confirmation ne prouve pas que le courriel n’est pas parti : la confirmation a pu se perdre après l’envoi. Avant de reprendre F42, la messagerie vérifie donc auprès du fournisseur un résultat incertain, avec la même clé. Dans tout ce parcours, la messagerie connaît la facturation, dont elle utilise la file et la commande de confirmation ; la facturation ignore toujours la messagerie.
Un bus de messages ne change rien à cette répartition. Il transporte les messages, mais le sens de leurs champs relève d’un modèle de données commun que tous les participants doivent accepter, selon la description du bus de messages par Hohpe et Woolf. Ce modèle a besoin d’un responsable, sans quoi chaque équipe risque d’en adopter une interprétation différente. Si ce modèle appartient à la facturation, la messagerie connaît toujours la facturation ; s’il appartient à un tiers qui en répond, les deux modules connaissent ce tiers et, si ce modèle est leur seule référence commune, s’ignorent l’un l’autre pour cet échange. Le bus ne décide pas non plus de la politique de doublons.
Les deux premiers cas semblent liés à la forme de l’échange : l’appel pour A connaît B, l’événement pour B connaît A. Ce lien n’est pas obligatoire. Dans l’appel direct, la messagerie fixe le contrat et la facturation s’y adapte ; l’inversion de dépendance renverse ce rapport sans changer l’appel. La facturation définit une interface qui exprime son besoin d’envoi et l’appelle ; le code propre au fournisseur la réalise. Le métier connaît le service attendu, mais ignore sa mise en œuvre technique.
Le principe d’inversion de dépendance, formulé par Robert C. Martin en 1996, veut que les règles de haut niveau et les détails techniques dépendent d’abstractions. Martin parle d’inversion parce que les méthodes de conception traditionnelles tendaient à faire dépendre les règles des détails, alors que ce sont les règles qui devraient obliger les détails à changer. Son exemple prévoit même une bibliothèque tierce impossible à modifier : un adaptateur traduit les opérations de l’interface dans les appels qu’elle attend. C’est le rôle de l’adaptateur du fournisseur ici. Inverser une dépendance n’oblige donc pas à passer par des événements asynchrones : une interface appelée suffit.
Exemple de dépendances du code
Avant : facturation → fournisseurX.ClientCourriel
Après : facturation définit EnvoiFacture et l’appelle
adaptateurX → facturation.EnvoiFacture
adaptateurX → fournisseurX.ClientCourriel
Contrat illustratif :
EnvoiFacture.soumettre(factureId, destinataire, document)
→ référence de prise en charge ou refus
À l’exécution, l’appel part encore de la facturation vers l’adaptateur. La dépendance du code va pourtant dans l’autre sens : l’adaptateur, qui tient ici la place de la messagerie, connaît le contrat défini par la facturation, et la facturation l’ignore. Le dessin est celui du deuxième cas, B connaît A, alors que la facturation appelle toujours et attend la prise en charge.
L’inversion n’ajoute donc pas de cas. Pour un même appel, elle permet de choisir entre les deux premiers selon le module qui définit le contrat : fourni par la messagerie, il donne A connaît B ; défini et rangé dans la facturation, il donne B connaît A. Ce choix sert par exemple à garder les règles de facturation à l’abri des détails techniques, ou à placer la dépendance qu’introduit un nouvel appel dans le sens déjà retenu entre les deux modules. Où qu’il vive, le contrat a besoin d’un responsable qui décide de son évolution.
Il arrive que l’enchaînement n’appartienne ni à la facturation ni à la messagerie. Le traitement d’une commande demande la création de la facture, puis déclenche la notification, et sait quoi faire si l’une des deux opérations échoue. Ce troisième module est un médiateur : il connaît la facturation et la messagerie, qui s’ignorent, et il porte leur relation.
Cette organisation rend visible un enchaînement que la publication d’événements disperse. Fowler observe qu’un parcours fait de notifications successives peut devenir difficile à voir, parce qu’il n’est écrit dans aucun programme (What do you mean by “Event-Driven”?, 2017). Quand l’ordre « facturer, puis prévenir » est lui-même une règle du métier, il gagne à être lu à un seul endroit.
Le risque apparaît lorsque tous les parcours finissent dans le même médiateur. Il accumule les règles et les dépendances de toute l’application, si bien qu’une modification locale oblige à comprendre ce composant central. Limitez donc son rôle à un parcours ou à une responsabilité identifiable.
Jusqu’ici, chaque contrat appartient à l’un des deux modules : à la messagerie dans l’appel direct, à la facturation avec l’inversion ou l’événement, et le médiateur utilise les contrats de l’une et de l’autre. La facturation n’est pourtant pas toujours seule à prévenir des clients : le traitement des commandes annonce les expéditions, le support confirme la réception d’une réclamation, et un module d’envoi de SMS rejoint la messagerie. Défini par la facturation, le contrat imposerait au module de SMS une interface pensée pour les factures ; fixé par la messagerie, il imposerait le courriel à tous les modules qui notifient. Aucun des deux n’a de raison de le dicter aux autres.
Un intermédiaire peut alors publier ce contrat et en répondre : une plateforme de notification, dont l’équipe décide de son évolution. Ce contrat ne parle ni de factures ni de fournisseur. La facturation l’appelle pour soumettre une notification ; la messagerie le réalise et s’inscrit auprès de la plateforme comme canal de courriel. La facturation et la messagerie connaissent la plateforme, qui ne connaît ni l’une ni l’autre, et les deux modules s’ignorent. La figure est celle du médiateur retournée, une sorte de médiateur inversé : le médiateur connaît les modules qu’il coordonne, alors qu’ici les modules connaissent l’intermédiaire.
Exemple de dépendances du code
facturation → notification.Notification
messagerie → notification.Notification
messagerie → fournisseurX.ClientCourriel
notification : ne dépend ni de facturation ni de messagerie
Contrat illustratif :
Notification.soumettre(destinataire, document, cleNotification)
→ référence de prise en charge ou refus
À l’exécution, la plateforme achemine pourtant chaque demande vers la messagerie. Elle le fait d’après l’inscription du canal, qu’elle reçoit comme une donnée : son code ne nomme pas la messagerie, et remplacer celle-ci par un autre canal ne le modifie pas. Dans cet exemple, la facturation garde la responsabilité de l’envoi et attend une prise en charge. La plateforme en fixe les termes, c’est-à-dire la référence renvoyée, les refus possibles, la clé de notification et le suivi, et chaque canal inscrit doit les tenir.
Ce quatrième cas ne se ramène pas aux deux premiers tant que le contrat reste hors des deux modules. Rangé dans la facturation, il fait de la messagerie le module qui connaît l’autre, comme avec l’inversion. Rangé dans la messagerie, il ramène à l’appel direct.
Hors des deux modules, deux questions se posent, qu’il vaut mieux séparer : où pointent les flèches du code, et qui décide de l’évolution du contrat. Pour le code, il suffit que le contrat sorte des deux modules. Si la facturation et la messagerie importent un même paquet de contrat, et que ce paquet n’importe ni l’une ni l’autre, les deux flèches vont vers lui, quelle que soit l’équipe qui le tient. Extraire EnvoiFacture dans un tel paquet produit ce dessin : la messagerie ne dépend plus de toute la facturation, seulement du contrat.
La décision, elle, peut rester où elle était. Si le contrat extrait garde le nom et le contenu du besoin de la facturation, c’est encore la facturation qui le fait évoluer, et la messagerie suit chacun de ses changements : une dépendance de fait que le graphe du code ne montre pas. La plateforme de notification réunit les deux conditions : un contrat hors des modules, et une équipe qui l’arbitre entre tous ses utilisateurs. C’est la forme complète du contrat partagé, celle qui illustre ici le quatrième cas.
Hohpe et Woolf décrivent la même forme pour l’intégration par messages : un modèle de données canonique, indépendant de chaque application, dans lequel toutes produisent et consomment leurs messages (Canonical Data Model). Ils en chiffrent le coût en traducteurs de formats, quand chaque application échange avec toutes les autres : entre deux applications, le modèle commun en demande quatre là où l’échange direct en demande deux ; entre six, il en demande douze au lieu de trente. Avec deux modules seulement, le contrat tiers n’en économise donc aucun. Il peut pourtant se justifier par son autonomie, quand son évolution ne doit dépendre ni de l’un ni de l’autre, et son intérêt grandit à mesure que d’autres modules l’appellent ou le réalisent. Une API produit publiée par une passerelle suit le même dessin, lorsque les applications qui l’appellent et celles qui la servent ne connaissent que son contrat.
Le risque fait pendant à celui du médiateur. Un contrat partagé qui cherche à couvrir les besoins de tous les modules devient un modèle de toute l’entreprise ; Fowler rappelle qu’Eric Evans juge l’unification complète du modèle d’un grand système ni faisable ni rentable (Bounded Context, 2014). Gardez au contrat de l’intermédiaire le périmètre d’un service, ici la notification.
Le changement du début sert de test : le nouveau fournisseur renvoie un identifiant d’acceptation au lieu d’un oui ou d’un non. Pour chaque organisation, le tableau indique ce que la facturation connaît, ce qui change quand la frontière est tenue, et le signe qu’un détail du fournisseur a fui hors du code d’envoi.
| Organisation | Ce que la facturation connaît | Ce qui change | Signe de fuite |
|---|---|---|---|
| La facturation appelle la bibliothèque du fournisseur | Ses classes et ses options | Le code de facturation | C’est la situation du début |
| La facturation appelle la messagerie (A connaît B) | Le contrat de la messagerie | L’adaptateur interne de la messagerie, qui traduit le nouveau résultat vers son contrat d’acceptation | La facturation manipule les classes de la bibliothèque du fournisseur |
| La messagerie observe « facture créée » (B connaît A) | Rien de l’envoi | Le transport de la messagerie, qui conserve sa clé de notification | La facturation ajoute dans son événement des champs propres au fournisseur |
| La facturation appelle le contrat qu’elle a défini (B connaît A, par inversion) | Son propre contrat d’envoi | L’adaptateur, qui réalise à nouveau EnvoiFacture.soumettre | Le contrat expose un objet technique que le nouveau fournisseur ne peut plus produire |
| Un médiateur coordonne les deux modules (C connaît A et B) | Rien de l’envoi | L’adaptateur de la messagerie ; le médiateur garde la règle « facture créée, puis notification acceptée » | Le médiateur interprète les codes techniques du fournisseur au lieu d’un résultat métier |
| La plateforme de notification publie le contrat (A et B connaissent C) | Le contrat de la plateforme | L’adaptateur de la messagerie, qui réalise à nouveau Notification.soumettre | Le contrat de la plateforme expose une option du fournisseur, que tous ses utilisateurs doivent alors connaître |
Les deux premières lignes ont la même forme, puisque la facturation y appelle un autre module ; seul diffère ce qu’elle en connaît. Dans les cinq dernières, remplacer le fournisseur ne change que le code d’envoi, à condition que le contrat reste stable et que le nouveau fournisseur tienne les garanties de l’ancien ; ces lignes se distinguent par le module qui connaît l’autre, et la place du refus et du suivi reste une décision à part.
Ces organisations se ramènent à quatre façons de répartir la connaissance entre deux modules A et B qui échangent : A connaît B, B connaît A, un tiers C connaît les deux, ou les deux connaissent C. L’inversion de dépendance n’en ajoute pas une cinquième : pour un même appel, elle fait passer de la première à la deuxième en confiant le contrat à la facturation. Un graphe plus large se lit liaison par liaison avec la même grille : une chaîne où A connaît C, qui connaît B, se décompose en deux liaisons de la première forme.
Imaginez maintenant que la facturation doive savoir si le courriel de F42 a été livré, et non plus seulement accepté, pour marquer la facture comme remise au client. Le contrat d’acceptation ne suffit plus : il faut une opération ou un événement supplémentaire, et désigner le module qui traite le suivi. Cette exigence modifie ce que le contrat promet, et aucune frontière ne la cache aux modules qui l’utilisent.
Le raccourci le plus tentant crée une boucle. Dans l’organisation par événement, la messagerie connaît déjà la facturation, puisqu’elle comprend « facture créée ». Si la facturation se met à interroger la messagerie sur l’état de livraison, elle connaît à son tour la messagerie : chacune dépend de l’autre. Cette situation compte comme une boucle, même si l’une des flèches passe par un événement et l’autre par un appel, car chaque module doit alors connaître une partie du fonctionnement de l’autre.
Une boucle peut aussi passer par plusieurs modules, quand chacun utilise le suivant et que le dernier utilise le premier. Chaque liaison semble raisonnable prise séparément ; leur combinaison complique les changements. Si ces modules doivent être construits ou livrés indépendamment, la boucle risque de les obliger à évoluer ensemble. C’est le problème traité par le principe des dépendances acycliques de Martin, « acyclique » signifiant simplement « sans boucle ». Dans son exemple, une seule dépendance ajoutée oblige trois paquets de code à être livrés ensemble, comme s’ils n’en formaient plus qu’un. Fowler tolère une boucle qui reste localisée, et la juge moins gênante entre deux paquets d’une même couche (Reducing Coupling, 2001). Entre des modules qui doivent évoluer séparément, n’en acceptez aucune : avant d’ajouter une dépendance d’un module X vers un module Y, cherchez si Y dépend déjà de X, directement ou en passant par d’autres modules.
Les deux moyens que Martin donne pour casser une boucle recoupent deux des quatre formes : placer l’interface dans le module qui en a besoin, c’est-à-dire inverser la dépendance, retourne une flèche ; créer un paquet dont les deux modules dépendent dessine la quatrième forme, où A et B connaissent C.
Pour l’exemple, le plus simple est de suivre le sens déjà choisi : la messagerie connaît la facturation, c’est donc elle qui informe. Quand elle apprend du fournisseur que le courriel de F42 a été livré, la messagerie envoie à la facturation une commande qui confirme cette livraison. La facturation marque alors la facture comme remise : cette responsabilité reste la sienne. Elle repère aussi les factures dont la confirmation tarde, et les inscrit dans son propre contrat comme livraisons à vérifier, une liste que la messagerie consulte. Une confirmation absente ne prouve pas que le courriel n’a pas été livré ; elle signale seulement une livraison à vérifier. La confirmation adressée à la facturation garde ainsi la dépendance de la messagerie vers la facturation, et la facturation ne connaît toujours pas la messagerie.
D’autres formes gardent aussi un seul sens ; elles diffèrent par le module qui définit le contrat de suivi ou qui en répond. Par inversion de dépendance, la facturation définit un contrat d’envoi qui comprend le suivi, et le code d’envoi le réalise. Avec une plateforme de notification, la facturation demande l’état de livraison à la plateforme, à qui la messagerie le déclare sans connaître la facturation. Si le suivi relève du parcours de commande, le médiateur le porte et transmet l’état à la facturation. Dans ces trois formes comme avec la confirmation envoyée par la messagerie, la liaison qui transmet l’état de livraison suit le sens des dépendances existantes : aucune boucle ne se forme entre les modules décrits ici. Dans un graphe plus large, le test du chemin inverse reste à faire.
Pour chaque liaison entre modules, notez ce que le premier doit connaître du second et pourquoi. Puis essayez un changement plausible : remplacer un fournisseur, ajouter un destinataire ou modifier une règle métier. Repérez les modules à modifier et vérifiez que chacun change pour une raison qui lui appartient.
Ce travail peut aussi servir de point de départ à une demande de cadrage ou de refonte d’architecture auprès d’Arcate : décrivez le module qui doit changer et les règles métier à préserver.
Dans l’exemple, le remplacement du fournisseur touchait la facturation parce qu’elle connaissait la bibliothèque du fournisseur. Une fois le sens du couplage choisi, le contrat confié à celui qui doit en décider, l’un des deux modules ou un intermédiaire, et la responsabilité de l’envoi attribuée, ce remplacement ne touche plus que le code d’envoi, à condition que le nouveau fournisseur tienne les garanties de l’ancien, comme la reconnaissance d’une clé de notification. Quand aucune dépendance existante ne l’impose, qui dépend de qui reste un choix libre, mais ce choix fixe quel module s’adaptera au contrat de l’autre. La preuve de livraison, elle, change ce que le contrat promet : elle oblige à revoir les contrats et, avant d’ajouter la liaison qui transmet cet état, à vérifier qu’aucun chemin de dépendances ne mène déjà en sens inverse.
Explorer
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.
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.
Une application peut se déployer en un bloc et garder des modules distincts. Exemple avec l’inscription et la facturation, leurs données et leurs échanges.
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
Votre commentaire sera relu avant d'être publié.