Flux d'événements et sourcing d'événements

Le streaming d'événements et le sourcing d'événements sont deux concepts liés mais différents dans l'architecture événementielle.

Le streaming d'événements est le processus de capture et d'enregistrement continu des événements qui se produisent dans le système. Ces événements peuvent être traités et analysés immédiatement ou stockés pour une analyse ultérieure. Le streaming d'événements est généralement utilisé dans les systèmes qui doivent traiter de grandes quantités de données en temps réel, telles que les transactions financières ou les plateformes de réseaux sociaux.

Voici un exemple simple de streaming d'événements dans Go à l'aide du système de messagerie populaire Kafka :

package main

import (
"context"
"fmt"
"github.com/segmentio/kafka-go"
)

func main() {
// 设置Kafka生产者以将事件发送到主题
writer := kafka.NewWriter(kafka.WriterConfig{
Brokers: []string{"localhost:9092"},
Topic: "my-topic",
})

// 发送一些事件到主题
writer.WriteMessages(context.Background(),
kafka.Message{
Key: []byte("key1"),
Value: []byte("value1"),
},
kafka.Message{
Key: []byte("key2"),
Value: []byte("value2"),
},
)

// 设置Kafka消费者以从主题读取事件
reader := kafka.NewReader(kafka.ReaderConfig{
Brokers: []string{"localhost:9092"},
Topic: "my-topic",
})

// 从主题读取事件
for {
msg, err := reader.ReadMessage(context.Background())
if err != nil {
break
}
fmt.Printf("Received message: key=%s, value=%sn", string(msg.Key), string(msg.Value))
}
}

Le sourcing d'événements est un modèle de création de systèmes qui stocke tous les changements dans l'état de l'application sous la forme d'une séquence d'événements. Ces événements peuvent ensuite être utilisés pour reconstruire l’état de l’application à tout moment. La recherche d'événements est souvent utilisée dans des systèmes qui nécessitent une auditabilité, une traçabilité ou une conformité, tels que les systèmes financiers ou les systèmes de santé.

Voici un exemple simple d'utilisation du stockage d'événements en mémoire pour la recherche d'événements dans Go :

package main

import (
"fmt"
)

type Event struct {
Type string
Data interface{}
}

type EventStore struct {
events []Event
}

func (store *EventStore) Append(event Event) {
store.events = append(store.events, event)
}

func (store *EventStore) GetEvents() []Event {
return store.events
}

type Account struct {
idstring
balance int
store *EventStore
}

func NewAccount(id string, store *EventStore) *Account {
return &Account{
id:id,
balance: 0,
store: store,
}
}

func (account *Account) Deposit(amount int) {
event := Event{
Type: "deposit",
Data: amount,
}
account.store.Append(event)
account.balance += amount
}

func (account *Account) Withdraw(amount int) {
if account.balance >= amount {
event := Event{
Type: "withdraw",
Data: amount,
}
account.store.Append(event)
account.balance -= amount
}
}

func (account *Account) GetBalance() int {
return account.balance
}

func main() {
store := &EventStore{}
account := NewAccount("123", store)

account.Deposit(100)
account.Withdraw(50)
account.Deposit(25)

events := store.GetEvents()
for _, event := range events {
switch event.Type {
case "deposit":
amount := event.Data.(int)
fmt.Printf("Deposited %dn", amount)
case "withdraw":
amount := event.Data.(int)
fmt.Printf("Withdrew %dn", amount)
}
}

fmt.Printf("Final balance: %dn", account.GetBalance())
}

Le sourcing d'événements est une approche consistant à enregistrer chaque modification apportée à un agrégat en tant qu'événement et à l'ajouter à un flux continu. Pour reconstruire l’état final de l’agrégat, ces événements doivent être lus séquentiellement puis appliqués à l’agrégat. Cela contraste avec les modifications à la volée effectuées dans un système de création, lecture, mise à jour et suppression (CRUD). Dans un système CRUD, toute modification apportée à l'état de l'enregistrement est stockée dans la base de données, remplaçant essentiellement la même chose

Une collection de versions précédentes.

Une fois les modifications de prix enregistrées dans le tableau Produits, seul le prix sera mis à jour, tandis que les autres parties resteront inchangées. Cependant, cette approche peut entraîner une perte des prix antérieurs et du contexte qui sous-tend les changements, comme le montre la figure 5.1.

Afin de conserver les informations, notamment les nouveaux prix et les métadonnées clés (telles que les raisons des ajustements), les enregistrements de modifications seront stockés en tant qu'événements dans le tableau Événements. Le prix précédent restera inchangé pour garantir qu'il puisse être récupéré si nécessaire.

Afin d'obtenir un sourcing d'événements efficace, il est recommandé d'utiliser un magasin d'événements qui offre de fortes garanties de cohérence et utilise un contrôle de concurrence optimiste. En pratique, cela signifie que lorsque plusieurs modifications se produisent simultanément, seule la modification initiale peut être ajoutée au flux. Les modifications ultérieures devront peut-être être réessayées ou échoueront.

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!