Von Spaghetti zu Lasagne: Domain-Driven Design im Code umsetzen

Schichtenarchitektur und taktische Muster: Entity, Value Object, Aggregate und Repository in der Praxis
Aktualisiert:
Abstract
- #Domain-Driven Design
- #DDD Layered Architecture
- #Softwarearchitektur
- #Moderne Softwareentwicklung
- #Taktisches Design
- #Aggregate
- #Hexagonale Architektur
- #Geschäftslogik-Organisation
- #Schichtentrennung
Wo gehört die Geschäftsregel hin? Wie DDD-Schichten und Bausteine den Code ordnen
Ein Webshop gewährt Stammkunden drei Prozent Rabatt. Die Regel steht im Controller, der den Warenkorb anzeigt, noch einmal in einer gespeicherten Prozedur für die Rechnung und ein drittes Mal im JavaScript des Frontends, damit der Preis sofort aktualisiert wird. Als der Rabatt auf fünf Prozent steigen soll, findet das Team zwei der drei Stellen. Die Rechnungen stimmen danach wochenlang nicht mit dem Warenkorb überein.
So sieht Spaghetti-Code im Alltag aus: Fachliche Regeln sind über Benutzeroberfläche, Datenbank und Hilfsklassen verstreut. Domain-Driven Design (DDD) setzt dem eine geordnete Struktur entgegen, bildlich gesprochen eine Lasagne aus klar getrennten Schichten mit einem festen Ort für die Geschäftslogik. Wie diese Ordnung im Code aussieht und welche Bausteine dabei helfen, zeigt dieser Text mit Beispielen in TypeScript.
Warum Software überhaupt in Schichten zerfällt
Das Bild von Spaghetti und Lasagne ist älter als DDD. Ende der 1960er-Jahre wuchsen Programme so stark, dass unkontrollierte Sprünge im Code nicht mehr beherrschbar waren. Edsger Dijkstras Aufsatz „Go To Statement Considered Harmful“ von 1968 steht sinnbildlich für den Übergang zur strukturierten Programmierung. Spaghetti steht für ein Geflecht, bei dem jedes Teil mit jedem verbunden ist. Lasagne steht für Lagen, die aufeinander aufbauen und sich einzeln betrachten lassen.
In den 1990er-Jahren setzten sich Schichten in Geschäftsanwendungen durch, zunächst als zweischichtige Client-Server-Systeme, später als Drei-Schichten-Architektur: Präsentation, Geschäftslogik, Datenzugriff. In vielen Systemen landete die Geschäftslogik allerdings in gespeicherten Prozeduren der Datenbank. Das war damals nachvollziehbar, führte aber dazu, dass Fachregeln an SQL und an ein bestimmtes Datenbankprodukt gebunden waren.
Eric Evans griff die Schichtenidee 2003 in seinem Buch über Domain-Driven Design auf und verfeinerte sie. Sein Ziel war, dem fachlichen Modell einen eigenen, von Technik freien Platz zu geben. Wie man dieses Modell zuvor fachlich findet und gegen andere Bereiche abgrenzt, also das strategische Design mit Bounded Contexts und gemeinsamer Fachsprache, beschreibt unser Beitrag Domain-Driven Design: Strategisches Design für komplexe Fachdomänen. Hier geht es um das, was danach im Code passiert.
Die vier Schichten der DDD-Architektur
Die DDD-Schichtenarchitektur teilt eine Anwendung in vier Lagen. Wichtiger als die Zahl ist die Abhängigkeitsrichtung: Jede Schicht darf nur Schichten unter sich kennen, und die Domänenschicht kennt idealerweise gar keine Technik.
Präsentationsschicht
Sie nimmt Eingaben entgegen und zeigt Ergebnisse an, etwa als Weboberfläche, App oder HTTP-Schnittstelle. Dabei arbeitet sie mit zwei Arten von Datenobjekten: dem Input Model, das beschreibt, was der Nutzer abschickt, und dem View Model, das genau die Daten enthält, die eine Ansicht braucht. Geschäftsregeln haben hier nichts zu suchen. Eine Rabattberechnung im Frontend darf es höchstens als Vorschau geben, verbindlich ist die Domäne.
Anwendungsschicht
Die Anwendungsschicht steuert die Anwendungsfälle, also Abläufe wie „Bestellung abschicken“ oder „Adresse ändern“. Sie lädt die benötigten Domänenobjekte, ruft deren Methoden auf, speichert das Ergebnis und stößt Folgeaktionen an. Sie entscheidet aber nicht selbst über fachliche Regeln. Weil sie vom HTTP-Kontext getrennt ist, lässt sie sich ohne Webserver testen. Kommt neben der Website eine mobile App hinzu, entstehen hier unter Umständen zusätzliche Anwendungsfälle, während die Domänenschicht unverändert bleibt.
Domänenschicht
Das Herz der Anwendung. Hier stehen die Regeln, die unabhängig vom jeweiligen Anwendungsfall gelten: Eine abgeschickte Bestellung kann nicht mehr verändert werden, ein Betrag kann nicht negativ sein. Die Domänenschicht enthält das Domänenmodell und die taktischen Bausteine, die weiter unten beschrieben werden. Sie importiert weder Datenbanktreiber noch Web-Frameworks.
Infrastrukturschicht
Sie stellt die Technik bereit: Datenbankzugriff, Nachrichtenversand, Dateispeicher, Logging, Authentifizierung, Caching und die Anbindung externer Dienste. Damit ein Wechsel der Datenbank oder des Mailanbieters nicht die Fachlogik berührt, definiert die Domäne Schnittstellen, die die Infrastruktur implementiert. Dieses Prinzip heißt Abhängigkeitsumkehr (Dependency Inversion) und ist der Schlüssel zum Vergleich mit anderen Architekturstilen weiter unten.
Drei Wege, Geschäftslogik zu organisieren
Martin Fowler beschrieb 2002 in „Patterns of Enterprise Application Architecture“ drei grundlegende Muster, um Geschäftslogik zu ordnen. Sie helfen bei der Entscheidung, wie viel Struktur ein Bereich wirklich braucht.
- Transaction Script: Jeder Anwendungsfall ist eine Prozedur, die von oben nach unten abläuft: Daten lesen, prüfen, rechnen, speichern. Das ist leicht zu verstehen und für einfache Abläufe völlig angemessen. Mit wachsender Zahl an Regeln entstehen jedoch Dubletten, wie im Rabattbeispiel oben.
- Table Module: Pro Datenbanktabelle gibt es eine Klasse, die die Logik für alle Datensätze dieser Tabelle bündelt. Das Muster passt zu Umgebungen, die stark mit Datensätzen und Tabellen arbeiten, ist heute aber selten.
- Domain Model: Die Logik steckt in Objekten, die fachliche Dinge mit Daten und Verhalten abbilden. Der Einstieg ist aufwendiger, dafür bleibt das System auch bei vielen verzahnten Regeln überschaubar.
DDD setzt in seinen taktischen Mustern auf das Domain Model. Das heißt aber nicht, dass jeder Teil eines Systems eines braucht. Ein Bereich mit wenigen Regeln ist mit einem Transaction Script oft besser bedient.
Die taktischen Bausteine im Code
Die folgenden Beispiele zeigen einen vereinfachten Bestellvorgang in TypeScript. Sie verzichten auf Frameworks, damit die Muster selbst sichtbar bleiben.
Value Object
Ein Value Object (Wertobjekt) hat keine eigene Identität. Zwei Geldbeträge von 10 Euro sind gleich, egal wo sie herkommen. Value Objects sind unveränderlich und prüfen ihre Gültigkeit beim Erzeugen. Statt überall mit nackten Zahlen zu hantieren, bekommt der Code einen Typ, der die Regeln kennt.
// Wertobjekt: unveränderlich, Gleichheit über den Inhalt
export class Geldbetrag {
readonly cent: number;
private constructor(cent: number) {
this.cent = cent;
}
static euro(cent: number): Geldbetrag {
if (!Number.isInteger(cent) || cent < 0) {
throw new Error('Betrag muss eine nicht negative Ganzzahl in Cent sein');
}
return new Geldbetrag(cent);
}
plus(anderer: Geldbetrag): Geldbetrag {
return new Geldbetrag(this.cent + anderer.cent);
}
mal(faktor: number): Geldbetrag {
return Geldbetrag.euro(Math.round(this.cent * faktor));
}
equals(anderer: Geldbetrag): boolean {
return this.cent === anderer.cent;
}
}
Beträge in Cent als Ganzzahl zu führen, vermeidet Rundungsfehler von Gleitkommazahlen. In echten Systemen kommt meist noch die Währung hinzu.
Entity und Aggregate
Eine Entity hat eine Identität, die über ihre Lebensdauer gleich bleibt. Eine Bestellung bleibt dieselbe Bestellung, auch wenn Positionen hinzukommen. Ein Aggregate fasst mehrere Objekte zu einer Einheit zusammen, die nur über ein Wurzelobjekt (Aggregate Root) verändert werden darf. Die Wurzel garantiert, dass die Regeln des Ganzen immer eingehalten sind.
import { Geldbetrag } from './geldbetrag.js';
type Position = {
artikelNr: string;
menge: number;
einzelpreis: Geldbetrag;
};
export type BestellungAbgeschickt = {
typ: 'BestellungAbgeschickt';
bestellId: string;
summe: Geldbetrag;
zeitpunkt: Date;
};
// Aggregate Root: Änderungen nur über diese Klasse
export class Bestellung {
readonly id: string;
private positionen: Position[] = [];
private status: 'offen' | 'abgeschickt' = 'offen';
private ereignisse: BestellungAbgeschickt[] = [];
constructor(id: string) {
this.id = id;
}
positionHinzufuegen(artikelNr: string, menge: number, einzelpreis: Geldbetrag): void {
if (this.status !== 'offen') {
throw new Error('Eine abgeschickte Bestellung kann nicht mehr geändert werden');
}
if (!Number.isInteger(menge) || menge <= 0) {
throw new Error('Die Menge muss eine positive Ganzzahl sein');
}
this.positionen.push({ artikelNr, menge, einzelpreis });
}
summe(): Geldbetrag {
return this.positionen.reduce(
(gesamt, p) => gesamt.plus(p.einzelpreis.mal(p.menge)),
Geldbetrag.euro(0),
);
}
abschicken(): void {
if (this.positionen.length === 0) {
throw new Error('Eine leere Bestellung kann nicht abgeschickt werden');
}
this.status = 'abgeschickt';
this.ereignisse.push({
typ: 'BestellungAbgeschickt',
bestellId: this.id,
summe: this.summe(),
zeitpunkt: new Date(),
});
}
// Liefert die gesammelten Domain Events und leert die Liste
ereignisseEntnehmen(): BestellungAbgeschickt[] {
const ergebnis = this.ereignisse;
this.ereignisse = [];
return ergebnis;
}
}
Die Positionen sind von außen nicht direkt veränderbar. Wer eine Position hinzufügen will, muss über positionHinzufuegen() gehen, und dort sitzen die Prüfungen. Eine Faustregel für den Zuschnitt: Aggregates klein halten und pro Transaktion nur eines verändern. Verweise auf andere Aggregates erfolgen über deren Kennung, nicht über Objektreferenzen.
Domain Events
Das Ereignis BestellungAbgeschickt im Beispiel ist ein Domain Event: eine Meldung über etwas fachlich Bedeutsames, das bereits geschehen ist, formuliert in der Vergangenheit. Andere Teile des Systems reagieren darauf, etwa der Versand einer Bestätigungsmail oder die Reservierung im Lager. Die Bestellung muss davon nichts wissen. Das entkoppelt die Bausteine und ist oft der Ausgangspunkt für ereignisgetriebene Architekturen.
Repository und Domain Service
Ein Repository verhält sich aus Sicht der Domäne wie eine Sammlung von Aggregates, die man laden und speichern kann. Die Schnittstelle gehört zur Domäne, die Implementierung mit SQL oder einem ORM zur Infrastruktur.
import { Bestellung, BestellungAbgeschickt } from './bestellung.js';
// Schnittstellen der Domäne, implementiert in der Infrastruktur
export interface BestellungRepository {
findeNachId(id: string): Promise<Bestellung | undefined>;
speichern(bestellung: Bestellung): Promise<void>;
}
export interface EreignisVerteiler {
veroeffentlichen(ereignisse: BestellungAbgeschickt[]): Promise<void>;
}
// Anwendungsfall in der Anwendungsschicht
export class BestellungAbschicken {
private readonly bestellungen: BestellungRepository;
private readonly verteiler: EreignisVerteiler;
constructor(bestellungen: BestellungRepository, verteiler: EreignisVerteiler) {
this.bestellungen = bestellungen;
this.verteiler = verteiler;
}
async ausfuehren(bestellId: string): Promise<void> {
const bestellung = await this.bestellungen.findeNachId(bestellId);
if (!bestellung) {
throw new Error(`Bestellung ${bestellId} nicht gefunden`);
}
bestellung.abschicken();
await this.bestellungen.speichern(bestellung);
await this.verteiler.veroeffentlichen(bestellung.ereignisseEntnehmen());
}
}
Die Klasse BestellungAbschicken enthält keine einzige Geschäftsregel. Sie koordiniert nur. Für Tests lässt sich das Repository durch eine einfache Variante im Arbeitsspeicher ersetzen. In produktiven Systemen sollten Speichern und Veröffentlichen zusammen gelingen oder scheitern; dafür gibt es Verfahren wie das Outbox-Muster, bei dem Ereignisse in derselben Datenbanktransaktion abgelegt und erst danach verteilt werden.
Ein Domain Service ist der Ort für Fachlogik, die zu keinem einzelnen Objekt passt, etwa eine Preisberechnung, die Bestellung, Kundenstatus und aktuelle Aktionen zusammen betrachtet. Domain Services sollten die Ausnahme bleiben. Wer die meisten Regeln dort ablegt, landet schnell beim nächsten Problem.
Das anämische Domänenmodell: Klassen ohne Verhalten
Martin Fowler nannte es 2003 das Anemic Domain Model: Klassen, die zwar Bestellung oder Kunde heißen, aber nur Felder mit Gettern und Settern haben. Die eigentliche Logik steckt in Service-Klassen, die von außen in den Objekten herumschreiben. Das sieht nach DDD aus, ist im Kern aber ein Transaction Script mit zusätzlichem Aufwand.
Woran Sie ein anämisches Modell erkennen:
- Domänenklassen haben öffentliche Setter für jedes Feld.
- Prüfungen wie „Bestellung darf nicht leer sein“ stehen in Services oder Controllern.
- Dieselbe Regel taucht an mehreren Stellen auf.
Der Gegenentwurf ist ein Modell, in dem Objekte ihre Regeln selbst durchsetzen, wie die Bestellung im Beispiel. Den Weg dorthin aus einer datenbankgetriebenen Codebasis beschreibt unser Beitrag Von datenbankzentrierten zu verhaltensorientierten Domain Models.
Schichten, Hexagon, Zwiebel: verwandte Architekturstile
Neben der klassischen DDD-Schichtenarchitektur begegnen Ihnen drei verwandte Stile, die oft mit DDD kombiniert werden:
| Stil | Herkunft | Kernidee |
|---|---|---|
| Schichtenarchitektur nach Evans | Eric Evans, 2003 | Vier Lagen, Abhängigkeiten von oben nach unten |
| Hexagonale Architektur (Ports and Adapters) | Alistair Cockburn, um 2005 | Die Anwendung definiert Ports, Adapter verbinden sie mit UI, Datenbank und Fremdsystemen |
| Onion Architecture | Jeffrey Palermo, 2008 | Konzentrische Ringe, das Domänenmodell liegt in der Mitte |
| Clean Architecture | Robert C. Martin, 2012 | Konzentrische Ringe mit der Regel, dass Abhängigkeiten nur nach innen zeigen |
Der wesentliche Unterschied: In der strengen Schichtenarchitektur liegt die Infrastruktur unten, und die Domäne hängt formal von ihr ab. Hexagonale, Onion- und Clean Architecture drehen diese Abhängigkeit konsequent um. Die Domäne steht im Zentrum, alles Technische hängt von ihr ab. In der Praxis setzen auch die meisten DDD-Teams mit Schichten diese Umkehr über Schnittstellen um, wie beim Repository oben. Die Stile liegen damit näher beieinander, als ihre Diagramme vermuten lassen. Welchen Namen ein Team wählt, ist weniger wichtig als die Regel, dass Fachlogik nicht von Datenbank oder Framework abhängen darf.
Wann sich die Umsetzung mit taktischen Mustern lohnt
Taktisches DDD bringt zusätzliche Klassen, Schnittstellen und Abbildungen zwischen Datenbank und Domänenobjekten. Dieser Aufwand rechnet sich dort, wo viele Regeln ineinandergreifen und sich häufig ändern: Tarifberechnungen, Vertragslogik, Disposition, Abrechnung. Für eine Verwaltungsoberfläche, die im Wesentlichen Datensätze anlegt und anzeigt, ist er überdimensioniert.
Auch innerhalb einer Anwendung kann die Antwort unterschiedlich ausfallen. Der Kernbereich bekommt ein sorgfältiges Domain Model, ein Nebenbereich ein schlichtes Transaction Script. Wo Lese- und Schreibzugriffe sehr unterschiedliche Anforderungen haben, kann zusätzlich eine Trennung beider Seiten sinnvoll sein; wie das funktioniert, zeigt unser Beitrag zu CQRS mit getrenntem Lese- und Schreibmodell.
Ein typischer Fehler ist, die Muster vollständig auf jede Klasse anzuwenden: Repository für jede Tabelle, Factory für jedes Objekt, Domain Service für jede Methode. Das Ergebnis ist eine Lasagne mit zu vielen Lagen, in der jede Änderung durch sechs Dateien wandert.
Was das für Ihr Team bedeutet
Unsere Empfehlung: Beginnen Sie bei der Frage, wo eine fachliche Regel ihren festen Platz hat. Wenn die Antwort lautet „in mehreren Controllern und einer Prozedur“, lohnt sich der Umbau. Value Objects sind dabei der dankbarste Einstieg. Sie lassen sich in bestehenden Code einführen, ohne die Architektur umzustellen, und verhindern sofort ganze Fehlerklassen, etwa negative Beträge oder vertauschte Einheiten.
Aggregates erfordern mehr Erfahrung, denn ein falscher Zuschnitt führt zu Sperrkonflikten oder zu Objekten, die halbe Datenbanken laden. Hier hilft es, die Grenzen zuerst fachlich zu klären, bevor sie im Code festgeschrieben werden.
Überschätzt werden Frameworks, die DDD versprechen. Die Muster brauchen keine Bibliothek, sondern Disziplin bei Abhängigkeiten und Namen. Unterschätzt wird dagegen die Testbarkeit: Eine Domänenschicht ohne Technik lässt sich in Millisekunden testen, und genau dort sitzen die Regeln, deren Fehler am teuersten sind.
Wer diese Architektur in einem bestehenden Projekt einführen oder im Team aufbauen möchte, findet auf unserer Themenseite zur Softwareentwicklung mit Beratung, Coaching und Seminaren passende Angebote.
Häufige Fragen zur Umsetzung von DDD im Code
Worin unterscheidet sich die DDD-Schichtenarchitektur von der klassischen Drei-Schichten-Architektur?
Die klassische Variante kennt eine einzige Geschäftslogikschicht. DDD teilt sie in die Anwendungsschicht, die Abläufe steuert, und die Domänenschicht, die Regeln durchsetzt. Außerdem fasst die Infrastrukturschicht mehr als nur den Datenzugriff zusammen, etwa Nachrichtenversand, Logging und Sicherheit.
Lässt sich DDD schrittweise in eine bestehende Anwendung einführen?
Ja, und das ist meist der bessere Weg als ein Neubau. Bewährt hat sich, mit Value Objects für zentrale Begriffe zu beginnen, dann einzelne Regeln aus Controllern und Prozeduren in Domänenklassen zu verlagern und schließlich Repositories als Schnittstellen einzuziehen. Jeder Schritt bleibt dabei einzeln lieferbar und testbar.
Setzt DDD eine objektorientierte Sprache voraus?
Nein. Die taktischen Muster stammen aus der objektorientierten Welt, lassen sich aber auch funktional umsetzen: Value Objects als unveränderliche Datentypen, Aggregates als Funktionen, die einen Zustand und einen Befehl entgegennehmen und einen neuen Zustand mit Ereignissen liefern. Entscheidend ist, dass die Fachregeln an einem Ort gebündelt und frei von Technik bleiben.
Kategorien
Schlagworte