accept(visitor) gọi ngược lại visitor.visit_X(self) (kỹ thuật double dispatch), nhờ vậy bạn thêm được thao tác mới lên cả một cây object mà không phải sửa class của chúng. Đánh đổi thì ngược với OOP thường ngày: thêm thao tác mới rất dễ, nhưng thêm loại element mới thì phải sửa mọi visitor. Python có sẵn một Visitor thật trong thư viện chuẩn: ast.NodeVisitor.Bạn có một cây đối tượng khá ổn định: cây thư mục, cây biểu thức, cây cú pháp của một ngôn ngữ, hay một cấu trúc Composite bất kỳ. Rồi yêu cầu bắt đầu dồn tới: tính tổng dung lượng, xuất ra JSON, xuất ra XML, đếm số nút, kiểm tra quy tắc lint, sinh báo cáo. Mỗi yêu cầu mới lại thêm một method vào tất cả các class node. Class node phình ra, và tệ hơn, chúng bị nhét đầy những thứ chẳng liên quan gì đến bản chất của chúng. Bài này nói về Visitor: cách lôi đống thao tác đó ra ngoài mà vẫn đi được khắp cây.
Visitor pattern là gì
Visitor là mẫu hành vi cho phép bạn định nghĩa một thao tác mới trên một tập hợp đối tượng mà không thay đổi class của các đối tượng đó. Thao tác được gói thành một object riêng gọi là visitor (khách thăm); cấu trúc dữ liệu chỉ cần biết cách đón khách.
Hợp đồng gồm đúng hai nửa:
- Mỗi element (phần tử trong cấu trúc) có method
accept(visitor). - Bên trong
accept, element gọi ngược lại đúng method của visitor dành cho loại của mình:visitor.visit_num(self),visitor.visit_add(self)...
Cú gọi ngược đó chính là double dispatch (điều phối kép). Trong lời gọi node.accept(v), lần dispatch thứ nhất chọn đúng accept theo loại của node; lần dispatch thứ hai chọn đúng visit_X theo loại của visitor. Kết quả cuối cùng phụ thuộc vào cả hai loại, trong khi lời gọi method thông thường chỉ phụ thuộc vào một (loại của đối tượng nhận). Đây là cách mô phỏng thứ mà các ngôn ngữ OOP phổ biến không cho sẵn: multiple dispatch.
accept). Người đến kiểm định điện, người đến đo diện tích, người đến chụp ảnh môi giới: mỗi khách mang theo việc của riêng mình và tự làm khi đi qua từng phòng. Muốn thêm một loại công việc mới, bạn thuê thêm một người khách, không đập sửa lại toà nhà.Vấn đề: thêm một thao tác là phải sửa mọi class element
Không có Visitor, chỗ tự nhiên nhất để đặt thao tác là ngay trong class element. Với cây biểu thức nhỏ gồm số, phép cộng, phép nhân, code thường trông như sau:
class Num:
def __init__(self, value): self.value = value
def eval(self): return self.value
def to_text(self): return str(self.value)
# muon them "dem nut"? sua o day
# muon them "xuat JSON"? lai sua o day
class Add:
def __init__(self, left, right): self.left, self.right = left, right
def eval(self): return self.left.eval() + self.right.eval()
def to_text(self): return f"({self.left.to_text()} + {self.right.to_text()})"
# va sua tiep o day
class Mul:
... # va o day nua
Ba vấn đề lộ ra ngay:
- Mỗi thao tác mới đụng vào N class. Có 8 loại node thì thêm một tính năng là 8 lần sửa, 8 cơ hội quên một chỗ.
- Logic của một thao tác bị xé nhỏ. Toàn bộ luật xuất JSON nằm rải rác ở 8 file, muốn đọc lại phải ghép trong đầu.
- Class element mất tập trung. Một node cây cú pháp lẽ ra chỉ mô tả cấu trúc, giờ gánh thêm chuyện in ấn, thống kê, kiểm tra lint. Đây là vi phạm nguyên tắc Single Responsibility trong SOLID.
Visitor đảo ngược cách sắp xếp: thay vì cắt theo loại element (mỗi class giữ mọi thao tác của nó), ta cắt theo thao tác (mỗi visitor giữ cách xử lý mọi loại element).
Cách hoạt động: ast.NodeVisitor của Python
Trước khi tự viết, hãy xem một Visitor thật đang chạy trong thư viện chuẩn. Module ast phân tích mã Python thành cây cú pháp trừu tượng (Abstract Syntax Tree), và ast.NodeVisitor chính là lớp Visitor để đi trên cây đó. Bạn chỉ cần khai báo các method tên visit_<TenNode>; phần điều phối thì ast lo hết.
import ast
SRC = '''
def tinh_tong(a, b):
print("dang tinh")
return a + b
class Report:
def render(self):
return load()
def load():
return [1, 2, 3]
'''
class ThongKe(ast.NodeVisitor):
def __init__(self):
self.ham = []
self.lop = []
self.dong_print = []
def visit_FunctionDef(self, node): # tham nut dinh nghia ham
self.ham.append(node.name)
self.generic_visit(node) # nho di tiep xuong con
def visit_ClassDef(self, node): # tham nut dinh nghia class
self.lop.append(node.name)
self.generic_visit(node)
def visit_Call(self, node): # tham moi loi goi ham
if isinstance(node.func, ast.Name) and node.func.id == "print":
self.dong_print.append(node.lineno)
self.generic_visit(node)
tk = ThongKe()
tk.visit(ast.parse(SRC))
print("So ham :", len(tk.ham))
print("Ten ham :", tk.ham)
print("Ten class :", tk.lop)
print("print() o dong:", tk.dong_print)
Vài điểm đáng chú ý:
- Bạn không sửa một dòng nào trong các class node của
ast. Thao tác mới nằm trọn trong classThongKe. - Muốn thêm một kiểm tra khác (bắt
eval(), bắtexcepttrống, đếm độ sâu vòng lặp), bạn viết thêm một class visitor nữa. Cây và class node giữ nguyên. generic_visit(node)là bước đệ quy xuống các nút con. Quên gọi nó thì visitor dừng ngay tại tầng đó, một lỗi rất hay gặp.
ast.NodeVisitor không dùng accept ở phía element. Nó điều phối bằng cách tra tên class của node rồi tìm method visit_<TenNode> tương ứng, một dạng dispatch động nhờ tính linh hoạt của Python. Ý định thì vẫn đúng là Visitor, chỉ khác ở chỗ Python không cần element phải hợp tác. Nếu muốn sửa cây chứ không chỉ đọc, dùng ast.NodeTransformer, bản visitor cho phép trả về node thay thế.Tự viết Visitor: nhìn rõ accept và visit
Để thấy double dispatch bằng mắt, đây là bản viết tay trên cây biểu thức, với ba visitor khác nhau chạy trên cùng một cây:
class Node:
def accept(self, visitor): # moi element chi biet "goi nguoc" visitor
raise NotImplementedError
class Num(Node):
def __init__(self, value): self.value = value
def accept(self, visitor): return visitor.visit_num(self)
class Add(Node):
def __init__(self, left, right): self.left, self.right = left, right
def accept(self, visitor): return visitor.visit_add(self)
class Mul(Node):
def __init__(self, left, right): self.left, self.right = left, right
def accept(self, visitor): return visitor.visit_mul(self)
class Eval: # visitor 1: tinh gia tri
def visit_num(self, n): return n.value
def visit_add(self, n): return n.left.accept(self) + n.right.accept(self)
def visit_mul(self, n): return n.left.accept(self) * n.right.accept(self)
class ToText: # visitor 2: in ra chuoi
def visit_num(self, n): return str(n.value)
def visit_add(self, n): return f"({n.left.accept(self)} + {n.right.accept(self)})"
def visit_mul(self, n): return f"({n.left.accept(self)} * {n.right.accept(self)})"
class DemNut: # visitor 3: dem so nut
def visit_num(self, n): return 1
def visit_add(self, n): return 1 + n.left.accept(self) + n.right.accept(self)
def visit_mul(self, n): return 1 + n.left.accept(self) + n.right.accept(self)
expr = Mul(Add(Num(2), Num(3)), Num(4))
print("Bieu thuc :", expr.accept(ToText()))
print("Gia tri :", expr.accept(Eval()))
print("So nut :", expr.accept(DemNut()))
Ba class Num, Add, Mul chỉ có đúng một method ngoài hàm khởi tạo: accept. Chúng không biết gì về việc tính toán hay in ấn. Muốn thêm thao tác thứ tư (rút gọn biểu thức, xuất LaTeX, đếm độ sâu), bạn viết thêm một class visitor, không mở lại file node.
Chú ý cách đệ quy: visitor không tự đi xuống bằng n.left.value mà gọi n.left.accept(self). Nhờ vậy, mỗi nút con lại tự chọn đúng method visit_X của nó. Việc đi trên cây và việc xử lý từng nút được ghép lại qua đúng một hợp đồng, rất hợp với Composite: Composite lo hình dáng cây, Visitor lo việc cần làm trên cây đó.
Trong hệ thống thật
Visitor không phải mẫu học thuật. Nó nằm ở lõi của những thứ bạn chạy hằng ngày:
- Trình biên dịch và công cụ phân tích mã. Chính module
astcủa Python, như ví dụ trên. Các linter và type checker như flake8, pylint, ruff, mypy đều đi trên cây cú pháp và áp từng luật như từng visitor riêng: mỗi rule là một thao tác mới, còn tập node của cây AST thì gần như không đổi. Đó là điều kiện lý tưởng cho Visitor. Một compiler cũng chạy nhiều lượt (pass) trên cùng cây: kiểm tra kiểu, tối ưu hằng số, sinh mã. - Serializer và exporter nhiều định dạng. Cùng một cấu trúc tài liệu hay một cây cấu hình, xuất ra JSON, YAML, XML, Markdown, HTML. Mỗi định dạng là một visitor; thêm định dạng mới không đụng vào model dữ liệu. Đây cũng là cách nhiều bộ render Markdown hoạt động sau khi parse xong.
- Trình tối ưu truy vấn của cơ sở dữ liệu. Một câu SQL được parse thành cây; bộ tối ưu chạy nhiều lượt trên cây đó: đẩy điều kiện lọc xuống sát bảng, gộp phép chiếu, chọn thứ tự join, ước lượng chi phí. Mỗi lượt là một thao tác độc lập trên cùng tập node ổn định. Các ORM và query builder cũng dùng cách này để dịch cây biểu thức sang SQL của từng dialect.
- Báo cáo và thống kê trên cây Composite. Cây thư mục: tính tổng dung lượng, tìm file trùng, liệt kê file lớn hơn 100 MB, xuất sơ đồ. Cây tổ chức nhân sự: tính quỹ lương, đếm nhân sự theo cấp. Cây thành phần giao diện: tính chi phí render, kiểm tra quy tắc accessibility. Cấu trúc thì đứng yên, số lượng báo cáo thì tăng mãi.
Điểm chung của cả bốn: tập các loại node ổn định, tập các thao tác thì mở rộng liên tục. Đó chính xác là hình dạng bài toán mà Visitor sinh ra để giải.
Trade-off
Được:
- Thêm thao tác mới không đụng vào element. Viết một class visitor mới là xong; các class node đóng lại với sửa đổi nhưng vẫn mở với mở rộng.
- Gom logic cùng loại vào một chỗ. Toàn bộ luật xuất XML nằm trong một file thay vì rải khắp 10 class node. Dễ đọc, dễ test riêng, dễ xoá khi không dùng nữa.
- Hợp với cấu trúc ổn định, nhất là cây. Visitor còn mang theo được trạng thái tích luỹ trong khi duyệt (bộ đếm, danh sách lỗi, chuỗi kết quả), thứ mà một hàm rời rạc khó làm gọn.
- Element giữ đúng vai trò của nó. Node chỉ mô tả cấu trúc, không gánh thêm mọi tính năng phái sinh.
Phải trả giá:
- Thêm loại element mới là phải sửa MỌI visitor. Đây là cái giá lớn nhất, và là đánh đổi ngược với OOP thông thường. Trong OOP thường ngày, thêm một class con là chuyện rẻ, thêm một method vào interface là chuyện đắt. Với Visitor thì ngược lại: thêm thao tác rẻ, thêm loại node đắt. Có 12 visitor mà thêm một node mới là 12 chỗ phải sửa, quên chỗ nào thì lỗi lộ ra lúc chạy.
- Double dispatch dài dòng. Mỗi element cần một
acceptgần như giống hệt nhau, chỉ khác tên method gọi ngược. Nhiều code lặp mà không mang thêm thông tin gì. - Dễ phá đóng gói (encapsulation). Visitor cần đọc chi tiết bên trong element để làm việc, nên element buộc phải mở ra nhiều thuộc tính public hơn mức đáng lẽ cần. Phần trạng thái nội bộ mà bạn muốn giấu lại phải phơi ra.
- Khó chịu với cấu trúc hay thay đổi. Nếu tập node còn biến động từng sprint, Visitor biến mỗi lần thêm node thành một đợt sửa lan rộng.
- Luồng điều khiển khó lần. Đọc
node.accept(v), bạn phải nhảy qua hai chặng mới biết code nào thật sự chạy. Người mới vào dự án hay lạc.
Khi nào KHÔNG nên dùng
Bỏ qua Visitor nếu bạn rơi vào một trong các trường hợp sau:
- Tập element còn đang thay đổi nhiều. Đây là tiêu chí số một. Cấu trúc chưa ổn định thì Visitor chỉ nhân chi phí sửa đổi lên.
- Chỉ có một hoặc hai thao tác. Một hàm đệ quy bình thường đọc dễ hơn nhiều so với một bộ visitor đầy đủ. Đợi đến khi số thao tác thật sự tăng rồi hãy tách.
- Cấu trúc phẳng, không phải cây. Một list đồng nhất thì vòng
forcộng với Iterator đã đủ, không cần double dispatch.
Trong Python còn một lựa chọn gọn hơn khi bạn không cần double dispatch đầy đủ: functools.singledispatch. Nó cho phép một hàm chọn nhánh cài đặt theo kiểu của tham số đầu tiên, tức là bạn vẫn tách được thao tác ra khỏi class element, nhưng không phải viết accept ở đâu cả:
from functools import singledispatch
class Num:
def __init__(self, value): self.value = value
class Add:
def __init__(self, left, right): self.left, self.right = left, right
class Mul:
def __init__(self, left, right): self.left, self.right = left, right
@singledispatch
def tinh(node):
raise TypeError(f"chua ho tro: {type(node).__name__}")
@tinh.register
def _(node: Num): return node.value
@tinh.register
def _(node: Add): return tinh(node.left) + tinh(node.right)
@tinh.register
def _(node: Mul): return tinh(node.left) * tinh(node.right)
expr = Mul(Add(Num(2), Num(3)), Num(4))
print("Gia tri:", tinh(expr))
class Neg: # loai element moi, chua dang ky
def __init__(self, inner): self.inner = inner
try:
tinh(Neg(Num(5)))
except TypeError as e:
print("Loi :", e)
So sánh nhanh: các class node giờ sạch hoàn toàn, không cần accept, không cần kế thừa Node. Mỗi thao tác là một hàm singledispatch với các nhánh register, vẫn nằm ngoài element. Đổi lại, bạn mất khả năng dispatch theo cả hai phía (thao tác giờ là một hàm, không phải object mang trạng thái), và trạng thái tích luỹ khi duyệt phải tự quản lý qua tham số hoặc closure. Lời khuyên của tôi: trong Python, thử singledispatch trước; chỉ dựng Visitor đầy đủ với accept khi bạn thật sự cần visitor là object có trạng thái, cần nhiều visitor thay thế lẫn nhau qua một hợp đồng chung, hoặc cần kiểm soát thứ tự duyệt phức tạp.
Và lưu ý cuối: chính ví dụ trên cũng cho thấy cái giá đã nói ở phần trade-off. Thêm class Neg, hàm tinh gãy ngay. Nếu bạn có mười thao tác, phải đăng ký thêm ở cả mười chỗ.
Tóm tắt
- Visitor tách thuật toán khỏi cấu trúc đối tượng: thao tác nằm trong class visitor, cấu trúc chỉ cần biết đón khách qua
accept(visitor). - Double dispatch là cơ chế cốt lõi:
acceptchọn theo loại element,visit_Xchọn theo loại visitor, kết quả phụ thuộc cả hai. - Đánh đổi quan trọng nhất: thêm thao tác mới thì rẻ, thêm loại element mới thì đắt vì phải sửa mọi visitor. Ngược hẳn với trực giác OOP thông thường.
- Chỉ dùng khi tập loại element đã ổn định còn số thao tác vẫn tăng: cây AST, cây truy vấn, cây tài liệu, cây Composite.
- Python có Visitor sẵn trong thư viện chuẩn:
ast.NodeVisitorđể đọc cây,ast.NodeTransformerđể sửa cây. - Trong Python,
functools.singledispatchthường là lựa chọn gọn hơn khi bạn không cần visitor mang trạng thái.
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 Visitor, nhóm Behavioral.
- Tài liệu Python, module
ast: các lớpast.NodeVisitorvàast.NodeTransformer. - Tài liệu Python,
functools.singledispatch: hàm generic điều phối theo kiểu của tham số đầu tiên.
- Kai