Bounded Contexts und Context Mapping
Teilen Sie große Domänen in Bounded Contexts auf, die sicher miteinander kommunizieren.
Bounded Contexts und Context Mapping ist eine kostenlose PHP Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des PHP Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.
Strategisches DDD
Taktische Muster modellieren Objekte innerhalb einer Domäne; strategisches DDD entscheidet, wie ein großes System in Teile aufgeteilt wird, die sich unabhängig voneinander weiterentwickeln können. Das zentrale Konzept ist der Bounded Context – eine klar definierte Grenze, innerhalb derer ein Domänenmodell und seine Sprache konsistent sind. Eine Context Map beschreibt, wie diese Kontexte zueinander in Beziehung stehen. Das hat oft größere Auswirkungen als das Design einer einzelnen Klasse.
Die Ubiquitous Language
Innerhalb eines Bounded Contexts verwendet das Team eine gemeinsame Ubiquitous Language – dieselben Begriffe in Gesprächen, im Code und im Modell. Der entscheidende Punkt: Ein Wort kann in verschiedenen Kontexten unterschiedliche Bedeutungen haben. Ein Customer im Vertrieb (Leads, Rabatte) ist nicht dasselbe wie ein Customer im Support (Tickets, SLAs). Ein Bounded Context macht diese Grenze explizit, statt ein überladenes gemeinsames Modell zu erzwingen.
Gleiches Wort, andere Modelle
Dasselbe fachliche Konzept erhält ein kontextspezifisches Modell. Ein Product im Catalog berücksichtigt Beschreibungen und Medien; im Inventory geht es um Bestand und Lagerort. Jeder Kontext definiert nur, was er benötigt.
<?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;
Warum kein großes Modell
Wenn Sie versuchen, mit einem kanonischen Customer die Anforderungen aller Teams abzudecken, entsteht eine God Class mit widersprüchlichen Anforderungen, Konflikten zwischen den Teams und schwer änderbarem Code. Bounded Contexts ermöglichen es jedem Team, sein eigenes Modell und seine eigene Sprache zu verwalten, unabhängig bereitzustellen und an den Grenzen zu übersetzen. An der Grenze tragen Sie geringe Integrationskosten, um hohe Kosten durch Kopplung zu vermeiden.
Context Maps
Eine Context Map ist eine Übersicht auf hoher Ebene über Ihre Bounded Contexts und deren Beziehungen. Sie dokumentiert sowohl die technische Integration als auch die teambezogene/politische Beziehung – wer von wem abhängt und wer Änderungen vorgeben kann. DDD benennt mehrere wiederkehrende Beziehungsmuster, die wir als Nächstes betrachten.
Conformist im Code
Beziehungen sind oft gerichtet: Ein upstream-Kontext beeinflusst einen downstream-Kontext (Customer/Supplier, Conformist, Anticorruption Layer). Ein nachgelagerter Conformist hat keinen Einfluss und übernimmt daher das Modell des vorgelagerten Kontexts unverändert: Er verwendet die fremde Struktur direkt und akzeptiert die daraus entstehende Kopplung.
<?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;
Anticorruption Layer
Ein ACL übersetzt ein externes oder veraltetes Modell in das saubere Modell Ihres Kontexts, sodass fremde Konzepte niemals nach innen gelangen. Dabei handelt es sich um das Adapter-Muster, angewendet an einer Kontextgrenze. So wird Ihre Ubiquitous Language geschützt.
<?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;
Shared Kernel im Code
- Shared Kernel: Zwei Kontexte teilen eine kleine, gemeinsam verwaltete Teilmenge (hier den gemeinsamen Typ
Money) – Änderungen daran sind nur im gegenseitigen Einvernehmen möglich. - Partnership: Zwei Teams haben nur gemeinsam Erfolg oder Misserfolg.
- Separate Ways: Eine Integration ist die Kosten nicht wert.
- Open Host Service / Published Language: Der vorgelagerte Kontext stellt für viele Konsumenten ein stabiles, dokumentiertes Protokoll bereit.
<?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'); }
Kontexte in PHP integrieren
In der Praxis integrieren sich Kontexte über klar definierte Verträge: eine übersetzende Methode, einen API-Client, der eine Published Language kapselt, oder Nachrichten. Die empfangende Seite überführt das fremde DTO in ihr eigenes Modell, sodass die Kopplung an der Grenze endet.
<?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
Kontexte und Architektur
Bounded Contexts lassen sich natürlich auf Bereitstellungseinheiten abbilden: auf einen modularen Monolithen mit klaren Modulgrenzen oder auf separate Microservices. Die Grenze sollte um die fachliche Fähigkeit gezogen werden, nicht um technische Schichten. Microservices, die einen einzigen eng gekoppelten Kontext aufteilen, erzeugen einen verteilten Monolithen. Gut ausgerichtete Kontextgrenzen ermöglichen Services, die sich unabhängig voneinander ändern lassen.
Events als Nahtstelle
In der Praxis ist der Austausch von Events eine saubere Möglichkeit für Kontexte, sich zu integrieren, ohne Modelle gemeinsam zu verwenden. Der vorgelagerte Kontext veröffentlicht ein kleines, stabiles Event (eine Published Language); der nachgelagerte Kontext abonniert es und überführt es in sein eigenes Modell – die Klassen des vorgelagerten Kontexts werden niemals importiert.
<?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;
Kurztest
Beziehungen zwischen Kontexten.
Zusammenfassung
Sie sind vom taktischen zum strategischen DDD übergegangen. Ein Bounded Context ist die Grenze, innerhalb derer ein Modell und seine Ubiquitous Language konsistent bleiben. Dadurch sind Teams nicht mehr an ein einziges überladenes gemeinsames Modell gebunden. Eine Context Map dokumentiert die Beziehungen – Customer/Supplier, Conformist, Anticorruption Layer, Shared Kernel, Partnership, Separate Ways, Open Host Service/Published Language – und erfasst sowohl die technische Integration als auch die Dynamik zwischen den Teams. Ziehen Sie Grenzen um fachliche Fähigkeiten und übersetzen Sie an den Grenzen, dann kann sich Ihr System in unabhängig bereitstellbaren Teilen weiterentwickeln.
Häufig gestellte Fragen
Ist die Lektion „Bounded Contexts und Context Mapping“ kostenlos?
Ja — der vollständige Text von „Bounded Contexts und Context Mapping“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des PHP Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Bounded Contexts und Context Mapping“?
Teilen Sie große Domänen in Bounded Contexts auf, die sicher miteinander kommunizieren. Du übst PHP Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um PHP Academy zu starten?
Keine Vorkenntnisse erforderlich. PHP Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Bounded Contexts und Context Mapping“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser PHP Academy-Lektion Code schreiben und ausführen?
Ja. Jede PHP Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- DDD-Bausteine: Entities und Value Objects
- Aggregates, Repositories und Factories
- Domain Events und Domain Services
- Bounded Contexts und Context Mapping