if/elif rải rác khắp nơi.Ở bài Program to interface & Composition over inheritance, tôi có nói pattern chỉ là cách áp dụng cụ thể của vài nguyên tắc thiết kế. Factory Method là ví dụ đầu tiên rất rõ của điều đó. Nó là một mẫu thuộc nhóm khởi tạo (creational) trong bộ Gang of Four, và nó giải quyết một câu hỏi tưởng nhỏ mà làm khổ nhiều codebase: "ai chịu trách nhiệm tạo ra đối tượng, và tạo ở đâu?"
Nghe qua thì việc tạo một đối tượng chỉ là gọi SomeClass(). Nhưng khi hệ thống có nhiều biến thể sản phẩm và bạn rắc lời gọi tạo đó ra khắp nơi, mỗi lần thêm biến thể mới là một lần đi sửa hàng loạt chỗ. Factory Method dựng lại trật tự cho việc đó.
Factory Method là gì?
Định nghĩa gọn: định nghĩa một phương thức (method) để tạo đối tượng, nhưng để lớp con quyết định tạo class cụ thể nào. Phương thức đó gọi là phương thức nhà máy (factory method). Lớp chứa nó (thường gọi là Creator) không tự chọn class con nào để tạo; nó chỉ khai báo "sẽ có một sản phẩm được tạo ở đây" rồi dùng sản phẩm đó qua interface chung. Các lớp con của Creator mới là nơi trả lời "tạo cái nào".
Hình dung một quán cà phê nhượng quyền. Công ty mẹ ban hành một quy trình chuẩn: khách gọi món, pha chế, giao ly. Quy trình đó không đổi ở mọi chi nhánh. Nhưng "pha ly đồ uống" cụ thể ra sao thì mỗi chi nhánh tự lo: chi nhánh trong nước pha cà phê sữa đá, chi nhánh ở nước ngoài pha espresso. Bước "tạo ra ly đồ uống" chính là factory method: quy trình chung gọi nó, còn từng chi nhánh (lớp con) quyết định pha ra loại đồ uống nào. Quy trình bán hàng ở tổng công ty không cần biết chi tiết từng công thức.
Điểm mấu chốt: phần code chung chỉ làm việc với interface sản phẩm ("một ly đồ uống có thể phục vụ"), không phụ thuộc vào công thức cụ thể. Đây đúng là tinh thần "program to an interface" áp dụng vào chuyện khởi tạo.
Vấn đề nó giải quyết
Giả sử bạn viết một hệ thống gửi thông báo, hỗ trợ Email, SMS, Push. Cách làm đầu tiên ai cũng nghĩ ra là một câu if/elif chọn loại theo tham số:
def send(kind, msg):
# chọn class cụ thể bằng if/elif - rải rác khắp code
if kind == "email":
return f"[Email] {msg}"
elif kind == "sms":
return f"[SMS] {msg}"
elif kind == "push":
return f"[Push] {msg}"
else:
raise ValueError(f"Khong ho tro kenh: {kind}")
print(send("email", "Don hang da xac nhan"))
print(send("sms", "Ma OTP: 481920"))
Với một chỗ duy nhất thì trông ổn. Vấn đề nảy sinh khi logic chọn loại này bị lặp lại ở nhiều nơi: chỗ gửi OTP, chỗ báo đơn hàng, chỗ nhắc lịch... mỗi chỗ lại một khối if/elif tương tự. Giờ bạn cần thêm kênh zalo. Bạn phải đi tìm và sửa tất cả các khối đó, sót một chỗ là sinh bug. Đây chính là vi phạm nguyên tắc Open/Closed (mở để mở rộng, đóng để sửa đổi): thêm tính năng đáng lẽ chỉ là thêm code mới, đằng này lại phải sửa code cũ khắp nơi.
Factory Method gom quyết định "tạo loại nào" về một chỗ, sau lưng một interface, để phần còn lại của hệ thống không phải bận tâm nữa.
Cách hoạt động + ví dụ chạy được
Có ba vai trò cần phân biệt:
- Sản phẩm (Product): interface chung mà client làm việc cùng. Ở đây là
Notificationvới methodsend. - Creator: lớp khai báo factory method (
create_notification) và dùng sản phẩm đó trong logic chung (notify). Nó không tự chọn class con. - Creator con (Concrete Creator): mỗi lớp con override factory method để trả về một sản phẩm cụ thể.
from abc import ABC, abstractmethod
# Sản phẩm: hợp đồng chung cho mọi kênh thông báo
class Notification(ABC):
@abstractmethod
def send(self, msg): ...
class EmailNotification(Notification):
def send(self, msg): return f"[Email] {msg}"
class SmsNotification(Notification):
def send(self, msg): return f"[SMS] {msg}"
class PushNotification(Notification):
def send(self, msg): return f"[Push] {msg}"
# Creator: khai báo factory method, tự dùng nó trong logic chung
class NotificationService(ABC):
@abstractmethod
def create_notification(self) -> Notification: # factory method
...
def notify(self, msg): # logic chung, không đổi
noti = self.create_notification()
return noti.send(msg)
# Các Creator con: mỗi lớp quyết định tạo sản phẩm cụ thể nào
class EmailService(NotificationService):
def create_notification(self): return EmailNotification()
class SmsService(NotificationService):
def create_notification(self): return SmsNotification()
class PushService(NotificationService):
def create_notification(self): return PushNotification()
# Client chỉ làm việc qua NotificationService, không biết class cụ thể
def run(service: NotificationService, msg):
return service.notify(msg)
print(run(EmailService(), "Don hang da xac nhan"))
print(run(SmsService(), "Ma OTP: 481920"))
print(run(PushService(), "Ban co 1 tin nhan moi"))
Để ý hai điều. Thứ nhất, hàm run và method notify không hề nhắc tên Email, Sms hay Push; chúng chỉ biết interface Notification và lớp NotificationService. Thứ hai, muốn thêm kênh Zalo, bạn chỉ viết thêm một class ZaloNotification và một class ZaloService; toàn bộ notify và run giữ nguyên. Không còn khối if/elif nào phải đi lùng sửa. Đó chính là Open/Closed thành hiện thực.
if/elif ở trên, kết quả in ra y hệt cho Email và SMS. Điểm khác không nằm ở output mà ở chi phí thay đổi: bản Factory Method cho phép mở rộng bằng cách thêm lớp mới, thay vì sửa code cũ.Phân biệt nhanh với "Simple Factory"
Bạn sẽ hay nghe tới "Simple Factory" và dễ nhầm nó với Factory Method. "Simple Factory" thực chất là một hàm/method gom câu if/elif chọn class vào một chỗ duy nhất, ví dụ:
def make_notification(kind): # Simple Factory: vẫn if/elif, chỉ gom về 1 chỗ
if kind == "email": return EmailNotification()
if kind == "sms": return SmsNotification()
raise ValueError(kind)
Cách này đã tốt hơn việc rải if/elif khắp nơi, và nhiều khi là đủ dùng. Nhưng nó không phải pattern GoF, và mỗi lần thêm loại vẫn phải sửa chính hàm đó. Factory Method khác ở chỗ nó dùng kế thừa và đa hình: việc chọn loại được đẩy cho lớp con qua override, nên bạn mở rộng bằng cách thêm lớp mới thay vì sửa hàm cũ. Nói ngắn gọn: Simple Factory tập trung quyết định vào một hàm; Factory Method phân tán quyết định đó xuống các lớp con.
classmethod kiểu from_config() hay from_dict(), một registry ánh xạ tên sang class rồi tra ra khi cần, hoặc đơn giản là truyền thẳng class/callable vào như một tham số. Cũng đừng đồng nhất "Factory Method" với "cách thay thế if/elif": bỏ được if/elif chỉ là hệ quả dễ thấy. Điều cốt lõi là hoãn quyết định chọn class cụ thể và cô lập nó khỏi code dùng, chứ không phải một cú pháp cụ thể nào.Khi nào dùng, khi nào không
Factory Method phát huy tác dụng khi:
- Bạn có nhiều biến thể sản phẩm cùng chung một interface, và danh sách biến thể còn tăng theo thời gian.
- Phần code chung muốn làm việc với sản phẩm qua interface, không muốn dính vào class cụ thể.
- Bạn muốn mỗi lớp con (mỗi ngữ cảnh) tự quyết định dùng biến thể nào mà không đụng vào logic chung.
SomeClass(). Dựng cả một cây Creator/Product cho một loại chỉ làm code khó đọc hơn mà chẳng đổi lại được gì. Pattern là để trả giá cho sự linh hoạt khi bạn thật sự cần linh hoạt.- Chưa có nỗi đau thì chưa cần. Giống mọi pattern, chỉ đưa Factory Method vào khi việc thêm loại mới hoặc thay class cụ thể đã bắt đầu gây khó, chứ đừng cài sẵn "cho chắc".
- Đừng nhầm với Simple Factory. Nếu một hàm gom
if/eliflà đủ và số loại ổn định, dùng nó cho gọn; đừng cố dựng kế thừa chỉ để nghe cho "đúng pattern".
Trong hệ thống thật
Bỏ ví dụ đồ chơi sang một bên, đây là những chỗ bạn thật sự gặp ý định của Factory Method trong code chạy production:
- Parser/exporter theo định dạng file. Một registry ánh xạ đuôi file sang handler:
csvraCsvParser,jsonraJsonParser,parquetraParquetParser. Code nghiệp vụ chỉ đưa vào tên định dạng rồi nhận về đúng handler. Ngay trong pandas,read_parquetcũng chọn engine (pyarrowhayfastparquet) theo tham số rồi mới dựng bộ đọc tương ứng. - Client thông báo theo kênh cấu hình. Cấu hình ghi
emailthì dựng client SMTP,smsthì dựng client Twilio,pushthì dựng client Firebase Cloud Messaging. Chỗ gọi chỉ biết một interfacesend(message), đúng như ví dụ ở trên nhưng với client thật. - Logging.
logging.getLogger("app.db")trả về logger theo tên và tự tạo mới nếu chưa có, thay vì để bạnLogger(...)trực tiếp. Cònlogging.config.dictConfigđọc khoáclasstrong cấu hình (logging.StreamHandler,logging.FileHandler,logging.handlers.RotatingFileHandler) rồi dựng handler tương ứng lúc chạy: đúng kiểu registry ánh xạ tên sang class. - Backend lưu trữ theo biến môi trường.
STORAGE_BACKEND=localkhi dev thì tạoLocalFileStorageghi thẳng ra đĩa,s3khi production thì tạoS3Storagedùng boto3. Django làm đúng việc này qua settingSTORAGES: bạn khai tên class backend, framework dựng nó lên hộ. Code nghiệp vụ chỉ gọistorage.save(...). - Connection theo loại cơ sở dữ liệu. SQLAlchemy
create_engine("postgresql+psycopg://...")đọc phần scheme của URL để chọn đúng dialect và driver; Django chọn backend theo khoáENGINEtrongDATABASES. Bạn đổi Postgres sang SQLite bằng cách đổi một chuỗi cấu hình, không đụng vào code truy vấn.
Trade-off
Factory Method không miễn phí. Trước khi đưa vào, cân hai cột này:
Được:
- Thêm loại sản phẩm mới chỉ cần viết thêm một lớp (hoặc đăng ký thêm một dòng vào registry), code dùng không phải sửa. Đây là Open/Closed đúng nghĩa.
- Quyết định "chọn class nào" gom về một chỗ duy nhất, thay vì rải
if/elifkhắp codebase và sót một chỗ là sinh bug. - Dễ thay bằng loại giả khi test: chỉ cần một Creator con trả về
FakeNotificationlà cả luồng chạy được mà không gửi email thật. - Code dùng chỉ phụ thuộc vào interface sản phẩm, nên nó đọc gọn hơn và ít lý do phải thay đổi hơn.
Phải trả giá:
- Thêm một tầng gián tiếp. Đọc code bạn thấy
create_notification()nhưng phải lần ngược qua cấu hình hoặc cây kế thừa mới biết class thật nào đang chạy. - Thừa thãi khi chỉ có một loại sản phẩm và chưa thấy biến thể thứ hai: bạn dựng cả bộ khung để đổi lại sự linh hoạt không ai dùng.
- Registry động (ánh xạ chuỗi sang class) làm mất phần lớn khả năng kiểm tra kiểu tĩnh: mypy khó biết bạn sẽ nhận về class gì.
- Lỗi cấu hình chỉ lộ ra lúc chạy. Gõ sai
STORAGE_BACKEND=s333thì trình biên dịch không cản, chương trình nổ giữa production. - Số lượng class tăng: mỗi sản phẩm kéo theo một Creator con, dễ thành một rừng file nhỏ nếu lạm dụng.
Tóm tắt
- Factory Method: khai báo một phương thức tạo đối tượng, để lớp con quyết định tạo class cụ thể nào; code chung làm việc với sản phẩm qua interface.
- Nó xoá các khối
if/elifchọn class rải rác, giúp thêm loại mới = thêm lớp mới, không phải sửa code cũ (đúng tinh thần Open/Closed). - Ba vai trò: Product (interface sản phẩm), Creator (khai báo factory method + logic chung), Concrete Creator (override để tạo sản phẩm cụ thể).
- Simple Factory chỉ là một hàm gom
if/elif, không phải pattern GoF; Factory Method dùng đa hình nên mở rộng không cần sửa code cũ. - Chỉ một loại sản phẩm, không có biến thể thì tạo trực tiếp, đừng thêm tầng thừa.
- Kai