@decorator của Python, dù cùng tên.Bạn có một ly espresso. Khách muốn thêm sữa. Rồi thêm đường. Rồi thêm foam. Mỗi thứ thêm vào phải cộng giá và nối thêm vào phần mô tả. Bạn sẽ giải quyết thế nào trong code? Nếu định đẻ ra một class cho mỗi tổ hợp (espresso-sữa, espresso-sữa-đường, espresso-đường-foam...) thì số class sẽ phình rất nhanh. Decorator sinh ra chính là để tránh cái bẫy đó.
Decorator là gì
Decorator (mẫu trang trí) là một mẫu thuộc nhóm Structural (cấu trúc). Ý tưởng: đặt đối tượng gốc vào bên trong một đối tượng bọc (wrapper) khác. Wrapper này cài đúng cùng interface với đối tượng gốc, nên với người dùng bên ngoài, cái đã bọc trông y hệt cái chưa bọc. Khi được gọi, wrapper làm thêm việc của nó rồi chuyển tiếp lời gọi vào đối tượng bên trong. Vì wrapper cũng cùng interface, bạn có thể bọc một wrapper bằng một wrapper khác, chồng lên nhiều lớp tuỳ ý.
Hình dung việc mặc áo: cơ thể bạn là đối tượng gốc. Mặc thêm áo sơ mi là bọc một lớp; khoác thêm áo len là bọc lớp nữa; ngoài cùng là áo mưa. Mỗi lớp thêm một chức năng (giữ ấm, chắn mưa) nhưng bạn vẫn là bạn, vẫn đi đứng bình thường. Cởi bớt một lớp cũng được. Ly trà sữa cũng vậy: mỗi topping bọc thêm một ít giá và một dòng mô tả lên phần đã có.
Vấn đề: bùng nổ số class con
Cách ngây thơ là dùng kế thừa (inheritance). Muốn có espresso thêm sữa thì viết một class con; thêm đường lại một class con; thêm cả sữa lẫn đường lại một class con nữa. Cứ mỗi tổ hợp là một class:
# Cách kế thừa: mỗi tổ hợp topping là một class con
class Espresso: ...
class EspressoMilk(Espresso): ...
class EspressoSugar(Espresso): ...
class EspressoMilkSugar(Espresso): ...
class EspressoMilkSugarFoam(Espresso): ...
# ... them 1 topping moi la nhan doi so class
Với 3 topping bạn đã cần tới 8 tổ hợp; thêm topping thứ tư là 16. Đây gọi là bùng nổ số class con (subclass explosion). Chưa kể chuyện thêm 2 lần đường (double sugar) thì cây kế thừa cứng nhắc này gần như bó tay. Gốc rễ vấn đề là kế thừa cố định hành vi ngay lúc viết code, còn cái bạn cần lại là ghép hành vi lúc chạy. Đó đúng là chỗ để áp dụng nguyên tắc composition over inheritance (xem bài Program to interface & Composition over inheritance).
Cách hoạt động
Ba mảnh ghép của Decorator:
- Interface chung: hợp đồng mà cả đối tượng gốc lẫn các lớp bọc đều tuân theo. Ở đây là
Beveragevới hai việc: tính giá và mô tả. - Đối tượng gốc (concrete component): thứ được bọc, ví dụ
Espresso. - Lớp bọc (decorator): cũng cài
Beverage, giữ một tham chiếu tới đối tượng bên trong, gọi vào nó rồi cộng thêm phần việc của mình.
from abc import ABC, abstractmethod
class Beverage(ABC): # interface chung: mọi thức uống đều có 2 việc này
@abstractmethod
def cost(self): ...
@abstractmethod
def describe(self): ...
class Espresso(Beverage): # đối tượng gốc, chưa thêm topping gì
def cost(self): return 30000
def describe(self): return "Espresso"
class ToppingDecorator(Beverage): # lớp bọc: giữ tham chiếu tới thức uống bên trong
def __init__(self, drink):
self._drink = drink
class Milk(ToppingDecorator):
def cost(self): return self._drink.cost() + 8000
def describe(self): return self._drink.describe() + " + sua"
class Sugar(ToppingDecorator):
def cost(self): return self._drink.cost() + 2000
def describe(self): return self._drink.describe() + " + duong"
class Foam(ToppingDecorator):
def cost(self): return self._drink.cost() + 5000
def describe(self): return self._drink.describe() + " + foam"
drink = Espresso() # bắt đầu bằng thức uống trần
drink = Milk(drink) # bọc thêm lớp sữa
drink = Sugar(drink) # bọc thêm lớp đường
drink = Foam(drink) # bọc thêm lớp foam
print(drink.describe())
print(f"Tong: {drink.cost():,} VND")
Để ý cách các lớp chồng lên nhau. Khi gọi drink.cost(), lớp ngoài cùng là Foam cộng 5000 rồi hỏi lớp Sugar bên trong; Sugar cộng 2000 rồi hỏi Milk; Milk cộng 8000 rồi hỏi Espresso; Espresso trả về 30000. Cộng ngược ra ngoài: 30000 + 8000 + 2000 + 5000 = 45000. Không một class nào biết trước nó sẽ bị bọc bởi ai, và cũng không cần biết.
Vì mọi lớp bọc đều cùng interface, bạn ghép tổ hợp nào cũng được, kể cả bọc chồng cùng một topping hai lần:
a = Espresso() # ly den, khong topping
b = Sugar(Sugar(Milk(Espresso()))) # 1 sua + 2 duong, bọc cùng lớp 2 lần
print(a.describe(), "=", f"{a.cost():,}")
print(b.describe(), "=", f"{b.cost():,}")
Cùng một ý tưởng áp dụng cho luồng dữ liệu (data stream): một stream gốc chỉ biết đọc/ghi byte, bạn bọc thêm lớp nén (compression), bọc thêm lớp mã hoá (encryption). Mỗi lớp vẫn phơi ra interface "đọc/ghi" như cũ, nên phần code dùng stream không cần đổi, dù bên trong đã qua nén rồi mã hoá.
Đừng nhầm với @decorator của Python
@decorator (dấu @ đặt trên def/class) là cú pháp của ngôn ngữ Python: nó nhận một hàm hoặc class và trả về một hàm/class đã được biến đổi. Hai thứ chỉ chung tinh thần "bọc", chứ không phải một.Ví dụ nhanh về @decorator của Python để bạn thấy khác biệt:
def log_call(func): # nhận vào 1 hàm, trả về 1 hàm mới bọc quanh nó
def wrapper(*args):
print(f"goi {func.__name__}{args}")
return func(*args)
return wrapper
@log_call # tương đương add = log_call(add)
def add(a, b): return a + b
print(add(2, 3))
Cái @log_call thao tác trên hàm add ngay lúc định nghĩa. Còn Decorator pattern thao tác trên đối tượng lúc chạy, và mục tiêu là chồng hành vi qua một interface chung. Tên giống nhau dễ gây rối, nên khi nói chuyện hãy nói rõ bạn đang đề cập cái nào.
Khi nào dùng và khi nào không
Nên dùng khi bạn cần thêm/bớt hành vi cho từng đối tượng riêng lẻ một cách linh hoạt, đặc biệt khi các hành vi đó tổ hợp tự do với nhau (topping đồ uống, các tầng xử lý của một stream, các lớp middleware). Decorator cho bạn thay đổi lúc chạy mà không đụng tới class gốc, tôn trọng nguyên tắc "mở để mở rộng, đóng để sửa đổi".
Trong hệ thống thật
Chỗ bạn gặp Decorator nhiều nhất không phải quán cà phê, mà là các lớp bọc hành vi cắt ngang (cross-cutting concern) quanh một handler hoặc một client: @retry thử lại khi lỗi mạng, @cached nhớ lại kết quả, @transactional mở và đóng transaction, @authenticated chặn lời gọi chưa đăng nhập, @rate_limited giới hạn số lời gọi mỗi giây. Lõi nghiệp vụ chỉ lo việc của nó, phần còn lại nằm ở các tầng bọc bên ngoài.
Vài chỗ cụ thể:
- Client gọi dịch vụ ngoài: bắt đầu bằng một HTTP client trần, bọc thêm lớp cache để khỏi gọi lại cùng một truy vấn, bọc tiếp lớp đo lường (metrics) để đếm số lời gọi và độ trễ, bọc ngoài cùng lớp circuit breaker để ngắt mạch khi dịch vụ kia chết. Ba mối quan tâm, ba lớp, không lớp nào biết lớp kia.
- Luồng dữ liệu: stream ghi file trần, bọc lớp nén rồi bọc lớp mã hoá; phần code ghi dữ liệu vẫn gọi đúng
write()như cũ. - Middleware trong web framework: mỗi middleware nhận handler bên trong và trả về một handler mới cùng chữ ký, nên chuỗi log, CORS, auth, nén gzip thực chất là một chồng decorator quanh handler cuối cùng.
- Họ hàng gần: Proxy cũng bọc cùng interface nhưng mục đích là kiểm soát truy cập, còn Chain of Responsibility chuyền yêu cầu dọc chuỗi cho tới khi có người xử lý, chứ không phải ai cũng góp một phần như Decorator.
Điểm hay chung: mỗi mối quan tâm là một lớp độc lập, bật hay tắt bằng cách ghép thêm hoặc bỏ bớt một lớp bọc, chứ không phải sửa lõi.
Trade-off
Được:
- Ghép tính năng lúc chạy thay vì đẻ ra một class con cho từng tổ hợp.
- Mỗi lớp bọc giữ đúng một trách nhiệm, nên test riêng từng lớp rất gọn.
- Thêm hoặc bỏ một tầng không đụng tới lõi lẫn các tầng còn lại.
- Một lớp bọc dùng lại được cho nhiều đối tượng khác nhau, miễn là chung interface.
Phải trả giá:
- Chuỗi bọc dài làm việc debug khó hơn hẳn: stack trace dài thêm một khung cho mỗi lớp bọc, lỗi thật bị đẩy xuống tận đáy.
- Thứ tự bọc là ngữ nghĩa ẩn: bọc cache ngoài retry khác hẳn bọc retry ngoài cache, mà code nhìn qua thì giống nhau.
- Nhiều lớp nhỏ khiến bạn khó lần ra lớp nào đã đổi kết quả, vì lớp nào cũng có quyền sửa đầu vào và đầu ra.
- Danh tính đối tượng và kiểu không còn là đối tượng gốc nữa:
isinstancetrả về lớp bọc,reprvà tên hàm bị che nếu quênfunctools.wraps. - Mỗi tầng thêm một chút chi phí gọi; với đường nóng bọc chục lớp thì cũng đáng đo lại.
functools.wraps khi viết lớp bọc dạng hàm, đặt tên lớp bọc theo việc nó làm, và ghi rõ thứ tự bọc ở chỗ lắp ráp để người sau không đổi bừa.Tóm tắt
- Decorator bọc một đối tượng trong một đối tượng khác cùng interface để thêm hành vi; bọc chồng được nhiều lớp.
- Nó là ứng dụng trực tiếp của composition over inheritance, giúp tránh bùng nổ số class con khi có nhiều tổ hợp tính năng.
- Ba mảnh: interface chung, đối tượng gốc, và lớp bọc giữ tham chiếu tới đối tượng bên trong rồi cộng thêm phần việc của mình.
- Đừng nhầm Decorator pattern (bọc object) với cú pháp
@decoratorcủa Python (biến đổi hàm/class). - Chỉ cần một biến thể cố định thì kế thừa hoặc viết thẳng là đủ; chuỗi bọc dài làm debug khó hơn và thứ tự bọc là một ngữ nghĩa ẩn dễ gây lỗi.
- Kai