Construire un système CQRS et d'approvisionnement d'événements avec PHP

Commandes et requêtes distinctes: utilisez CQRS pour découpler les opérations d'écriture (telles que CreateUser) à partir des opérations de lecture (telles que GetUserById), le côté de la commande traite la logique métier et enregistre les événements, et le côté de la requête obtient rapidement des données à partir de tables de lecture optimisées (telles que Users_View); 2. Implémentez la traçabilité des événements: les événements d'enregistrement et de lecture (tels que les créés par l'utilisateur) via la racine agrégée (racine agrégée), les changements d'état sont persistés sous la forme d'événements, soutenant l'audit, le débogage et la reconstruction de l'État; 3. Construire le stockage des événements: utilisez MySQL et d'autres bases de données pour stocker des flux d'événements, charger les séquences d'événements en fonction de l'ID agrégé pour reconstruire les instances agrégées; 4. Mettez à jour le modèle de lecture: appliquez les événements de manière synchrone ou asynchrone à la table de lecture du modèle via le projecteur pour garder la vue de requête mise à jour; 5. Ilétré progressivement: aucun framework n'est requis, commencer par une implémentation simple, se concentrer sur la sérialisation des événements, le contrôle des versions et les tests d'agrégation et s'assurer que la logique du champ central est fiable. Après une mise en œuvre correcte, le système aura une évolutivité élevée, une traçabilité et des capacités d'évolution flexibles.

La construction d'un système CQRS et d'approvisionnement en événements en PHP peut sembler intimidant au début, mais une fois que vous le décomposez, il devient un moyen puissant de concevoir des applications évolutives et maintenables, en particulier lorsqu'elle traite avec une logique commerciale complexe. Voici un guide pratique pour vous aider à démarrer, sans se noyer en théorie.

Ce que vous construisez réellement

CQRS (Command Query Responsibility Segregation) signifie séparer les opérations d'écriture (commandes) des opérations de lecture (requêtes).
L'approvisionnement en événement signifie stocker les changements d'état comme une séquence d'événements, plutôt que comme l'état actuel.

Ensemble, ils vous permettent de:

• Suivre pourquoi et comment les données ont changé (trace d'audit par conception)
• Reconstruire l'état des événements (idéal pour le débogage ou l'analyse)
• L'échelle lit et écrit indépendamment

Voyons une implémentation simplifiée mais réelle dans PHP.

1. Structurez votre application avec les limites CQRS

Commencez par diviser votre application en deux côtés:

• Côté de la commande : gère les actions comme "CreateUser", "UpdateMail"
• Côté de la requête : gère la récupération des données comme "GetUserByid", "ListUsers"

 // Exemple: commande
classe CreateUserCommand
{
    fonction publique __construct (
        Public ReadOnly String $ userId,
        Public ReadOnly String $ Name,
        Public ReadOnly String $ Email
    ) {}
}

// Exemple: gestionnaire de commandes
classe CreateUserHandler
{
    EventStore privé $ EventStore;

    Fonction publique __construct (EventStore $ EventStore)
    {
        $ this-> eventStore = $ EventStore;
    }

    Fonction publique __invoke (CreateUserCommand $ Command): void
    {
        $ user = user :: FromCommand ($ Command);
        $ this-> eventStore-> Enregistrer ($ user-> getunCitTevents ());
        $ user-> ClearEvents (); // IMPORTANT: Réinitialisez après enregistrer
    }
}

Du côté de la requête, restez simple et rapide:

 Classe UserQueryHandler
{
    PDO privé $ PDO;

    fonction publique getUserByid (String $ id) :? Array
    {
        $ stmt = $ this-> pDo-> prépare ("select * dans users_view où id =?");
        $ stmt-> exécuter ([$ id]);
        return $ stmt-> fetch (pdo :: fetch_assoc) ?: null;
    }
}

? Idée clé: le côté de la requête se lit dans une table dénormalisée (comme users_view ) optimisé pour les lectures. Le côté de la commande met à jour le magasin d'événements.

2. Implémentez l'approvisionnement des événements avec une racine agrégée

Un agrégat est un groupe d'objets de domaine traités comme une seule unité. Par exemple, User est une racine agrégée.

 Cours abstraits agrégateroot
{
    Array protégé $ événements = [];
    protégé int $ version = 0;

    Fonction protégée RecordEvent (événement DomaineEvent $): void
    {
        $ this-> événements [] = $ événement;
        $ this-> appliquer ($ event);
    }

    La fonction protégé abstraite s'applique (événement DomaineVent $): void;

    fonction publique getunCitmitedEvents (): Array
    {
        retourner $ this-> événements;
    }

    Fonction publique ClearEvents (): void
    {
        $ this-> events = [];
    }

    fonction publique getVersion (): int
    {
        retourner $ this-> version;
    }
}

Maintenant, créez un agrégat User :

 L'utilisateur de la classe étend la totalité
{
    chaîne privée $ id;
    chaîne privée $ name;
    chaîne privée $ e-mail;
    Bool privé $ actif = true;

    Fonction statique publique Create (CreateUserCommand $ Command): Self
    {
        $ user = new self ();
        $ user-> RecordEvent (Nouveau UserCated (
            $ command-> userId,
            $ Command-> Nom,
            $ Command-> Email
        ));
        retourner $ utilisateur;
    }

    Fonction protégée s'appliquent (événement DomaineVent $): void
    {
        Switch ($ Event) {
            Case $ Événement instance de l'utilisateur créé:
                $ this-> id = $ event-> userId;
                $ this-> name = $ event-> name;
                $ this-> email = $ event-> e-mail;
                $ this-> version;
                casser;
        }
    }
}

Et l'événement:

 Classe Créée par l'utilisateur implémente DomaineEvent
{
    fonction publique __construct (
        Public ReadOnly String $ userId,
        Public ReadOnly String $ Name,
        Public ReadOnly String $ Email,
        Public ReadOnly DatetimeMutable $ se produit = new DateTimeMutable ()
    ) {}
}

3. Construisez un magasin d'événements simples

Le magasin d'événements économise des événements et les charge pour reconstruire des agrégats.

 Interface EventStore
{
    Fonction publique Save (String $ agrégateType, String $ agrégateId, Array $ Events, int $ attendursion): void;
    Charge de fonction publique (String $ agrégateID): Array;
}

Classe MySQLeventStore implémente EventStore
{
    PDO privé $ PDO;

    Fonction publique __construct (PDO $ PDO)
    {
        $ this-> PDO = $ PDO;
    }

    Fonction publique Save (String $ AggregateType, String $ agrégateId, Array $ Events, int $ attendursion): void
    {
        $ this-> pDo-> beginTransaction ();

        foreach ($ Events As $ Event) {
            $ stmt = $ this-> pDo-> préparer (
                "Insérer dans les événements (agrégate_type, agrégate_id, type, charge utile, version, se produit_at)
                 Valeurs (?,?,?,?,?,?,?) "
            ));
            $ stmt-> exécuter ([[
                $ globateType,
                $ agrégateid,
                get_class ($ event),
                JSON_ENCODOD ($ Event),
                $ this-> version, // incrément par événement
                $ Event-> se produit-> format ('ymd h: i: s.u')
            ]));
        }

        $ this-> pDo-> commit ();
    }

    Charge de fonction publique (String $ agrégateid): tableau
    {
        $ stmt = $ this-> pDo-> prépare ("select * dans les événements où agrégate_id =? commander par version");
        $ stmt-> exécuter ([$ agrégateID]);

        $ événements = [];
        foreach ($ stmt comme $ row) {
            $ Payload = JSON_DECODE ($ row ['Payload'], true);
            // Dans les applications réelles, utilisez un mappeur ou un sérialiseur
            $ Events [] = Match ($ row ['type']) {
                UserCated :: class => new UserCreated (
                    $ upload ['userId'],
                    $ la charge utile ['name'],
                    $ upload ['e-mail'],
                    Nouveau DatetimeMutable ($ Payload ['se produit']))
                ),
                default => Throw New \ Exception ("Événement inconnu:". $ Row ['Type'])
            };
        }

        retourner $ événements;
    }
}

? Astuce: vous voudrez verser vos événements et gérer les modifications du schéma plus tard (par exemple, à l'aide de Upcasters).

4. Reconstruire l'état des événements

Lors du chargement d'un User , rejouez tous les événements:

 L'utilisateur de la classe étend la totalité
{
    // ... code précédent

    Fonction statique publique depuis History (Array $ événements): Self
    {
        $ user = new self ();
        foreach ($ Events As $ Event) {
            $ user-> appliquer ($ event);
            $ user-> version;
        }
        retourner $ utilisateur;
    }
}

Utilisation dans le gestionnaire:

 Fonction publique __invoke (CreateUserCommand $ Command): void
{
    $ events = $ this-> eventStore-> chargement ($ command-> userId);
    if (! vide ($ events)) {
        lancer une nouvelle exception ("l'utilisateur existe déjà");
    }

    $ user = user :: create ($ commande);
    $ this-> eventStore-> Enregistrer ('utilisateur', $ command-> userId, $ user-> getunComMttedEvents (), $ user-> getVersion ());
    $ user-> ClearEvents ();
}

5. Mettez à jour le modèle de lecture (projections)

Une fois un événement enregistré, mettez à jour vos tables optimisées en lecture.

 projecteur d'interface
{
    Projet de fonction publique (événement DomaineEvent $): void;
}

Classe UserProjector implémente le projecteur
{
    PDO privé $ PDO;

    Projet de fonction publique (événement DomaineVent $): void
    {
        if ($ event instanceof userreated) {
            $ this-> PDO-> Préparer (
                "Insérer dans users_view (id, nom, e-mail, création_at) VALEURS (?,? ,?)"
            ) -> exécuter ([
                $ event-> userId,
                $ Event-> Nom,
                $ event-> e-mail,
                $ event-> se produit-> format ('ymd h: i: s')
            ]));
        }
    }
}

Vous pouvez gérer des projets:

• Synchrone (simple, cohérent)
• Via une file d'attente de messages (cohérence évolutive, éventuelle)

Notes finales

• Utilisez une injection de dépendance (par exemple, Symfony, Laravel ou Container Plain)
• Sérialiser attentivement
• Envisagez d'utiliser des Uuids pour les ID agrégés
• Ajouter des métadonnées aux événements (par exemple, IP utilisateur, ID de trace)
• Testez vos agrégats fortement - ils sont le cœur de votre domaine

Ce n'est pas trivial, mais vous n'avez pas besoin d'un cadre pour commencer. Avec PHP ordinaire, les interfaces et la bonne séparation, vous pouvez construire une base solide. La véritable puissance apparaît lorsque vos règles commerciales augmentent et que vous devez auditer, rejouer ou étendre le comportement sans casser les choses.

Fondamentalement: commencez petit, obtenez le bon flux et laissez les événements parler.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!