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.
Historybiết quá rõ cấu trúc củaEditor. Thêm một field, đổitagstừ 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)
Vài điểm đáng để ý trong output:
- Caretaker không thấy gì cả. Dòng
Caretaker thaychỉ in ra hai cái nhãn.Historybiết có hai mốc và biết mốc nào mới hơn, nhưng không biết trong đó cócontenthaycursor. 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ả
cursorvề 30 và nhãndraft. Undo lần hai về mốc A, lúc đótagscòn rỗng. - Bản sao sâu là thứ giữ cho ảnh chụp đứng yên.
tagslà list, nếu chỉ lưu tham chiếu thì lệnheditor.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.
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.
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 sp1rồiROLLBACK TO sp1chí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ó
friendnhư 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
- Chỉ cần quay lui một bước, trạng thái vài field. Giữ một biến
previouslà 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àpicklelà 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:
copyvàpickle(mục__getstate__/__setstate__và phần cảnh báo an toàn).
- Kai