Ở bài Design Pattern là gì? tôi có nói: pattern chỉ là hệ quả của vài nguyên tắc thiết kế sâu hơn. Bài này đi vào hai nguyên tắc quan trọng nhất trong số đó. Hiểu chúng rồi, phần lớn các mẫu GoF (Strategy, Decorator, Factory, Observer...) sẽ hiện ra như những cách áp dụng cụ thể của cùng hai ý tưởng.
Nguyên tắc 1: Program to an interface, not an implementation
Dịch thoáng: hãy phụ thuộc vào cái trừu tượng (interface), đừng phụ thuộc vào cái cụ thể (class cài đặt). "Interface" ở đây hiểu rộng: một hợp đồng về những việc một đối tượng làm được (các method), không quan tâm nó làm bằng cách nào.
Hình dung cái ổ cắm điện: nó là một giao diện chuẩn. Bạn cắm quạt, sạc điện thoại hay nồi cơm đều chạy, mà không cần biết phía sau là thuỷ điện hay điện gió. Thiết bị chỉ phụ thuộc vào "ổ cắm" (interface), không phụ thuộc vào "nhà máy điện" (implementation). Đổi nguồn điện thoải mái, thiết bị không cần sửa.
Trong code, khi một hàm nhận vào cái trừu tượng thay vì class cụ thể, bạn thay hay thêm cài đặt mới mà không phải sửa hàm đó:
from abc import ABC, abstractmethod
class Notifier(ABC): # interface: chỉ hứa "gửi được tin"
@abstractmethod
def send(self, msg): ...
class EmailNotifier(Notifier):
def send(self, msg): return f"Email gui: {msg}"
class SlackNotifier(Notifier):
def send(self, msg): return f"Slack gui: {msg}"
def alert(notifier: Notifier, msg): # phụ thuộc Notifier, KHÔNG phụ thuộc Email/Slack
return notifier.send(msg)
print(alert(EmailNotifier(), "Server sap!"))
print(alert(SlackNotifier(), "Server sap!"))
Hàm alert không hề biết Email hay Slack. Thêm SmsNotifier sau này chỉ là viết một class mới, alert giữ nguyên. Đây cũng chính là tinh thần của chữ D (Dependency Inversion) trong SOLID: module cấp cao phụ thuộc vào abstraction, không phụ thuộc vào chi tiết.
ABC vẫn chạy (chỉ cần đối tượng có method send). Nhưng khai báo interface rõ ràng giúp đọc code và bắt lỗi sớm hơn, nên tôi vẫn khuyến khích với các ranh giới quan trọng.Nguyên tắc 2: Favor composition over inheritance
Kế thừa (inheritance) là quan hệ "is-a" (con là một loại cha). Composition là quan hệ "has-a" (đối tượng có/ghép các thành phần để tạo hành vi). Nguyên tắc này khuyên: khi cần tái sử dụng hay thay đổi hành vi, hãy ưu tiên ghép nối thay vì kế thừa.
Vì sao? Kế thừa nghe gọn nhưng cứng. Ví dụ kinh điển: bạn có Duck, rồi muốn vịt biết bay và biết kêu. Nếu nhét mọi hành vi vào cây kế thừa, số class phình theo tổ hợp:
# Cách kế thừa: bùng nổ số class theo tổ hợp hành vi
class FlyingQuackingDuck(Duck): ...
class FlyingSilentDuck(Duck): ...
class NonFlyingQuackingDuck(Duck): ...
# ... thêm "bơi", "lặn" nữa là nhân đôi tiếp
Thêm một kiểu bay hay một kiểu kêu là phải đẻ thêm một loạt class con, lại còn dễ dính lỗi "fragile base class" (sửa lớp cha làm vỡ lớp con ở xa). Composition tháo được nút thắt này: tách mỗi hành vi ra, rồi ghép vào đối tượng, đổi được cả lúc chạy:
class Duck:
def __init__(self, fly, quack): # ghép hành vi vào, không kế thừa
self._fly, self._quack = fly, quack
def describe(self):
return f"{self._fly()} | {self._quack()}"
def fly_wings(): return "bay bang canh"
def fly_no(): return "khong bay duoc"
def quack_loud(): return "quac quac"
def quack_silent(): return "(im lang)"
print("Vit troi :", Duck(fly_wings, quack_loud).describe())
print("Vit nhua :", Duck(fly_no, quack_silent).describe())
Giờ "bay" và "kêu" là các mảnh độc lập, lắp vào con vịt nào cũng được, tổ hợp thoải mái mà không đẻ thêm class. Hãy hình dung ghép Lego (tháo lắp từng mảnh) thay vì đúc một khối nhựa liền (muốn đổi phải đúc lại từ đầu). Đây đúng là hạt nhân của Strategy pattern mà bạn sẽ gặp lại ở bài sau.
Hai nguyên tắc đi cùng nhau
Để ý: ở ví dụ con vịt, các "mảnh hành vi" được ghép vào qua một hợp đồng chung (đều là "thứ gọi được, trả về mô tả"). Đó là lúc hai nguyên tắc gặp nhau: bạn ghép các thành phần (composition), và ghép chúng qua interface (program to an interface). Kết hợp lại, bạn có được thứ mà GoF theo đuổi: hệ thống lỏng lẻo về phụ thuộc (loose coupling), dễ thay thế và mở rộng. Hầu hết pattern chỉ là các biến thể của công thức này.
Cạm bẫy
- Kế thừa không phải là xấu. Khi quan hệ thật sự là "is-a" và ổn định (vd
SavingsAccountlà mộtAccount), kế thừa vẫn gọn và đúng. Nguyên tắc là "ưu tiên composition", không phải "cấm inheritance". - Đừng trừu tượng hoá quá sớm. Giống pattern, chỉ tách interface / chuyển sang composition khi cơn đau (khó thay thế, khó test, class phình) đã xuất hiện.
Trong hệ thống thật
Hai nguyên tắc này không chỉ sống trong ví dụ con vịt. Đi làm backend, bạn gặp chúng mỗi ngày, thường là ở những chỗ sau:
- Service nhận vào cổng trừu tượng.
CheckoutServicenhận mộtPaymentGatewaychứ không nhận thẳngStripeClient. Lúc chạy thật bạn truyền bản Stripe; lúc test bạn truyền mộtFakeGatewayluôn trả về "thành công" hoặc cố tình trả về lỗi thẻ. Test không cần mạng, không cần sandbox key, chạy trong vài mili giây. Cùng công thức choStorage(S3 hay ổ đĩa) vàNotifier(email, Slack, hay một list trong bộ nhớ để assert). - Repository interface. Bạn định nghĩa
UserRepositoryvớiget(id)/save(user), rồi có hai cài đặt: một bản Postgres cho production, một bản in-memory (dict) cho test. Phần logic nghiệp vụ không đổi một dòng khi bạn đổi qua lại, và bộ test chạy được trên máy không có DB. logging.Handlercủa Python. Đây là hợp đồng "nhận một log record và xử lý nó". Nhờ vậy bạn cắm đích log bất kỳ - ra console, ra file xoay vòng, ra syslog, hay một handler tự viết đẩy log lên dịch vụ tập trung - mà toàn bộ code gọilogger.info(...)không hề biết.- Giao thức file-like object. Python quy ước "thứ nào có
read/writethì dùng được như file". Nhờ vậy cùng một hàm chạy được với file thật, vớiio.StringIOtrong test, hay với một đối tượng bọc S3. - Composition ở tầng service. Một
OrderServicethực tế thường gom repo + cache + payment client + notifier vào trong nó, mỗi thứ một vai. Đó là has-a. Cách ngược lại - cho mọi service kế thừa mộtBaseServicekhổng lồ để "dùng chung tiện ích" - là cái bẫy quen thuộc: lớp cha phình dần, mỗi service chỉ xài một phần nhỏ của nó, và sửa cha thì cả chục con có nguy cơ vỡ.
Một điểm rất Python đáng nhấn: ở đây hợp đồng thường là giao thức ngầm (duck typing) hoặc typing.Protocol, không nhất thiết phải ABC. Class cài đặt không cần kế thừa gì cả, chỉ cần có đúng method; Protocol giúp type checker kiểm tra giùm bạn mà vẫn không ràng buộc cây kế thừa:
import io
from typing import Protocol
class Storage(Protocol): # hop dong, khong can ke thua
def write(self, data: str) -> int: ...
def export_report(dest: Storage, rows): # phu thuoc hop dong "ghi duoc"
n = 0
for r in rows:
n += dest.write(r + "\n")
return n
class FakeS3: # khong ke thua gi, chi co .write
def __init__(self): self.parts = []
def write(self, data):
self.parts.append(data)
return len(data)
buf = io.StringIO()
print("ghi vao StringIO :", export_report(buf, ["a,1", "b,2"]), "ky tu")
print("noi dung :", repr(buf.getvalue()))
s3 = FakeS3()
print("ghi vao FakeS3 :", export_report(s3, ["a,1", "b,2"]), "ky tu")
print("noi dung :", s3.parts)
export_report không biết đích ghi là gì, và FakeS3 cũng chẳng kế thừa của ai. Đó chính là "program to an interface" phiên bản Python: hợp đồng nằm ở hình dạng của đối tượng, không nằm ở dòng họ của nó.
Trade-off
Hai nguyên tắc này không miễn phí. Bạn đổi một thứ để lấy một thứ, và nên biết mình đang trả gì:
Được:
- Thay cài đặt mà không đụng code gọi: đổi Stripe sang cổng nội địa, đổi ổ đĩa sang S3, phần nghiệp vụ đứng yên.
- Test bằng test double dễ: fake / stub cắm vào đúng chỗ hợp đồng, test không cần mạng, không cần DB thật, và mô phỏng được cả ca lỗi.
- Ranh giới rõ nên chia việc trong nhóm dễ: chốt interface trước, hai người làm hai bên song song mà không dẫm chân nhau.
- Hoãn được quyết định hạ tầng: chưa chốt queue hay storage vẫn viết được nghiệp vụ, dựng bản in-memory chạy tạm.
- Composition cho phép đổi hành vi lúc chạy, thứ mà kế thừa không làm được vì cây kế thừa đã chốt từ lúc viết code.
Phải trả giá:
- Thêm một tầng trừu tượng phải bảo trì: interface cũng là code, cũng phải sửa khi yêu cầu đổi, và sửa nó thì mọi cài đặt phải sửa theo.
- Đọc code mệt hơn: từ chỗ gọi, bạn nhảy vào interface và chỉ thấy
..., phải tìm tiếp xem cài đặt nào đang được wire vào mới biết điều gì thực sự xảy ra. - Interface đặt sai chỗ còn tệ hơn không có: cắt sai đường biên thì mỗi lần thêm tính năng bạn lại phải sửa cả hai phía, tức là chịu chi phí trừu tượng mà không được lợi ích nào.
- Chỉ có đúng một cài đặt mãi mãi thì đó là chi phí thuần: nếu đoạn code đó sẽ không bao giờ có implementation thứ hai và bạn cũng chẳng test qua nó, cái interface kia chỉ là một file phải mở thêm.
- Composition thường dài dòng hơn kế thừa: những thứ lớp cha cho không, giờ bạn phải tự nhận vào và tự chuyển tiếp.
Tóm tắt
- Program to an interface, not an implementation: phụ thuộc vào hợp đồng (cái làm được gì), không phụ thuộc vào class cụ thể. Dễ thay, dễ test, dễ mở rộng.
- Favor composition over inheritance: ghép hành vi (has-a) linh hoạt hơn kế thừa cứng (is-a); tránh bùng nổ số class và fragile base class.
- Hai cái kết hợp cho ra loose coupling - nền tảng của gần như mọi design pattern.
- Đừng cực đoan: interface đúng chỗ, inheritance vẫn hợp khi quan hệ "is-a" thật sự; và đừng trừu tượng hoá quá sớm.
Nguồn tham khảo
- Gamma, Helm, Johnson, Vlissides (Gang of Four), Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994 - hai câu "program to an interface, not an implementation" và "favor object composition over class inheritance" là kim chỉ nam nêu ở phần mở đầu sách.
- Kai