Bạn từng mua một bộ bàn ghế cùng bộ sưu tập: bàn, ghế, tủ đều cùng tông gỗ, cùng kiểu tay nắm, đặt cạnh nhau là ăn khớp. Giờ tưởng tượng bạn mua lẻ từng món ở ba cửa hàng khác nhau: một cái bàn hiện đại, một cái ghế cổ điển, một cái tủ tân cổ. Kê chung một phòng là lệch pha ngay. Trong code cũng vậy - nhiều khi bạn không tạo một đối tượng đơn lẻ, mà tạo cả một nhóm đối tượng phải hợp phong cách với nhau. Abstract Factory sinh ra để lo đúng chuyện đó.
Abstract Factory là gì?
Abstract Factory là một mẫu thuộc nhóm Creational (khởi tạo). Nó cung cấp một giao diện (interface) để tạo ra một họ các đối tượng liên quan hoặc phụ thuộc lẫn nhau, mà không cần chỉ định class cụ thể của từng đối tượng.
Từ khoá cần nhớ là "họ" (family). Một họ sản phẩm là một nhóm các đối tượng được thiết kế để đi cùng nhau: bộ nút bấm (Button) và ô tick (Checkbox) của cùng một theme, hay bộ cửa sổ, thanh cuộn, hộp thoại của cùng một hệ điều hành. Abstract Factory đóng vai như một "cửa hàng bán trọn bộ": bạn chọn cửa hàng (concrete factory) một lần, rồi mọi món lấy ra từ đó chắc chắn cùng phong cách.
Quay lại analogy bộ nội thất: Abstract Factory chính là bộ sưu tập. Bạn chọn "bộ Bắc Âu" hay "bộ tân cổ điển" (chọn factory), sau đó gọi lấy bàn, lấy ghế, lấy tủ - và yên tâm chúng đồng bộ vì đều thuộc cùng một bộ. Bạn không phải tự đi so từng món.
Khác gì với Factory Method?
Nếu bạn đã gặp Factory Method (cũng nhóm Creational), rất dễ nhầm hai mẫu này. Ranh giới thực ra rất rõ:
- Factory Method tạo ra MỘT sản phẩm. Nó trả lời câu hỏi "tạo một đối tượng loại nào?" và thường là một method duy nhất để lớp con quyết định class cụ thể.
- Abstract Factory tạo ra MỘT HỌ nhiều sản phẩm liên quan. Nó gom nhiều method tạo đối tượng (create_button, create_checkbox...) vào chung một giao diện, để cả nhóm luôn đồng bộ.
Nói ngắn gọn: Factory Method lo một món; Abstract Factory lo cả bộ. Trên thực tế, một Abstract Factory thường được cài đặt bằng cách gom nhiều Factory Method lại - mỗi method tạo một loại sản phẩm trong họ. Bạn có thể xem Abstract Factory như "nhiều Factory Method đứng chung một mái nhà, cùng cam kết một phong cách".
if theme == "dark": btn = DarkButton() rồi vài chục dòng sau lại if theme == "dark": chk = DarkCheckbox(). Rải rác khắp nơi, chỉ cần một chỗ quên cập nhật là bạn có nút Dark ghép với ô tick Light - lệch phong cách mà trình biên dịch không hề báo lỗi. Abstract Factory dồn toàn bộ quyết định "chọn họ nào" về một điểm duy nhất.Cách hoạt động và ví dụ Python
Ta dựng một bộ UI đơn giản có hai phong cách theme: Light và Dark. Mỗi họ gồm hai sản phẩm phải đồng bộ với nhau: Button và Checkbox. Bộ khung gồm bốn phần:
- Sản phẩm trừu tượng (
Button,Checkbox): hợp đồng chung cho từng loại sản phẩm. - Sản phẩm cụ thể (
LightButton,DarkCheckbox...): cài đặt thật cho từng phong cách. - Abstract Factory (
ThemeFactory): giao diện hứa tạo được cả họ. - Concrete factory (
LightThemeFactory,DarkThemeFactory): mỗi cái khoá chặt vào một phong cách.
from abc import ABC, abstractmethod
# --- Các "san pham" truu tuong: cung mot ho UI ---
class Button(ABC):
@abstractmethod
def render(self): ...
class Checkbox(ABC):
@abstractmethod
def render(self): ...
# --- Ho san pham phong cach Light ---
class LightButton(Button):
def render(self): return "[ Nut nen sang, chu den ]"
class LightCheckbox(Checkbox):
def render(self): return "[x] o tick vien xam nhat"
# --- Ho san pham phong cach Dark ---
class DarkButton(Button):
def render(self): return "[ Nut nen toi, chu trang ]"
class DarkCheckbox(Checkbox):
def render(self): return "[x] o tick vien xam dam"
# --- Abstract Factory: hop dong tao CA HO san pham ---
class ThemeFactory(ABC):
@abstractmethod
def create_button(self) -> Button: ...
@abstractmethod
def create_checkbox(self) -> Checkbox: ...
# --- Concrete factory: moi cai khoa chat vao MOT phong cach ---
class LightThemeFactory(ThemeFactory):
def create_button(self): return LightButton()
def create_checkbox(self): return LightCheckbox()
class DarkThemeFactory(ThemeFactory):
def create_button(self): return DarkButton()
def create_checkbox(self): return DarkCheckbox()
# --- Code dung chi biet ThemeFactory + Button + Checkbox (deu truu tuong) ---
def build_form(factory: ThemeFactory):
button = factory.create_button()
checkbox = factory.create_checkbox()
print(button.render())
print(checkbox.render())
print("Giao dien Light:")
build_form(LightThemeFactory())
print()
print("Giao dien Dark:")
build_form(DarkThemeFactory())
Để ý hàm build_form: nó chỉ biết tới ThemeFactory, Button và Checkbox - toàn cái trừu tượng, không hề nhắc tên LightButton hay DarkCheckbox. Bạn chọn theme một lần duy nhất khi truyền factory vào. Từ đó mọi sản phẩm lấy ra chắc chắn cùng họ. Đây chính là chỗ Abstract Factory phát huy: client đi qua factory thì không còn phải tự chọn và tự ghép sản phẩm, vì mỗi concrete factory chỉ đẻ ra đồ cùng phong cách của nó - con đường dễ đi nhất cũng là con đường đúng. Nói cho chính xác: pattern không cấm được ai đó viết thẳng LightButton() rồi ghép với DarkCheckbox(), ngôn ngữ vẫn cho phép làm vậy. Muốn chặn cứng thì cần cơ chế khác: kiểm tra lúc chạy xem các sản phẩm có cùng họ hay không, hoặc không export các class cụ thể ra ngoài module mà chỉ để lộ factory.
Muốn cho người dùng đổi theme lúc chạy? Chỉ cần đổi đúng một biến factory. Muốn thêm theme "High Contrast"? Viết thêm một HighContrastThemeFactory cùng bộ sản phẩm của nó, build_form giữ nguyên không sửa một dòng. Đó là tinh thần "phụ thuộc vào cái trừu tượng, không phụ thuộc vào class cụ thể" mà tôi đã nói ở bài Program to interface & Composition over inheritance, và cũng là chữ O (Open/Closed) lẫn D (Dependency Inversion) trong SOLID: mở để mở rộng, đóng với sửa đổi.
Khi nào nên - và khi nào KHÔNG nên
Nên dùng khi:
- Bạn cần tạo nhiều họ sản phẩm có thể hoán đổi, và mỗi họ phải đồng bộ nội bộ (bộ UI theo theme, bộ widget cross-platform Windows/Mac/Linux, bộ driver theo loại cơ sở dữ liệu...).
- Bạn muốn dồn quyết định "chọn họ nào" về một điểm duy nhất, để phần còn lại của hệ thống không phải rải rác câu
ifkiểm tra loại. - Bạn muốn ngăn từ gốc việc trộn nhầm sản phẩm khác họ với nhau.
KHÔNG nên (đừng vẽ rắn thêm chân) khi:
- Chỉ có một họ sản phẩm, hoặc họ hầu như không bao giờ đổi. Lúc đó cả tầng abstract factory chỉ là lớp gián tiếp thừa - khởi tạo thẳng cho nhanh.
- Họ sản phẩm hay phải thêm loại mới. Đây là điểm yếu cố hữu: mỗi khi thêm một loại sản phẩm vào họ (ví dụ thêm
Sliderbên cạnh Button/Checkbox), bạn phải sửa giao diện abstract factory và TẤT CẢ concrete factory. Nếu đang có 5 theme, đó là 5 chỗ phải cập nhật. Abstract Factory dễ thêm họ mới nhưng khó thêm loại sản phẩm mới. - Nhu cầu chỉ là "tạo một đối tượng tuỳ loại" - đó là việc của Factory Method, đơn giản hơn, đừng nâng cấp lên Abstract Factory cho nặng nề.
if theme == ... lặp lại nhiều nơi, hoặc đã từng dính bug trộn nhầm sản phẩm khác họ. Đừng dựng sẵn bộ khung bốn tầng cho một thứ mới có một phiên bản, đó đúng là kiểu over-engineering mà tôi hay nhắc.Trong hệ thống thật
Ví dụ theme UI dễ hình dung, nhưng chỗ tôi gặp Abstract Factory nhiều nhất lại là backend. Vài chỗ quen mặt:
- Bộ adapter theo nhà cung cấp cloud. Một họ là S3 + SQS + Secrets Manager của AWS, họ kia là GCS + Pub/Sub + Secret Manager của GCP. Chọn một nhà cung cấp nghĩa là lấy trọn bộ ba đồng bộ, chứ không phải ghép lưu trữ của bên này với hàng đợi của bên kia rồi tự xoay cấu hình.
- Họ đối tượng theo loại cơ sở dữ liệu. Connection, dialect và query builder của PostgreSQL phải đi chung với nhau; đổi sang MySQL là đổi cả ba. Một factory theo loại cơ sở dữ liệu giữ cho ba món đó không bao giờ lệch nhau.
- Bộ test double đồng bộ cho môi trường test. Fake repository + fake queue + fake clock dựng từ cùng một factory, nên cả bộ chia sẻ chung một trạng thái trong bộ nhớ và cùng một mốc thời gian giả. Thay toàn bộ tầng hạ tầng bằng một dòng đổi factory.
- Bộ client theo môi trường. Cổng thanh toán thường có sandbox và production, mỗi bên một endpoint, một bộ khoá, một webhook verifier. Gom thành hai concrete factory thì không trộn nhầm sandbox với production được nữa.
Cái tôi thấy đáng giá nhất ở đây không phải là bớt được vài dòng if, mà là loại hẳn một lớp bug tốn kém: gọi API production bằng khoá sandbox, hoặc ghi dữ liệu thật vào bucket test. Quyết định nằm ở một chỗ duy nhất, nhìn là thấy.
Trade-off
Được:
- Cả họ sản phẩm luôn đồng bộ, không còn cảnh mỗi món một phiên bản.
- Quyết định chọn họ gom về một chỗ duy nhất, thường là chỗ khởi tạo ứng dụng.
- Thêm một họ mới rất rẻ: viết thêm một concrete factory, code dùng giữ nguyên.
- Khi test, thay toàn bộ hạ tầng thật bằng một họ giả chỉ bằng việc truyền factory khác.
Phải trả giá:
- Thêm một loại sản phẩm mới vào họ thì phải sửa interface factory và mọi concrete factory.
- Nhiều tầng class cho một bài toán có khi rất nhỏ.
- Người mới đọc code phải nhảy qua vài lớp trừu tượng mới thấy class thật nằm đâu.
- Nếu thực tế chỉ có đúng một họ, toàn bộ tầng này là chi phí thuần, không đổi lại được gì.
Tóm tắt
- Abstract Factory tạo ra cả một họ đối tượng liên quan mà không đụng class cụ thể, và bảo đảm các sản phẩm trong cùng họ luôn đồng bộ.
- Phân biệt: Factory Method tạo một sản phẩm; Abstract Factory tạo một họ nhiều sản phẩm (thường là gom nhiều Factory Method lại).
- Điểm mạnh: dồn quyết định chọn họ về một chỗ, dễ thêm họ mới, chặn việc trộn nhầm sản phẩm khác phong cách.
- Điểm yếu: thêm một loại sản phẩm mới vào họ phải sửa mọi factory; thừa thãi nếu chỉ có một họ hoặc họ hiếm khi đổi.
- Kai