Laravel-Entwicklung: Wie erstellt man ereignisgesteuerte Anwendungen mit Laravel Event Sourcing?

Laravel-Entwicklung: Wie erstellt man ereignisgesteuerte Anwendungen mit Laravel Event Sourcing?

Eine ereignisgesteuerte Anwendung ist eine Anwendung, die mithilfe von Ereignissen und Ereignishandlern (Ereignishandler) implementiert wird. Eine ereignisgesteuerte Architektur erleichtert die Erweiterung und Wartung von Anwendungen, ist flexibler und lässt sich leichter an Änderungen anpassen.

Laravel ist ein beliebtes PHP-Framework, das eine Funktion namens Event Sourcing bietet, die uns beim Erstellen ereignisgesteuerter Anwendungen helfen kann. In diesem Artikel wird erläutert, wie Sie mit Laravel Event Sourcing eine einfache ereignisgesteuerte Anwendung erstellen.

1. Was ist Laravel Event Sourcing?

Laravel Event Sourcing ist ein ereignisgesteuertes Modellierungsframework, eine von Laravel bereitgestellte Suite, die uns beim Erstellen ereignisgesteuerter Anwendungen unterstützt. Es speichert Ereignisse und stellt sie wieder her, sodass wir den Status in der Anwendung reproduzieren und zu früheren Zuständen zurückkehren können.

2. Warum Laravel Event Sourcing nutzen?

Der Vorteil der Verwendung von Laravel Event Sourcing besteht darin, dass es die Skalierbarkeit und Wartbarkeit der Anwendung verbessern kann. Wenn wir ereignisgesteuerte Anwendungen verwenden, ist es einfacher, verschiedene Teile der Anwendung zu verstehen und zu ändern, und die Anwendung ist robuster.

Mit Laravel Event Sourcing können wir problemlos mehrere Modi implementieren, darunter den CQRS-Modus (Command Query Responsibility Segregation) und den ES-Modus (Event Sourcing).

3. Wie erstellt man eine ereignisgesteuerte Anwendung mit Laravel Event Sourcing?

In diesem Beispiel erstellen wir eine einfache Aufgabenverwaltungsanwendung, mit der Benutzer Aufgaben erstellen und erledigen können.

Schritt 1: Erstellen Sie eine Aufgabe

Wir können demonstrieren, wie Sie Laravel Event Sourcing verwenden, indem Sie eine Aufgabe erstellen. Zuerst müssen wir ein „TaskCreated“-Ereignis erstellen, um das Verhalten beim Erstellen einer Aufgabe zu verwalten.

php artisan make:event TaskCreated

Schritt 2: Erstellen Sie einen Event-Handler für die Aufgabe

Sobald wir ein Event erstellt haben, müssen wir einen Event-Handler erstellen, um das Event zu verarbeiten. Jetzt müssen wir einen Event-Handler erstellen, um das „TaskCreated“-Event zu verarbeiten.

php artisan make:listener CreateTaskListener --event=TaskCreated

Schritt 3: Event und Event-Handler zusammenbinden

Jetzt müssen wir das Event und den Event-Handler zusammenbinden. Wir können dies in der EventServiceProvider-Datei von Laravel erreichen.

protected $listen = [
    TaskCreated::class => [
        CreateTaskListener::class,
    ],
];

Schritt 4: Verwenden Sie den Event-Handler, um das Ereignis der Aufgabenerstellung zu verarbeiten

Jetzt können wir unseren Event-Handler verwenden, um das Ereignis der Aufgabenerstellung zu verarbeiten. Der erste Event-Handler, den wir implementieren werden, ist CreateTaskListener, der tatsächlich die neue Aufgabe erstellt.

public function handle(TaskCreated $event)
{
    $task = new Task;
    $task->name = $event->name;
    $task->save();
}

Schritt 5: Verwenden Sie Laravel Event Sourcing, um Ereignisse zu speichern

Mit Laravel Event Sourcing können wir Ereignisse speichern und wiederherstellen. Wir müssen die Event Sourcing-Bibliothek in Laravel verwenden, beispielsweise die Broadway-Bibliothek.

Wir können die Datei „composer.json“ von Laravel verwenden, um die Broadway-Bibliothek hinzuzufügen:

"require": {
    "broadway/broadway": "^1.0",
    "broadway/serializer": "^1.0",
    "broadway/event-store": "^1.0"
}

Führen Sie dann den folgenden Befehl aus, um die Broadway-Bibliothek zu installieren:

composer install

Schritt 6: Verwenden Sie Laravel Event Sourcing

Jetzt können wir Laravel Event Sourcing verwenden, um Store-Events.

Wir müssen einen Event-Store erstellen, um Events zu speichern und abzurufen. Wir können es implementieren, indem wir eine Klasse namens TaskEventStore.php im App-Ordner von Laravel erstellen:

use BroadwayEventStoreEventStore;
use BroadwayEventSourcingEventSourcingRepository;

class TaskEventStore extends EventSourcingRepository
{
    public function __construct(EventStore $eventStore)
    {
        parent::__construct(
            $eventStore,
            new TaskAggregateRootEventSourcedFactory(),
            new TaskAggregateRootEventSourcedRepository()
        );
    }
}

Wir müssen ein neues Ereignis-Repository im Konstruktor der TaskEventStore-Klasse erstellen und das EventSourcingRepository aus der Broadway-Bibliothek Store Events verwenden. Wir müssen außerdem eine Aggregate-Root-Factory und ein Aggregate-Root-Repository definieren, um unsere Aggregate-Roots zu verwalten.

Jetzt können wir die TaskEventStore-Klasse zum Speichern von Ereignissen verwenden. Wir können den folgenden Code im CreateTaskListener-Ereignishandler hinzufügen:

$eventStore = $this->app->make(TaskEventStore::class);
$eventStream = new DomainEventStream([$event]);

$aggregateRoot = $eventStore->load($command->taskId);
$aggregateRoot->handle($event);

$eventStore->save(
    $aggregateRoot->getUncommittedEvents(),
    $aggregateRoot->getId()
);

Dieses Codefragment ruft eine Instanz der TaskEventStore-Klasse ab, erstellt einen Ereignisstrom, lädt den Aggregatstamm, ruft die Handle-Methode auf und speichert die nicht festgeschriebenen Ereignisse.

Wir müssen auch die TaskEventStore-Klasse in der ServiceProvider-Klasse von Laravel binden:

$this->app->singleton(TaskEventStore::class, function ($app) {
    $eventStore = new InMemoryEventStore;
    return new TaskEventStore($eventStore);
});

Schritt 7: Aufgaben finden und anzeigen

Da wir nun eine neue Aufgabe erstellt haben, können wir dem Benutzer alle Aufgaben anzeigen, indem wir unsere Abfrage „Aufgabe“ ändern .

Erstellen Sie einen Befehl namens ShowTasks:

php artisan make:command ShowTasks

Der erste Befehlsprozessor, den wir implementieren werden, ist ShowTasks, der alle Aufgaben zur Listenanzeige zurückgibt.

public function handle()
{
    $tasks = Task::all();
    foreach ($tasks as $task) {
        $this->info("Name: {$task->name}");
    }
}

Schritt 8: Aufgabe als erledigt markieren

Jetzt wollen wir das Verhalten beim Markieren der Aufgabe als erledigt simulieren. Wir können ein „TaskCompleted“-Ereignis verwenden, um dieses Verhalten zu verfolgen.

Zuerst müssen wir ein „TaskCompleted“-Ereignis erstellen:

php artisan make:event TaskCompleted

Dann erstellen wir einen Ereignishandler namens CompleteTaskHandler, um dieses Ereignis zu verarbeiten.

php artisan make:listener CompleteTaskHandler --event=TaskCompleted

Als nächstes binden wir das „TaskCompleted“-Ereignis und den CompleteTaskHandler-Ereignishandler:

protected $listen = [
    TaskCreated::class => [
        CreateTaskListener::class,
    ],
    TaskCompleted::class => [
        CompleteTaskHandler::class,
    ],
];

Der zweite Ereignishandler, den wir schließlich implementieren möchten, ist der CompleteTaskHandler, der den Aufgabenstatus auf „Abgeschlossen“ setzt.

public function handle(TaskCompleted $event)
{
    $task = Task::where('name', $event->name)->firstOrFail();
    $task->completed = true;
    $task->save();
}

Zu diesem Zeitpunkt haben wir erfolgreich eine ereignisgesteuerte Anwendung erstellt, mit der Benutzer Aufgabenlisten erstellen, vervollständigen und anzeigen können.

Fazit

Der Einsatz von Laravel Event Sourcing kann uns beim Erstellen ereignisgesteuerter Anwendungen helfen. Ereignisgesteuerte Anwendungen sind skalierbarer, wartbarer und flexibler. Mit Laravel Event Sourcing können wir problemlos mehrere Muster implementieren, einschließlich CQRS- und ES-Muster. Daher empfehlen wir Entwicklern, beim Erstellen von Anwendungen eine ereignisgesteuerte Architektur zu verwenden.

Das obige ist der detaillierte Inhalt vonLaravel-Entwicklung: Wie erstellt man ereignisgesteuerte Anwendungen mit Laravel Event Sourcing?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!