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

Memento Pattern: chụp lại trạng thái để quay lui mà không phá vỡ đóng gói

TL;DR: Memento (nhóm Behavioral) cho phép bạn lưu lại một ảnh chụp (snapshot) trạng thái nội bộ của một đối tượng ra bên ngoài, để sau này khôi phục lại đúng mốc đó, mà không phá vỡ đóng gói (encapsulation). Bên ngoài chỉ cầm cái ảnh chụp như cầm một chiếc hộp kín: giữ được, xếp thành lịch sử, trả lại được, nhưng không đọc hay sửa ruột bên trong. Ba vai: Originator (đối tượng có trạng thái), Memento (ảnh chụp), Caretaker (người giữ lịch sử).

Bạn cần nút Undo. Phản xạ đầu tiên là mở toang đối tượng ra: thêm getter cho từng thuộc tính, cho một class "history" bên ngoài đọc hết rồi tự nhớ, lúc cần thì set ngược lại. Chạy thì chạy, nhưng bạn vừa biến mọi chi tiết nội bộ thành API công khai. Thêm một field là phải sửa cả chỗ lưu lẫn chỗ khôi phục; đổi cách biểu diễn dữ liệu bên trong là vỡ chỗ khác. Bài này nói về Memento pattern: cách lưu và khôi phục trạng thái mà vẫn giữ kín ruột đối tượng.

Memento là gì

Memento là một mẫu thuộc nhóm Behavioral (hành vi). Ý định của nó, theo đúng chữ của GoF: ghi lại trạng thái nội bộ của một đối tượng ra bên ngoài mà không vi phạm đóng gói, để sau này có thể phục hồi đối tượng về đúng trạng thái đó.

Ba vai diễn:

  • Originator (đối tượng gốc): thứ có trạng thái cần lưu. Chỉ nó biết cần chụp những gì, và chỉ nó biết cách đọc lại ảnh chụp để tự phục hồi.
  • Memento (ảnh chụp): một đối tượng bọc kín bản sao trạng thái tại một thời điểm. Với thế giới bên ngoài, nó gần như rỗng: may lắm có một cái nhãn hay mốc thời gian.
  • Caretaker (người giữ): giữ danh sách các memento, biết thứ tự, biết cái nào cũ cái nào mới, nhưng không mở memento ra xem. Khi cần undo, nó lấy memento ra và đưa lại cho Originator.

Hình dung chuyện lưu game. Bạn bấm Save, máy tạo một file save. Bạn không biết trong file có gì: toạ độ nhân vật, máu, đồ trong túi, cờ nhiệm vụ, tất cả là chuyện của game. Bạn chỉ làm được đúng hai việc: giữ file đó, và đưa nó lại cho game khi muốn quay về. Bạn là Caretaker, game là Originator, file save là Memento. Bản nháp tự lưu trong Google Docs cũng vậy: lịch sử phiên bản cho bạn nhảy về mốc 10 phút trước, còn cấu trúc dữ liệu thật của tài liệu thì bạn không cần biết, cũng không sờ vào được.

Vấn đề: muốn quay lui mà không phơi ruột đối tượng

Giả sử có một editor giữ nội dung, vị trí con trỏ và vài nhãn. Cách làm phản xạ là để bên ngoài tự lo việc lưu:

class Editor:
    def __init__(self):
        self.content = ""       # tat ca thanh public de ben ngoai doc duoc
        self.cursor = 0
        self.tags = []

class History:
    def backup(self, ed):
        # History phai biet Editor co dung 3 field nao, va biet ca kieu du lieu
        self.saved = (ed.content, ed.cursor, list(ed.tags))

    def undo(self, ed):
        ed.content, ed.cursor, ed.tags = self.saved

Ba vấn đề lộ ra ngay:

  • Đóng gói bị phá. Mọi thuộc tính nội bộ phải thành public chỉ vì nhu cầu sao lưu. Ai cũng sửa được cursor, kể cả code chẳng liên quan.
  • Hai chỗ phải đi cùng nhau. History biết quá rõ cấu trúc của Editor. Thêm một field, đổi tags từ list sang set, là phải sửa cả History. Đây đúng là kiểu phụ thuộc chặt mà program to interface muốn tránh.
  • Dễ sai âm thầm. Quên list(ed.tags) là bạn lưu tham chiếu chứ không lưu bản sao; đối tượng đổi thì "ảnh chụp" đổi theo, undo xong vẫn thấy dữ liệu mới.

Memento đảo lại trách nhiệm: chính Originator tự chụp và tự phục hồi, bên ngoài chỉ cầm hộ cái ảnh chụp.

Cách hoạt động

Originator có hai method: một cái trả về memento, một cái nhận memento vào để tự khôi phục. Memento giữ bản sao sâu (deep copy) của trạng thái và không mở ra cho ai. Caretaker xếp các memento thành một ngăn xếp lịch sử.

import copy

class Memento:                                  # Memento: anh chup, ben ngoai khong doc duoc
    __slots__ = ("_state", "label")
    def __init__(self, state, label):
        self._state = copy.deepcopy(state)      # chup tach roi khoi ban goc
        self.label = label                      # nhan cong khai, khong phai ruot
    def __repr__(self):
        return "<Memento " + self.label + ">"

class Editor:                                   # Originator: doi tuong co state
    def __init__(self):
        self._content = ""
        self._cursor = 0
        self._tags = []

    def type(self, text):
        self._content += text
        self._cursor = len(self._content)

    def tag(self, name):
        self._tags.append(name)

    def save(self, label):                      # chi Originator biet chup gi
        return Memento({"content": self._content,
                        "cursor": self._cursor,
                        "tags": self._tags}, label)

    def restore(self, m):                       # chi Originator moi mo memento ra
        s = copy.deepcopy(m._state)
        self._content, self._cursor, self._tags = s["content"], s["cursor"], s["tags"]

    def __str__(self):
        return "content=%r cursor=%d tags=%s" % (self._content, self._cursor, self._tags)

class History:                                  # Caretaker: giu lich su, khong mo memento
    def __init__(self, editor):
        self._editor = editor
        self._stack = []
    def backup(self, label):
        self._stack.append(self._editor.save(label))
    def undo(self):
        if not self._stack:
            return None
        m = self._stack.pop()
        self._editor.restore(m)                 # tra memento ve cho Originator
        return m.label

editor = Editor()
history = History(editor)

editor.type("Chuong 1: mo dau.")
history.backup("moc A")

editor.type(" Cau thu hai.")
editor.tag("draft")
history.backup("moc B")

editor.type(" Cau thu ba viet hong.")
print("Truoc restore :", editor)
print("Caretaker thay:", history._stack)

print("Undo ve       :", history.undo())
print("Sau restore   :", editor)
print("Undo ve       :", history.undo())
print("Sau restore   :", editor)
Truoc restore : content='Chuong 1: mo dau. Cau thu hai. Cau thu ba viet hong.' cursor=52 tags=['draft'] Caretaker thay: [<Memento moc A>, <Memento moc B>] Undo ve : moc B Sau restore : content='Chuong 1: mo dau. Cau thu hai.' cursor=30 tags=['draft'] Undo ve : moc A Sau restore : content='Chuong 1: mo dau.' cursor=17 tags=[]

Vài điểm đáng để ý trong output:

  • Caretaker không thấy gì cả. Dòng Caretaker thay chỉ in ra hai cái nhãn. History biết có hai mốc và biết mốc nào mới hơn, nhưng không biết trong đó có content hay cursor. Nó chỉ xếp hàng và trả lại đúng cái cần.
  • Khôi phục là quay về nguyên một mốc. Undo lần một không "xoá câu thứ ba"; nó dựng lại toàn bộ trạng thái của mốc B, kể cả cursor về 30 và nhãn draft. Undo lần hai về mốc A, lúc đó tags còn rỗng.
  • Bản sao sâu là thứ giữ cho ảnh chụp đứng yên. tags là list, nếu chỉ lưu tham chiếu thì lệnh editor.tag("draft") sau đó sẽ làm bẩn luôn ảnh chụp của mốc A. Nhờ copy.deepcopy ở cả lúc chụp lẫn lúc phục hồi, mốc A vẫn sạch.

Để ý cách đóng gói được giữ: trạng thái của Editor vẫn là private, không có getter nào cho _content. Thứ duy nhất đi ra ngoài là một Memento đục, và nó chỉ có ý nghĩa khi được đưa ngược lại cho Editor.

Python có sẵn vài công cụ, nhưng đừng nhầm công cụ với pattern. copy.deepcopy sao chép sâu một cấu trúc; __getstate__ và __setstate__ cho bạn tự định nghĩa "chụp cái gì" và "dựng lại thế nào" (bỏ qua cache, bỏ qua socket, bỏ qua field nặng); pickle biến trạng thái thành bytes để ghi ra đĩa hay gửi đi. Cả ba đều là phương tiện. Memento là ý định: lưu lại để khôi phục, mà không để lộ ruột đối tượng cho người giữ. Bạn hoàn toàn có thể cài Memento bằng một dict tự viết; ngược lại, rải pickle khắp nơi cũng không làm code của bạn thành Memento. Riêng pickle, nhớ là nó không an toàn với dữ liệu từ nguồn không tin cậy: mở một file pickle lạ tương đương chạy code lạ.

Memento và Command: trạng thái hay thao tác

Hai mẫu này hay bị gộp làm một vì cùng xuất hiện ở chữ "undo", nhưng chúng lưu hai thứ khác hẳn nhau.

Memento vs Command-undo. Memento lưu TRẠNG THÁI: undo nghĩa là quay về đúng ảnh chụp cũ, bất kể trong lúc đó đã làm những gì. Command lưu THAO TÁC: mỗi lệnh biết cách tự làm ngược lại chính nó, undo nghĩa là gọi undo() của lệnh cuối cùng để gỡ đúng phần nó đã gây ra.

Ưu nhược đi kèm: snapshot tốn bộ nhớ khi trạng thái lớn hoặc lịch sử dài, nhưng khôi phục chắc chắn, không phải nghĩ thêm, sai cũng khó sai. Thao tác ngược rất tiết kiệm (chỉ lưu một lệnh nhỏ với vài tham số), nhưng khó viết đúng: phải nghĩ ra phép nghịch đảo cho từng lệnh, mà nhiều thao tác không có nghịch đảo sạch (xoá một đoạn có định dạng, chuẩn hoá dữ liệu, tác dụng phụ ra bên ngoài).

Trong thực tế, các hệ thống undo nghiêm túc thường dùng cả hai. Editor lưu chuỗi command cho từng thao tác nhỏ để undo nhanh và nhẹ, đồng thời chụp snapshot định kỳ (cứ vài chục thao tác một cái) làm mốc neo. Khi cần nhảy lùi xa, hệ thống về snapshot gần nhất trước điểm đó rồi phát lại (replay) các command còn lại, thay vì gỡ ngược hàng nghìn bước. Cùng ý tưởng đó, event sourcing lưu chuỗi sự kiện và chèn snapshot để không phải dựng lại trạng thái từ sự kiện đầu tiên mỗi lần.

Chọn thế nào cho đơn giản: nếu trạng thái nhỏ và gọn, cứ chụp cả cụm, đỡ đau đầu. Nếu trạng thái to mà mỗi thao tác chỉ đụng một mẩu, và phép nghịch đảo dễ viết, dùng command. Ranh giới nằm ở chỗ chi phí bộ nhớ so với chi phí viết đúng phép nghịch đảo.

Trong hệ thống thật

Memento không chỉ sống trong editor, nó nằm rải khắp những chỗ cần chữ "quay lại":

  • Undo/redo trong editor và công cụ đồ hoạ. Mỗi mốc là một snapshot của tài liệu hoặc của một vùng chọn. Redo chỉ là giữ thêm một ngăn xếp thứ hai: pop từ stack undo thì push sang stack redo.
  • Checkpoint trong job chạy dài. Một job ETL chạy 6 tiếng mà chết ở phút thứ 300 thì không ai muốn chạy lại từ đầu. Job định kỳ ghi checkpoint (đã xử lý tới offset nào, biến tích luỹ đang là bao nhiêu) xuống đĩa hay object storage; lần chạy sau nạp checkpoint gần nhất rồi đi tiếp. Các engine xử lý luồng như Spark Structured Streaming hay Flink đều xây quanh ý này.
  • Transaction rollback và savepoint trong database. SAVEPOINT sp1 rồi ROLLBACK TO sp1 chính là đặt mốc và quay về mốc. Ứng dụng đặt tên mốc và ra lệnh quay về, nhưng không hề biết database lưu mốc đó bằng cấu trúc gì bên trong. Đóng gói nguyên vẹn, đúng tinh thần Memento.
  • Wizard nhiều bước. Form đăng ký 5 bước, người dùng bấm Back ở bước 4. Mỗi bước hoàn tất thì chụp lại trạng thái form, Back là restore mốc trước, không phải gỡ ngược từng field một.
  • Versioning bản nháp nội dung. CMS, Google Docs, Notion: mỗi lần lưu là một phiên bản, danh sách phiên bản là caretaker, và bạn khôi phục cả bản chứ không sửa ngược từng ký tự.
  • Snapshot của máy trạng thái. Một State machine phức tạp (quy trình duyệt đơn, luồng thanh toán) hay được chụp lại trước khi thử một nhánh xử lý, để nếu nhánh đó hỏng thì trả về mốc trước một cách chắc chắn. Tương tự là snapshot của VM hay container trước khi nâng cấp.

Cũng nên nhớ một họ hàng gần: Prototype cũng sao chép đối tượng, nhưng để tạo ra một đối tượng mới dùng song song với bản gốc. Memento sao chép để cất đi và sau này trả lại cho chính đối tượng cũ. Cùng kỹ thuật copy, khác mục đích.

Trade-off

Được:

  • Khôi phục đáng tin. Quay về một ảnh chụp trọn vẹn thì không có chuyện gỡ ngược sót một bước rồi để lại trạng thái nửa vời.
  • Giữ được đóng gói. Không phải mở getter/setter cho từng field chỉ vì nhu cầu lưu trữ. Đổi cấu trúc nội bộ của Originator không làm vỡ Caretaker.
  • Lịch sử rõ ràng. Một danh sách các mốc có thứ tự, có nhãn: dễ hiển thị cho người dùng, dễ giới hạn số lượng, dễ xoá bớt.
  • Trách nhiệm tách bạch. Originator lo nội dung ảnh chụp, Caretaker lo vòng đời của lịch sử. Hai phần thay đổi độc lập.

Phải trả giá:

  • Tốn bộ nhớ hoặc đĩa. Trạng thái lớn nhân với lịch sử dài là một con số đáng sợ. Gần như luôn phải đặt trần: giữ N mốc gần nhất, hoặc chỉ snapshot sau mỗi K thao tác.
  • Phải quyết shallow hay deep copy. Sao chép nông thì nhanh nhưng ảnh chụp có thể bị đối tượng gốc làm bẩn qua tham chiếu chung; sao chép sâu thì an toàn nhưng chậm và ngốn bộ nhớ. Không có lựa chọn đúng cho mọi trường hợp, phải nhìn vào dữ liệu cụ thể.
  • Chi phí serialize. Muốn snapshot sống qua lần chạy sau thì phải ghi ra đĩa, kéo theo chi phí mã hoá, giải mã, và bài toán tương thích phiên bản: snapshot ghi bằng code cũ có đọc được bằng code mới không.
  • Dữ liệu nhạy cảm nằm lại trong snapshot. Ảnh chụp có thể chứa token, mật khẩu đang nhập dở, thông tin cá nhân. Chúng sống lâu hơn bản thân trạng thái gốc, có khi còn nằm trong log hay file tạm. Hãy loại trừ field nhạy cảm ngay lúc chụp (đây là chỗ __getstate__ có ích) và đặt thời hạn xoá.
  • Vẫn rò rỉ đóng gói nếu làm ẩu. Nếu Memento có đủ getter public thì bạn chỉ đổi tên chứ không giải quyết gì. Python không có friend như C++, nên ranh giới này dựa vào quy ước: đặt tên có gạch dưới, dùng __slots__, và giữ kỷ luật là chỉ Originator mới đụng vào ruột memento.

Khi nào không nên dùng

Đừng chụp khi trạng thái quá lớn hoặc thay đổi quá dày. Một đối tượng nắm vài trăm MB dữ liệu, thay đổi vài chục lần mỗi giây, mà cứ mỗi lần lại deepcopy thì bạn không làm undo, bạn đang làm một cái máy ngốn RAM. Trường hợp đó hãy nghĩ tới command với phép nghịch đảo, tới cấu trúc dữ liệu bất biến chia sẻ phần chung (persistent data structure), hoặc snapshot thưa kết hợp replay.
  • Chỉ cần quay lui một bước, trạng thái vài field. Giữ một biến previous là xong, không cần dựng ba class.
  • Trạng thái đã bất biến sẵn. Nếu mỗi thay đổi tạo ra một object mới và object cũ không bao giờ bị sửa, thì giữ tham chiếu tới object cũ chính là snapshot rồi, khỏi cần chụp lại.
  • Thao tác có tác dụng phụ ra bên ngoài. Khôi phục trạng thái trong bộ nhớ không rút lại được email đã gửi, tiền đã trừ hay file đã xoá. Memento chỉ quản được phần state nó chụp; phần ngoài phải có cơ chế bù trừ (compensating action) riêng.
  • Đã có sẵn cơ chế của tầng dưới. Nếu database đã cho bạn transaction và savepoint, đừng tự dựng một lớp snapshot song song ở tầng ứng dụng rồi phải tự lo chuyện đồng bộ giữa hai cái.

Tóm tắt

  • Memento lưu ảnh chụp trạng thái nội bộ của một đối tượng ra bên ngoài để sau này khôi phục, mà không phá vỡ đóng gói.
  • Ba vai: Originator tự chụp và tự phục hồi, Memento là hộp kín chứa bản sao, Caretaker giữ lịch sử nhưng không mở hộp ra xem.
  • Trong Python, copy.deepcopy, __getstate__/__setstate__ và pickle là phương tiện; pattern nằm ở ý định lưu và khôi phục mà không lộ ruột.
  • Memento lưu trạng thái, Command lưu thao tác. Snapshot tốn bộ nhớ nhưng khôi phục chắc; thao tác ngược tiết kiệm nhưng khó viết đúng. Hệ thống undo thật thường kết hợp cả hai.
  • Giá phải trả là bộ nhớ, lựa chọn shallow hay deep copy, chi phí serialize và rủi ro dữ liệu nhạy cảm nằm lại trong ảnh chụp. Luôn đặt trần cho lịch sử.
  • Trạng thái quá lớn, thay đổi quá dày, hoặc đã có transaction ở tầng dưới thì đừng dựng Memento cho có.

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 Memento, nhóm Behavioral.
  • Tài liệu Python: copy và pickle (mục __getstate__/__setstate__ và phần cảnh báo an toàn).
Series Design Patterns - nhóm Behavioral. Đọc kèm: Command (undo bằng thao tác ngược), Prototype (cùng kỹ thuật copy, khác mục đích) và State (thứ hay được chụp snapshot). 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