Domain-driven Design

Domain-Driven Design (DDD) ist eine Herangehensweise an die Modellierung komplexer objektorientierter Software. Die Modellierung der Software wird dabei maßgeblich von den umzusetzenden Fachlichkeiten der Anwendungsdomäne beeinflusst. Der Begriff „Domain-Driven Design“ wurde von Eric Evans in seinem gleichnamigen Buch geprägt.

Domain-Driven Design ist nicht nur eine Technik oder Methode. Es ist viel mehr eine Denkweise und Priorisierung zur Steigerung der Produktivität von Softwareprojekten im Umfeld komplexer fachlicher Zusammenhänge. Domain-Driven Design basiert auf folgenden zwei Annahmen:

• Der Schwerpunkt des Softwaredesigns liegt auf der Fachlichkeit und der Fachlogik.
• Der Entwurf komplexer fachlicher Zusammenhänge sollte auf einem Modell der Anwendungsdomäne, dem Fachmodell basieren.

Domain-Driven Design ist an keinen bestimmten Softwareentwicklungsprozess gebunden, orientiert sich aber an agiler Softwareentwicklung. Insbesondere setzt es iterative Softwareentwicklung und eine enge Zusammenarbeit zwischen Entwicklern und Fachexperten voraus.

Beschreibung

Schichtenarchitektur

Der Sinn jeder Software ist es, die Aufgabenstellungen einer bestimmten Anwendungsdomäne zu unterstützen. Um dies erfolgreich machen zu können, muss die Software harmonisch zu der Fachlichkeit der Anwendungsdomäne passen, für die sie bestimmt ist. Domain-Driven Design ermöglicht dies, indem die Software grundlegende Konzepte und Elemente der Anwendungsdomäne, sowie deren Beziehungen modelliert.

Dabei wird eine Gliederung der Software durch eine Schichtenarchitektur vorausgesetzt. Das Hauptaugenmerk von Domain-Driven Design liegt dabei auf der Geschäftslogikschicht. Dabei wird bewusst ein anemisches Fachmodell, ein Antipattern welches ein Fachmodell ohne Fachlogik beschreibt, vermieden. Die Klassen des Fachmodells enthalten im Domain-Driven Design sowohl die Daten als auch die gesamte Funktionalität der umzusetzenden Fachlichkeit, also die gesamte Fachlogik.

Ubiquitäre Sprache

Domain-Driven Design basiert auf einer Reihe von Konzepten, welche bei der Modellierung – aber auch anderen Tätigkeiten der Softwareentwicklung – berücksichtigt werden sollten. Das Hauptaugenmerk hierbei fällt auf die Einführung einer ubiquitären (allgemein verwendeten, allgegenwärtigen englisch ubiquitous) Sprache, welche in allen Bereichen der Softwareerstellung verwendet werden sollte. Eine Sprache für die Beschreibung der Fachlichkeit, der Elemente des Fachmodells, der Klassen und Methoden etc. Sie wird definiert als:

“A language structured around the domain model and used by all team members to connect all the activities of the team with the software.”

„Eine Sprache, welche um die Anwendungsdomäne strukturiert ist, und von allen Teammitgliedern verwendet wird, um alle Aktivitäten des Teams mit der Software zu verknüpfen.“

– Eric Evans: Präsentationsunterlagen seines Vortrages vom 6. November 2007 auf der JAOO

Domain-Driven Design ist selbst unabhängig von Programmiersprachen, Tools und Frameworks. Dennoch gibt es eine Reihe von Tools und Frameworks, die Unterstützung für die Realisierung spezifischer DDD-Patterns anbieten oder die Herangehensweise von DDD unterstützen.

Bestandteile des Fachmodells

Fachmodell

Domain-Driven Design unterscheidet die folgenden Bestandteile des Fachmodells:

Entitäten (englisch Entities, englisch Reference Objects)

Objekte des Modelles, welche nicht durch ihre Eigenschaften, sondern durch ihre Identität definiert werden. Beispielsweise wird eine Person meist als Entität abgebildet. Eine Person bleibt somit dieselbe Person, wenn sich ihre Eigenschaften ändern; und sie unterscheidet sich von einer anderen Person, auch wenn diese dieselben Eigenschaften hat. Entitäten werden oft mit Hilfe von eindeutigen Identifikatoren modelliert.

Wertobjekte (englisch Value Objects)

Objekte des Modelles, welche keine konzeptionelle Identität haben oder benötigen und somit allein durch ihre Eigenschaften definiert werden. Wertobjekte werden üblicherweise als unveränderliche Objekte (englisch immutable objects) modelliert, damit sind sie wiederverwendbar (vgl. Flyweight) und verteilbar.

Aggregate (englisch Aggregates)

Aggregate sind Zusammenfassungen von Entitäten und Wertobjekten und deren Assoziationen untereinander zu einer gemeinsamen transaktionalen Einheit. Aggregate definieren genau eine Entität als einzigen Zugriff auf das gesamte Aggregat. Alle anderen Entitäten und Wertobjekte dürfen von außerhalb nicht statisch referenziert werden. Damit wird garantiert, dass alle Invarianten des Aggregats und der einzelnen Bestandteile des Aggregats sichergestellt werden können.

Assoziationen (englisch Associations)

Assoziationen sind, wie bei UML definiert, Beziehungen zwischen zwei oder mehr Objekten des Fachmodells. Hier werden nicht nur statische, durch Referenzen definierte Beziehungen betrachtet, sondern auch dynamische Beziehungen, die beispielsweise erst durch die Abarbeitung von SQL-Queries entstehen.

Serviceobjekte (englisch Services)

Bei Domain-Driven Design werden Funktionalitäten, welche ein wichtiges Konzept der Fachlichkeit darstellen und konzeptionell zu mehreren Objekten des Fachmodelles gehören, als eigenständige Serviceobjekte modelliert. Serviceobjekte sind üblicherweise zustandslose (eng. stateless) und daher wiederverwendbare Klassen ohne Assoziationen, mit Methoden, die den angebotenen Funktionalitäten entsprechen. Diese Methoden bekommen die Wertobjekte und Entitäten übergeben, die zur Abarbeitung der Funktionalität notwendig sind.

Fachliche Ereignisse (englisch Domain Events)

Fachliche Ereignisse sind Objekte, welche fachliche Ereignisse beschreiben, die ein oder mehrere Aktionen oder Änderungen in den Fachobjekten bewirken. Damit wird die Modellierung komplexer, sich unter Umständen dynamisch ändernder fachlicher Aktionen vereinfacht. Fachliche Ereignisse ermöglichen auch die Modellierung verteilter Systeme. Die einzelnen Subsysteme kommunizieren ausschließlich über fachliche Ereignisse, damit werden sie stark entkoppelt und das gesamte System somit wartbarer und skalierbarer.

Module (englisch Modules, englisch Packages)

Module teilen das Fachmodell in fachliche (nicht technische) Bestandteile. Sie sind gekennzeichnet durch starke innere Kohäsion und geringe Kopplung zwischen den Modulen.

Darüber hinaus kennt Domain-Driven Design noch zwei weitere Bestandteile des Fachmodells – Factories und Repositories. Diese implementieren zwar selbst nicht Fachlichkeit, sind aber dennoch Bestandteil des Fachmodells, da sie für den Lebenszyklus der Fachobjekte wichtige Funktionalität bereitstellen.

Fabriken (englisch Factories)

Fabriken dienen dazu, die Erzeugung von Fachobjekten in spezielle Fabrik-Objekte auszulagern. Dies ist sinnvoll, wenn entweder die Erzeugung komplex ist (und beispielsweise Assoziationen benötigt, die das Fachobjekt selbst nicht mehr benötigt) oder die spezifische Erzeugung der Fachobjekte zur Laufzeit ausgetauscht werden können soll. Fabriken werden üblicherweise durch erzeugende Entwurfsmuster wie Abstrakte Fabrik, Fabrikmethode oder Erbauer umgesetzt.

Repositories

Repositories abstrahieren die Persistierung und Suche von Fachobjekten. Mittels Repositories werden die technische Infrastruktur sowie alle Zugriffsmechanismen auf diese von der Geschäftslogikschicht getrennt. Für alle Fachobjekte, welche über die Infrastruktur-Schicht geladen werden, wird eine Repository Klasse bereitgestellt, welche die verwendeten Lade- und Suchtechnologien nach außen abkapselt. Die Repositories selbst sind Teil des Fachmodells und somit Teil der Geschäftslogikschicht. Sie greifen als einzige auf die Objekte der Infrastruktur-Schicht, welche meist mittels der Entwurfsmuster Data Access Objects, Query Objects oder Metadata Mapping Layers umgesetzt werden, zu.

Die Namen der diesen Mustern entsprechenden Klassen der Geschäftslogikschicht sind Teile der ubiquitären Sprache und sollten entsprechend benannt werden. Eine Änderung des Namens eines Fachobjektes durch Refactoring entspricht somit einer Änderung der Fachlichkeit der Applikation.

Weitere Techniken

Domain-Driven Design beschreibt und empfiehlt eine Reihe weiterer Techniken und Herangehensweisen für die Umsetzung des Fachmodells:

Architekturtechniken

Evolvierende Struktur (englisch evolving order)

geht davon aus, dass große Strukturen im Fachmodell idealerweise erst mit der Zeit entstehen beziehungsweise sich über die Zeit entwickeln. Große Strukturen sollten möglichst einfach und mit möglichst wenigen Ausnahmen umgesetzt sein.

Systemmetapher (englisch system metaphor)

ist ein Konzept aus Extreme Programming, welche die Kommunikation zwischen allen Beteiligten erleichtert, indem es das System mittels einer Metapher, einer inhaltlich ähnlichen, für alle Seiten verständlichen Alltagsgeschichte beschreibt. Diese sollte möglichst gut passen und zur Stärkung der ubiquitären Sprache verwendet werden.

Verantwortlichkeitsschichten (englisch responsibility layers)

ist die Aufteilung des Fachmodells in Schichten gemäß Verantwortlichkeiten. Domain-Driven Design schlägt folgende Schichten vor: Entscheidungsschicht, Regelschicht, Zusagen, Arbeitsabläufe, Potential.

Wissenslevel (englisch knowledge level)

beschreibt das explizite Wissen über das Fachmodell. Es ist in Situationen notwendig, wo die Abhängigkeiten und Rollen zwischen den Entitäten situationsbedingt variieren. Das Wissenslevel sollte diese Abhängigkeiten und Rollen von außen anpassbar enthalten, damit das Fachmodell weiterhin konkret und ohne unnötige Abhängigkeiten bleiben kann.

Erweiterungsframeworks (englisch pluggable component framework)

ist die Überlegung verschiedene Systeme über ein Komponentenframework miteinander zu verbinden.

Designtechniken

Intentionen beschreibende Schnittstellen (englisch intention-revealing interfaces)

bezeichnen Schnittstellen von Klassen und Komponenten, welche es den Entwicklern ermöglichen ebendiese zu verwenden, ohne deren Sourcecode studieren zu müssen. Damit wird sowohl bei Verwendung als auch bei der Wartung dieser Klassen und Komponenten sichergestellt, dass diese gemäß deren Intentionen erfolgt.

Nebeneffektfreie Funktionen (englisch side-effect-free functions)

sind Methoden, welche keinen Einfluss auf den Zustand eines Moduls haben. Diese sind einfacher zu testen und sollten somit bevorzugt werden. Sie sollten daher den Großteil der Applikationslogik enthalten. Den Zustand verändernde Methoden – sogenannte command Methoden – sollten von ihnen getrennt werden, möglichst einfach gehalten werden und keine Klassen des Fachmodells retournieren.

Assertions

dienen im Domain-Driven Design dazu, Nebeneffekte von aufgerufenen Methoden sichtbar zu machen, ohne deren Sourcecode studieren zu müssen. Diese, dem design by contract nahe Vorgangsweise führt dazu, dass Entwickler die Auswirkungen der verwendeten Methoden verstehen können, und somit erst Datenkapselung richtig eingesetzt werden kann.

Eigenständige Klassen (englisch standalone classes)

sind Klassen, welche keine expliziten oder impliziten Abhängigkeiten zu anderen Klassen haben. Sie sind einfacher zu verstehen und sollten somit durch Eliminierung aller unnötigen Abhängigkeiten angestrebt werden.

Konzeptionelle Konturen (englisch conceptual contours)

beschreibt die Konzepte, welche der Struktur eines Designs zugrunde liegen. Diese sollten durch sukzessive Refactorings an die stabilen Aspekte der Fachlichkeit angepasst werden. Damit steigt die Wahrscheinlichkeit, dass zukünftige Änderungen mit dem bestehenden Design leichter umgesetzt werden können.

Funktionsabschlüsse (englisch closure of operations)

sind beim Domain-Driven Design Methoden, deren Rückgabetyp derselbe ist, wie derjenige ihrer Argumente oder der in der Methode verwendeten Attribute. Diese Methoden erweitern zwar die Möglichkeiten einer Klasse, führen aber keine Abhängigkeiten auf andere Konzepte ein. Sie sind daher gegenüber Methoden, deren Rückgabe andere Typen einführen, vorzuziehen.

Antikorruptionsschicht (englisch anticorruption layer)

ist eine architekturelle Schicht, welche das Fachmodell von anderen Modellen trennt. Selbst ein Teil des Fachmodells, ermöglicht es die Antikorruptionsschicht dass auf das fremde Modell so zugegriffen werden kann, wie das eigene Fachmodell es benötigt. Dabei werden die eigenen Konzepte und Sprachelemente auf die des fremden Modells übersetzt, das eigene Fachmodell wird nicht durch das fremde Modell beeinflusst. Dies wird zumeist mit den Entwurfsmustern Fassade, Adapter und Transferobjekt implementiert.

Diese und weitere gängige Designtechniken der Objektorientierung führen zu einem deklarativen Stil (englisch declarative style) des Designs. Damit wird der Code nicht nur kürzer, leichter zu verstehen und einfacher zu testen, sondern ermöglichen es auch die Kernfachlichkeit herauszuarbeiten und somit eine Konzentration auf die relevanten fachlichen Funktionen einer Software.

Vorgehensweisen

Darüber hinaus definiert Domain-Driven Design eine Reihe von Vorgehensweisen, welche dazu dienen die Integrität der Modelle zu gewährleisten. Dies ist insbesondere dann notwendig, wenn mehrere Teams unter unterschiedlichem Management und Koordination an verschiedenen Fachlichkeiten, aber in einem großen Projekt zusammenarbeiten sollen.

Die Grafik zeigt die Abhängigkeiten zwischen diesen und anderen Elementen von Domain-Driven Design.

Vorgehensweisen

Vision der Fachlichkeit (englisch domain vision statement)

ist eine kurze Beschreibung der hinter der Kernfachlichkeit stehenden Vision und der damit verbundenen Ziele. Sie gibt die Entwicklungsrichtung des Fachmodells vor und dient als Bindeglied zwischen Projektvision/Systemmetapher und den Details der Kernfachlichkeit und des Codes.

Kontextübersicht (englisch context map)

dient einer gesamthaften Übersicht über alle Modelle, deren Grenzen und Schnittstellen. Dadurch wachsen die Kontexte nicht in Bereiche anderer Kontexte und die Kommunikation zwischen den Kontexten läuft über wohldefinierte Schnittstellen.

Kontextgrenzen (englisch bounded context)

beschreiben die Grenzen jedes Kontexts in vielfältiger Hinsicht wie beispielsweise Teamzuordnung, Verwendungszweck, dahinter liegende Datenbankschemata. Damit wird klar, wo ein Kontext seine Gültigkeit verliert und potentiell ein anderer Kontext seinen Platz einnimmt.

Kernfachlichkeit (englisch core domain)

ist der wertvollste Teil des Fachmodells, der Teil, welcher am meisten Anwendernutzen stiftet. Die anderen Teile des Fachmodells dienen vor allem dazu die Kernfachlichkeit zu unterstützen und mit weniger wichtigen Funktionen anzureichern. Bei der Modellierung sollte besonderes Augenmerk auf die Kernfachlichkeit gelegt werden und sie sollte durch die besten Entwickler umgesetzt werden.

Geteilter Kern (englisch shared kernel)

ist ein Teil der Fachlichkeit der zwischen unterschiedlichen Projektteilen geteilt wird. Dies ist sinnvoll, wenn die verschiedenen Projektteile nur lose miteinander verbunden sind und das Projekt zu groß ist um in einem Team umgesetzt zu werden. Der geteilte Kern wird hierbei von allen Projektteams, die ihn nützen, gemeinsam entwickelt. Dies benötigt sowohl viel Abstimmungs- als auch Integrationsaufwand.

Kunde-Lieferant (englisch customer-supplier)

ist die Metapher für die Beziehung zwischen Projektteams, bei denen ein Team eine Fachlichkeit umsetzt, auf die das andere Team aufbaut. Damit wird sichergestellt, dass das abhängige Team vom umsetzenden Team gut unterstützt wird, da ihre Anforderungen mit derselben Priorität umgesetzt werden, wie die eigentlichen Anforderungen an das Lieferantenteam.

Separierter Kern (englisch segregated core)

bezeichnet die Überlegung die Kernfachlichkeit, auch wenn sie eng mit unterstützenden Modellelementen gekoppelt ist, in ein eigenes Modul zu verlagern und die Kopplung mit anderen Modulen zu reduzieren. Damit wird die Kernfachlichkeit vor hoher Komplexität bewahrt und die Wartbarkeit erhöht.

Generische Sub-Fachlichkeiten (englisch generic subdomains)

bezeichnet die Idee, diejenigen Teile des Fachmodells, welche nicht zur Kernfachlichkeit gehören, in Form von möglichst generischen Modellen in eigenen Modulen abzulegen. Diese könnten, da sie nicht die Kernfachlichkeit repräsentieren und generisch sind, outgesourced entwickelt oder durch Standardsoftware ersetzt werden.

Kontinuierliche Integration (englisch continuous integration)

dient beim Domain-Driven Design dazu, alle Veränderungen eines Fachmodells laufend miteinander zu integrieren und gegen bestehende Fachlichkeit automatisiert testen zu können.

Vergleich mit anderen Vorgehensweisen und Techniken

Objektorientierte Analyse und Design

Obwohl sich DDD theoretisch nicht auf objektorientierte Konzepte beschränkt, wird DDD in der Praxis hauptsächlich für objektorientierte Analyse und Design eingesetzt. Viele der Konzepte von DDD basieren auf Paradigmen der objektorientierten Softwareentwicklung. DDD kann somit als Methodik für objektorientierte Analyse und Design angesehen werden.

Modellgetriebene Softwareentwicklung und Model Driven Architecture (MDA)

DDD ist zwar mit modellgetriebener Softwareentwicklung kompatibel, hat aber unterschiedliche Intentionen. modellgetriebene Softwareentwicklung befasst sich mehr mit den Techniken, wie Modelle in unterschiedlichen Softwareplattformen umgesetzt werden können, während DDD sich hauptsächlich damit befasst, wie bessere Fachmodelle erreicht werden können. Im Gegensatz zu modellgetriebener Softwareentwicklung setzt DDD stark auf ein kontinuierlich evolvierendes Modell, welches durch laufendes Refactoring verbessert wird.

Plain Old Java Objects (POJOs) und Plain Old CLR Objects (POCOs)

POJOs und POCOs sind technische Konzepte aus Java und .NET. Sie basieren allerdings auf der in DDD ebenfalls propagierten Ansicht, dass Fachobjekte ausschließlich Anforderungen der Fachlichkeiten des Fachmodells und nicht technologiespezifische Anforderungen implementieren sollen.

Naked Objects

Naked Objects ist ein Architekturmuster, welches wie DDD davon ausgeht, dass die gesamte Fachlogik in Fachobjekten abzubilden ist. Weiters propagiert das Naked Objects Architekturmuster, dass die Benutzerschnittstelle eine direkte Abbildung der Fachobjekte sei und somit vollständig aus den Fachobjekten generiert werden sollte – eine Forderung, die DDD nicht stellt.

Objektorientierte Persistenzmechanismen

Objektorientierte Persistenzmechanismen wie Objektrelationale Abbildung oder Objektdatenbanken beschäftigen sich mit dem Ersatz der Datenzugriffsschicht unter den Fachobjekten. Sie sind somit eine synergetische Ergänzung für Domain-Driven Design, da sich damit die Architektur noch stärker auf die Fachobjekte zentriert.

Data Context Interaction (DCI)

Data Context Interaction ist ein Architekturmuster welches die Bestandteile des Fachmodells des Domain-Driven Designs (Entitäten, Wertobjekte, Aggregate, Serviceobjekte und Fachliche Ereignisse) ergänzen kann, beziehungsweise durch diese ergänzt werden kann. So können die Datenobjekte von DCI durch die Entitäten, Wertobjekte und Aggregate von DDD verfeinert werden, Kontext Objekte wiederum lassen sich durch Serviceobjekte und Fachliche Ereignisse abbilden. Die Rollen der Interaktionen von DCI jedoch erweitern wiederum die Bestandteile des Domain-Driven Designs. Beide Technologien können also durchaus als kompatibel und einander ergänzend betrachtet werden.

Domänenspezifische Sprache (DSL)

Eine domänenspezifische Sprache (englisch domain-specific language, DSL) ist eine formale Sprache, die speziell für ein bestimmtes Problemfeld (die Problemdomäne) entworfen und implementiert wird. DDD ist selbst keine und benötigt auch keine DSL, um funktionieren zu können.

Aspektorientierte Programmierung (AOP)

AOP ist eine Technologie, die es im DDD ermöglicht, bestimmte, sonst üblicherweise tief verwobene technische Aspekte (wie Logging, Security, Transaktionsmanagement) vom Fachmodell zu trennen. Damit wird es einfach, dem von DDD gestellten Anspruch der vollständigen Trennung des Fachmodells vom Rest der Applikation gerecht zu werden.

Literatur

• Eric Evans: Domain-Driven Design. Tackling Complexity in the Heart of Software. Addison-Wesley, 2003, ISBN 978-0-321-12521-7 (domaindrivendesign.org). 
• Dan Haywood: Domain-Driven Design using Naked Objects. Pragmatic Programmers, 2009, ISBN 978-1-934356-44-9 (Domain-Driven Design using Naked Objects). 
• Floyd Marinescu, Abel Avram: Domain-Driven Design Quickly. Lulu Press, 2006, ISBN 978-1-4116-0925-9 (InfoQ: Domain Driven Design Quickly). 
• Jimmy Nilsson: Applying Domain-Driven Design and Patterns. With Examples in C# and .NET. 2006, ISBN 0-321-26820-2 (Artikel auf InfoQ). 
• Vaughn Vernon: Implementing Domain-Driven Design. Addison-Wesley, 2013, ISBN 978-0-321-83457-7. 
• Tim McCarthy: .NET Domain Driven Design with C#. Problem - Design - Solution. Wiley, 2008, ISBN 978-0-470-38402-2. 
• Daniel Liebhart, Guido Schmutz, Marcel Lattmann, Markus Heinisch, Michael Könings, Mischa Kölliker, Perry Pakull, Peter Welkenbach: Architektur Blueprints. Ein Leitfaden zur Konstruktion von Softwaresystemen mit Java Spring, .NET, ADF, Forms und SOA. Carl Hanser, 2007, ISBN 978-3-446-41201-9, 1.5, S. 30–47. 

Weblinks

• Putting the Model to Work und Strategic Design, 2-teiliger Vortrag von Eric Evans auf der JAOO vom 6. November 2007
• Domain Driven Design, Interview mit Jimmy Nilsson
• Eric Evans: What I’ve learned about DDD since the book, Vortrag von Eric Evans, ursprünglich präsentiert auf der QCon London 2009, aufgenommen bei DDD-NYC SIG.
• Domain-Driven Design Community
• Dan Haywood: An Introduction to Domain Driven Design. Methods & Tools, , abgerufen am 12. Juli 2010 (englisch).