DDD: Aggregate Transactional Consistency Boundary

Author: hoc081098Estimated 8 min readHits

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.

Aggregate, transaction và 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 đã Submitted không được thêm hoặc xóa OrderLine.
  • Order phải có ít nhất một OrderLine để Submit() thành công.
  • Order.Total phải phản ánh chính xác tổng giá trị các OrderLine theo 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 + 2 chẳ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 rowversion column.
  • Trong PostgreSQL, có thể dùng xmin system column làm concurrency token ở cấp row.
  • Hoặc application có thể tự quản lý một property Version là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 ❤