Techblog

DDD, Event-Sourcing und CQRS - Teil 2

Von Golo Roden

19. Januar 2018

Teil 2: DDD, Event-Sourcing und CQRS im Beispiel

Golo Roden ist Gründer und CTO von the native web. Wir freuen uns riesig über seinen Gasteitrag in unserem Blog. Er twittert unter @goloroden


Wie im ersten Teil beschrieben sind fachliche Events das verbindende Element von Domain-Driven Design (DDD), Event-Sourcing und CQRS. Sie beschreiben Veränderungen, die in der Domäne stattgefunden haben. Wenn Sie eine Anwendung auf der Basis und mit dem Nutzen von Events entwickeln möchten, müssen Sie sich daher zunächst überlegen, welche Events in der jeweiligen Domäne enthalten sind. Sie beginnen die Arbeit also mit einer Modellierung.

Als Beispiel soll im Folgenden ein einfacher Instant-Messaging-Dienst im Stil von Slack entwickelt werden, der allerdings auf die wichtigsten Funktionen reduziert ist. Die wichtigste Einschränkung ist, dass die Anwendung nur einen einzigen Channel unterstützt, in dem Sie Nachrichten verfassen und bewerten können. Auch das Authentifizieren der Anwender bleibt Außen vor.

Von der Idee zum Modell

Der Kern der Anwendung ist der Versand von Nachrichten. Daher liegt es Nahe, ein sent-Event einzuführen, das immer dann ausgelöst wird, wenn eine Nachricht von einem Anwender versendet wurde. Außerdem ist es sinnvoll, ein liked-Event einzuführen. Das Event weist darauf hin, dass eine Nachricht positiv bewertet wurde. Auslösen können Sie die Events mit den beiden zugehörigen Commands send und like.

Die gemeinsame Logik befindet sich gemäß DDD in einem Aggregate. Da sich die Commands und Events auf eine einzelne Nachricht beziehen, liegt es nahe, das Aggregate message zu nennen. Bei alldem geht es um die Kommunikation innerhalb eines Teams, weshalb das Aggregate dem Kontext communication zugeordnet wird. Nur innerhalb der sprachlichen Grenze dieses Kontexts gilt die bislang entwickelteTerminologie, die in DDD als Ubiquitous Language bezeichnet wird.

Die gleiche Anwendung kann unter Umständen über weitere Kontexte verfügen, die sich mit anderen Aspekten beschäftigen, beispielsweise der Verwaltung der Anwender oder der Abrechnung. Auch hier könnten die Begriffe message, sent und liked auftreten – gegebenenfalls aber mit anderer Semantik. Alle Kontexte zusammen bilden die Domäne, die Sie in dem Fall beispielsweise chat nennen können.

Vom Modell zum Code

Um das Modell zu implementieren (in diesem Fall als in JavaScript geschriebene Node.js-Anwendung), legen Sie als erstes ein Verzeichnis für die Anwendung an. Da Sie primär das Backend entwickeln werden, empfiehlt es sich, darin direkt ein server-Verzeichnis anzulegen:

$ mkdir -p chat/server

Gemäß CQRS verfügt der Server über eine Schreib- und eine Leseseite. Auch hierfür legen Sie wiederum Verzeichnisse an. Außerdem müssen Sie ein Verzeichnis flows anlegen, in dem Sie langlaufende Workflows ablegen können. Solche Workflows werden in dem vorliegenden Beispiel zwar nicht benötigt, das Verzeichnis muss aber trotzdem zumindest in leerer Form existieren:

$ mkdir -p chat/server/writeModel
$ mkdir -p chat/server/readModel
$ mkdir -p chat/server/flows

Die Schreibseite enthält die zuvor modellierte Domäne. Erzeugen Sie daher ein Verzeichnis mit dem Namen des Kontexts, also communication:

$ mkdir -p chat/server/writeModel/communication

Dem Verzeichnis fügen Sie nun die Datei message.js für das Aggregate hinzu. Initialisieren Sie die Datei mit der folgenden Struktur:

  1. 'use strict';
  2. const initialState = {};
  3. const commands = {};
  4. const events = {};
  5. module.exports = { initialState, commands, events };

Der initialState enthält den initialen Zustand des Aggregates. Da eine Nachricht zunächst keinen Text enthält und noch nicht bewertet wurde, setzen Sie folgende Werte:

  1. const initialState = {
  2.   text: undefined,
  3.   likes: 0
  4. };

Nun folgen die beiden Events sent und liked. Sie werden durch zwei Funktionen repräsentiert, die aufgerufen werden, wenn das jeweilige Event ausgelöst wurde. Da Events eine Veränderung darstellen, müssen Sie den Zustand des Aggregates ändern. Dazu dient die Funktion setState, die Sie am message-Aggregate aufrufen:

  1. const events = {
  2.   sent (message, event) {
  3.     message.setState({ text: event.data.text });
  4.   },
  5.   liked (message, event) {
  6.     message.setState({ likes: event.data.likes });
  7.   }
  8. };

Um die Events auszulösen, benötigen Sie die beiden Commands send und like. Die Commands müssen ihre Parameter prüfen und entscheiden, welche Events sie am Aggregate auslösen. Dazu dient die events.publish-Funktion, die Sie wiederum am message-Aggregate aufrufen. Markieren Sie das Command darüberhinaus als erfolgreich ausgeführt oder als fehlgeschlagen, indem Sie die Funktion mark.asDone oder mark.asRejected aufrufen:

  1. const commands = {
  2.   send (message, command, mark) {
  3.     if (!command.data.text) {
  4.       return mark.asRejected('Text is missing.');
  5.     }
  6.     message.events.publish('sent', { text: command.data.text });
  7.     mark.asDone();
  8.   },
  9.   like (message, command, mark) {
  10.     message.events.publish('liked', { likes: message.state.likes + 1 });
  11.     mark.asDone();
  12.   }
  13. };

Da eingangs festgelegt wurde, auf Authentifizierung zu verzichten, müssen Sie die Commands und Events schließlich noch für jedermann zugänglich machen. Dazu erweitern Sie den initialState wie folgt:

  1. const initialState = {
  2.   text: undefined,
  3.   likes: 0,
  4.   isAuthorized: {
  5.     commands: {
  6.       send: { forPublic: true },
  7.       like: { forPublic: true }
  8.     },
  9.     events: {
  10.       sent: { forPublic: true },
  11.       liked: { forPublic: true }
  12.     }
  13.   }
  14. };

Damit ist das fachliche Modell implementiert. Selbstverständlich fehlen für eine ausführbare Anwendung noch zahlreiche Aspekte wie eine HTTPS- oder Websocket-API oder eine Datenbankanbindung. All diese Aspekte sind aber technischer, nicht fachlicher Natur.

Die Leseseite implementieren

Da die UI eine Liste aller Nachrichten anzeigen soll, muss die Leseseite der Anwendung die entsprechenden Daten bereithalten. Dazu ist eine Interpretation der fachlichen Events erforderlich. Die Interpretation muss der Liste bei einem sent-Event einen neuen Eintrag hinzufügen, bei einem liked-Event hingegen einen bereits bestehenden Eintrag aktualisieren.

Zu dem Zweck legen Sie zunächst ein Verzeichnis lists innerhalb der Leseseite an:

$ mkdir -p chat/server/readModel/lists

Anschließend fügen Sie dem Verzeichnis die Datei messages.js hinzu, und initialisieren sie mit folgendem Code:

  1. 'use strict';
  2. const fields = {};
  3. const when = {};
  4. module.exports = { fields, when };

Als Felder muss die Liste nicht nur den Text der einzelnen Nachrichten und die Anzahl der jeweiligen Bewertungen enthalten, sondern auch den Zeitpunkt, wann eine Nachricht gesendet wurde. Da der Zeitpunkt als Sortierkriterium dient, empfiehlt es sich, ihn zu indexieren:

  1. const fields = {
  2.   timestamp: { initialState: 0, fastLookup: true },
  3.   text: { initialState: '' },
  4.   likes: { initialState: 0 }
  5. };

Nun müssen Sie noch die Liste aktualisieren, wenn ein relevantes Event ausgelöst wird: 

  1. const when = {
  2.   'communication.message.sent' (messages, event, mark) {
  3.     messages.add({
  4.       text: event.data.text,
  5.       timestamp: event.metadata.timestamp
  6.     });
  7.     mark.asDone();
  8.   },
  9.   'communication.message.liked' (messages, event, mark) {
  10.     messages.update({
  11.       where: { id: event.aggregate.id },
  12.       set: {
  13.         likes: event.data.likes
  14.       }
  15.     });
  16.     mark.asDone();
  17.   }
  18. };

Damit ist aus fachlicher Sicht alles implementiert, was für die Leseseite erforderlich ist.

Die Anwendung starten

Tatsächlich müssen Sie sich um den weiteren technischen Unterbau nicht kümmern, denn die Arbeit kann Ihnen problemlos ein Framework abnehmen, beispielsweise wolkenkit. Die Modellierung mit DDD müssen Sie also selbst vornehmen, aber für die Implementierung auf Basis von Event-Sourcing und CQRS können Sie auf einen generischen Ansatz zurückgreifen.

Um die Anwendung zu starten, müssen Sie folglich zunächst wolkenkit installieren, ein CQRS- und Event-Sourcing-Framework für JavaScript und Node.js, das speziell als technischer Unterbau für DDD entwickelt wurde. Das Framework wird als Open-Source entwickelt, daher finden Sie den Quellcode auf GitHub. Die eigentliche Installation erfolgt mit Hilfe von npm:

$ npm install -g wolkenkit

Außerdem müssen Sie lokal Docker installieren. Hinweise zur Installation finden Sie in der Dokumentation von wolkenkit für macOS, Linux und Windows. Zu guter letzt müssen Sie Ihrer Anwendung im Verzeichnis chat noch eine Datei namens package.json hinzufügen, in der Sie einen wolkenkit-spezifischen Abschnitt hinterlegen:

  1. {
  2.   "name": "chat",
  3.   "version": "1.0.0",
  4.   "wolkenkit": {
  5.     "application": "chat",
  6.     "runtime": {
  7.       "version": "1.2.0"
  8.     },
  9.     "environments": {
  10.       "default": {
  11.         "api": {
  12.           "address": {
  13.             "host": "local.wolkenkit.io",
  14.             "port": 3000
  15.           },
  16.           "allowAccessFrom": "*"
  17.         },
  18.         "node": {
  19.           "environment": "development"
  20.         }
  21.       }
  22.     }
  23.   }
  24. }

Sobald alle Voraussetzungen erfüllt sind, können Sie die Anwendung starten. Beim ersten Start muss wolkenkit verschiedene Docker-Images herunterladen, weshalb der Vorgang ein paar Minuten dauern kann. Anschließend braucht der Start im Verzeichnis chat aber jeweils nur wenige Sekunden:

$ wolkenkit start

Als Ergebnis haben Sie nun ein lauffähiges Backend, das Sie über HTTPS und Websockets ansprechen können und das sich um die Persistenz der Daten gemäß Event-Sourcing kümmert.

Den Client anbinden

Für den Client müssen Sie zunächst das npm-Modul wolkenkit-client installieren. Anschließend können Sie das Modul in Ihre Webanwendung integrieren und eine Verbindung zum Server herstellen:

  1. const wolkenkit = require('wolkenkit-client');
  2. const chat = await wolkenkit.connect({
  3.   host: 'local.wolkenkit.io',
  4.   port: 3000
  5. });

Danach verwenden Sie das chat-Objekt, um auf das Backend zuzugreifen und beispielsweise Nachrichten zu versenden:

  1. chat.communication.message().send({
  2.   text: 'Hallo Welt!'
  3. });

Außerdem können Sie auch die Liste der gesendeten Nachrichten abrufen und anzeigen, wobei Sie sogar anfordern können, dass die Liste im Client live aktualisiert wird, sobald neue Nachrichten gesendet oder bewertet wurden:

  1. chat.lists.messages.readAndObserve({
  2.   orderBy: { timestamp: 'descending' },
  3.   take: 50
  4. }).
  5.   started((messages, cancel) => {
  6.     // ...
  7.   }).
  8.   updated((messages, cancel) => {
  9.     // ...
  10.   });

Wenn Sie nun gerne ein vollständig lauffähiges Beispiel einschließlich einer grafischen Oberfläche haben möchten, können Sie sich die Arbeit einfach machen. Beenden Sie dazu bitte zunächst die laufende Anwendung:

$ wolkenkit stop

Weisen Sie nun das Kommandozeilenwerkzeug wolkenkit in einem leeren Verzeichnis an, eine neue Anwendung zu initialisieren:

$ wolkenkit init

Standardmäßig verwendet wolkenkit für neue Anwendungen eine Vorlage, die eben jenen Chat enthält, den Sie in diesem Blogeintrag von Hand entwickelt haben. Die Details, wie Sie den Chat ausführen, finden Sie im zugehörigen GitHub-Repository:

Abschließend bleibt zu sagen, dass die Entwicklung auf Basis von DDD, Event-Sourcing und CQRS zwar zunächst ungewohnt ist, nach einer kurzen Eingewöhnungszeit aber weitaus effizienter sein kann als das klassische Vorgehen. Insbesondere die Tatsache, dass man auf Grund von DDD gezwungen ist, vor der Implementierung zunächst in einem interdisziplinären Team zu modellieren, trägt viel zum Erreichen einer guten Softwarequalität bei.

Frameworks wie wolkenkit können Sie dabei in hohem Maß unterstützen, indem sie Ihnen ermöglichen, sich auf das Wesentliche zu konzentrieren, nämlich das Lösen der tatsächlich relevanten fachlichen Probleme. Und genau das ist letzten Endes der Grund, warum Sie Software entwickeln: Um das Leben von anderen Menschen einfacher, komfortabler oder sicherer zu gestalten.

Neuen Kommentar schreiben

Public Comment form

  • Zulässige HTML-Tags: <a> <em> <strong> <cite> <blockquote> <code> <ul> <ol> <li> <dl> <dt> <dd><p><h1><h2><h3>

Plain text

  • Keine HTML-Tags erlaubt.
  • Internet- und E-Mail-Adressen werden automatisch umgewandelt.
  • HTML - Zeilenumbrüche und Absätze werden automatisch erzeugt.

ME Landing Page Question

Erhalten Sie regelmäßig Praxis-Tipps per E-Mail

Praxis-Tipps per E-Mail erhalten