Command pattern: từ Undo/Redo tới CQRS và Saga

- Published on
- 12 mins read
Phỏng vấn hỏi: "Ngoài cái remote bật tắt đèn ra, bạn dùng Command Pattern ở đâu?". Khá nhiều người khựng lại ở câu này.
Lỗi không hẳn ở người trả lời. Ví dụ Remote Control & Light trong sách dễ hiểu thật, nhưng nó làm pattern trông như một mẹo để... tách nút bấm giao diện.
Ở góc độ kiến trúc, Command làm một việc lớn hơn nhiều: biến một động từ (lời gọi hàm) thành một danh từ (đối tượng dữ liệu hạng nhất - First-Class Object). Gọi hàm xong là stack frame biến mất. Còn khi hành động đã thành một object nằm trên heap, bạn giữ nó lại để chạy sau (Queueing / Delayed Execution), gửi nó qua mạng (RPC / Message Bus), ghi xuống đĩa (Write-Ahead Logging), hoặc đảo ngược khi có lỗi (Undo / Compensating Transaction). CQRS, Event Sourcing và Saga trong Microservices đều xây trên viên gạch này.
# bản chất kiến trúc: biến động từ thành danh từ (objectifying actions)
Bình thường, một hành động là một method được gọi và chạy ngay:
// Lập trình thủ tục: Thực thi gắn chặt với thời gian và không gian
accountService.transferMoney(fromAcc, toAcc, amount);Với Command Pattern, hành động đó được "đóng băng" thành một object dữ liệu độc lập:
# command tách rời được những gì
Một lời gọi hàm thông thường bị trói chặt vào thời điểm gọi, vào luồng đang chạy và không để lại dấu vết sau khi kết thúc. Đóng gói lời gọi đó thành Command object giúp bạn gỡ được ba ràng buộc cùng lúc:
- Tách theo thời gian (Temporal Decoupling): lệnh tạo lúc 8h sáng nhưng có thể nằm trong hàng đợi, đến 2h đêm mới chạy (Batch Job / Off-Peak processing).
- Tách theo không gian (Spatial Decoupling): lệnh tạo ở Frontend Web Server, serialize thành JSON, gửi qua RabbitMQ rồi chạy trên Worker Pod ở một Data Center khác.
- Đảo ngược được (Reversibility): mỗi lệnh mang đủ tham số hoặc snapshot trước khi chạy để biết cách tự hoàn tác chính nó.
# kiến trúc bộ động cơ hoàn tác: dual-stack undo/redo engine
Phần mềm nghiệp vụ kiểu chỉnh bảng tính tài chính hay bản vẽ kỹ thuật thì gần như bắt buộc phải có Undo/Redo. Cách phổ biến là kết hợp Command Pattern với Memento Pattern, dùng hai stack: Undo Stack và Redo Stack:
# cài đặt undo/redo engine an toàn đa luồng
public interface TransactionCommand {
void execute();
void undo();
String getDescription();
}
public class UndoRedoManager {
private final int maxHistorySize;
private final Deque<TransactionCommand> undoStack = new ArrayDeque<>();
private final Deque<TransactionCommand> redoStack = new ArrayDeque<>();
public UndoRedoManager(int maxHistorySize) {
this.maxHistorySize = maxHistorySize;
}
public synchronized void executeCommand(TransactionCommand command) {
command.execute();
// Giới hạn dung lượng stack để tránh OOM Memory Leak
if (undoStack.size() >= maxHistorySize) {
undoStack.removeLast(); // Vứt bỏ lịch sử cũ nhất
}
undoStack.push(command);
redoStack.clear(); // Bắt buộc xóa Redo stack khi người dùng phát sinh hành động mới
}
public synchronized boolean undo() {
if (undoStack.isEmpty()) {
return false;
}
// peek trước, chỉ pop khi undo() chạy xong không lỗi,
// để command không bị "rơi mất" khỏi cả hai stack nếu undo() ném exception
TransactionCommand command = undoStack.peek();
command.undo();
undoStack.pop();
redoStack.push(command);
return true;
}
public synchronized boolean redo() {
if (redoStack.isEmpty()) {
return false;
}
TransactionCommand command = redoStack.peek();
command.execute();
redoStack.pop();
undoStack.push(command);
return true;
}
}Chữ "an toàn đa luồng" ở đây chỉ có nghĩa là các thao tác trên hai stack không giẫm lên nhau, nhờ synchronized. Nó hợp với một phiên làm việc của một người dùng (một tài liệu đang mở). Nếu undo() hay execute() ném exception thì command vẫn nằm nguyên ở stack cũ, người dùng thử lại được, thay vì bị mất khỏi lịch sử như khi pop() trước rồi mới chạy.
# tiến hóa lên kiến trúc CQRS (Command query responsibility segregation)
Trong hệ thống phân tán quy mô lớn (High-Load Architecture), ý tưởng "hành động là một object" phát triển thành hẳn một phong cách kiến trúc: CQRS. Nói cho đúng gốc gác thì CQRS do Greg Young đặt tên, phát triển từ nguyên tắc CQS (Command-Query Separation) của Bertrand Meyer, chứ không phải từ GoF. Command trong CQRS cũng khác GoF một chút: nó thường chỉ là dữ liệu (một record CreateOrderCommand), còn logic nằm ở CommandHandler riêng, thay vì command tự có execute().
# nguyên tắc của CQRS
- Commands: thể hiện ý định thay đổi trạng thái (Create, Update, Delete). Đặt tên theo động từ mệnh lệnh (
CreateOrderCommand,CancelSubscriptionCommand). Không trả về dữ liệu nghiệp vụ, chỉ trả về trạng thái (Success / Failure / TransactionId). - Queries: tra cứu dữ liệu (
GetOrderByIdQuery). Không được làm thay đổi trạng thái (Side-Effect Free).
Đánh đổi lớn nhất khi tách hẳn Write DB và Read DB như sơ đồ trên là độ trễ đồng bộ (Eventual Consistency). Giữa lúc CommandHandler ghi xong vào Master DB và lúc Event Projector cập nhật xong bên Elasticsearch có thể lệch từ vài chục mili-giây tới vài giây (lúc projector bị dồn việc); nếu client vừa gửi CreateOrderCommand xong đã gọi ngay FindOrderQuery thì rất dễ gặp cảnh chưa thấy đơn hàng đâu. Thực tế, nếu chưa cần scale đọc/ghi độc lập thì bạn vẫn tách tầng Command và Query trong code được mà dùng chung một database để tránh độ phức tạp này.
# Saga pattern: compensating transactions (giao dịch bù trừ)
Khi một nghiệp vụ không còn nằm gọn trong một database mà trải qua nhiều microservice, bài toán "undo" ở đầu bài bước sang một cấp độ khó hơn hẳn. Trong Microservices, mỗi service giữ database riêng, nên thường không dùng được (hoặc không nên dùng) Distributed Two-Phase Commit để rollback khi một bước bị lỗi: 2PC khoá tài nguyên suốt lúc chờ coordinator, coordinator chết là cả hệ thống treo, và nhiều message broker hay NoSQL không hỗ trợ XA. Saga (khái niệm từ paper của Garcia-Molina và Salem năm 1987) xử lý bằng Giao dịch bù trừ (Compensating Transaction), và mỗi bước lẫn mỗi bước bù đều là một command:
# compensating Command là gì
Khác với ROLLBACK vật lý trong database, Compensating Command là một command nghiệp vụ hoàn toàn mới, có nhiệm vụ đảo ngược tác động logic của lệnh đi trước. Chẳng hạn lệnh xuôi là ChargeCreditCardCommand($100) thì lệnh bù trừ tương ứng là RefundCreditCardCommand($100).
Điểm cần nhớ là bù trừ không xoá được dấu vết lịch sử: khách hàng vẫn thấy một dòng trừ tiền rồi một dòng hoàn tiền trên sao kê. Vì vậy khi thiết kế Saga thực tế, người ta hay xếp các bước khó bù hoặc để lại tác động bên ngoài (trừ tiền, gửi email) về sau các bước dễ bù hoặc dễ thất bại. Ví dụ ở sơ đồ trên, nếu đổi thứ tự sang giữ hàng trong kho (ReserveStockCommand) trước rồi mới trừ tiền (ProcessPaymentCommand), ca hết hàng sẽ dừng ngay từ bước kho mà không phải chạy hoàn tiền.
# cài đặt: ledger balance Command có khả năng hoàn tác
Ví dụ trong hệ thống Core Banking: lệnh chuyển tiền có thể hoàn tác. Chỗ này khác hẳn trình soạn thảo ở trên. Tài khoản là dữ liệu dùng chung, giữa lúc chuyển và lúc hoàn tác có thể đã có giao dịch khác cộng trừ vào. Nếu undo bằng cách ghi đè lại số dư cũ (Memento) thì mọi giao dịch xen giữa sẽ bị xoá sạch. Nên undo ở đây là một bút toán ngược (chuyển lại đúng amount), đúng tinh thần compensating command:
public class TransferMoneyCommand implements TransactionCommand {
private final AccountRepository accountRepo;
private final TransactionTemplate txTemplate;
private final String sourceAccId;
private final String targetAccId;
private final BigDecimal amount;
private boolean executed = false;
public TransferMoneyCommand(
AccountRepository accountRepo,
TransactionTemplate txTemplate,
String sourceAccId,
String targetAccId,
BigDecimal amount) {
this.accountRepo = accountRepo;
this.txTemplate = txTemplate;
this.sourceAccId = sourceAccId;
this.targetAccId = targetAccId;
this.amount = amount;
}
@Override
public void execute() {
// Command được tạo bằng new, không phải Spring bean, nên @Transactional
// đặt trên method này sẽ không có tác dụng. Dùng TransactionTemplate.
txTemplate.executeWithoutResult(status -> {
move(sourceAccId, targetAccId, amount);
this.executed = true;
});
}
@Override
public void undo() {
if (!executed) return;
// Bút toán ngược: chuyển lại đúng số tiền, không ghi đè số dư cũ
txTemplate.executeWithoutResult(status -> {
move(targetAccId, sourceAccId, amount);
this.executed = false;
});
}
private void move(String fromId, String toId, BigDecimal value) {
var from = accountRepo.findById(fromId).orElseThrow();
var to = accountRepo.findById(toId).orElseThrow();
if (from.getBalance().compareTo(value) < 0) {
throw new InsufficientBalanceException("Số dư không đủ");
}
from.setBalance(from.getBalance().subtract(value));
to.setBalance(to.getBalance().add(value));
accountRepo.save(from);
accountRepo.save(to);
}
@Override
public String getDescription() {
return "Chuyển tiền: " + amount + " từ " + sourceAccId + " sang " + targetAccId;
}
}Hai chỗ cần để ý. Thứ nhất, @Transactional của Spring chỉ chạy khi method được gọi qua proxy của một bean; command tự new ra thì annotation đó bị bỏ qua âm thầm, nên ở đây truyền TransactionTemplate vào. Thứ hai, findById rồi save như trên vẫn dính lost update nếu hai giao dịch cùng chạm một tài khoản: production cần khoá dòng (@Lock(PESSIMISTIC_WRITE) trên query của repository) hoặc optimistic lock bằng cột @Version. Undo cũng có thể thất bại thật (người nhận đã tiêu hết tiền), và đó là chuyện nghiệp vụ phải quyết, không phải chuyện kỹ thuật.
# bảng kiểm tra sẵn sàng vận hành (architect's checklist)
- 1. Giới hạn kích thước Undo Stack: cấu hình dung lượng tối đa cho
undoStack(ví dụ: 50 phần tử) để tránh rò rỉ Heap khi giữ hàng ngàn command quá lâu. - 2. Command bất biến (Immutability): tham số đầu vào của Command nên bất biến (dùng Java Record) để không bị can thiệp giữa lúc tạo và lúc thực thi.
- 3. Compensating Command phải Idempotent: chạy 1 lần hay nhiều lần đều an toàn, phòng khi bị retry do mạng.
- 4. Serialization Support: nếu Command được lưu vào Queue hoặc Database, class phải chuyển đổi JSON hai chiều được qua Jackson. Muốn vậy thì tách phần dữ liệu (record chỉ gồm id tài khoản, số tiền) khỏi phần xử lý (handler giữ repository); command như
TransferMoneyCommandở trên giữ cảAccountRepositorynên không serialize được. - 5. Audit Logging: mọi Command làm thay đổi trạng thái nhạy cảm phải được ghi vào bảng Audit Trail kèm người dùng và thời gian.
# lời kết
Muốn thử ngay thì chọn một chỗ trong code đang gọi thẳng service để làm một việc có thể cần chạy lại hoặc hoàn tác (gửi lệnh thanh toán, đổi trạng thái đơn hàng). Tách tham số của lời gọi đó thành một record rồi thử serialize ra JSON. Ra gọn thì bạn đã có thứ để xếp hàng, retry và ghi audit. Chưa ra được thì nhìn lại mục 4 của checklist ở trên: nhiều khả năng command đang ôm luôn cả repository.
CQRS và Saga mỗi thứ có một bài riêng, đọc tiếp ở CQRS và Saga pattern.
Chỉ là những ghi chép cá nhân với hy vọng mang lại chút giá trị. Nếu thấy hữu ích, đừng ngại chia sẻ cho bạn bè & đồng nghiệp nhé!
Happy coding 😎 👍🏻 🚀 🔥.
On this page
- # bản chất kiến trúc: biến động từ thành danh từ (objectifying actions)
- # command tách rời được những gì
- # kiến trúc bộ động cơ hoàn tác: dual-stack undo/redo engine
- # cài đặt undo/redo engine an toàn đa luồng
- # tiến hóa lên kiến trúc CQRS (Command query responsibility segregation)
- # nguyên tắc của CQRS
- # Saga pattern: compensating transactions (giao dịch bù trừ)
- # compensating Command là gì
- # cài đặt: ledger balance Command có khả năng hoàn tác
- # bảng kiểm tra sẵn sàng vận hành (architect's checklist)
- # lời kết