DDD: Aggregate Transactional Consistency Boundary
Chúng ta đã qua hai bài số 1 và bài số 2:
Bài 1: Entity, Value Object và Aggregate Root → cover phần semantics nền: identity, value, lifecycle, Aggregate Root, consistency boundary.
Bài 2: Rich Domain Model, Invariant & Behavior → đào sâu cách Domain Model tự bảo vệ state, state transition, tránh Anemic Domain Model.
Giờ chúng ta qua bài số 3 focus vào việc vì sao Aggregate boundary thường liên quan tới transaction boundary, cách các thay đổi của Aggregate được persist atomically, và vì sao vẫn cần quan tâm tới concurrency control.
Tổng quan vai trò của Aggregate, transaction và concurrency control trong ví dụ Order.
💠 Aggregate and transaction
Nhắc lại về Aggregate, đây là boundary của state và các invariants cần giữ nhất quán (consistency) cùng nhau. Dù domain code đã bảo vệ các invariants trên model trong memory, nhưng khi persist các thay đổi xuống database, một partial failure có thể khiến cho một phần thay đổi được ghi, điều đó có thể làm cho state đã lưu bị vi phạm invariant.
Database transaction đảm bảo atomicity (tính nguyên tử) theo semantics all-or-nothing. Các thay đổi trong một transaction hoặc được commit cùng nhau như một đơn vị, hoặc bị rollback toàn bộ. Thông thường, các thay đổi của một state transition trong Aggregate, thông qua Aggregate Root, được persist trong cùng một transaction để giữ các thay đổi atomic, tránh persist dở dang khi có partial failure.
Ngoài ra, dưới góc nhìn objects trong lập trình, ta thường hình dung Aggregate như một object graph. Cách hiểu này giúp dễ hình dung, nhưng nếu nhìn đúng bản chất DDD thì cách xác định Aggregate phải dựa trên consistency boundary. Và ở tầng database, boundary này thường tương ứng với một transactional consistency boundary.
Cũng cần phải lưu ý rằng 1 database transaction về mặt kỹ thuật vẫn có thể update nhiều Aggregate. DDD khuyến khích giữ transaction boundary nhỏ và thường xoay quanh một Aggregate khi có thể. Hơn nữa, ta còn có thể thêm database constraints để enforce một số invariants có thể biểu diễn được ở tầng persistence, làm như thế là ta đang tuân thủ Defense in Depth: Domain → Database Constraints.
💠 Ví dụ
Giả sử hệ thống thương mại điện tử có:
Order
├── OrderLine
│ └── Product
└── Customer
Order có những invariant sau:
OrderđãSubmittedkhông được thêm hoặc xóaOrderLine.Orderphải có ít nhất mộtOrderLineđểSubmit()thành công.Order.Totalphải phản ánh chính xác tổng giá trị cácOrderLinetheo pricing rules.
Các invariant này liên quan trực tiếp tới Order và OrderLine. Vì vậy, ta có thể thiết kế:
Order Aggregate
│
├── Order (Aggregate Root)
│ ├── Id
│ ├── Status
│ ├── Total
│ ├── TotalQuantity
│ └── OrderLines
│ ├── OrderLine #1
│ └── OrderLine #2
│
└── Invariants
├── Submitted → Cannot add/remove lines
├── Submit → At least one line
└── Total → Consistent with lines
Trong khi đó, Customer và Product có thể thuộc Aggregate riêng, với identity, lifecycle, behavior và invariant
riêng. Chúng không nhất thiết phải thuộc Aggregate của Order, mà ta chỉ cần store reference theo identity của chúng.
Order chỉ cần lưu: public CustomerId CustomerId { get; private set; } và mỗi OrderLine có thể lưu ProductId,
cùng snapshot giá tại thời điểm đặt hàng.
Và dưới góc nhìn relational database, những reference đó có thể được map thành khóa ngoại (foreign key), nhưng chúng ta cũng đừng nhầm lẫn giữa Aggregate boundary với persistence technology. Aggregate boundary được xác định bởi consistency requirements, không phải foreign keys / navigation properties.
💠 Concurrency Control
Nhưng với những thứ ta vừa kể thì vẫn chưa đủ! Hai state transition chạy đồng thời (race) vẫn có thể conflict trong
chuỗi read-check-modify-write và dẫn tới lost update, ngay cả khi domain code đã kiểm tra invariants và transaction đã
đảm bảo atomicity.
Với Order ở trên, xét hai request cùng load Aggregate Root từ database. Mỗi request gọi AddItem() để thêm 2 đơn vị
và tính lại TotalQuantity, được lưu trong column total_quantity.
Trong PostgreSQL với isolation level mặc định READ COMMITTED, giả sử cả hai transaction dùng SELECT thông thường,
không dùng FOR UPDATE hay concurrency token, rồi ghi giá trị mới đã tính ở application. Cả hai đều có thể đọc
TotalQuantity = 8 trước khi thực hiện update. Timeline dưới đây chỉ xét phần update TotalQuantity.
Initial: total_quantity = 8
T1 BEGIN
T2 BEGIN
T1 reads total_quantity = 8
T2 reads total_quantity = 8
T1 evaluates invariants in AddItem() -> allowed
T2 evaluates invariants in AddItem() -> allowed
T1 modifies loaded Order -> TotalQuantity = 10
T2 modifies loaded Order -> TotalQuantity = 10
T1 UPDATE orders SET total_quantity = 10 WHERE id = @id
T1 COMMIT
T2 UPDATE orders SET total_quantity = 10 WHERE id = @id
T2 COMMIT
Final: total_quantity = 10
Giá trị cuối là 10 thay vì 12, đây là lost update kinh điển. Mỗi request evaluate invariants trong AddItem()
trên snapshot TotalQuantity = 8 rồi tính giá trị mới là 10. Khi T2 ghi xuống database, điều kiện WHERE id = @id
vẫn match row, và câu UPDATE ghi đè kết quả mà T1 đã commit.
Với những invariant khác, stale decision từ snapshot cũ còn có thể làm cho state đã persist vi phạm business
invariant. Vì vậy, atomicity không đảm bảo serializability. Một transaction có atomicity không có nghĩa concurrent
execution của nhiều transaction sẽ tương đương với việc chúng chạy tuần tự theo một thứ tự nào đó. Chuỗi
read → evaluate invariant → modify → write vẫn cần isolation/concurrency control phù hợp khi có race.
Thực ra riêng phép cộng trong ví dụ này có thể dùng SQL
UPDATE ... SET total_quantity = total_quantity + 2chẳng hạn, nhưng ta đang ví dụ cho trường hợp Aggregate có nhiều invariant, nhiều Entity con, và invariants có thể phức tạp hơn, nên ở đây ta chọn evaluate invariants và tính toán state mới trong domain code thay vì đẩy hết vào SQL.
Lúc này ta cần Concurrency Control phù hợp cho flow trên, ví dụ như Optimistic Concurrency Control (OCC) với 1 concurrency token.
- Trong SQL Server, ta thường dùng
rowversioncolumn. - Trong PostgreSQL, có thể dùng
xminsystem column làm concurrency token ở cấp row. - Hoặc application có thể tự quản lý một property
Versionlàm concurrency token.
Nếu Aggregate trải trên nhiều Entity con, thì concurrency control phải bao phủ toàn bộ những mutation mà ta muốn bảo
vệ trong cùng một consistency boundary. Việc update một row của OrderLine không đồng nghĩa concurrency token trên
row Order cũng tự thay đổi theo.
Vì vậy, nếu dùng token của Order để đại diện cho version của toàn Aggregate, thì persistence strategy phải chủ động
kiểm tra token cũ và làm token đó thay đổi trong cùng transaction với các state change cần được bảo vệ, kể cả khi
chỉ sửa Entity con.
Khi đã cấu hình concurrency token trong EF Core, ORM sẽ thêm điều kiện kiểm tra token vào WHERE khi update tracked
Entity qua SaveChanges(). Ví dụ SQL với token do application quản lý:
UPDATE orders
SET total_quantity = @new_total_quantity,
token = @new_token
WHERE id = @id
AND token = @old_token;
Ở SQL trên, token là column do application quản lý, nên application tự tạo @new_token và gán nó trong SET để thay
token cũ.
Còn nếu dùng rowversion của SQL Server hoặc xmin của PostgreSQL thì database tự sinh token khi row được update.
Application vẫn dùng token cũ trong WHERE clause để kiểm tra conflict, nhưng phần SET chỉ ghi các field dữ liệu như
total_quantity, còn database tự cập nhật token.
Khi áp dụng cơ chế này, sau khi T1 commit với token mới, câu UPDATE của T2 dùng token cũ sẽ không match row nào.
Nếu câu UPDATE có affected rows = 0 do concurrency token không còn match hoặc row đã bị xóa, ORM có thể báo
concurrency conflict. Với EF Core, SaveChanges() ném DbUpdateConcurrencyException trong trường hợp này
(framework/library khác có thể dùng lỗi tương đương).
Sau đó application có thể reload state mới nhất, re-evaluate invariants rồi quyết định retry, merge/reconcile hoặc
report conflict cho client tùy API semantics (409 Conflict chẳng hạn).
Tóm gọn
- Aggregate xác định state và invariants cần phải được giữ nhất quán cùng nhau.
- Transaction đảm bảo các thay đổi được persist của một state transition có tính atomic.
- Concurrency control bảo vệ consistency khi nhiều transaction cùng sửa state của Aggregate.
Tiếp theo
Bài sau sẽ tập trung vào các trade-offs về performance như Aggregate lớn có xu hướng load nhiều state hơn từ database, tăng lock contention/concurrency conflicts và làm transactional work nặng hơn. Aggregate quá nhỏ thì có thể cần tới orchestration giữa các Aggregate và cân nhắc eventual consistency nếu requirements cho phép. Tùy cách giao tiếp, ta có thể dùng tới domain events. Còn nếu có messaging thì cân nhắc outbox pattern & idempotent consumer pattern.
Bài viết có sự cộng tác của ChatGPT ❤