Contextes délimités et cartographie des contextes
Divisez les grands domaines en contextes délimités qui communiquent de manière sûre.
Contextes délimités et cartographie des contextes est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.
DDD stratégique
Les modèles tactiques représentent les objets au sein d’un domaine ; le DDD stratégique détermine comment diviser un grand système en éléments capables d’évoluer indépendamment. Le concept central est le contexte délimité — une frontière explicite à l’intérieur de laquelle un modèle de domaine et son langage restent cohérents. La cartographie des contextes décrit les relations entre ces contextes. Cela a souvent plus d’impact que la conception d’une seule classe.
Le langage omniprésent
Au sein d’un contexte délimité, l’équipe partage un langage omniprésent — les mêmes termes sont employés dans les conversations, le code et le modèle. La difficulté est qu’un mot peut avoir des sens différents selon le contexte. Un Customer dans le domaine des Ventes (prospects, réductions) n’est pas le même qu’un Customer dans l’Assistance (demandes, accords de niveau de service). Un contexte délimité rend cette frontière explicite au lieu d’imposer un modèle partagé hypertrophié.
Un même mot, des modèles différents
Un même concept métier reçoit un modèle propre à son contexte. Un Product dans le Catalogue s’intéresse aux descriptions et aux supports multimédias ; dans le Stock, il s’intéresse aux quantités disponibles et à l’emplacement. Chaque contexte ne définit que ce dont il a besoin.
<?php
namespace Catalog;
final class Product {
public function __construct(
public readonly string $sku,
public readonly string $description
) {}
}
namespace Inventory;
final class Product {
public function __construct(
public readonly string $sku,
public readonly int $onHand
) {}
}
namespace App;
$c = new \Catalog\Product('A1', 'Blue mug');
$i = new \Inventory\Product('A1', 42);
echo $c->description, ' / ', $i->onHand, PHP_EOL;
Pourquoi pas un modèle unique
Essayer de faire servir un Customer de référence à toutes les équipes produit une classe fourre-tout aux exigences contradictoires, des conflits entre équipes et des évolutions fragiles. Les contextes délimités permettent à chaque équipe de posséder son modèle et son langage, de déployer indépendamment et de traduire aux frontières. C’est à la frontière que vous payez un petit coût d’intégration pour éviter un coût de couplage bien plus élevé.
Cartes de contexte
Une carte de contexte est une représentation générale de vos contextes délimités et des relations qui les unissent. Elle consigne à la fois l’intégration technique et la relation entre équipes et rapports de force (qui dépend de qui, qui peut imposer les changements). Le DDD nomme plusieurs modèles de relations récurrents, que nous allons examiner maintenant.
Le conformisme dans le code
Les relations sont souvent orientées — un contexte en amont influence un contexte en aval (Customer/Fournisseur, Conformiste, Couche anticorruption). Un contexte aval conformiste n’a aucun moyen d’action et adopte donc simplement le modèle du contexte amont tel quel : il consomme directement la structure étrangère, en acceptant le couplage.
<?php
// Upstream's shape, used verbatim downstream (Conformist)
final class UpstreamUser {
public function __construct(public readonly int $userId, public readonly string $login) {}
}
final class Greeter { // conforms: depends directly on upstream type
public function greet(UpstreamUser $u): string {
return "Hello {$u->login} (#{$u->userId})";
}
}
echo (new Greeter())->greet(new UpstreamUser(7, 'jane')), PHP_EOL;
Couche anticorruption
Un ACL traduit un modèle externe ou ancien dans le modèle propre à votre contexte, afin qu’aucun concept étranger ne puisse leak vers l’intérieur. Il s’agit du motif Adaptateur appliqué à une frontière de contexte, qui protège votre langage omniprésent.
<?php
// Our clean domain model
final class Customer {
public function __construct(public readonly string $id, public readonly string $name) {}
}
// Legacy/external shape we must not let leak in
$legacy = ['CUST_NO' => '0042', 'FULL_NM' => 'Jane Doe'];
final class LegacyCustomerAcl {
public function toDomain(array $row): Customer {
return new Customer($row['CUST_NO'], $row['FULL_NM']);
}
}
$customer = (new LegacyCustomerAcl())->toDomain($legacy);
echo $customer->id, ' ', $customer->name, PHP_EOL;
Le noyau partagé dans le code
- Noyau partagé : deux contextes partagent un petit sous-ensemble détenu conjointement (ci-dessous, un type
Moneycommun) — ne le modifiez qu’après accord. - Partenariat : deux équipes réussissent ou échouent ensemble.
- Voies séparées : l’intégration n’en vaut pas le coût.
- Service d’hôte ouvert / Langage publié : le contexte amont propose un protocole stable et documenté à de nombreux consommateurs.
<?php
namespace Shared; // small, jointly-owned kernel
final class Money {
public function __construct(public readonly int $cents, public readonly string $cur) {}
public function format(): string { return number_format($this->cents / 100, 2) . ' ' . $this->cur; }
}
namespace Billing; // depends on the shared kernel
use Shared\Money;
function invoiceTotal(): Money { return new Money(4999, 'USD'); }
namespace Payroll; // also depends on the SAME shared kernel
use Shared\Money;
function salary(): Money { return new Money(500000, 'USD'); }
Intégrer des contextes en PHP
Concrètement, les contextes s’intègrent au moyen de contrats bien définis : une méthode de traduction, un client d’interface de programmation encapsulant un langage publié ou des messages. Le côté récepteur convertit l’objet de transfert de données étranger dans son propre modèle afin que le couplage s’arrête à la frontière.
<?php
// Published Language DTO from an upstream Open Host Service
final class PricingDto {
public function __construct(public readonly string $sku, public readonly int $cents) {}
}
// Our downstream model
final class CatalogPrice {
public function __construct(public readonly string $sku, public readonly float $amount) {}
}
final class PricingTranslator {
public function translate(PricingDto $dto): CatalogPrice {
return new CatalogPrice($dto->sku, $dto->cents / 100);
}
}
$p = (new PricingTranslator())->translate(new PricingDto('A1', 1599));
echo $p->amount, PHP_EOL; // 15.99
Contextes et architecture
Les contextes délimités correspondent naturellement aux unités de déploiement : un monolithe modulaire aux frontières de modules claires ou des microservices séparés. La frontière doit être tracée autour de la capability métier, et non autour des couches techniques. Des microservices qui divisent un seul contexte fortement couplé créent un monolithe distribué ; des frontières de contexte bien alignées produisent des services qui évoluent indépendamment.
Les événements comme point de jonction
En pratique, un moyen efficace pour que les contextes s’intègrent sans partager leurs modèles consiste à échanger des événements. Le contexte amont publie un événement réduit et stable (un langage publié) ; le contexte aval s’y abonne et le convertit dans son propre modèle — sans jamais importer les classes du contexte amont.
<?php
// Published Language: a minimal stable contract
final class OrderPlacedEvent {
public function __construct(public readonly string $orderId, public readonly int $cents) {}
}
// Downstream (Shipping context) maps it to its own model
final class Shipment {
public function __construct(public readonly string $forOrder) {}
}
final class ShippingListener {
public function on(OrderPlacedEvent $e): Shipment {
return new Shipment($e->orderId); // ignores fields it doesn't need
}
}
$shipment = (new ShippingListener())->on(new OrderPlacedEvent('o1', 1300));
echo 'shipment for ', $shipment->forOrder, PHP_EOL;
Vérification rapide
Relations entre contextes.
Récapitulatif
Vous êtes passé du DDD tactique au DDD stratégique. Un contexte délimité est la frontière à l’intérieur de laquelle un modèle et son langage omniprésent restent cohérents, ce qui libère les équipes d’un modèle partagé hypertrophié. Une carte de contexte documente les relations — Customer/Fournisseur, Conformiste, Couche anticorruption, Noyau partagé, Partenariat, Voies séparées, Service d’hôte ouvert/Langage publié — en consignant à la fois l’intégration technique et la dynamique des équipes. Tracez les frontières autour des capacités métier, traduisez aux frontières et votre système pourra évoluer en parties déployables indépendamment.
Questions Fréquemment Posées
La leçon « Contextes délimités et cartographie des contextes » est-elle gratuite ?
Oui — le texte complet de « Contextes délimités et cartographie des contextes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Contextes délimités et cartographie des contextes » ?
Divisez les grands domaines en contextes délimités qui communiquent de manière sûre. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer PHP Academy ?
Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Contextes délimités et cartographie des contextes » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?
Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Éléments constitutifs du DDD : entités et objets-valeurs
- Agrégats, dépôts et fabriques
- Événements et services de domaine
- Contextes délimités et cartographie des contextes