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

Decorator Pattern: bọc thêm hành vi cho đối tượng mà không cần đẻ subclass

TL;DR: Decorator gắn thêm hành vi cho một đối tượng bằng cách bọc (wrap) nó trong một đối tượng khác cùng interface, và bạn có thể bọc chồng nhiều lớp. Đây là ứng dụng trực tiếp của "composition over inheritance": thay vì đẻ ra một class con cho mỗi tổ hợp tính năng, bạn ghép từng tính năng lại lúc chạy. Lưu ý: Decorator pattern (bọc object) khác với cú pháp @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à Beverage vớ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")
Espresso + sua + duong + foam Tong: 45,000 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():,}")
Espresso = 30,000 Espresso + sua + duong + duong = 42,000

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

Hai thứ khác nhau tuy cùng tên. "Decorator" trong bài này là một mẫu thiết kế: bạn bọc một đối tượng trong một đối tượng khác cùng interface, chồng được nhiều lớp, lắp ghép lúc chạy. Còn @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))
goi add(2, 3) 5

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".

Khi KHÔNG nên. Nếu bạn chỉ cần một biến thể cố định (luôn luôn là espresso có sữa, không đổi), thì bọc lớp là thừa: viết thẳng vào class hoặc dùng kế thừa cho gọn. Ngoài ra, bọc quá nhiều lớp khiến việc debug khó: khi lần theo một lời gọi, bạn phải nhảy qua từng lớp bọc mới tới được đối tượng gốc, và stack trace dài ra. Chỉ dùng Decorator khi nhu cầu tổ hợp linh hoạt là có thật.

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: isinstance trả về lớp bọc, repr và tên hàm bị che nếu quên functools.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.
Về chuyện debug. Khi một lời gọi đi qua sáu bảy lớp bọc, câu hỏi khó nhất không phải "sai ở đâu" mà là "lớp nào đã đổi kết quả". Stack trace dài thêm một khung cho mỗi lớp, và các khung đó thường trông giống hệt nhau. Thứ tự bọc còn đáng sợ hơn: để cache ngoài retry thì lần trúng cache không thử lại gì cả và mọi lần thử đều nằm dưới cache; đảo lại, để retry ngoài cache thì mỗi lần thử lại đều đi qua cache, và một kết quả hỏng lỡ ghi vào cache sẽ được trả lại y nguyên cho cả ba lần thử. Hai cách xếp cho hai hành vi khác nhau, chỉ khác đúng thứ tự hai dòng code. Thói quen đỡ khổ: luôn 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 @decorator củ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.
Series Design Patterns - nhóm Structural. Decorator dựng trên hai nguyên tắc nền: đọc lại Program to interface & Composition over inheritance và Lập trình hướng đối tượng là gì nếu cần. 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