Pattern 04/22 · Creational
Factory Method Phương thức nhà máy
Đóng việc "new class nào" vào một method hoặc function duy nhất, để nơi gọi chỉ khai báo nó cần gì, còn chọn implementation nào do subclass, config hay registry quyết định lúc chạy.
01 — Mở đầu bằng code đang hỏng
Vấn đề
Task: cho phép tải báo cáo. Route export đầu tiên dài đúng năm phút: lấy rows, gọi const exporter = new CsvExporter(), rồi res.send(exporter.render(rows)). Không ai phàn nàn — CsvExporter là một class sạch, có test, làm đúng một việc, và cú pháp new thì ai cũng viết được khi ngủ.
Rồi product muốn thêm JSON và PDF. Route thành ba nhánh if, mỗi nhánh một câu new. Cùng lúc đó tính năng "xuất dữ liệu" được đòi ở năm nơi: trang admin, job cron cuối ngày, API công khai, CLI nội bộ, và module báo cáo của khách hàng. Tới đây thì new CsvExporter() nằm trong 12 file khác nhau, copy-paste quanh một if (format === ...).
Một buổi chiều thứ Sáu, CsvExporter cần thêm tham số delimiter và timezone trong constructor. Bạn sửa 12 chỗ, type-check xanh, deploy. Ba mươi phút sau alert nổ: hai chỗ ở module báo cáo cũ vẫn truyền signature cũ, và chúng nằm trong một object kiểu any nên TypeScript không nhìn thấy. Không có lỗi nào trong 12 chỗ bạn sửa — lỗi nằm ở 2 chỗ bạn không biết là có tồn tại.
Chuyện thứ hai, lặp lại với hạ tầng: dev dùng SQLite file, staging dùng bản read-replica của Postgres, prod dùng pool với ssl: true. Câu new Pool(connectionString) nằm ngay trong class service. Hệ quả: test unit cũng phải dựng database thật, và mỗi lần cần đổi cách mở connection là một cuộc tìm-then-thay trên toàn repo.
Vấn đề không phải new là xấu. Vấn đề: new CsvExporter() là một literal — nó hàn file gọi dính vào một file cụ thể, và đóng băng quyết định "dùng class nào" ngay tại thời điểm bạn gõ code. Mọi thứ đến sau (format mới, env mới, plugin của team khác) đều đòi bạn sửa lại chỗ đã đóng băng đó.
02 — Ý tưởng, chưa động vào code
Giải pháp
Đổi câu hỏi ở nơi gọi. Thay vì "tạo một CsvExporter", nơi gọi hỏi "cho tôi một exporter cho format này". Câu new dời vào một method riêng; caller chỉ còn nhìn thấy interface ReportExporter. Từ đây, thêm format mới là sửa một chỗ, và chỗ đó là chỗ duy nhất được phép biết tên class.
Sức mạnh thật của bản GoF nằm ở chữ method: vì nó là method nên subclass override được. Cùng một quy trình run() (lấy dữ liệu → render → đặt tên file → stream), nhưng job công khai chọn theo query còn job audit thì ép cứng JSON. Đây là anh em sinh đôi của Template Method: quy trình cố định, đúng một bước bị để ngỏ — chỉ khác bước đó tạo object chứ không tính toán.
Còn bản sống sót lâu dài trong TypeScript thì đơn giản hơn nhiều: một function thuần createExporter(format), hoặc một map Record<string, () => Exporter>. Không this, không prototype chain, tree-shake được, test bằng cách truyền function giả vào. Bản abstract class trả giá bằng bug this mất binding khi bạn callback hoá, và đổi lại bạn chỉ có đúng một khả năng: subclass được quyền chọn class. Nếu bạn không có subclass, đừng trả cái giá đó.
03 — Làm thật, mỗi bước một fragment code
Từng bước một
Đếm số chỗ new và số loại trước đã
Trước khi trừu tượng hoá cái gì, đo xem nó đáng không. Chạy một lệnh grep cho một loại object và nhìn vào con số:
# Bao nhiêu chỗ tự tay new exporter?
rg -n "new (Csv|Json|Pdf)Exporter" src | wc -l
# 12
# Bao nhiêu file chứa quyết định "chọn exporter nào"?
rg -l "format === 'json'" src
# routes/report.ts jobs/night.ts cli/export.ts ...new trực tiếp là quyết định đúng.Rút new ra một function có tên nói lên ý định
Bước đầu tiên không cần class nào. Chỉ cần dời new vào một function, và đặt tên function theo nhu cầu nghiệp vụ chứ không theo tên class: createExporterFor(format), đừng đặt makeCsvHayJson.
Nhìn hình dưới, đây là toàn bộ "pattern" ở dạng thô sơ nhất:
export interface ReportExporter {
readonly format: string
render(rows: Record<string, string | number>[]): string
extension(): string
}
export function createExporter(format: string): ReportExporter {
if (format === 'json') return new JsonExporter()
if (format === 'pdf') return new PdfExporter()
return new CsvExporter()
}new giờ đứng cùng nhau. Từ khoá "duy nhất" bắt đầu có nghĩa: muốn biết hệ thống xuất được những gì, chỉ cần mở một file.Cho factory trả về interface, đừng trả về class cụ thể
Rất nhiều người viết function createExporter(f: string): CsvExporter | JsonExporter | PdfExporter. Trông thì chính xác hơn, thực ra bạn vừa đào thoát khỏi pattern: nơi gọi nhận một union của các class cụ thể, nên nó có quyền gọi exporter.delimiter — và một tháng sau bạn không đổi implementation được nữa.
Return type phải là interface, tức là thứ nhỏ hơn khả năng của cả ba class. Đây không phải "nguyên tắc trừu tượng hoá" cho oai: kiểu trả về chính là hợp đồng bạn dám giữ ổn định.
// Sai: union của class cụ thể -> caller biết quá nhiều
function createExporterBad(f: string): CsvExporter | JsonExporter {
/* ... */
}
// Đúng: caller chỉ thấy đúng những gì quy trình cần dùng
function createExporter(f: string): ReportExporter {
/* ... */
}
const exporter = createExporter(query.format)
exporter.render(rows) // OK
exporter.delimiter = ';' // Lỗi biên dịch — tốt, đó chính là bức tường bạn muốnnew cũng vô ích.Viết lại quy trình chung cho tới khi sạch tên class
Bây giờ sửa nơi dùng. Tiêu chí rất cơ học: trong body của hàm nghiệp vụ không còn chữ nào là tên class cụ thể. Nếu còn CsvExporter xuất hiện, nghĩa là bạn chưa chuyển xong.
import { createExporter } from './create-exporter'
export class ReportService {
handle(query: { format: string }, rows: Row[]) {
const exporter = createExporter(query.format) // <- chỗ duy nhất "chọn"
return {
body: exporter.render(rows),
contentType: CONTENT_TYPE[exporter.format],
filename: 'bao-cao.' + exporter.extension(),
}
}
}
// Thêm PdfExporter: hàm này không đổi một ký tự nào.CONTENT_TYPE[exporter.format]: quy trình lấy thông tin từ dữ liệu exporter tự khai báo, không cần biết nó là class gì.Bản GoF: biến nó thành method để subclass được quyền chọn
Factory function đã đủ cho 80% dự án. Nhưng có những tình huống bạn muốn phân hệ con quyết định: bạn viết ReportJob làm khung, và mỗi loại job (public, audit, đối tác) có luật chọn định dạng riêng — audit thì bắt buộc JSON bất kể query, job đối tác thì chỉ được CSV.
Đây là lúc createReport trở thành một method để ngỏ trong abstract class, và mỗi subclass điền vào:
abstract class ReportJob {
/** Factory Method: bước để ngỏ. */
abstract createReport(format: string): Report
/** Template: cố định, không subclass nào được sửa. */
run(query: { format: string }, rows: Row[]): string {
const r = this.createReport(query.format)
return '[' + r.format + '] ' + r.render(rows)
}
}
class PublicJob extends ReportJob {
createReport(format: string) { return format === 'json' ? new JsonReport() : new CsvReport() }
}
class AuditJob extends ReportJob {
createReport() { return new JsonReport() } // cứng, không đọc query
}run(), hai số phận. Đây là thứ factory function thuần không làm được — trừ khi bạn cho nó nhận một tham số chiến lược, và khi đó bạn quay về bản function.this binding (callback mất this là bug kinh điển), và bằng mất tree-shaking. Hãy mua khi cần, đừng mua vì sơ đồ GoF vẽ vậy.Truyền factory vào, đừng import nó
Kể cả khi đã có factory function, service của bạn vẫn import trực tiếp — nghĩa là test vẫn chạy đúng code production, vẫn mở connection thật. Biến factory thành tham số và bạn có đường may rẻ nhất từng có để test:
export class ReportService {
constructor(
private makeExporter: (format: string) => ReportExporter = createExporter,
) {}
handle(query: { format: string }, rows: Row[]) {
return this.makeExporter(query.format).render(rows)
}
}
// prod: new ReportService() — default là factory thật.
// test: không DB, không S3, không mock library:
const svc = new ReportService(() => ({
format: 'fake',
extension: () => 'txt',
render: () => 'MOCK',
}))Thay switch bằng registry khi danh sách đến từ dữ liệu
Trong hệ thống thật, format không đến từ code mà từ query string, từ cột settings.export_format trong DB, từ config admin vừa bấm lưu. Lúc đó if/else chuỗi dài là sai hình: bạn cần tra. Và đây cũng là chỗ plugin của team khác gắn vào mà không sửa core.
type Format = 'csv' | 'json' | 'pdf'
const registry: Record<Format, () => ReportExporter> = {
csv: () => new CsvExporter(),
json: () => new JsonExporter(),
pdf: () => new PdfExporter(),
}
export function createExporter(format: string): ReportExporter {
const make = registry[format as Format]
if (!make) throw new Error('Format không được hỗ trợ: ' + format)
return make()
}
// Ghi chú: value là () => Exporter chứ không phải Exporter,
// để PdfExporter chỉ được tạo khi thực sự cần (nó nặng).Format làm khoá, và throw to khi không thấy. Fallback ngầm về cái đầu tiên là cách biến một typo thành một báo cáo sai gửi cho khách.Đo lại: thêm một loại mới tốn bao nhiêu file
Nghiệm thu của refactor này không phải "code đẹp hơn" mà là một con số. Thêm định dạng XLSX. Bạn chạm vào mấy file?
// File MỚI, cộng đúng 2 dòng registry + 1 dòng union.
import type { ReportExporter } from './create-exporter'
export class XlsxExporter implements ReportExporter {
readonly format = 'xlsx'
extension() { return 'xlsx' }
render(rows: Record<string, string | number>[]) { /* exceljs */ return '' }
}
// registry.ts: xlsx: () => new XlsxExporter(),
// type Format = 'csv' | 'json' | 'pdf' | 'xlsx'ReportService.handle() để thêm một if, nghĩa là còn new hoặc còn so sánh chuỗi nằm sai chỗ. Quay lại grep.04 — Ai nói chuyện với ai
Cấu trúc
- Product (Report)Interface mà mọi nơi gọi nhìn thấy: `format`, `render(rows)`, `extension()`.
- ConcreteProductCsvReport, JsonReport, PdfReport. Không class nào biết các class khác tồn tại.
- Creator (ReportJob)Khai báo factory method là `abstract`, và chứa quy trình chung chỉ dùng interface.
- ConcreteCreatorPublicJob, AuditJob. Override factory method — đây là nơi luật chọn class sống.
- ClientGọi `job.run(query, rows)`. Trong code của nó không có tên class cụ thể nào.
Client ──► job.run(query, rows) client chỉ thấy interface
│
▼
┌─────────────────────────────────────────────┐
│ Creator: abstract ReportJob │
│ + run(query, rows) │ <- quy trình cố định
│ 1. r = this.createReport(query.format) │ <- bước để ngỏ
│ 2. return '[' + r.format + '] ' + ... │
│ + {abstract} createReport(fmt): Report │
└──────────────┬───────────────┬──────────────┘
override override
▼ ▼
┌────────────┐ ┌────────────┐
│ PublicJob │ │ AuditJob │ ConcreteCreator
│ csv|json │ │ ép json │
└─────┬──────┘ └─────┬──────┘
│ new │ new
▼ ▼
┌────────────┐ ┌────────────┐
│ CsvReport │ │ JsonReport │ ConcreteProduct
└────────────┘ └────────────┘05 — Sửa tuỳ ý, chạy ngay tại đây
Chạy thử: cùng một run(), hai cách chọn class
type Row = Record<string, string | number>
interface Report { readonly format: string, render(rows: Row[]): string }
class CsvReport implements Report {
readonly format = 'csv'
render(rows: Row[]): string {
const keys = Object.keys(rows[0] ?? {})
return keys.join(',') + ' ; ' + rows.map(r => keys.map(k => r[k]).join(',')).join(' ; ')
}
}
class JsonReport implements Report {
readonly format = 'json'
render(rows: Row[]): string { return JSON.stringify(rows) }
}
abstract class ReportJob {
// Factory Method: mọi quyết định "class nào" dồn vào đúng đây.
abstract createReport(format: string): Report
// Quy trình chung: body không còn chứa tên class cụ thể nào.
run(query: { format: string }, rows: Row[]): string {
const r = this.createReport(query.format)
return '[' + r.format + '] ' + r.render(rows)
}
}
class PublicJob extends ReportJob {
createReport(format: string): Report {
return format === 'json' ? new JsonReport() : new CsvReport()
}
}
class AuditJob extends ReportJob {
createReport(): Report { return new JsonReport() } // audit: bỏ qua query
}
const rows: Row[] = [{ id: 1, name: 'Minh' }, { id: 2, name: 'An' }]
console.log('public query=csv -> ' + new PublicJob().run({ format: 'csv' }, rows))
console.log('public query=json -> ' + new PublicJob().run({ format: 'json' }, rows))
console.log('audit query=csv -> ' + new AuditJob().run({ format: 'csv' }, rows))public query=csv -> [csv] id,name ; 1,Minh ; 2,An
public query=json -> [json] [{"id":1,"name":"Minh"},{"id":2,"name":"An"}]
audit query=csv -> [json] [{"id":1,"name":"Minh"},{"id":2,"name":"An"}]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
- Nơi gọi biết mình cần gì nhưng không thể biết dùng class nào cho tới lúc chạy: format đến từ query string, driver đến từ env, loại báo cáo đến từ một cột trong DB.
- Việc tạo object phải làm thêm việc ngoài khởi tạo — đọc config, chọn pool, bọc retry, chọn encoding. Một function cho mấy dòng đó một nơi ở tử tế, thay vì nằm rải ở 12 call site.
- Bạn cần một đường may để test: truyền
() => fakeExportervào service thay vì để nó tự mở connection thật. - Bạn viết core và muốn plugin của team khác gắn loại của họ vào mà không sửa code cũ (registry của factory function).
- Bạn có class framework với quy trình cố định và muốn cho phân hệ con quyền quyết định một bước tạo object — lúc đó bản abstract class mới thật sự có lý do.
- Constructor signature của một class hay đổi và bạn không muốn grep toàn repo mỗi lần nó đổi.
Đừng dùng khi
- Over-engineering. Một format, một call site, và bạn không gọi tên được loại thứ hai sẽ đến từ đâu?
new CsvExporter()ngay tại chỗ là quyết định đúng. Đừng viết abstract class để sau này — "sau này" thường không đến, còn tầng trừu tượng thì ở lại mãi. - Đừng dựng cả một hệ abstract Creator chỉ cho khớp sơ đồ GoF. Trong TS bạn đổi lấy bug
thismất binding khi method bị truyền như callback, mất tree-shaking, và một cấp kế thừa không mang theo hành vi nào. Factory function thuần tốt hơn trong tuyệt đại đa số case. - Registry dùng khoá là chuỗi.
registry["cvs"]biên dịch vẫn xanh và nổ lúc chạy. Giữ union type cho khoá,asở đúng một chỗ, và throw ngay khi không tìm thấy — đừng fallback về giá trị đầu tiên của map. - Factory có tác dụng phụ là bom hẹn giờ:
createConnection()mà đã mở socket thì không idempotent, gọi hai lần là hai connection, test hai lần là hai pool. Tách rõ "tạo object" và "kết nối", và cho cái thứ hai một method riêng. - Factory Method không xoá quyết định, nó dời quyết định. Nếu sau refactor bạn vẫn thấy
if (format === ...)ở ba file khác nhau, bạn mới dời được một nửa — quyết định vẫn đang bị sao chép.
07 — Bạn đã gặp nó rồi, chỉ là không gọi tên
Trong code thật
document.createElement(tag)
Factory Method kinh điển nhất mà bạn gọi mỗi ngày. Truyền "a" bạn nhận về một HTMLAnchorElement, truyền "div" bạn nhận HTMLDivElement — bạn không bao giờ gọi new HTMLAnchorElement() trong code ứng dụng. Một function, một chuỗi đầu vào, nhiều class trả về, và caller chỉ biết interface Element/HTMLElement.
Node: crypto.createHash, fs.createReadStream, stream.Readable.from
Toàn bộ API tạo object của Node là factory function. crypto.createHash("sha256") trả về instance của một class nội bộ không export — bạn không thể tự new nó một cách chính thức. Đó là lý do bạn chỉ thấy interface: họ cố tình giữ quyền đổi implementation bên trong.
axios.create(config) và ofetch createFetch
Cùng một "creator", mỗi config cho ra một instance với interceptor, baseURL, timeout riêng. Plugin Nuxt thay đúng factory này để gắn auth header và cookie forwarding — code ứng dụng không đổi, vì nó chỉ thấy interface của client.
Nitro/Nuxt server: chọn driver theo runtimeConfig lúc boot
Bạn mount storage hoặc chọn driver CSDL dựa trên runtimeConfig/env, không dựa trên code gọi. Server test thì mount driver memory, staging trỏ read-replica, prod trỏ pool thật — cùng một đường khởi tạo, class thật chỉ được chọn ở một chỗ duy nhất.
08 — Tự tay làm
Bài tập
Bạn có `class AuditJob` với method `private makeUploader()` trả về `new S3Uploader("audit-prod")`. Có thêm 2 chỗ khác cũng tự `new S3Uploader`. Hãy refactor sao cho: (a) không còn `new S3Uploader` nào ngoài factory, (b) test chạy được mà không gọi S3, (c) thêm `LocalUploader` cho môi trường dev mà không sửa `AuditJob`.
Gợi ý, mở từng cái một:
- Hợp đồng tối thiểu của một uploader là gì? Thường chỉ
put(key, body): string. - Thay vì
importS3Uploader trong AuditJob, nhậnmakeUploader: () => Uploadertrong constructor và cho nó giá trị mặc định là factory thật. - Muốn dev tự khai báo uploader riêng mà không sửa AuditJob: đăng ký trong
Record<string, () => Uploader>, đọc key từ env.
Rút interface Uploader, đặt factory createUploader() (đọc env, trả về Uploader) vào một file riêng, và cho AuditJob nhận factory qua constructor với giá trị mặc định. Thêm LocalUploader = thêm class mới + một dòng registry. Test truyền thẳng () => ({ put: ... }), không mock library, không S3.
interface Uploader { put(key: string, body: string): string }
class S3Uploader implements Uploader {
constructor(private bucket: string) {}
put(key: string) { return 's3://' + this.bucket + '/' + key }
}
class LocalUploader implements Uploader {
put(key: string) { return 'file:///tmp/audit/' + key }
}
type UploaderFactory = () => Uploader
const registry: Record<string, UploaderFactory> = {
s3: () => new S3Uploader('audit-prod'),
local: () => new LocalUploader(),
}
// Đọc env ở ĐÚNG một chỗ. Sai key thì chết ngay lúc boot, rất tốt.
export function createUploader(kind = process.env.UPLOADER ?? 's3'): Uploader {
const make = registry[kind]
if (!make) throw new Error('Uploader không tồn tại: ' + kind)
return make()
}
export class AuditJob {
constructor(private makeUploader: UploaderFactory = createUploader) {}
run(key: string, body: string): string {
return 'uploaded ' + this.makeUploader().put(key, body)
}
}
// Test: không S3, không mock framework.
console.log(new AuditJob(() => ({ put: k => 'memory://' + k })).run('a.log', 'x'))09 — Đọc cặp để hiểu bản chất
Pattern liên quan
- Abstract FactoryFactory Method tạo MỘT sản phẩm; Abstract Factory tạo cả MỘT HỌ sản phẩm phải đi cùng nhau. Họ nhiều sản phẩm thường được khai báo bằng nhiều factory method.
- Template MethodCùng bộ xương: quy trình cố định, một bước để ngỏ cho subclass. Template Method để ngỏ một bước tính toán, Factory Method để ngỏ bước tạo object.
- SingletonCreator hay factory function là chỗ tự nhiên để đặt singleton: cả hệ thống lấy connection/driver từ đúng một điểm.
- PrototypeThay vì `new Class` bên trong factory, factory có thể clone một instance mẫu. Bỏ được dependency vào class cụ thể, đổi mẫu là đổi hành vi.