Doanh nghiệpEnterprise

Event Sourcingaka Event Store, Append-only log

Không lưu trạng thái hiện tại — lưu chuỗi sự kiện đã xảy ra, rồi phát lại để tính ra trạng thái.Don't store the current state — store the sequence of events that happened, and replay them to get the state.

Độ khóDifficulty: KhóHard
Mức phổ biếnUsage: Mức phổ biếnUsage 2/5
Thời gian đọcReading time: ~9 phút đọc~9 min read

Thảo luậnDiscussion

Ví dụ đời thườngReal-life analogy

Sổ tiết kiệm ngân hàng ngày xưa: không ai tẩy xoá số dư rồi ghi số mới. Mỗi dòng là một giao dịch — gửi 5 triệu, rút 2 triệu, lãi 30 nghìn. Muốn biết số dư thì cộng dồn từ đầu (hoặc từ dòng 'số dư chuyển trang' — chính là snapshot). Ghi sai thì không xoá, mà thêm một dòng điều chỉnh.An old-school bank passbook: nobody erases the balance and writes a new one. Each line is a transaction — deposit 5 million, withdraw 2 million, interest 30 thousand. To know the balance you add up from the start (or from the 'balance carried forward' line — that's a snapshot). A mistake is never erased; a correcting line is added.

Vấn đề và giải phápProblem and solution

Không có patternWithout the pattern

Bảng wallet chỉ có cột balance. Khách khiếu nại 'sao tôi mất 200 nghìn?' — bạn chỉ thấy số dư hiện tại, không biết nó đã thay đổi thế nào. UPDATE balance = balance - 200000 ghi đè mất lịch sử; bảng audit log viết tay thì hay bị quên hoặc lệch với dữ liệu thật. Kiểm toán, đối soát và debug đều phải đoán.The wallet table only has a balance column. A customer complains 'where did my 200k go?' — you only see the current balance, not how it got there. UPDATE balance = balance - 200000 overwrites history; a hand-written audit table gets forgotten or drifts from the real data. Audits, reconciliation and debugging all become guesswork.

Với Event SourcingWith Event Sourcing

Mỗi thay đổi được lưu thành một event bất biến (WalletOpened, MoneyDeposited, MoneyWithdrawn) vào một event store chỉ-thêm, đánh số version theo từng stream (mỗi ví một stream). Muốn có trạng thái: load các event và apply lần lượt (rehydrate). Để khỏi replay hàng nghìn event, định kỳ lưu snapshot. Ghi đồng thời được chặn bằng optimistic concurrency: UNIQUE(stream_id, version). Màn hình đọc dùng projection (thường kèm CQRS).Every change is stored as an immutable event (WalletOpened, MoneyDeposited, MoneyWithdrawn) in an append-only event store, versioned per stream (one stream per wallet). To get state: load the events and apply them in order (rehydrate). To avoid replaying thousands of events, save periodic snapshots. Concurrent writes are blocked with optimistic concurrency: UNIQUE(stream_id, version). Read screens use projections (usually with CQRS).

Thành phần tham giaParticipants

Event: Sự thật bất biến đã xảy ra, đặt tên thì quá khứ (MoneyWithdrawn).An immutable fact that happened, named in the past tense (MoneyWithdrawn).
Aggregate: Kiểm tra quy tắc, sinh event mới; trạng thái chỉ đổi qua apply(event).Enforces rules and raises new events; state changes only via apply(event).
Event store: Bảng/log chỉ-thêm, đánh version theo stream, chặn ghi đồng thời.An append-only table/log, versioned per stream, blocking concurrent writes.
Snapshot: Ảnh chụp trạng thái tại version N để rehydrate nhanh.A state picture at version N for fast rehydration.
Projection: Read model dựng từ event (số dư, sao kê) — có thể xoá và dựng lại.A read model built from events (balances, statements) — can be dropped and rebuilt.

Sơ đồ và luồng thực thiDiagram and execution flow

Dùng Tự chạy hoặc phím mũi tên để đi qua từng bước gọi giữa các object. Console hiển thị output tương ứng của chương trình.Use Autoplay or the arrow keys to step through each call between objects. The console shows the matching program output.

1Lệnh rút 200.000đ. Service lấy snapshot mới nhất của ví: version 300, số dư 1.500.000đ.A 200,000 VND withdrawal. The service fetches the wallet's latest snapshot: version 300, balance 1,500,000.

← →

console

1snapshot v300 balance=1500000

implementsimplementsextendsextendsgọi / dùngcalls / usestạo racreatesgửi qua channelsends via channel1thứ tự chạy (bấm để nhảy bước)execution order (click to jump)

Code: Java Spring Boot ⇄ GoCode: Java Spring Boot ⇄ Go

Cùng một bài toán, hai ngôn ngữ. Rê chuột hoặc focus vào chú thích (số màu cam) để làm nổi bật dòng code tương ứng.Same problem, two languages. Hover or focus an annotation (orange number) to highlight its line.

JavaSpring Boot 3 · Java 21Spring Boot 3 · Java 21

package com.wallet.domain;

import java.time.Instant;
import java.util.UUID;

// Events are immutable facts, named in the past tense.
// "sealed" lets the compiler check every switch over them.
public sealed interface WalletEvent {1
    UUID walletId();
    Instant at();

    record WalletOpened(UUID walletId, String owner, Instant at)2
        implements WalletEvent {}

    record MoneyDeposited(UUID walletId, long amount, String source, Instant at)
        implements WalletEvent {}

    record MoneyWithdrawn(UUID walletId, long amount, String reason, Instant at)3
        implements WalletEvent {}
}

GoGo 1.23 · thư viện chuẩnGo 1.23 · standard library

package wallet

import (
	"encoding/json"
	"fmt"
)

// Event is an immutable fact, named in the past tense.
type Event interface{ EventType() string }1

// Snapshot caches the state at Version to speed up rehydration.
type Snapshot struct {
	WalletID string
	Balance  int64
	Version  int64
}

type Opened struct {
	WalletID string `json:"walletId"`
	Owner    string `json:"owner"`
}

type Deposited struct {
	Amount int64  `json:"amount"`
	Source string `json:"source"`
}

type Withdrawn struct {
	Amount int64  `json:"amount"`
	Reason string `json:"reason"`
}

func (Opened) EventType() string    { return "WalletOpened" }
func (Deposited) EventType() string { return "MoneyDeposited" }
func (Withdrawn) EventType() string { return "MoneyWithdrawn" }

func as[T Event](payload []byte) (Event, error) {2
	var e T
	err := json.Unmarshal(payload, &e)
	return e, err
}

// decode turns a stored (type, payload) row back into a typed event.
func decode(typ string, payload []byte) (Event, error) {3
	switch typ {
	case "WalletOpened":
		return as[Opened](payload)
	case "MoneyDeposited":
		return as[Deposited](payload)
	case "MoneyWithdrawn":
		return as[Withdrawn](payload)
	}
	return nil, fmt.Errorf("unknown event type %q", typ)
}

Khác biệt chính giữa Java và GoKey differences between Java and Go

01Java 21 có sealed interface + record + pattern-matching switch: tập event đóng và compiler kiểm tra đủ case. Go dùng interface + type switch, không kiểm tra exhaustive — bù bằng test.Java 21 has sealed interfaces + records + pattern-matching switch: a closed event set with compiler-checked exhaustiveness. Go uses an interface + type switch with no exhaustiveness check — compensate with tests.
02Bất biến: record Java tự bất biến. Struct Go truyền theo giá trị nên bản sao không ảnh hưởng gốc, nhưng không có gì cấm sửa field — phải giữ kỷ luật.Immutability: Java records are immutable by design. Go structs passed by value are copies, but nothing forbids mutating fields — it takes discipline.
03Deserialize: Jackson cần @JsonTypeInfo/@JsonSubTypes hoặc map type→class. Go dùng hàm decode với switch theo tên event, generics giúp gọn hơn.Deserializing: Jackson needs @JsonTypeInfo/@JsonSubTypes or a type→class map. Go uses a decode function switching on the event name, with generics keeping it tidy.
04Xung đột đồng thời: Spring ném DuplicateKeyException (đã dịch từ SQLState). Go tự kiểm tra *pgconn.PgError với mã 23505 qua errors.As.Concurrency conflicts: Spring throws DuplicateKeyException (translated from the SQLState). Go checks *pgconn.PgError for code 23505 via errors.As.

Ứng dụng thực tếReal-world usage

Axon Framework & EventStoreDBAxon Framework & EventStoreDB
Axon cho Spring Boot có @EventSourcingHandler (chính là apply), snapshotting và Axon Server. EventStoreDB (Kurrent) là database chuyên cho event, có client Java và Go.Axon for Spring Boot has @EventSourcingHandler (that's apply), snapshotting and Axon Server. EventStoreDB (Kurrent) is a purpose-built event database with Java and Go clients.
Sổ cái kế toán & ví điện tửAccounting ledgers & e-wallets
Sổ cái kép, lịch sử giao dịch ví (Momo, ZaloPay) bản chất là event log chỉ-thêm: số dư được tính, không được ghi đè.Double-entry ledgers and wallet histories (Momo, ZaloPay) are append-only event logs by nature: balances are derived, never overwritten.
Git và KafkaGit and Kafka
Git lưu chuỗi commit, checkout = replay. Kafka với log compaction / retention vô hạn thường làm 'xương sống' event cho hệ thống event-sourced.Git stores a chain of commits, checkout = replay. Kafka with compaction / infinite retention often serves as the event backbone for event-sourced systems.
Theo dõi đơn hàng / vận đơnOrder / shipment tracking
Hành trình vận đơn (Đã lấy hàng → Đang trung chuyển → Giao thành công) là danh sách event; màn tracking chỉ là một projection.A shipment's journey (Picked up → In transit → Delivered) is a list of events; the tracking screen is just a projection.

Khi nào dùng và khi nào khôngWhen to use it, and when not

Nên dùng khiUse it when

Cần audit đầy đủ, không thể chối cãi: tài chính, ví, bảo hiểm, y tế.You need a complete, tamper-evident audit trail: finance, wallets, insurance, healthcare.
Cần trả lời 'trạng thái lúc 15h hôm qua là gì?' (temporal query) hoặc phát lại để debug.You need to answer 'what was the state at 3pm yesterday?' (temporal queries) or replay to debug.
Nhiều read model khác nhau phải dựng từ cùng một nguồn sự kiện (đi cùng CQRS).Many different read models must be built from the same event source (paired with CQRS).

Không nên dùng khiAvoid it when

CRUD đơn giản (danh mục, cấu hình) — chi phí phức tạp lớn hơn nhiều so với lợi ích.Simple CRUD (catalogs, settings) — the complexity cost far outweighs the benefit.
Team chưa quen eventual consistency, versioning event và projection.The team isn't familiar with eventual consistency, event versioning and projections.
Dữ liệu phải xoá hẳn theo yêu cầu (quyền được lãng quên) mà chưa có chiến lược như crypto-shredding.Data must be truly erasable on request (right to be forgotten) without a strategy like crypto-shredding.

Ưu điểmPros

Audit log hoàn hảo miễn phí — lịch sử chính LÀ dữ liệu.A perfect audit log for free — the history IS the data.
Dựng lại trạng thái tại bất kỳ thời điểm nào; thêm read model mới bằng cách replay.Rebuild state at any point in time; add new read models by replaying.
Ghi chỉ-thêm rất nhanh, optimistic concurrency đơn giản theo version.Append-only writes are fast; optimistic concurrency by version is simple.

Nhược điểmCons

Thay đổi cấu trúc event (versioning, upcasting) rất khó vì event cũ tồn tại mãi.Evolving event schemas (versioning, upcasting) is hard since old events live forever.
Truy vấn trạng thái phải qua projection — luôn kéo theo CQRS và eventual consistency.Querying state requires projections — CQRS and eventual consistency come along.
Đường cong học tập cao, dễ làm sai (event quá chung chung, apply có side effect).Steep learning curve, easy to get wrong (generic events, side effects in apply).

Anti-pattern: lỗi thường gặpAnti-pattern: common mistake

apply() có side effect và kiểm tra quy tắcapply() with side effects and rule checks

Đặt gửi SMS và kiểm tra hạn mức vào apply(): mỗi lần rehydrate (mỗi request!) khách lại nhận SMS cũ, và event hợp lệ năm ngoái bị từ chối vì hạn mức năm nay đã đổi — không dựng lại được trạng thái. Kiểm tra quy tắc ở method nghiệp vụ, side effect ở projection/handler.Putting SMS sending and limit checks into apply(): every rehydration (every request!) re-sends old SMS, and last year's valid event is rejected because this year's limit changed — state can't be rebuilt. Check rules in the business method, put side effects in projections/handlers.

private void apply(WalletEvent e) {
    switch (e) {
        case MoneyWithdrawn w -> {
            if (w.amount() > dailyLimitService.current()) {   // ❌ today's rule on old facts
                throw new LimitExceededException();
            }
            balance -= w.amount();
            sms.send(owner, "You withdrew " + w.amount());      // ❌ fires on every replay
        }
        default -> { }
    }
}

Dễ nhầm vớiEasily confused with

Event Sourcing vs CQRS

Event Sourcing là cách LƯU trạng thái (bằng event). CQRS là cách TÁCH mô hình đọc/ghi. ES gần như luôn cần CQRS, nhưng CQRS không cần ES.Event Sourcing is how you STORE state (as events). CQRS is how you SPLIT read/write models. ES almost always needs CQRS, but CQRS doesn't need ES.

Event Sourcing vs Memento

Memento lưu ảnh chụp trạng thái để undo (giống snapshot). Event Sourcing lưu từng thay đổi — snapshot chỉ là phần phụ.Memento stores state pictures for undo (like a snapshot). Event Sourcing stores every change — snapshots are just an add-on.

Bài tập áp dụngExercise

Thêm tính năng 'đóng băng ví' (FreezeWallet) cho bộ phận chống gian lận: ví bị đóng băng thì không rút tiền được, nhưng vẫn nhận tiền. Viết event, cập nhật aggregate và apply.Add a 'freeze wallet' feature for the fraud team: a frozen wallet can't withdraw but can still receive money. Write the event, update the aggregate and apply.

Kiểm tra kiến thứcKnowledge check

Câu 1 / 6Question 1 of 6

Trong Event Sourcing, nguồn sự thật (source of truth) là gì?In Event Sourcing, what is the source of truth?

Phím 1–4 để chọn đáp án, Enter để kiểm tra.Press 1–4 to choose an answer, Enter to check.

Thẻ ghi nhớFlashcards

Ôn tập ngắt quãng (spaced repetition): thẻ được lặp lại sau 1 → 3 → 7 → 14 → 30 ngày để củng cố trí nhớ dài hạn.Spaced repetition: cards are repeated after 1 → 3 → 7 → 14 → 30 days to build long-term memory.

Dùng trong bài toánUsed in problems

3 bài toán Backend dùng pattern này3 backend problems use this pattern

Pattern liên quanRelated patterns

CQRS Memento Transactional Outbox Command

Thảo luậnDiscussion

Event Sourcingaka Event Store, Append-only log

KhóHard

Mức phổ biếnUsage 2/5

~9 phút đọc~9 min read

package com.wallet.domain; import java.time.Instant; import java.util.UUID; // Events are immutable facts, named in the past tense. // "sealed" lets the compiler check every switch over them. public sealed interface WalletEvent {1 UUID walletId(); Instant at(); record WalletOpened(UUID walletId, String owner, Instant at)2 implements WalletEvent {} record MoneyDeposited(UUID walletId, long amount, String source, Instant at) implements WalletEvent {} record MoneyWithdrawn(UUID walletId, long amount, String reason, Instant at)3 implements WalletEvent {} }

package wallet import ( "encoding/json" "fmt" ) // Event is an immutable fact, named in the past tense. type Event interface{ EventType() string }1 // Snapshot caches the state at Version to speed up rehydration. type Snapshot struct { WalletID string Balance int64 Version int64 } type Opened struct { WalletID string `json:"walletId"` Owner string `json:"owner"` } type Deposited struct { Amount int64 `json:"amount"` Source string `json:"source"` } type Withdrawn struct { Amount int64 `json:"amount"` Reason string `json:"reason"` } func (Opened) EventType() string { return "WalletOpened" } func (Deposited) EventType() string { return "MoneyDeposited" } func (Withdrawn) EventType() string { return "MoneyWithdrawn" } func as[T Event](payload []byte) (Event, error) {2 var e T err := json.Unmarshal(payload, &e) return e, err } // decode turns a stored (type, payload) row back into a typed event. func decode(typ string, payload []byte) (Event, error) {3 switch typ { case "WalletOpened": return as[Opened](payload) case "MoneyDeposited": return as[Deposited](payload) case "MoneyWithdrawn": return as[Withdrawn](payload) } return nil, fmt.Errorf("unknown event type %q", typ) }

private void apply(WalletEvent e) { switch (e) { case MoneyWithdrawn w -> { if (w.amount() > dailyLimitService.current()) { // ❌ today's rule on old facts throw new LimitExceededException(); } balance -= w.amount(); sms.send(owner, "You withdrew " + w.amount()); // ❌ fires on every replay } default -> { } } }