if/elif khổng lồ để chọn người. Bạn thêm, bớt, đổi thứ tự các cấp xử lý mà không phải sửa nơi gửi.Bạn có gặp cảnh này chưa: một hàm nhận yêu cầu vào, rồi có một chuỗi if/elif dài dằng dặc để quyết định "ai" xử lý nó. Mỗi lần thêm một trường hợp mới, bạn lại phải mở đúng cái hàm đó ra sửa. Chain of Responsibility là câu trả lời của Gang of Four cho tình huống này: tách mỗi cấp xử lý thành một đối tượng riêng, rồi xâu chúng thành một chuỗi. Yêu cầu tự chạy dọc chuỗi cho tới khi gặp người xử lý được.
Chain of Responsibility là gì
Đây là một mẫu thuộc nhóm hành vi (behavioral). Ý tưởng cốt lõi: thay vì để một chỗ duy nhất quyết định ai xử lý yêu cầu, bạn dựng một chuỗi (chain) gồm nhiều đối tượng xử lý (handler). Yêu cầu được đưa vào đầu chuỗi. Mỗi handler tự hỏi một câu: "việc này có thuộc phần của tôi không?". Nếu có, nó xử lý và dừng lại. Nếu không, nó đẩy yêu cầu cho handler kế tiếp trong chuỗi.
Hình dung quy trình duyệt chi tiêu trong công ty. Bạn xin duyệt một khoản tiền. Trưởng nhóm duyệt được tới một hạn mức; vượt mức đó, hồ sơ chuyển lên quản lý; vượt tiếp nữa thì lên giám đốc. Bạn (người gửi yêu cầu) chỉ nộp hồ sơ cho cấp đầu tiên, không cần biết cuối cùng ai ký. Mỗi cấp biết rõ hạn mức của mình và biết "sếp kế tiếp" là ai để đẩy lên. Đó chính xác là Chain of Responsibility.
Một analogy quen thuộc khác là tổng đài hỗ trợ khách hàng nhiều tầng: nhân viên tuyến 1 xử lý câu hỏi cơ bản, gặp ca khó thì chuyển tuyến 2, khó hơn nữa thì lên kỹ thuật chuyên sâu. Yêu cầu đi lên dần cho tới khi gặp người đủ khả năng.
Vấn đề: khối if/elif chọn người xử lý
Khi chưa biết mẫu này, ta thường gom việc chọn người xử lý vào một chỗ. Với ví dụ duyệt chi tiêu, nó trông như sau:
def duyet(amount):
if amount <= 1000:
return "Truong nhom duyet"
elif amount <= 5000:
return "Quan ly duyet"
elif amount <= 20000:
return "Giam doc duyet"
else:
return "Khong ai duyet duoc"
Nhìn thì gọn, nhưng nó có mấy điểm đau. Thứ nhất, hàm duyet phải biết hết mọi cấp và mọi hạn mức; nó dính chặt (coupling) vào toàn bộ quy trình. Thứ hai, thêm một cấp mới (ví dụ chèn "phó phòng" giữa trưởng nhóm và quản lý) buộc bạn mở đúng hàm này ra sửa, dễ đụng nhầm các nhánh khác. Thứ ba, thứ tự xử lý bị đóng cứng trong code, không đổi lúc chạy được. Đây đúng là kiểu vi phạm nguyên tắc Open/Closed trong SOLID: muốn mở rộng hành vi thì phải sửa code cũ.
Cách hoạt động
Chain of Responsibility tháo khối if/elif đó ra thành nhiều handler độc lập. Mỗi handler giữ hai thứ: điều kiện xử lý của riêng nó (ở đây là hạn mức) và tham chiếu tới handler kế tiếp. Logic của mỗi handler rất đơn giản: xử lý được thì xử lý, không thì đẩy tiếp.
Ta dùng lại ví dụ duyệt chi tiêu, lần này viết theo chuỗi trách nhiệm:
class Approver:
def __init__(self, name, limit):
self.name = name
self.limit = limit # muc tien toi da duoc duyet
self._next = None
def set_next(self, nxt): # noi handler ke tiep, tra ve no de xau chuoi
self._next = nxt
return nxt
def handle(self, amount):
if amount <= self.limit:
return f"{self.name} duyet khoan {amount}k"
if self._next is not None:
return self._next.handle(amount) # chuyen tiep len cap tren
return f"Khong cap nao du quyen duyet {amount}k"
lead = Approver("Truong nhom", 1000)
manager = Approver("Quan ly", 5000)
director = Approver("Giam doc", 20000)
lead.set_next(manager).set_next(director) # xau chuoi: lead, manager, director
for amount in (500, 3000, 15000, 50000):
print(lead.handle(amount))
Để ý mấy điểm. Khoản 500k dừng ngay ở trưởng nhóm, không đi tiếp. Khoản 15000k đi qua trưởng nhóm và quản lý (cả hai không đủ quyền), tới giám đốc thì được xử lý và dừng tại đó. Nơi gọi chỉ làm việc với lead, hoàn toàn không biết phía sau có bao nhiêu cấp. Muốn chèn một cấp mới, bạn chỉ tạo thêm một Approver rồi nối vào chuỗi bằng set_next, không đụng vào lớp Approver lẫn nơi gửi yêu cầu.
Cùng một mẫu, một ứng dụng khác: middleware xử lý request
Nếu bạn từng viết web, mẫu này quen hơn bạn tưởng. Chuỗi middleware xử lý HTTP request chính là Chain of Responsibility: mỗi middleware (kiểm tra xác thực, ghi log, giới hạn tần suất...) nhận request, làm phần việc của mình, rồi quyết định gọi tiếp mắt xích sau hay dừng chuỗi (ví dụ trả về lỗi 401 ngay khi chưa đăng nhập). Cùng một khung xương với ví dụ duyệt chi tiêu, chỉ khác nội dung xử lý.
Ba kiểu chuỗi hay gặp trong thực tế
Ví dụ duyệt chi tiêu ở trên chạy theo quy ước "ai xử lý được đầu tiên thì dừng". Đó chỉ là một biến thể, và nếu chỉ biết mỗi kiểu đó bạn sẽ thấy lạ khi đọc code middleware thật. Trong thực tế có ít nhất ba kiểu chuỗi:
- Dừng ở người xử lý đầu tiên (kiểu kinh điển của Gang of Four). Yêu cầu chạy dọc chuỗi tới khi gặp handler khớp, handler đó xử lý rồi chuỗi kết thúc. Duyệt chi tiêu theo hạn mức, định tuyến yêu cầu về đúng bộ phận đều thuộc kiểu này.
- Mọi handler đều chạy. Không ai "nuốt" yêu cầu, mắt xích nào cũng làm phần việc của mình rồi để yêu cầu đi tiếp. Pipeline xác thực dữ liệu chạy hết mọi luật để thu thập tất cả lỗi thay vì dừng ở lỗi đầu tiên, hay một chuỗi log ghi cùng một dòng ra nhiều đích (file, console, hệ thống tập trung), là kiểu này.
- Chuỗi bọc hai chiều, kiểu middleware. Mỗi mắt xích chạy một phần việc trước, gọi tiếp mắt xích sau, rồi chạy nốt phần việc sau khi lời gọi quay về. Nghĩa là mỗi handler được đụng tới hai lần, bọc quanh toàn bộ phần còn lại của chuỗi. Đây là cách middleware của Django và FastAPI hoạt động, và nó khác hẳn kiểu GoF thuần ở chỗ handler không chỉ "chuyển tiếp rồi thôi". Nếu thấy quen, đúng là nó gần với Decorator: cùng ý tưởng bọc, khác ở chỗ đây là bọc cả một chuỗi.
Điểm chung của cả ba: người gửi không cần biết ai sẽ xử lý, chỉ đưa yêu cầu vào đầu chuỗi. Khác nhau nằm ở quy ước dừng hay đi tiếp: dừng ở người đầu tiên, luôn đi hết, hay đi hết rồi quay ngược về. Khi đọc một codebase lạ, câu hỏi đầu tiên cần trả lời là chuỗi ở đây theo quy ước nào.
Kiểu bọc hai chiều dễ thấy nhất khi viết ra:
class Middleware:
def __init__(self, name):
self.name = name
self._next = None
def set_next(self, nxt):
self._next = nxt
return nxt
def handle(self, req):
print(f"[{self.name}] truoc")
if self._next is not None:
res = self._next.handle(req)
else:
res = f"xu ly xong: {req}" # loi goi cuoi chuoi
print(f"[{self.name}] sau")
return res
log = Middleware("log")
auth = Middleware("auth")
timer = Middleware("timer")
log.set_next(auth).set_next(timer)
print(log.handle("GET /orders"))
Nhìn thứ tự in ra: phần "truoc" chạy xuôi từ ngoài vào trong, phần "sau" chạy ngược từ trong ra ngoài. Đúng cái hình chiếc hộp lồng nhau. Nhờ vậy một middleware đo thời gian mới bấm giờ được ở lượt đi và chốt giờ ở lượt về, còn middleware xử lý lỗi mới bọc được mọi thứ nằm sau nó.
Cạm bẫy
- Chuỗi quá dài khó lần vết. Khi một yêu cầu đi qua chục handler, việc trả lời câu hỏi "rốt cuộc ai đã xử lý nó, hay tại sao nó bị bỏ qua?" trở nên mệt. Giữ chuỗi ngắn, đặt tên handler rõ ràng, và cân nhắc log lại mắt xích nào đã xử lý để dễ debug.
- Không có gì bảo đảm yêu cầu được xử lý. Bản chất mẫu này là "gửi đi rồi hy vọng có người nhận". Nếu nghiệp vụ bắt buộc mọi yêu cầu phải được xử lý, bạn phải tự thêm ràng buộc đó (handler mặc định, hoặc kiểm tra kết quả), mẫu không tự lo giúp.
Khi nào dùng, khi nào không
Dùng Chain of Responsibility khi: có nhiều đối tượng có thể xử lý một yêu cầu và bạn không muốn cố định trước ai; khi tập người xử lý hoặc thứ tự của họ cần thay đổi lúc chạy; hoặc khi bạn muốn tách một khối if/elif chọn người xử lý thành các phần độc lập, dễ thêm bớt.
if đơn giản còn dễ đọc hơn.Trong hệ thống thật
Mẫu này nằm ngay dưới chân bạn mỗi ngày, chỉ là ít khi ai gọi đúng tên nó:
- Middleware của Django và FastAPI. Xác thực người dùng, kiểm tra CORS, ghi log request, đo thời gian phản hồi, nén nội dung trả về: mỗi thứ là một mắt xích, xếp theo thứ tự khai báo trong
MIDDLEWARE(Django) hoặc theo thứ tựapp.add_middleware(FastAPI). Xuống thêm một tầng, bản thân giao diện ASGI và WSGI cũng là chuỗi bọc hai chiều: mỗi lớp nhận một ứng dụng và trả về một ứng dụng bọc ngoài nó. - Module
loggingcủa Python. Một bản ghi log đi qua chuỗi handler đã gắn vào logger, và nếupropagatecòn bật thì tiếp tục đi lên logger cha. Đây là kiểu "mọi handler đều chạy":FileHandlerghi ra file,StreamHandlerin ra console, không ai chặn ai. - Pipeline xác thực và làm sạch dữ liệu đầu vào. Chuỗi luật chạy lần lượt: cắt khoảng trắng thừa, chuẩn hoá chữ hoa chữ thường, kiểm tra định dạng, kiểm tra ràng buộc nghiệp vụ. Tuỳ yêu cầu mà chuỗi dừng ở lỗi đầu tiên hay gom hết lỗi rồi trả về một lượt.
- Chuỗi bộ lọc sự kiện và quy tắc chống gian lận. Một giao dịch đi qua loạt luật: chặn theo danh sách đen, kiểm tra tần suất bất thường, đối chiếu vị trí địa lý, chấm điểm rủi ro. Bộ phận nghiệp vụ thêm bớt luật mà không ai phải đụng vào code lõi.
- Định tuyến yêu cầu hỗ trợ theo cấp. Ticket vào tuyến 1, không giải quyết được thì lên tuyến 2, rồi tới đội kỹ thuật chuyên sâu. Đúng nguyên bản ví dụ tổng đài ở đầu bài.
- Chuỗi thử nhiều nhà cung cấp cho tới khi một cái thành công. Gửi SMS qua nhà mạng A, lỗi thì chuyển sang B, vẫn lỗi thì rơi xuống email. Thanh toán, gửi mail, lưu trữ file đều hay dựng theo kiểu này.
Trade-off
Được:
- Thêm hoặc bỏ một mắt xích không đụng tới phần còn lại của chuỗi, cũng không đụng nơi gửi yêu cầu.
- Thứ tự xử lý trở thành cấu hình, một danh sách bạn đọc được và đổi được, thay vì nằm chôn trong các khối
iflồng nhau. - Mỗi handler nhỏ, chỉ lo một việc, nên viết test riêng cho từng cái rất dễ.
- Chuỗi có thể dựng lúc chạy, khác nhau theo môi trường hoặc theo loại yêu cầu.
Phải trả giá:
- Yêu cầu có thể đi hết chuỗi mà không ai xử lý, nếu bạn quên đặt handler mặc định ở cuối.
- Khó lần vết khi chuỗi dài: muốn biết ai đã đụng vào yêu cầu, bạn phải đọc cả chuỗi chứ không có một chỗ duy nhất để nhìn.
- Thứ tự sai gây lỗi rất khó tìm. Đặt middleware log trước middleware xác thực thì log được cả request chưa đăng nhập; đặt sau thì mất sạch. Cùng một bộ handler, khác thứ tự là khác hành vi.
- Hiệu năng giảm nếu mỗi mắt xích đều làm việc nặng, vì mọi yêu cầu đều phải chạy qua hết phần đầu chuỗi mới tới được người xử lý.
Tóm tắt
- Chain of Responsibility cho yêu cầu đi qua một chuỗi handler; mỗi handler tự xử lý hoặc chuyển tiếp cho mắt xích kế.
- Người gửi chỉ làm việc với đầu chuỗi, không cần biết ai xử lý, nhờ đó tách được khối
if/elifvà giảm coupling. - Thêm, bớt, đổi thứ tự các cấp mà không sửa nơi gửi, cũng không sửa các handler khác.
- Có ít nhất ba kiểu chuỗi: dừng ở người xử lý đầu tiên, mọi handler đều chạy, và chuỗi bọc hai chiều kiểu middleware.
- Cạm bẫy: yêu cầu đi hết chuỗi mà không ai xử lý (cần handler mặc định); chuỗi dài khó lần vết; thứ tự sai gây lỗi khó tìm.
- Không nên dùng khi bạn luôn biết chính xác ai xử lý, lúc đó gọi thẳng là gọn nhất.
- Kai