Zum Inhalt springen
Lernsafari

Domain Driven Design: verständlich erklärt am Beispiel

Von der Lernsafari-Redaktion Stand 7 Minuten Lesezeit

Mehrere Arbeitsbereiche einer Online-Buchhandlung als abgegrenzte Inseln auf einem Plan, verbunden durch Pfade

Im Katalog einer Online-Buchhandlung ist ein Buch ein Titel mit Klappentext und Verkaufspreis. Im Lager ist es ein Exemplar auf einem Regalplatz, mit Gewicht und Maßen. Die Buchhaltung sieht einen Artikel mit 7 Prozent Umsatzsteuer. Domain Driven Design (DDD) behandelt diese drei Sichten als drei getrennte Modelle und baut die Software entlang dieser Grenzen. In diesem Artikel lernst du die wichtigsten Konzepte an einem durchgehenden Beispiel kennen, dazu einen Plan für den Einstieg.

Was ist Domain-Driven Design eigentlich?

Der Begriff stammt von Eric Evans. 2003 erschien sein Buch mit dem Untertitel „Tackling Complexity in the Heart of Software“, und genau darum geht es: komplexe Fachlichkeit beherrschbar machen. „Domain“ heißt hier Fachgebiet, also alles, was die Buchhandlung als Geschäft ausmacht, von der Vorbestellung bis zur Retoure. Datenbank, Framework und Oberfläche betrachtet DDD erst danach, als austauschbare Technik. Wie du diese Technik im Code vom Fachmodell trennst, beschreibt die Clean Architecture mit ihrer Dependency Rule.

Konkret heißt das: Entwickler sprechen so lange mit den Fachleuten, bis beide Seiten dieselben Wörter für dieselben Dinge verwenden. Diese gemeinsame Sprache heißt Ubiquitous Language. Sie steht später wörtlich im Quelltext. Sagt die Fachabteilung „Vorbestellung“, heißt die Klasse Vorbestellung und nicht PendingOrderRecord. Die Intention einer Methode soll man am Namen ablesen können.

Aus den Gesprächen entsteht ein Modell der Domäne: eine vereinfachte Abbildung der fachlichen Regeln, unabhängig von der technischen Umsetzung. Domain-Driven Design (DDD) arbeitet dabei auf zwei Ebenen:

Ebene Leitfrage Werkzeuge Ergebnis
Strategisches Design Wie schneiden wir das System fachlich? Subdomains, Bounded Context, Context Map, Event Storming Grenzen und Zuständigkeiten pro Team
Taktisches Design Wie bauen wir ein Modell im Code? Entity, Value Object, Aggregate, Repository, Domain Event Fachlich benannte Klassen, die ihre Regeln selbst schützen

Für den Anfang reicht es, beide Ebenen auseinanderzuhalten. Häufig übernehmen Teams nur die taktischen Building Blocks und lassen das strategische Design weg. Damit verschenken sie den größeren Teil des Nutzens.

Wann lohnt sich DDD, und wann nicht?

DDD kostet Zeit. Workshops und das ständige Nachschärfen der Begriffe zahlen sich nur aus, wenn die Fachlichkeit kompliziert genug ist. Eine grobe Orientierung:

  • Lohnt sich: viele fachliche Regeln, die sich häufig ändern; Fachleute, die Zeit für Gespräche haben; Software, die zehn Jahre und länger laufen soll.
  • Lohnt sich eher nicht: reine Formularanwendungen, die Daten speichern und anzeigen (CRUD); Prototypen; Werkzeuge, die technisch anspruchsvoll, fachlich aber schlicht sind, etwa ein Bildkonverter.

Innerhalb einer Domäne gibt es außerdem Unterschiede. Zur Core Domain der Buchhandlung gehören Preisgestaltung und Empfehlungen, denn damit hebt sich der Shop ab. Login und Rechnungsversand sind generische Subdomains: Die kauft man besser ein oder nimmt eine fertige Bibliothek. Unsere Einschätzung: Steck den Aufwand in die eine Subdomain, die das Geschäft wirklich ausmacht, und bau den Rest mit möglichst wenig Zeremonie.

Wer gerade erst programmieren lernt, sollte DDD zurückstellen. Die Muster ergeben erst dann Sinn, wenn du einmal an einem System mit unübersichtlichen Regeln gearbeitet hast.

Was ist ein Bounded Context?

Ein Bounded Context ist eine Grenze, innerhalb derer ein Modell und seine Sprache eindeutig gelten. Außerhalb darf dasselbe Wort etwas anderes meinen. Martin Fowler schildert in seinem Eintrag zum Bounded Context einen Fall aus einem Energieversorger: Dort meinte „meter“ je nach Abteilung die Verbindung zwischen Netz und Standort, die Verbindung zwischen Netz und Kunde oder das physische Messgerät.

In der Buchhandlung sieht das so aus:

  • Katalog: Buch = Titel mit ISBN, Beschreibung, Autor, Preis.
  • Lager: Buch = Exemplar mit Regalplatz, Bestand und Gewicht.
  • Bestellung: Buch = Position mit Menge und dem Preis zum Zeitpunkt des Kaufs.
  • Versand: Das Buch interessiert kaum noch, hier zählen Paket, Adresse und Sendungsnummer.

Jeder dieser vier Bereiche bekommt sein eigenes Modell. Der Katalog muss nichts über Regalplätze wissen. An den Grenzen wird übersetzt, meistens über die ISBN oder eine Bestellnummer. Wie die Teile zusammenhängen, hält eine Context Map fest: wer Daten liefert, wer sich anpasst und wo eine Übersetzungsschicht sitzt.

Infografik: Was „Buch“ in den vier Bereichen Katalog, Lager, Bestellung und Versand einer Buchhandlung bedeutet
Ein Wort, vier Modelle: Katalog, Lager, Bestellung und Versand sehen das Buch jeweils anders.

Was sind Entities, Value Objects und Aggregates?

Mit diesen Bausteinen aus taktischem Design wird das Modell im Code abgebildet. Evans beschreibt noch weitere, etwa Repositories. Für den Einstieg genügen diese drei.

Entity: etwas mit Identität

Eine Entity bleibt dieselbe, auch wenn sich ihre Daten ändern. Die Kundin zieht um und bleibt trotzdem Kundin Nummer 48213. Auch eine Bestellung ist eine Entity. Sie hat eine Bestellnummer und durchläuft Zustände von „aufgegeben“ bis „zugestellt“.

Value Object: nur der Wert zählt

Ein Wertobjekt hat keine Identität. Zwei Geldbeträge von 24,90 Euro sind gleich, egal woher sie kommen. Solche Objekte sind unveränderlich und prüfen ihre Regeln selbst. Typische Kandidaten: Geldbetrag, ISBN, Adresse, Zeitraum. Die Implementierung in Python ist kurz:

from dataclasses import dataclass
from decimal import Decimal


@dataclass(frozen=True)
class Geldbetrag:
    betrag: Decimal
    waehrung: str = "EUR"

    def __post_init__(self):
        if self.betrag < 0:
            raise ValueError("Ein Geldbetrag ist nie negativ.")
        if len(self.waehrung) != 3:
            raise ValueError("Währung als ISO-Code mit drei Buchstaben, etwa EUR.")

    def plus(self, anderer: "Geldbetrag") -> "Geldbetrag":
        if anderer.waehrung != self.waehrung:
            raise ValueError("Beträge in verschiedenen Währungen")
        return Geldbetrag(self.betrag + anderer.betrag, self.waehrung)


preis = Geldbetrag(Decimal("24.90"))
versand = Geldbetrag(Decimal("3.95"))
print(preis.plus(versand))                    # Geldbetrag(betrag=Decimal('28.85'), waehrung='EUR')
print(preis == Geldbetrag(Decimal("24.90")))  # True

frozen=True verhindert Änderungen nach dem Erzeugen, plus liefert ein neues Objekt. Decimal statt float vermeidet Rundungsfehler, was bei Geld insbesondere an der Kasse auffällt. Kleine, gut benannte Typen sind auch ein Thema von Clean Code.

Aggregate: eine Einheit mit Regeln

Ein Aggregate fasst Entities und Wertobjekte zusammen, die gemeinsam konsistent bleiben müssen. Von außen spricht man nur mit der Wurzel, dem Aggregate Root. In der Buchhandlung ist die Bestellung so eine Wurzel. Bestellpositionen ändert niemand direkt, sondern nur über Methoden wie fuegePositionHinzu(). So kann die Bestellung ihre Regeln an einer Stelle durchsetzen. Ein Beispiel: Eine bezahlte Bestellung nimmt keine neuen Positionen mehr an.

Der Haken: Aggregates wachsen schnell. Vaughn Vernon empfiehlt, sie klein zu halten und andere Aggregates nur über deren ID zu referenzieren. Die Bestellung speichert also die Kundennummer statt des kompletten Kundenobjekts. Gespeichert und geladen wird ein Aggregate immer als Einheit, über ein Repository. Für erste Skizzen reichen Klassendiagramme, wie sie im Beitrag zu UML-Diagrammen beschrieben sind.

Wie fängst du an, zum Beispiel mit Event Storming?

Event Storming ist ein Workshop-Format, das Alberto Brandolini entwickelt hat. Fachleute und Entwickler stehen vor einer langen Papierbahn an der Wand und kleben auf, was in der Domäne passiert. Über Klassen und Tabellen redet in dieser Phase niemand.

Gruppe an einer langen Papierbahn mit farbigen Haftnotizen in Reihen, im Stil einer ruhigen Illustration
Event Storming: zuerst die Ereignisse sammeln, dann Commands und Grenzen ergänzen.

So läuft eine erste Runde ab:

  1. Ereignisse sammeln: Alle schreiben Domain Events in der Vergangenheitsform auf orange Zettel, etwa „Bestellung aufgegeben“, „Zahlung eingegangen“, „Paket versendet“.
  2. Zeitlich ordnen: Die Zettel kommen von links nach rechts in eine Reihenfolge. Lücken und Streit über Begriffe sind erwünscht, sie zeigen ungeklärte Fachlichkeit.
  3. Commands ergänzen: Auf blaue Zettel kommt, was ein Ereignis auslöst, zum Beispiel „Bestellung aufgeben“. Commands sind Absichten, Events sind Tatsachen.
  4. Aggregates und Grenzen finden: Wo sich Zettel um dieselbe Sache drehen, liegt ein Aggregate. Wo die Sprache wechselt, liegt oft eine Kontextgrenze.

Rechne für die erste Runde mit einem halben bis ganzen Tag. Danach hast du einen Entwurf der fachlichen Grenzen und eine Liste offener Fragen. Erst jetzt lohnt der Blick auf die taktischen Bausteine.

Wie passt DDD zu Microservices?

Gut, solange du die Reihenfolge einhältst. Ein Bounded Context ist ein naheliegender Kandidat für die Grenze eines Microservice, weil er ein eigenes Modell und eine eigene Sprache hat. Services, die quer durch die fachlichen Bereiche geschnitten sind, rufen sich ständig gegenseitig auf und müssen gemeinsam geändert werden. Die Kopplung ist dann stark, obwohl die Teile getrennt deployt werden.

Die Bereiche tauschen Nachrichten über Ereignisse aus: Die Bestellung meldet „Bestellung bezahlt“, das Lager reserviert daraufhin die entsprechenden Exemplare. Ein Kontext muss aber nicht ein eigener Service sein. Für kleinere Teams würden wir mit einem modularen Monolithen anfangen, in dem jeder fachliche Bereich ein Modul mit klarer Schnittstelle ist. Trennen kannst du später, wenn Last oder Teamgröße es verlangen.

Welche Bücher helfen beim Weiterlernen?

  • „Domain-Driven Design“ von Eric Evans (Addison-Wesley, 2003): das Grundlagenwerk und die Quelle der Begriffe. Anspruchsvoll, mit langen Passagen über Modellierung. Eher für Fortgeschrittene, die schon größere Systeme kennen.
  • „Implementing Domain-Driven Design“ von Vernon (Addison-Wesley, 2013): praxisnäher, mit Java-Beispielen zu Aggregates, Domain Events und Context Mapping. Gut als zweites Buch.
  • „Domain-Driven Design kompakt“, ebenfalls von Vernon (dpunkt.verlag, 2017): die deutsche Ausgabe seines Kurzbuchs „Distilled“, übersetzt von Carola Lilienthal und Henning Schwentner. Schmal und für den Einstieg gedacht.

Steckbriefe zu diesen und weiteren Titeln findest du im Lernsafari-Bücherregal.

Kernaussagen zum Mitnehmen

  • DDD lohnt sich bei komplizierter Fachlichkeit, für Formularanwendungen ist es zu schwer.
  • Die gemeinsame Sprache mit den Fachleuten bringt mehr als jedes Pattern.
  • Getrennte Modelle sind richtig, wenn dasselbe Wort in zwei Abteilungen Verschiedenes bedeutet.
  • Wertobjekte sind der leichteste Einstieg: klein, unveränderlich, selbst prüfend.
  • Für den Start: ein Event-Storming-Workshop zu einer Kerndomäne, danach ein Typ wie Geldbetrag im eigenen Projekt.

Mehr aus Architektur & Clean Code