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

Factory Method: để lớp con quyết định tạo đối tượng nào

TL;DR: Factory Method khai báo một phương thức để tạo đối tượng, nhưng nhường cho lớp con quyết định class cụ thể nào được tạo. Nhờ đó, phần code chung làm việc với sản phẩm qua interface, còn việc "chọn loại nào" được gom về một chỗ. Thêm loại sản phẩm mới chỉ là viết thêm một lớp con, không phải đi sửa các câu 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"))
[Email] Don hang da xac nhan [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à Notification với method send.
  • 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"))
[Email] Don hang da xac nhan [SMS] Ma OTP: 481920 [Push] 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.

So với bản 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.

Đây là hình thức kinh điển, không phải khuôn duy nhất. Dạng sách giáo khoa ở trên, tức lớp con override một method tạo sản phẩm, là hình thức kinh điển (canonical form) của Factory Method. Trong code hiện đại, nhất là Python, cùng một ý định đó thường xuất hiện dưới dạng khác: một hàm factory ở cấp module, một 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.
Đừng thêm tầng thừa. Nếu bạn chỉ có một loại sản phẩm duy nhất và không thấy biến thể nào sắp xuất hiện, thì cứ tạo trực tiếp bằng 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/elif là đủ 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: csv ra CsvParser, json ra JsonParser, parquet ra ParquetParser. Code nghiệp vụ chỉ đưa vào tên định dạng rồi nhận về đúng handler. Ngay trong pandas, read_parquet cũng chọn engine (pyarrow hay fastparquet) 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 email thì dựng client SMTP, sms thì dựng client Twilio, push thì dựng client Firebase Cloud Messaging. Chỗ gọi chỉ biết một interface send(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ạn Logger(...) trực tiếp. Còn logging.config.dictConfig đọc khoá class trong 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=local khi dev thì tạo LocalFileStorage ghi thẳng ra đĩa, s3 khi production thì tạo S3Storage dùng boto3. Django làm đúng việc này qua setting STORAGES: bạn khai tên class backend, framework dựng nó lên hộ. Code nghiệp vụ chỉ gọi storage.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á ENGINE trong DATABASES. 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/elif khắ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ề FakeNotification là 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=s333 thì 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/elif chọ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.
Series Design Patterns - nhóm Creational. Đây là bài mở đầu nhóm Khởi tạo (Creational). Nếu cần nền tảng, đọc lại Design Pattern là gì?, SOLID và Program to interface & Composition over inheritance. 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