Event-Flow und Event-Sourcing

Event-Streaming und Event-Sourcing sind zwei verwandte, aber unterschiedliche Konzepte in der ereignisgesteuerten Architektur.

Event-Streaming ist der Prozess der kontinuierlichen Erfassung und Aufzeichnung von Ereignissen, die im System auftreten. Diese Ereignisse können sofort verarbeitet und analysiert oder für eine spätere Analyse gespeichert werden. Event-Streaming wird typischerweise in Systemen verwendet, die große Mengen an Echtzeitdaten verarbeiten müssen, wie etwa Finanztransaktionen oder Social-Media-Plattformen.

Hier ist ein einfaches Beispiel für Event-Streaming in Go mithilfe des beliebten Kafka-Nachrichtensystems:

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))
}
}

Event Sourcing ist ein Muster zum Aufbau von Systemen, das alle Änderungen im Anwendungsstatus als Abfolge von Ereignissen speichert. Diese Ereignisse können dann verwendet werden, um den Status der Anwendung zu jedem Zeitpunkt zu rekonstruieren. Event Sourcing wird häufig in Systemen eingesetzt, die Prüfbarkeit, Rückverfolgbarkeit oder Compliance erfordern, wie etwa Finanzsysteme oder Gesundheitssysteme.

Hier ist ein einfaches Beispiel für die Verwendung von In-Memory-Ereignisspeicher für die Ereignisbeschaffung in 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())
}

Event Sourcing ist ein Ansatz, bei dem jede Änderung an einem Aggregat als Ereignis aufgezeichnet und an einen kontinuierlichen Stream angehängt wird. Um den Endzustand des Aggregats zu rekonstruieren, müssen diese Ereignisse nacheinander gelesen und dann auf das Aggregat angewendet werden. Dies steht im Gegensatz zu den spontanen Änderungen, die in einem System zum Erstellen, Lesen, Aktualisieren und Löschen (CRUD) durchgeführt werden. In einem CRUD-System werden alle Änderungen am Status des Datensatzes in der Datenbank gespeichert und überschreiben diesen im Wesentlichen

Eine Sammlung früherer Versionen.

Nachdem die Preisänderungen in der Produkttabelle gespeichert wurden, wird nur der Preis aktualisiert, während die anderen Teile unverändert bleiben. Dieser Ansatz kann jedoch dazu führen, dass frühere Preise und der Kontext hinter Änderungen verloren gehen, wie in Abbildung 5.1 dargestellt.

Um Informationen einschließlich neuer Preise und wichtiger Metadaten (z. B. Gründe für Anpassungen) beizubehalten, werden Änderungsdatensätze als Ereignisse in der Ereignistabelle gespeichert. Der bisherige Preis bleibt unverändert, um bei Bedarf einen Rückruf zu gewährleisten.

Um eine effektive Ereignisbeschaffung zu erreichen, wird empfohlen, einen Ereignisspeicher zu verwenden, der starke Konsistenzgarantien bietet und eine optimistische Parallelitätskontrolle verwendet. In der Praxis bedeutet dies, dass beim gleichzeitigen Auftreten mehrerer Änderungen nur die ursprüngliche Änderung an den Stream angehängt werden kann. Nachfolgende Änderungen müssen möglicherweise erneut durchgeführt werden oder schlagen möglicherweise fehl.

Das obige ist der detaillierte Inhalt vonEvent-Flow und Event-Sourcing. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!