Event Sourcing: Hör auf, Geschichte zu verlieren, und nutz sie

Event Sourcing: was es ist (und nein, es ist nicht nur Logging)

Bei Event Sourcing sind Ereignisse die Quelle der Wahrheit. Du speicherst nicht den „Endzustand“ eines Objekts, du speicherst alles, was ihm passiert. Danach baust du den Zustand durch Replay der Ereignisse wieder auf. Ja, wie ein Replay. Und nein, es sind nicht „nur Logs“: Ein Log erzählt, ein Event gilt.

Beispiel: Statt balance = 120 zu speichern, protokollierst du MoneyDeposited(200) und danach MoneyWithdrawn(80). Der Kontostand ist ein Ergebnis, kein magischer Wert aus dem Nichts.

Warum solltest du dir das antun?

Weil dein Zukunfts-Ich dankbar ist, wenn:

• du auditieren musst, wer was, wann und warum gemacht hat,
• du debuggen willst, indem du die Realität nachspielst,
• du ein Modell nach Business-Änderungen rekonstruieren musst,
• du Projektionen (Read Models) willst, ohne die Datenbank zu schreddern.

Kurz: Du zahlst jetzt etwas Komplexität, damit du später keine Post-Mortems improvisierst.

Die Bausteine (ohne Rauch)

• Event: eine unveränderliche Tatsache in der Vergangenheit. OrderPlaced, nicht PlaceOrder.
• Stream: die Ereignisfolge eines Aggregats.
• Aggregat: das Domain-Objekt, das Events anwendet, um den Zustand aufzubauen.
• Projektion: eine abgeleitete Sicht (SQL, Elastic, Cache, etc.) für schnelle Reads.

Wann einsetzen (und wann lieber nicht)

Nutze es, wenn:

• dein Domänenmodell sich häufig ändert,
• Historie kritisch ist,
• du knallharte Nachvollziehbarkeit brauchst.

Lass es, wenn:

• dein CRUD banal ist,
• du keine Audits brauchst,
• dein Team gerade erst Repositories entdeckt.

Kleines Symfony-Einstiegsbeispiel

Wir halten es simpel: ein Cart-Aggregat, Events und ein In-Memory-Event-Store. Kein volles CQRS, kein Kafka, keine Zauberei. Nur der Kern.

1) Event definieren

php
1<?php
2
3namespace App\Cart\Domain\Event;
4
5final class ItemAdded
6{
7    public function __construct(
8        public readonly string $cartId,
9        public readonly string $sku,
10        public readonly int $quantity,
11    ) {
12    }
13}

2) Aggregat, das Events abspielt

php
1<?php
2
3namespace App\Cart\Domain;
4
5use App\Cart\Domain\Event\ItemAdded;
6
7final class Cart
8{
9    private array $items = [];
10    private array $recordedEvents = [];
11
12    public static function reconstitute(array $events): self
13    {
14        $cart = new self();
15        foreach ($events as $event) {
16            $cart->apply($event);
17        }
18        return $cart;
19    }
20
21    public function addItem(string $cartId, string $sku, int $quantity): void
22    {
23        $event = new ItemAdded($cartId, $sku, $quantity);
24        $this->record($event);
25    }
26
27    public function recordedEvents(): array
28    {
29        return $this->recordedEvents;
30    }
31
32    private function record(object $event): void
33    {
34        $this->apply($event);
35        $this->recordedEvents[] = $event;
36    }
37
38    private function apply(object $event): void
39    {
40        if ($event instanceof ItemAdded) {
41            $this->items[$event->sku] = ($this->items[$event->sku] ?? 0) + $event->quantity;
42        }
43    }
44}

3) Minimaler In-Memory-Event-Store

php
1<?php
2
3namespace App\Cart\Infrastructure;
4
5final class InMemoryEventStore
6{
7    private array $streams = [];
8
9    public function append(string $streamId, array $events): void
10    {
11        $this->streams[$streamId] ??= [];
12        $this->streams[$streamId] = array_merge($this->streams[$streamId], $events);
13    }
14
15    public function load(string $streamId): array
16    {
17        return $this->streams[$streamId] ?? [];
18    }
19}

4) Nutzung in einem Symfony-Service

php
1<?php
2
3namespace App\Cart\Application;
4
5use App\Cart\Domain\Cart;
6use App\Cart\Infrastructure\InMemoryEventStore;
7
8final class AddItemToCart
9{
10    public function __construct(private InMemoryEventStore $eventStore)
11    {
12    }
13
14    public function __invoke(string $cartId, string $sku, int $quantity): void
15    {
16        $events = $this->eventStore->load($cartId);
17        $cart = Cart::reconstitute($events);
18
19        $cart->addItem($cartId, $sku, $quantity);
20
21        $this->eventStore->append($cartId, $cart->recordedEvents());
22    }
23}

Fertig. Kein ORM, kein Cache, kein Umzug. Nur die zentrale Idee: Events sind die Wahrheit, der Zustand ist eine berechnete Sicht. Später kannst du Projektionen und Symfony-Messenger-Listener anhängen, wenn du mit den Großen spielen willst.

Merke (falls du's erklären musst)

• Event Sourcing speichert Historie, nicht nur Resultate.
• Du rekonstruierst den Zustand durch Replay der Events.
• Perfekt für Audit und sich ändernde Domänen, unnötig für langweiliges CRUD.
• Symfony macht's nicht für dich, lässt dich aber sauber strukturieren.

Wenn dir das schwer vorkommt: gut so. Du tauschst kurzfristigen Komfort gegen langfristige Klarheit. Du zahlst jetzt oder Zukunfts-Ich später. Deine Wahl.