Pattern 16/22 · Creational
Abstract Factory Nhà máy trừu tượng
Một factory duy nhất tạo ra cả một họ sản phẩm có quan hệ với nhau (Button + Input + Card của cùng một theme), để client không còn khả năng vô tình trộn sản phẩm của hai họ khác nhau.
01 — Mở đầu bằng code đang hỏng
Vấn đề
Bạn làm design system. Việc đầu tiên: không ai được tự viết <button class="...">, phải qua createButton(variant) để class CSS luôn đúng. Một hàm, một tham số, sạch sẽ. Đây chính là Factory Method và nó đang phục vụ bạn tốt.
Sáu tháng sau, thiết kế đòi đồng bộ cả họ: button, input, card, badge, toast. Bạn thêm createInput(variant), createCard(variant) — mỗi cái vẫn là một factory function riêng, vẫn đẹp. Rồi SettingsForm.vue render ra một bên nút màu đen cạnh một ô input màu trắng. Điều tra: variant của button đến từ prop của component, còn input lấy từ composable useTheme() — hai đường truyền khác nhau, và ở màn hình đó chúng không trùng giá trị.
Không ai viết sai logic. Vấn đề là shape của code cho phép bạn lấy button ở họ này và input ở họ kia, và TypeScript hoàn toàn im lặng, vì createButton trả về Button và createInput trả về Input — hai interface độc lập, không có ràng buộc nào nói "hai cái này phải cùng nguồn". Một screenshot xấu là triệu chứng sớm; bug thật của họ nhà này nằm im hơn nhiều.
Biến thể backend của cùng câu chuyện, và nó đau hơn nhiều. Bạn viết createConnection(dialect), rồi cần createQuoter(dialect) để bọc tên cột, rồi createMigrator(dialect). Ba factory riêng, ba lần truyền dialect. Một lần refactor tên biến, một file còn sót "mysql" trong khi hai file kia là "postgres". Postgres không bọc identifier bằng backtick, nên câu SQL chạy được, trả về kết quả rỗng, và chẳng báo lỗi ở đâu cả. Bạn debug hai ngày để đi tới kết luận: thứ bị sai đã được tạo ở một file khác, từ rất lâu rồi.
Bài học: khi sản phẩm chỉ có một, Factory Method chặn được mọi thứ. Khi sản phẩm đi theo họ và chúng có ràng buộc với nhau, bạn cần một đơn vị code biểu diễn chính cái "họ" đó — chứ không phải ba factory cùng đọc một chuỗi từ context.
02 — Ý tưởng, chưa động vào code
Giải pháp
Nghịch lý: bạn gọi db.selectFrom(...) và nhận về SQL đúng chuẩn Postgres. Bạn làm gì khác khi dùng MySQL? Không gì cả — bạn chỉ đổi một dòng khởi tạo. Đó là Abstract Factory: một object duy nhất, interface của nó liệt kê mọi cách tạo trong họ (createAdapter(), createDriver(), createIntrospector(), createQueryCompiler()), và mỗi dialect cài đặt lại toàn bộ danh sách đó.
Cấu trúc: một interface UIFactory với button(), input(), card(); mỗi họ một object dark, light, hc. Client chỉ nhận một factory và gọi mọi thứ từ nó, nên nó không còn khả năng trộn họ. Số chỗ phân nhánh co về một — composition root, nơi bạn đọc theme từ config và chọn object.
Nên bỏ ngay hình ảnh "factory của factory" trong đầu. Trong TypeScript, Abstract Factory thường chỉ là một interface mô tả contract của một plugin/driver/theme, và mỗi họ là một object literal khớp contract đó. Nếu họ của bạn chỉ có đúng MỘT sản phẩm, thì đây không phải Abstract Factory — nó là Factory Method, và bạn vừa thêm một tầng gói vô ích. Pattern này chỉ có lý do khi sản phẩm đi theo cặp trở lên và chúng bắt buộc phải ăn khớp nhau.
03 — Làm thật, mỗi bước một fragment code
Từng bước một
Kể tên các họ và các product của mỗi họ trước khi viết code
Abstract Factory đứng hay ngã ở bước này, không phải ở bước code. Liệt kê ra giấy: họ là thứ bạn chọn một lần rồi dùng cả năm (theme, nền tảng, dialect CSDL). Product là thứ bạn tạo nhiều lần trong phiên làm việc (button, input, connection, quoter).
Bài kiểm tra tính chính đáng: liệu có tình huống nào hai product khác họ cùng xuất hiện trong một màn hình hay một transaction không? Nếu có và hệ thống vẫn chạy đúng, họ đó giả — đừng dùng pattern này.
Họ (chọn 1 lần lúc boot) Product (tạo nhiều lần) Ràng buộc giữa các product
----------------------- ------------------------ --------------------------
theme: dark button, input, card cùng bảng màu, cùng radius
theme: light button, input, card cùng bảng màu, cùng radius
dialect: postgres connection, quoter, SQL "col" chứ không phải backtick
dialect: mysql connection, quoter, SQL backtick, LIMIT khác nhauViết interface cho từng product, như bình thường
Chưa có gì đặc biệt. Mỗi product một interface nhỏ, mô tả đúng những gì client cần dùng — không hơn. Nhớ rằng interface product tự nó không chặn được việc trộn họ, nên đừng cố nhét thông tin họ vào đó:
export interface Button {
readonly kind: string
render(label: string): string
}
export interface Input {
readonly kind: string
render(placeholder: string): string
}
// Đừng làm cái này: kiểu hoá "họ" vào từng product.
// type DarkButton = Button & { theme: 'dark' }
// -> bạn phải lặp lại nó cho mọi product, và không ai kiểm tra chéo.Khai báo interface của CẢ HỌ — đây là bước của pattern
Một interface, một method cho mỗi product. Kiểu trả về là interface product, không phải class cụ thể. Interface này là thứ chặn được trộn họ, vì client chỉ có thể lấy sản phẩm từ một object duy nhất:
export interface UIFactory {
readonly name: string
button(): Button
input(): Input
card(): Card
}
// Ràng buộc giờ nằm trong KIỂU: một UIFactory phải trả về
// button + input + card "hợp nhau", và client không có
// đường nào khác để lấy chúng.createButton/createInput/createCard rời nhau cho phép 3 nguồn theme khác nhau. Một object thì không.Cài một factory cho mỗi họ, bằng object literal
TypeScript cho bạn bản sạch nhất của pattern mà không cần một class nào: object literal khai báo satisfies UIFactory. Thiếu method là lỗi biên dịch ngay tại file của họ đó — không phải lúc chạy.
import type { UIFactory } from './ui-factory'
export const dark = {
name: 'dark',
button: () => ({
kind: 'dark-btn',
render: label => '<button class="btn--dark">' + label + '</button>',
}),
input: () => ({
kind: 'dark-input',
render: ph => '<input class="input--dark" placeholder="' + ph + '">',
}),
card: () => ({
kind: 'dark-card',
render: title => '<div class="card--dark">' + title + '</div>',
}),
} satisfies UIFactorysatisfies cho cùng độ an toàn với ít ceremony hơn.satisfies chứ không : UIFactory nếu bạn muốn giữ literal type hẹp; dùng : UIFactory khi bạn muốn ép đúng interface.Cho client chỉ nhận đúng một factory
Nơi tiêu thụ sản phẩm không được tự chọn họ. Nó nhận factory như một tham số/prop, và mọi product nó hiển thị đều chui ra từ cái object đó. Đây là chỗ pattern trả tiền:
import type { UIFactory } from './ui-factory'
export function renderSettingsForm(ui: UIFactory): string {
// Trộn họ là BẤT KHẢ ở đây: không có nguồn thứ hai nào.
return ui.button().render('Lưu') + ' || ' + ui.input().render('Email')
}
// Bản Vue: một InjectionKey đã typed, cha provide một lần.
export const UI_KEY = Symbol('ui') as InjectionKey<UIFactory>
// app/plugin: provide(UI_KEY, pickUI(useRuntimeConfig().theme))
// component: const ui = inject(UI_KEY)! // không còn đường nào khácvariant/theme riêng để tự chọn, bạn đã vô hiệu hoá pattern: nguồn duy nhất lại thành hai nguồn.Chỗ duy nhất được if: composition root
Một file. Đọc env/config/user preference, chọn object, đưa cho app. Mọi if (theme === ...) khác trong codebase là smell:
// server/utils hoặc plugin: ĐÚNG MỘT chỗ chọn họ.
import { dark } from './ui/dark'
import { light } from './ui/light'
import { highContrast } from './ui/hc'
const families = { dark, light, hc: highContrast } as const
export function pickUI(mode: string): UIFactory {
const found = families[mode as keyof typeof families]
if (!found) throw new Error('Theme không tồn tại: ' + mode)
return found
}
// app/plugin/ui.ts:
// provide(key, pickUI(useRuntimeConfig().theme))theme/variant/dialect xuất hiện trong code nghiệp vụ thay vì chỉ ở composition root, họ sản phẩm đang bị rò.Trả giá thật: thêm một product vào họ
Đây là điểm yếu kinh điển của Abstract Factory, và bạn nên biết trước khi cam kết. Thêm method switch() vào UIFactory ⇒ mọi họ hiện có lập tức biên dịch lỗi. Pattern đóng kín với họ mới (thêm file hc.ts: dễ) nhưng mở sai hướng với product mới (sửa interface: đau).
Cái giá này là có thật và không có trick nào xoá được. Bạn chỉ chọn nơi muốn đau: hoặc thêm họ tốn 1 dòng, hoặc thêm product tốn N file.
interface UIFactory {
button(label: string): Button
input(placeholder: string): Input
switch(name: string, on: boolean): Toggle // <- mới
}
// dark.ts, light.ts, hc.ts: cả ba đỏ. Đúng lúc bạn muốn thấy nó.
// Giảm đau (không hết đau): một base factory lo default, mỗi họ spread nó vào.
const base = { switch: (name: string) => ({ kind: 'toggle', render: () => name }) }
export const dark = { ...base, button: () => ({ render: l => l }), input: () => ({ render: p => p }) }
// dark.ts cũ vẫn đỏ cho tới khi nó chịu cài switch().Cắt nghi thức: nó chỉ là contract của một plugin
Bỏ hết tên GoF đi thì thứ bạn viết ra là: một interface mô tả plugin, và mỗi plugin là một object khớp interface. Kysely gọi nó là Dialect, ORM khác gọi là Driver, bundler gọi là Plugin, Nuxt gọi nó là module với runtimeConfig. Bạn đã dùng Abstract Factory hàng tuần mà không gọi tên nó.
Việc nhận ra điều này cứu bạn khỏi hai tai nạn: dựng "factory of factories" lồng nhau (factory trả về factory — bạn sẽ không đọc nổi code của mình nữa), và tạo interface cho một họ chỉ có một thành viên.
// Trích API thật của Kysely: một họ = 4 product đi cùng nhau.
interface Dialect {
createAdapter(): DialectAdapter
createDriver(): Driver
createIntrospector(db: Kysely<any>): DatabaseIntrospector
createQueryCompiler(): QueryCompiler
}
const db = new Kysely<Db>({ dialect: new PostgresDialect({ pool }) })
// Bạn không chọn "quoter" riêng, không chọn "compiler" riêng.
// Một họ, một quyết định, ở một chỗ....Factory và nó chỉ có một method, bạn không viết Abstract Factory — bạn viết Factory Method và nên gọi nó bằng tên thật.04 — Ai nói chuyện với ai
Cấu trúc
- AbstractFactoryInterface khai báo **cả họ**: `button()`, `input()`, `card()`. Đây là thứ client nhìn thấy.
- AbstractProductInterface của từng product: `Button`, `Input`, `Card`. Client chỉ dùng đúng interface này.
- ConcreteFactoryMột họ: `dark`, `light`, `hc`. Cài đặt mọi method, và chỉ tạo product của họ mình.
- ConcreteProductDarkButton, DarkInput, HcCard. Không biết gì về họ khác và cũng không cần biết.
- ClientQuy trình render/query nhận **một** factory và lấy mọi product từ nó. Không chứa tên class cụ thể nào.
┌─────────────────────────────┐
Client ── 1 object ─►│ AbstractFactory: UIFactory │
renderForm(ui) │ button(label): Button │
│ input(ph): Input │
└───────┬──────────────┬──────┘
┌─────────┘ └──────────┐
▼ ▼
DarkFactory LightFactory
button() ──► DarkButton button() ──► LightButton
input() ──► DarkInput input() ──► LightInput
└── mọi product đi ra từ cùng một object ──┘
trộn họ không còn là lỗi compile, nó là lỗi KHÔNG TỒN TẠI05 — Sửa tuỳ ý, chạy ngay tại đây
Chạy thử: ba họ, một client, không trộn được
interface Button { render(): string }
interface Input { render(): string }
interface UIFactory {
readonly name: string
button(label: string): Button
input(placeholder: string): Input
}
const dark: UIFactory = {
name: 'dark',
button: label => ({ render: () => '<button class="btn--dark">' + label + '</button>' }),
input: p => ({ render: () => '<input class="input--dark" placeholder="' + p + '">' }),
}
const light: UIFactory = {
name: 'light',
button: label => ({ render: () => '<button class="btn--light">' + label + '</button>' }),
input: p => ({ render: () => '<input class="input--light" placeholder="' + p + '">' }),
}
// Họ thứ ba: chỉ cần thêm 1 object, không sửa client nào.
const highContrast: UIFactory = {
name: 'hc',
button: label => ({ render: () => '<button class="btn--hc">' + label + '</button>' }),
input: p => ({ render: () => '<input class="input--hc" placeholder="' + p + '">' }),
}
// Composition root: chỗ DUY NHẤT chọn họ.
const families: Record<string, UIFactory> = { dark, light, hc: highContrast }
// Client: không một tên product cụ thể nào lọt vào đây.
const renderForm = (f: UIFactory): string =>
f.button('Lưu').render() + ' || ' + f.input('Email').render()
for (const key of ['dark', 'light', 'hc']) {
const f = families[key]
console.log('[' + f.name + '] ' + renderForm(f))
}[dark] <button class="btn--dark">Lưu</button> || <input class="input--dark" placeholder="Email"> [light] <button class="btn--light">Lưu</button> || <input class="input--light" placeholder="Email"> [hc] <button class="btn--hc">Lưu</button> || <input class="input--hc" placeholder="Email">
Cùng code này chạy được bằng Bun: bun run demo.ts. Output in ra được kiểm tự động trong quá trình build site.
06 — Thành thật về cái giá
Khi nào dùng, khi nào đừng
Dùng khi
- Sản phẩm đi theo họ ≥ 2 thành phần và chúng chia sẻ ràng buộc: cùng bảng màu, cùng dialect SQL, cùng protocol version, cùng encoding.
- Bạn muốn thay toàn bộ một hoạn sản phẩm lúc khởi động hoặc theo config (theme, nền tảng, môi trường, tenant) mà không đụng code nghiệp vụ.
- Bạn muốn một chỗ duy nhất chứa tên class cụ thể (composition root), để phần còn lại của repo chỉ nói chuyện qua interface.
- Bạn thiết kế API plugin/driver cho người khác cài đặt: contract của plugin chính là Abstract Factory, và họ đăng ký cả họ chứ không đăng ký từng mẩu.
- Việc trộn sản phẩm khác họ tạo ra lỗi im lặng (SQL trả về rỗng, render lệch theme, dữ liệu thiếu) thay vì exception rõ ràng — đây là dấu hiệu mạnh nhất.
Đừng dùng khi
- Over-engineering là lỗi số một của pattern này. Họ có đúng MỘT product? Thì đó là Factory Method, và object factory chỉ là một wrapper không thêm thông tin nào. Hãy đếm product trước, rồi hãy đặt tên pattern.
- Thêm một product vào interface làm mọi factory hiện có lỗi biên dịch. Đây là chi phí thiết kế, không phải bug: nếu product list của bạn còn đổi hàng tháng, Abstract Factory đang sai hình.
- Chuyền tay factory qua 4 tầng rồi "tiện" lấy thêm product ở tầng cuối là con đường ngắn nhất tới service locator: component gọi
ui.button()vàui.reportWriter()trong cùng một object to đùng. Mỗi layer chỉ nhận đúng cái nó dùng — tách interface nhỏ ra. - Kiểu chỉ an toàn khi interface hẹp. Một
UIFactorytrả vềany, hoặc client vẫn nhận thêm biếnvariantriêng để tự chọn, thì bạn mất toàn bộ tính chặn trộn và chỉ còn lại ceremony. - Đừng lồng factory: factory tạo factory, rồi đọc config của factory cha. Sau ba tháng không ai trả lời được "cái object này ai tạo". Nếu cần nhiều họ độc lập, cho mỗi họ một factory riêng và ghép ở composition root.
07 — Bạn đã gặp nó rồi, chỉ là không gọi tên
Trong code thật
Kysely: interface Dialect
Contract thật, trong thư mục dialect/dialect.ts: createAdapter(), createDriver(), createIntrospector(db), createQueryCompiler(). PostgresDialect trả về bộ bốn sản phẩm Postgres, MysqlDialect trả về bộ bốn sản phẩm MySQL. Bạn không bao giờ chọn quoter hay compiler riêng — đó chính xác là mục đích của pattern.
TypeORM: một Driver per dialect
PostgresDriver, MysqlDriver, CockroachDriver... mỗi cái tự lo pool kết nối (createPool), tự escape identifier theo đúng syntax của database của mình (Postgres dùng dấu phẩy kép, MySQL dùng backtick), và tự sinh SQL. Chọn driver là chọn cả họ; không có API nào để lấy quoter của MySQL cắm vào connection Postgres.
Playwright: chromium / firefox / webkit
Mỗi BrowserType sinh ra một họ object nhất quán: Browser → BrowserContext → Page → Locator, và chúng tương thích nội bộ với nhau. Test của bạn viết một lần, chạy trên ba họ bằng cách đổi đúng một chỗ khởi tạo.
Nuxt/Vue: một theme object qua provide với InjectionKey
Cách lành mạnh để chủ đề hoá cả cây component: một object theme (token màu, radius, class) được provide một lần với InjectionKey<UIFactory>, các component chỉ đọc từ đó. Cùng một nguyên tắc: một nguồn duy nhất cho cả họ, không component nào tự chọn variant.
08 — Tự tay làm
Bài tập
Bạn có `createButton(v)`, `createInput(v)`, `createCard(v)` và một component đã render ra nút dark cạnh input light. Hãy đổi sang Abstract Factory với ba họ `dark`, `light`, `hc`, sao cho (a) mixing không còn viết được, (b) số chỗ so sánh theme là đúng 1, (c) thêm họ `hc` không phải sửa component nào.
Gợi ý, mở từng cái một:
- Viết interface
UIFactorycóname,button(),input(),card(). Nhận ra rằng component không còn nhậnvariantnữa. - Mỗi họ một file,
export const dark = { ... } satisfies UIFactory. Thêm họ = thêm file. - Gom hết về
pickUI(mode): UIFactoryở một file, rồiprovide(key, pickUI(...))một lần trong plugin. Xoá hếtif (mode === ...)còn lại.
Định nghĩa UIFactory; mỗi họ một object literal khớp interface; component nhận factory qua prop/inject và không còn tham số variant nào. pickUI(mode) là nơi duy nhất map chuỗi sang object, và nó throw khi key lạ. Thêm hc = một file mới + một dòng trong map. Muốn chứng minh mixing hết đường: thử viết dark.button() cạnh light.input() trong cùng một function render — bạn sẽ thấy không có cách nào gọi cả hai vì render chỉ nhận đúng một object.
interface Button { render(label: string): string }
interface Input { render(placeholder: string): string }
interface UIFactory {
readonly name: string
button(): Button
input(): Input
}
const dark = {
name: 'dark',
button: () => ({ render: l => '<btn dark>' + l + '</btn>' }),
input: () => ({ render: p => '<input dark ph=' + p + '>' }),
} satisfies UIFactory
const light = {
name: 'light',
button: () => ({ render: l => '<btn light>' + l + '</btn>' }),
input: () => ({ render: p => '<input light ph=' + p + '>' }),
} satisfies UIFactory
const hc = {
name: 'hc',
button: () => ({ render: l => '<btn hc>' + l + '</btn>' }),
input: () => ({ render: p => '<input hc ph=' + p + '>' }),
} satisfies UIFactory
// CHỖ DUY NHẤT chọn họ.
const families: Record<string, UIFactory> = { dark, light, hc }
export function pickUI(mode: string): UIFactory {
const f = families[mode]
if (!f) throw new Error('Theme không tồn tại: ' + mode)
return f
}
// Client: một tham số, không có cửa trộn.
const renderForm = (ui: UIFactory) => ui.button().render('Lưu') + ' ' + ui.input().render('Email')
for (const m of ['dark', 'light', 'hc'])
console.log(m + ': ' + renderForm(pickUI(m)))09 — Đọc cặp để hiểu bản chất
Pattern liên quan
- Factory MethodFactory Method tạo MỘT sản phẩm và cho phép subclass chọn; Abstract Factory là một *bộ* nhiều factory method bị buộc phải đi cùng nhau. Họ nhiều sản phẩm thường được khai báo bằng các factory method.
- BridgeRất dễ nhầm: Bridge tách một class thành hai phân cấp abstraction/implement rồi nối chúng bằng composition; Abstract Factory sinh ra cả họ implement đó. Bridge nói "ghép thế nào", Abstract Factory nói "ai tạo bộ nào".
- SingletonConcrete factory không có state nên thường được dùng như một hằng số export (`export const dark`), hoặc singleton đăng ký ở composition root — GoF ghi rõ đây là cặp hay đi cùng nhau.
- PrototypeThay vì mỗi concrete factory `new` từng product, nó có thể clone các instance mẫu. Thêm họ mới đôi khi chỉ là đăng ký một bộ prototype, không cần code mới.