Introduction

Bienvenue dans ce tutoriel sur l'implémentation de l'Event Sourcing en PHP ! Dans cet article, nous allons explorer les concepts fondamentaux de l'Event Sourcing, son architecture avancée et ses cas d'utilisation appropriés. Nous allons également apprendre à concevoir et implémenter un système Event Sourcing en PHP, en utilisant des bibliothèques telles que Prooph, Broadway ou EventSauce. Enfin, nous aborderons les techniques avancées telles que l'optimisation avec des snapshots, la gestion des migrations de schémas d'événements et la projection en temps réel.

Table des matières

• Concepts fondamentaux de l'Event Sourcing
• Implémentation de l'Event Sourcing en PHP
• Intégration avec des bibliothèques PHP
• Techniques avancées de l'Event Sourcing
• Combinaison avec d'autres patterns
• Projet guidé : implémentation d'un système de gestion basé sur l'Event Sourcing

Concepts fondamentaux de l'Event Sourcing

Dans cette section, nous allons explorer les concepts fondamentaux de l'Event Sourcing.

Événements comme source de vérité

L'Event Sourcing est une approche qui consiste à utiliser des événements comme source de vérité dans un système. Au lieu de stocker uniquement l'état courant d'un objet, nous enregistrons tous les événements qui ont modifié cet objet au fil du temps. Cela permet de reconstruire l'état courant à tout moment en rejouant les événements.

Séquence immuable

Les événements sont stockés dans une séquence immuable, ce qui signifie qu'une fois qu'un événement est enregistré, il ne peut plus être modifié ou supprimé. Cela garantit l'auditabilité du système et permet de revenir à n'importe quel état précédent.

Reconstruction d'états

En utilisant la séquence d'événements, nous pouvons reconstruire l'état courant d'un objet en appliquant tous les événements dans l'ordre. Cela nous permet de voir comment l'objet a évolué au fil du temps et de récupérer n'importe quel état précédent.

Projections

Les projections sont des vues dérivées de la séquence d'événements. Elles sont utilisées pour répondre aux requêtes de lecture du système. Les projections peuvent être construites en temps réel ou en différé, selon les besoins.

Implémentation de l'Event Sourcing en PHP

Modélisation des événements

La première étape de l'implémentation de l'Event Sourcing en PHP consiste à modéliser les événements. Les événements sont des objets immuables qui représentent les changements survenus dans le système. Chaque événement doit avoir un nom et des propriétés qui décrivent l'état modifié.

 final class OrderCreated {     private OrderId $orderId;     private string $customerName;      public function __construct(OrderId $orderId, string $customerName)     {         $this->orderId = $orderId;         $this->customerName = $customerName;     }      public function getOrderId(): OrderId     {         return $this->orderId;     }      public function getCustomerName(): string     {         return $this->customerName;     } } 

Agrégats de domaine

Les agrégats de domaine sont des objets qui encapsulent la logique métier et maintiennent la cohérence des événements. Ils sont responsables de la validation des événements et de la génération de nouveaux événements en réponse à des commandes ou des événements.

 final class Order {     private OrderId $orderId;     private string $customerName;     private array $events = [];      public function __construct(OrderId $orderId, string $customerName)     {         $this->orderId = $orderId;         $this->customerName = $customerName;          $this->events[] = new OrderCreated($orderId, $customerName);     }      public function changeCustomerName(string $newCustomerName): void     {         $this->customerName = $newCustomerName;          $this->events[] = new CustomerNameChanged($this->orderId, $newCustomerName);     }      // ... } 

Event Store

L'Event Store est une base de données spéciale qui stocke les événements dans une séquence immuable. Il permet d'ajouter de nouveaux événements à la séquence et de les récupérer dans l'ordre. Il peut être implémenté à l'aide d'une base de données relationnelle, d'une base de données NoSQL ou d'une solution personnalisée.

 class EventStore {     public function append(Event $event): void     {         // Ajouter l'événement à la séquence     }      public function getEventsForAggregate(AggregateId $aggregateId): array     {         // Récupérer tous les événements pour un agrégat donné     }      // ... } 

Gestionnaires d'événements

Les gestionnaires d'événements sont responsables de la construction des agrégats de domaine à partir de la séquence d'événements. Ils sont également utilisés pour construire des projections en temps réel ou en différé.

 class OrderProjection {     public function __invoke(Event $event): void     {         // Construire la projection à partir de l'événement     }      // ... } 

Intégration avec des bibliothèques PHP

Prooph

Prooph est une bibliothèque PHP qui facilite l'implémentation de l'Event Sourcing. Elle fournit des classes de base pour les événements, les agrégats de domaine, l'Event Store et les gestionnaires d'événements. Elle offre également des fonctionnalités avancées telles que la gestion des snapshots et la projection en temps réel.

Broadway

Broadway est une autre bibliothèque PHP populaire pour l'Event Sourcing. Elle propose une approche basée sur les acteurs, où chaque agrégat de domaine est représenté par un acteur. Elle fournit également des fonctionnalités telles que la gestion des événements concurrents et la projection en temps réel.

EventSauce

EventSauce est une bibliothèque PHP légère pour l'Event Sourcing. Elle se concentre sur la simplicité et la flexibilité. Elle fournit les fonctionnalités de base telles que les événements, les agrégats de domaine et l'Event Store, mais ne propose pas de fonctionnalités avancées telles que la projection en temps réel.

Techniques avancées de l'Event Sourcing

Snapshots

Les snapshots sont une technique d'optimisation qui consiste à stocker l'état courant d'un agrégat de domaine à un moment donné. Cela permet de réduire le nombre d'événements à rejouer lors de la reconstruction de l'état courant.

Gestion des migrations de schémas d'événements

Comme les événements sont stockés dans une séquence immuable, il peut être nécessaire de mettre à jour le schéma des événements au fil du temps. La gestion des migrations de schémas d'événements est une technique qui permet de mettre à jour l'Event Store tout en préservant l'intégrité des données.

Projection en temps réel

La projection en temps réel est une technique qui consiste à construire des projections à la volée à partir de la séquence d'événements. Cela permet d'obtenir des réponses rapides aux requêtes de lecture, mais cela peut également nécessiter des ressources supplémentaires.

Combinaison avec d'autres patterns

CQRS

L'Event Sourcing est souvent utilisé en combinaison avec le modèle CQRS (Command Query Responsibility Segregation). Le CQRS sépare les opérations de lecture et d'écriture en utilisant des modèles différents. L'Event Sourcing peut être utilisé pour gérer la partie écriture du système, tandis que d'autres modèles peuvent être utilisés pour gérer la partie lecture.

DDD

L'Event Sourcing est également souvent utilisé en combinaison avec la conception pilotée par le domaine (DDD). DDD est une approche qui consiste à modéliser le domaine métier de manière précise et à l'exprimer dans le code. L'Event Sourcing peut être utilisé pour capturer et représenter les événements du domaine.

Microservices

L'Event Sourcing peut être utilisé dans un environnement de microservices pour garantir la cohérence des données entre les services. Chaque service peut avoir son propre Event Store et utiliser l'Event Sourcing pour gérer les événements liés à son domaine.

Projet guidé : implémentation d'un système de gestion basé sur l'Event Sourcing

Pour mettre en pratique ce que nous avons appris jusqu'à présent, nous allons implémenter un système de gestion basé sur l'Event Sourcing. Dans ce projet guidé, nous allons construire progressivement un système complet en utilisant l'Event Sourcing pour la gestion des événements. Nous allons également montrer comment reconstruire les états et créer plusieurs projections à partir du même flux d'événements.

Étape 1 : Modélisation des événements

La première étape consiste à modéliser les événements que nous allons utiliser dans notre système. Dans cet exemple, nous allons créer un système de gestion des tâches.

 final class TaskCreated {     private TaskId $taskId;     private string $title;      public function __construct(TaskId $taskId, string $title)     {         $this->taskId = $taskId;         $this->title = $title;     }      // ... } 

Étape 2 : Agrégats de domaine

Ensuite, nous allons créer les agrégats de domaine qui vont encapsuler la logique métier liée aux tâches.

 final class Task {     private TaskId $taskId;     private string $title;     private bool $completed = false;     private array $events = [];      public function __construct(TaskId $taskId, string $title)     {         $this->taskId = $taskId;         $this->title = $title;          $this->events[] = new TaskCreated($taskId, $title);     }      public function complete(): void     {         $this->completed = true;          $this->events[] = new TaskCompleted($this->taskId);     }      // ... } 

Étape 3 : Event Store

Nous allons maintenant créer un Event Store pour stocker les événements de notre système.

 class EventStore {     public function append(Event $event): void     {         // Ajouter l'événement à la séquence     }      public function getEventsForAggregate(AggregateId $aggregateId): array     {         // Récupérer tous les événements pour un agrégat donné     }      // ... } 

Étape 4 : Gestionnaires d'événements

Enfin, nous allons créer des gestionnaires d'événements pour construire nos projections en temps réel ou en différé.

 class TaskProjection {     public function __invoke(Event $event): void     {         // Construire la projection à partir de l'événement     }      // ... } 

Félicitations ! Vous avez maintenant terminé le projet guidé d'implémentation d'un système de gestion basé sur l'Event Sourcing. Vous avez appris les concepts fondamentaux de l'Event Sourcing, l'implémentation en PHP, l'intégration avec des bibliothèques populaires et les techniques avancées. Vous pouvez maintenant appliquer ces connaissances à vos propres projets et tirer parti des avantages de l'Event Sourcing pour une meilleure auditabilité et une plus grande flexibilité.

Conclusion

Dans cet article, nous avons exploré l'Event Sourcing en PHP. Nous avons découvert les concepts fondamentaux, appris à modéliser les événements, les agrégats de domaine et l'Event Store, et nous avons vu comment construire des gestionnaires d'événements et des projections. Nous avons également abordé l'intégration avec des bibliothèques populaires telles que Prooph, Broadway et EventSauce, ainsi que les techniques avancées telles que les snapshots, les migrations de schémas d'événements et la projection en temps réel. Enfin, nous avons réalisé un projet guidé d'implémentation d'un système de gestion basé sur l'Event Sourcing.

J'espère que vous avez apprécié ce tutoriel et que vous vous sentez plus confiant dans votre compréhension de l'Event Sourcing en PHP. N'hésitez pas à explorer davantage ce sujet et à l'appliquer dans vos propres projets. L'Event Sourcing peut être un outil puissant pour la construction de systèmes évolutifs et flexibles.