👋 Chào mừng đến với Nocoem — kiến thức Backend, System Design và lập trình. Khám phá ngay

Command Pattern: đóng gói yêu cầu thành đối tượng để undo, queue và log

TL;DR: Command gói một yêu cầu (thao tác cần làm) thành một đối tượng riêng, có method execute(). Nhờ vậy người phát lệnh (invoker) không cần biết ai thực thi (receiver) hay thực thi bằng cách nào. Vì yêu cầu giờ là một thứ cầm nắm được, Command đặc biệt hữu ích cho undo/redo, hàng đợi (queue) và ghi log. Nếu chỉ gọi một hành động đơn giản và không cần những thứ đó, Command là thừa.

Bạn bấm Ctrl+Z và dòng chữ vừa gõ biến mất. Bấm tiếp, dòng trước đó cũng lùi lại. Cái cơ chế "quay ngược thời gian" đó không tự nhiên mà có: chương trình phải nhớ được từng thao tác đã làm và cách đảo ngược nó. Command là mẫu thiết kế sinh ra đúng để làm việc này, và bài này tôi sẽ dựng lại một trình soạn thảo mini có undo bằng nó.

Command là gì?

Command (mẫu Command, nhóm hành vi - Behavioral) biến một yêu cầu thành một đối tượng độc lập. Thay vì gọi thẳng doc.addText("abc"), bạn tạo một đối tượng AddText nắm sẵn mọi thứ cần cho thao tác đó, và đối tượng này có một method chung là execute(). Ai cầm nó cũng chỉ cần gọi execute() mà không phải biết bên trong làm gì.

Có ba vai trò cần phân biệt:

  • Command: đối tượng gói yêu cầu, có execute() (và undo() nếu cần hoàn tác).
  • Receiver (người thực thi): nơi chứa logic và dữ liệu thật, là kẻ thực sự làm việc khi command chạy.
  • Invoker (người phát lệnh): kẻ giữ và kích hoạt command, nhưng không biết gì về receiver.

Hình dung việc gọi món ở nhà hàng. Bạn nói món ăn, bồi bàn ghi vào một phiếu gọi món rồi đưa xuống bếp. Cái phiếu đó chính là command: nó đóng gói đầy đủ "làm món gì, mấy phần". Bồi bàn là invoker, chỉ cầm phiếu chuyển đi chứ không nấu. Bếp là receiver, đọc phiếu và nấu thật. Nhờ tấm phiếu, bồi bàn và bếp tách rời nhau: bồi bàn không cần biết nấu, bếp không cần biết ai gọi. Phiếu còn xếp được thành hàng chờ, ghi lại được để đối chiếu - y hệt queue và log trong phần mềm.

Vấn đề khi không có Command

Giả sử làm trình soạn thảo. Cách trực tiếp nhất là cho phần giao diện gọi thẳng vào tài liệu:

def on_key(doc, ch):        # nút bấm gọi thang vao document
    doc.text += ch          # invoker DINH CHAT voi receiver

def on_delete(doc, n):
    doc.text = doc.text[:-n]

Chạy thì được, nhưng nó khoá bạn lại ở hai điểm:

  • Invoker dính chặt receiver. Phần xử lý phím biết tường tận cấu trúc bên trong của doc (thuộc tính text, cách nối chuỗi). Muốn cùng một nút đó áp dụng cho đối tượng khác, hay đổi cách lưu trữ, là phải sửa lại chỗ gọi.
  • Không có chỗ nào để undo. Sau khi doc.text += ch chạy xong, thông tin về thao tác vừa rồi bay mất. Muốn hoàn tác, bạn phải tự chế cơ chế nhớ lại "đã làm gì, đảo ngược ra sao" cho từng loại thao tác, rải rác khắp nơi. Thêm queue hay log lại càng rối.

Gốc rễ: một thao tác ở đây chỉ là lời gọi hàm thoáng qua, không phải một thứ bạn giữ lại được. Command sửa đúng điểm này bằng cách vật thể hoá mỗi thao tác thành một đối tượng có thể cất vào danh sách, chạy lại, hay đảo ngược.

Cách hoạt động (có undo)

Ý tưởng: mỗi thao tác là một class command với hai method execute() và undo(). Một Editor đóng vai invoker, chỉ biết gọi execute() và đẩy command vào một danh sách lịch sử (history). Khi cần hoàn tác, nó lấy command gần nhất ra và gọi undo(). Mấu chốt là mỗi command tự nhớ đủ thông tin để đảo ngược chính nó.

from abc import ABC, abstractmethod

class Document:                       # receiver: noi chua du lieu that
    def __init__(self):
        self.text = ""

class Command(ABC):                   # hop dong: moi lenh deu execute + undo
    @abstractmethod
    def execute(self): ...
    @abstractmethod
    def undo(self): ...

class AddText(Command):
    def __init__(self, doc, s):
        self.doc, self.s = doc, s
    def execute(self):
        self.doc.text += self.s
    def undo(self):
        self.doc.text = self.doc.text[:-len(self.s)]

class DeleteLast(Command):            # xoa n ky tu cuoi
    def __init__(self, doc, n):
        self.doc, self.n, self.saved = doc, n, ""
    def execute(self):
        self.saved = self.doc.text[-self.n:]      # nho lai de undo
        self.doc.text = self.doc.text[:-self.n]
    def undo(self):
        self.doc.text += self.saved

class Editor:                         # invoker: chi biet execute() va giu lich su
    def __init__(self, doc):
        self.doc, self.history = doc, []
    def run(self, cmd):
        cmd.execute()
        self.history.append(cmd)
    def undo(self):
        if self.history:
            self.history.pop().undo()

doc = Document()
ed = Editor(doc)
ed.run(AddText(doc, "Xin chao"))
ed.run(AddText(doc, ", Nocoem"))
ed.run(DeleteLast(doc, 7))            # xoa " Nocoem"
print("Sau 3 lenh   :", repr(doc.text))

ed.undo()                            # hoan tac DeleteLast
print("Undo lan 1   :", repr(doc.text))
ed.undo()                            # hoan tac AddText ", Nocoem"
print("Undo lan 2   :", repr(doc.text))
ed.undo()                            # hoan tac AddText "Xin chao"
print("Undo lan 3   :", repr(doc.text))
Sau 3 lenh : 'Xin chao,' Undo lan 1 : 'Xin chao, Nocoem' Undo lan 2 : 'Xin chao' Undo lan 3 : ''

Để ý mấy điểm quan trọng. Editor (invoker) hoàn toàn không biết AddText hay DeleteLast làm gì; nó chỉ gọi execute() qua hợp đồng Command chung, đúng tinh thần "program to an interface" ở bài nền tảng. Nhờ đó thêm một loại lệnh mới (vd đổi chữ hoa) chỉ là viết thêm một class, Editor giữ nguyên.

Cái hay thứ hai là undo lần lượt. Vì mọi command đã chạy đều nằm trong history theo đúng thứ tự, hoàn tác chỉ là lấy phần tử cuối ra rồi gọi undo(). DeleteLast khôn ở chỗ nó lưu lại đoạn văn bản bị xoá vào self.saved ngay lúc execute(), nên lúc undo mới dán trả lại được.

Nói cho chính xác: có undo() mới chỉ cho bạn undo, chưa phải redo. Muốn redo, phải quản lý lịch sử tử tế hơn - cách thông dụng là hai ngăn xếp.

Thêm redo: hai ngăn xếp

Luật chơi gọn trong ba dòng:

  • Chạy một lệnh mới: đẩy command vào undo stack, và xoá sạch redo stack (nhánh lịch sử cũ không còn hợp lệ nữa).
  • Undo: lấy command trên đỉnh undo stack, gọi undo(), rồi đẩy nó sang redo stack.
  • Redo: lấy command trên đỉnh redo stack, gọi lại execute(), rồi đẩy ngược về undo stack.
class EditorWithRedo:                 # invoker: hai ngan xep undo va redo
    def __init__(self, doc):
        self.doc = doc
        self.undo_stack, self.redo_stack = [], []
    def run(self, cmd):
        cmd.execute()
        self.undo_stack.append(cmd)
        self.redo_stack.clear()       # lenh moi lam redo cu het hieu luc
    def undo(self):
        if self.undo_stack:
            cmd = self.undo_stack.pop()
            cmd.undo()
            self.redo_stack.append(cmd)
    def redo(self):
        if self.redo_stack:
            cmd = self.redo_stack.pop()
            cmd.execute()             # chay lai chinh command do
            self.undo_stack.append(cmd)

doc = Document()
ed = EditorWithRedo(doc)

def show(step):
    print("%-12s text=%-20r undo=%d redo=%d"
          % (step, doc.text, len(ed.undo_stack), len(ed.redo_stack)))

ed.run(AddText(doc, "Xin chao"));  show("run 1")
ed.run(AddText(doc, ", Nocoem"));  show("run 2")
ed.undo();                         show("undo")
ed.undo();                         show("undo")
ed.redo();                         show("redo")
ed.run(AddText(doc, "!"));         show("run 3")
ed.redo();                         show("redo")
run 1 text='Xin chao' undo=1 redo=0 run 2 text='Xin chao, Nocoem' undo=2 redo=0 undo text='Xin chao' undo=1 redo=1 undo text='' undo=0 redo=2 redo text='Xin chao' undo=1 redo=1 run 3 text='Xin chao!' undo=2 redo=0 redo text='Xin chao!' undo=2 redo=0

Dòng cuối mới là chỗ đáng chú ý: sau khi undo hai lần rồi redo một lần, tôi chạy một lệnh mới (AddText("!")). Lệnh mới đó xoá sạch redo stack, nên lần redo() sau cùng không làm gì cả - đúng như mọi trình soạn thảo bạn từng dùng. Không có bước xoá này, redo sẽ dán lại một thao tác thuộc về nhánh lịch sử đã bị bỏ, và văn bản ra kết quả vô nghĩa.

Undo không phải lúc nào cũng dễ. Hai ngăn xếp chỉ lo phần trình tự; undo có đúng hay không còn phụ thuộc mỗi lệnh có đủ thông tin để đảo ngược chính nó hay không. AddText thì dễ (biết đã thêm gì thì cắt bỏ bấy nhiêu), nhưng nhiều thao tác mất mát thông tin: định dạng lại cả tài liệu, chuẩn hoá dữ liệu, ghi đè một trường. Với những lệnh đó, cách chắc ăn là lưu snapshot trạng thái trước khi chạy rồi undo bằng cách khôi phục snapshot - đó chính là mẫu Memento, thường đi cặp với Command.
Command mở ra nhiều tính năng khác cùng một cơ chế. Vì mỗi lệnh là một đối tượng, bạn có thể xếp chúng vào một hàng đợi để chạy sau (queue), ghi từng lệnh xuống file để tua lại (log), hay gửi lệnh qua mạng cho nơi khác thực thi. Tất cả đều nhờ việc "yêu cầu" giờ đã là thứ cầm nắm được.

Khi nào dùng, khi nào không

Command hợp lý khi bạn cần một trong các thứ sau:

  • Hoàn tác/làm lại (undo/redo): đây là lý do phổ biến nhất, như trình soạn thảo, phần mềm đồ hoạ, bảng tính.
  • Xếp hàng và trì hoãn (queue): gom các thao tác lại chạy sau, chạy nền, hay chạy theo lịch (vd hàng đợi tác vụ - task queue).
  • Ghi log và tái lập: lưu chuỗi lệnh để phát lại sau sự cố, hoặc để kiểm toán.
  • Tách UI khỏi hành động: cùng một lệnh gán cho nút bấm, menu và phím tắt mà không lặp code; đây cũng là ý tưởng "nút remote gán lệnh".
Đừng lạm dụng. Nếu một thao tác chỉ là gọi hành động đơn giản, chạy một lần, không cần undo, không cần queue hay log, thì bọc nó thành class command chỉ thêm tầng gián tiếp vô ích. Gọi thẳng method là đủ. Command trả giá bằng số class tăng lên, nên chỉ dùng khi bạn thật sự cần một trong các lợi ích ở trên.

Trong hệ thống thật

Command không chỉ sống trong trình soạn thảo. Vài chỗ bạn gặp nó hàng ngày, có khi không gọi tên:

  • CQRS và command handler. Trong kiến trúc CQRS, mỗi ý định thay đổi dữ liệu là một object: CreateOrderCommand, CancelOrderCommand, RefundPaymentCommand. Chúng đi qua một bus tới đúng handler (CreateOrderHandler), tách hẳn khỏi phía đọc (query). Chính vì command là dữ liệu nên chèn validate, phân quyền, ghi log hay retry vào giữa đường mới dễ.
  • Task queue. Một Celery task về bản chất là một command được serialize để chạy sau: tên hàm cộng tham số được đóng gói, đẩy vào Redis hoặc RabbitMQ, worker ở máy khác lấy ra và execute(). Sidekiq (Ruby), BullMQ (Node), AWS SQS cộng consumer đều cùng một hình dạng.
  • Retry và replay từ log lệnh. Vì lệnh đã ghi xuống đĩa, job hỏng chạy lại được từ chính bản ghi đó. Kafka dùng làm command log rồi phát lại để dựng lại trạng thái là ứng dụng quen thuộc; write-ahead log của Postgres cũng là ý này ở tầng thấp hơn.
  • Audit log. Ghi lại "ai đã làm gì, lúc nào" dưới dạng command ({actor, command, payload, ts}) cho bạn một sổ cái tra cứu được, thay vì phải suy ngược từ trạng thái cuối cùng. Ngành tài chính và y tế gần như bắt buộc có thứ này.
  • Undo trong trình soạn thảo. Google Docs, Figma, Photoshop, VS Code - mọi thao tác đều là một object đảo ngược được (thường kèm Memento cho các lệnh mất mát thông tin).
  • Batch và transaction script. Gom nhiều command thành một lệnh tổng (Composite) rồi chạy cả cụm; hỏng giữa chừng thì undo ngược lại từng cái - đúng kiểu compensating transaction trong Saga.

Trade-off

Được:

  • Biến thao tác thành dữ liệu, nên xếp hàng, ghi log, gửi qua mạng và phát lại được.
  • Tách invoker khỏi receiver: nút bấm, menu, phím tắt, API endpoint cùng dùng một lệnh mà không biết ai thực thi.
  • Dễ test: mỗi lệnh là một đơn vị nhỏ, tự chứa, test riêng không cần dựng cả UI.
  • Mở đường cho undo/redo và audit log mà không phải sửa lại chỗ gọi.
  • Thêm lệnh mới chỉ là thêm class, invoker giữ nguyên (đúng nguyên tắc Open/Closed).

Phải trả giá:

  • Bùng nổ số class: mỗi thao tác tí xíu cũng thành một class command, đọc code phải nhảy qua nhiều file.
  • Ngữ nghĩa undo phức tạp: không phải thao tác nào cũng đảo ngược được (gửi email, tính lại toàn bộ bảng), nhiều khi phải lưu snapshot hoặc chấp nhận lệnh một chiều.
  • Phải quản lý vòng đời và kích thước lịch sử: giữ bao nhiêu lệnh, ai dọn, một history ôm snapshot lớn sẽ ăn hết bộ nhớ.
  • Thêm một tầng gián tiếp: khi thực ra chỉ cần gọi thẳng một hàm, lớp command chỉ làm chậm việc đọc hiểu.
  • Lệnh serialize để chạy sau sẽ gặp bài toán phiên bản: lệnh cũ nằm trong queue phải chạy được với code mới.

Tóm tắt

  • Command đóng gói một yêu cầu thành đối tượng có execute(), tách invoker (người phát lệnh) khỏi receiver (người thực thi).
  • Thêm undo() và một lịch sử thì có undo; muốn cả redo phải dùng hai ngăn xếp (undo stack và redo stack), và xoá sạch redo stack mỗi khi chạy lệnh mới.
  • Undo chỉ đúng khi lệnh đủ thông tin để đảo ngược chính nó; nếu không, lưu snapshot trạng thái - đó là mẫu Memento.
  • Vì yêu cầu giờ là đối tượng cầm nắm được, bạn còn queue, log và gửi lệnh đi xa được, tất cả cùng một cơ chế.
  • Không cần undo/queue/log thì đừng dùng Command; gọi thẳng method cho gọn.

Nguồn tham khảo

  • Gamma, Helm, Johnson, Vlissides (Gang of Four), Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994 - chương trình bày Command với ý "encapsulate a request as an object", nêu rõ các ứng dụng undo, queue và logging.
Series Design Patterns - nhóm Hành vi (Behavioral). Command là một trong các mẫu hành vi, tập trung vào cách các đối tượng giao tiếp và phân chia trách nhiệm. Các mẫu hành vi khác đã có bài: Observer, Strategy và State. Nếu chưa nắm hai nguyên tắc gốc, đọc lại Program to interface & Composition over inheritance và SOLID. Xem toàn bộ lộ trình ở mục lục Design Patterns.

- Kai

Thấy bài viết hữu ích?

0 lượt thích

Đăng nhận xét