Pattern 01/22 · Behavioral
Template Method Khuôn mẫu phương thức
Cố định thứ tự các bước của một thuật toán ở đúng một nơi, và để mở chỉ những bước có thể thay đổi — bản GoF mở bằng inheritance, bản hiện đại trong JS mở bằng hook/callback.
01 — Mở đầu bằng code đang hỏng
Vấn đề
Bạn viết job import user từ CSV: đọc file, tách dòng, chuẩn hoá từng dòng, insert vào DB, in báo cáo "x/y dòng". Một tuần sau có job import sản phẩm. Bạn copy hàm đó, sửa đúng phần chuẩn hoá dòng, đổi tên hàm. Rồi job thứ ba — đơn hàng từ đối tác, lần này nguồn là JSON body chứ không phải file.
Bây giờ ba hàm import đang chứa cùng một quy trình và hai dòng khác nhau. Bạn copy-paste lần thứ ba không chậm đi một giây nào — vấn đề đến sau. Dev A phát hiện quy trình thiếu retry, sửa trong importUsers(). Dev B gặp sự cố tương tự trong importOrders() ba tuần sau, không biết bản A đã được sửa, và sửa lại từ đầu. Version 3 của quy trình nằm ở đâu đó trong git.
Kiểu thứ hai của cùng bệnh này lộ ra ở nơi khác: một class có sáu method và caller phải tự nhớ gọi đúng thứ tự — connect(), auth(), subscribe(), rồi close() trong finally. Có người quên close(). Có người gọi subscribe() trước auth(), và nó có vẻ chạy được cho tới khi broker đổi chính sách. Bất biến "luôn đóng kết nối" sống trong đầu người viết, không sống trong code.
Cả hai mùi đều có chung một nguyên nhân: phần quy trình (thứ tự bước, tài nguyên, xử lý lỗi) bị trộn với phần nghiệp vụ (một dòng dữ liệu biến thành gì), nên quy trình bị sao chép và bị sửa sai ở từng bản sao. Bạn không cần ít hàm import hơn — bạn cần một nơi duy nhất chứa quy trình.
Đây là lúc một pattern cổ có câu trả lời rất rõ, kể cả trong code không có class nào: framework giữ flow, bạn điền chỗ trống.
02 — Ý tưởng, chưa động vào code
Giải pháp
Tách skeleton ra khỏi các bước. Skeleton là một hàm (thường tên run, execute, handle) liệt kê thứ tự bước một lần duy nhất: đọc → tách → chuẩn hoá → ghi → báo cáo. Nó không chứa nghiệp vụ nào, chỉ gọi các "chỗ trống". Chỗ trống được khai báo như những method protected abstract (bắt buộc phải viết) và method rỗng (hook — muốn thì viết, không muốn thì bỏ qua).
Bản GoF mở các bước bằng inheritance: abstract class ImportPipeline chứa skeleton, mỗi ConcretePipeline override đúng bước của nó. Trong JS/TS hiện đại, cùng cấu trúc đó được biểu diễn bằng composition: một hàm nhận object options, mỗi bước khả biến là một property có default. Sức mạnh nằm ở chỗ hoán vị điều khiển — code của bạn không gọi framework, framework gọi code của bạn — nên thứ tự bước, transaction, cleanup và logging không ai quên được, kể cả người mới.
Vì sao pattern này "vô hình" trong JS? Bởi vì không ai gọi nó bằng tên GoF nữa. Nó là onMounted, là beforeEach, là route middleware, là app.use(plugin), là _transform() của stream. Bạn đã viết Template Method cả trăm lần. Điều pattern này cho bạn không phải một syntax mới, mà là ngôn ngữ để nhận ra khi nào mình nên đưa flow vào framework thay vì để caller tự nhớ.
03 — Làm thật, mỗi bước một fragment code
Từng bước một
Phân loại bước: phần bất biến và phần khả biến
Trước khi sửa code, liệt kê quy trình thành danh sách bước và tự hỏi từng bước: "bước này có đổi theo loại dữ liệu không?" Quy trình import: đọc nguồn, tách dòng, chuẩn hoá một dòng, ghi từng dòng, báo cáo tổng.
Trong năm bước, đúng một bước thực sự đổi theo từng loại nguồn. Những bước còn lại là quy trình chết người phải chạy đủ, và đó chính là thứ không nên nằm trong tay caller.
QUY TRINH IMPORT COI LA "BAT BIEN"?
1. doc nguon (file / HTTP body / stream) CO -> moi loai nguon mot cach doc
2. tach nguon thanh tung dong CO -> CSV khac JSON
3. chuan hoa MOT dong -> row | null KHONG -> day la buoc kha bien
4. ghi tung row (insert / upsert) CO -> giong het nhau
5. bao cao tong (x/y dong) CO -> giong het nhau
=> Skeleton = 1 + 2 + 4 + 5 (+ thu tu + loi + cleanup).
=> Hook = buoc 3, va tuy chon la buoc 1/2/5.Viết bản copy-paste, rồi nhìn xem nó lệch chỗ nào
Không ai cố ý viết ba bản sao của cùng một quy trình. Nó hình thành tự nhiên: job thứ hai cần đúng hai dòng khác job thứ nhất, và copy là con đường ngắn nhất.
async function importUsers(body: string): Promise<void> {
const rows = body.split('\n').filter(l => l.trim() !== '')
let kept = 0
for (const raw of rows) {
const parts = raw.split(',')
if (parts.length < 2) continue
await db.insert(users).values({ name: parts[0], email: parts[1] })
kept++
}
console.log('users: ' + kept + '/' + rows.length)
}
async function importProducts(body: string): Promise<void> {
const rows = body.split('\n').filter(l => l.trim() !== '') // <— giống hệt
let kept = 0 // <— giống hệt
for (const raw of rows) { // <— giống hệt
const parts = raw.split('|') // <- khác: kí tự tách
if (parts.length < 3) continue
await db.insert(products).values({ sku: parts[0], name: parts[1], price: parts[2] })
kept++
}
console.log('products: ' + kept + '/' + rows.length)
}Dựng skeleton: một hàm chạy hết quy trình
Skeleton là một hàm duy nhất liệt kê quy trình một lần. Nó gọi các bước qua this, không tự chứa nghiệp vụ. Từ giờ, thêm loại dữ liệu mới nghĩa là viết một subclass, không phải viết lại vòng lặp.
Để ý điều bạn vừa có ngoài ý định: bất biến "dòng bị loại thì không được ghi" giờ chỉ tồn tại ở một chỗ. Ở bản copy-paste, nó là một continue mà ai cũng phải nhớ viết lại.
export abstract class ImportPipeline {
/** Skeleton: thu tu buoc nam o day, khong noi khac. */
run(input: string): number {
const rows = input.split('\n').filter(l => l.trim() !== '')
console.log(' doc: ' + rows.length + ' dong hop le')
let kept = 0
for (const raw of rows) {
const row = this.transformRow(raw)
if (row === null) continue // <-- bất biến nằm ĐÂY, không phải trong subclass
this.write(row)
kept++
}
this.summary(rows.length, kept)
return kept
}
protected abstract transformRow(raw: string): string | null
protected write(row: string): void { console.log(' ghi: ' + row) }
protected summary(total: number, kept: number): void {}
}Đóng skeleton, mở đúng các hook
Skeleton chỉ còn nghĩa nếu không ai override nó. TypeScript không có final, nên thủ tục chuẩn là: skeleton khai báo private, và client đi qua một hàm cửa execute() mỏng tang chỉ gọi skeleton. Subclass muốn đổi flow thì phải đổi... không được.
Còn lại mở đúng ba khe: transformRow bắt buộc (abstract — compiler ép viết), write và summary là hook có default. Một subclass tối thiểu chỉ cần một method.
export abstract class ImportPipeline {
/** Lối vào duy nhất cho client. Chua 0 logic, vi the override no cung chang de lam gi. */
execute(input: string): number {
return this.run(input)
}
/** Template method. Private la cach noi: "thu tu nay khong phai cua ban". */
private run(input: string): number {
const rows = input.split('\n').filter(l => l.trim() !== '')
console.log(' doc: ' + rows.length + ' dong hop le')
let kept = 0
for (const raw of rows) {
const row = this.transformRow(raw)
if (row === null) {
this.onRejected(raw)
continue
}
this.write(row)
kept++
}
this.summary(rows.length, kept)
return kept
}
protected abstract transformRow(raw: string): string | null
protected write(row: string): void { console.log(' ghi: ' + row) }
protected onRejected(raw: string): void { console.log(' loai: ' + raw) }
protected summary(total: number, kept: number): void {
console.log(' xong: ' + kept + '/' + total)
}
}Bước bắt buộc (abstract) và hook rỗng: chọn cho đúng
GoF gọi bước bắt buộc là primitive operation, bước tuỳ chọn là hook. Dịch sang TypeScript: bắt buộc = abstract (compiler chặn, không viết là không build được), tuỳ chọn = body rỗng (subclass im lặng được).
Chọn sai bên nào cũng trả giá. Bắt buộc quá thì codebase đầy method {} với comment "khong lam gi"; tuỳ chọn hoá một bước quan trọng thì có subclass quên nó và chạy sai âm thầm. Hỏi: subclass nào không viết bước này thì có bug không?
/** BAT BUOC: subclass khong viet thi khong build duoc. Dung cho buoc loi dung cua job. */
protected abstract transformRow(raw: string): string | null
/** HOOK: metric/cache/audit chen vao day neu can. Khong can thi bo qua. */
protected onWrite(row: string): void {}
/** HOOK co nghia: default la nem loi. Subclass chi doi CACH bao cao, khong doi flow. */
protected onError(raw: string, e: unknown): void {
throw e
}abstract = compiler đòi. {} = subclass được phép lờ đi. Số hook phải nhỏ hơn số người có thể nhớ.Bản JS hiện đại: hook là function, không cần inheritance
TypeScript chỉ cho extend một class. Và code JS hiện đại hiếm khi lấy class làm đơn vị tái sử dụng. Cùng skeleton đó, viết bằng composition: một factory nhận options, mỗi bước khả biến là một property có default, trả về một hàm chạy.
Đây vẫn chính là Template Method — skeleton cố định, chỗ trống do người khác điền, flow do skeleton quyết. Chỉ khác cơ chế mở. Và đó là lý do pattern này gần như vô hình trong JS: nó xuất hiện dưới tên options, hooks, plugins, createX, không dưới tên GoF.
export interface PipelineOptions<T> {
split?: (input: string) => string[]
transform: (raw: string) => T | null
write?: (row: T) => void
summary?: (total: number, kept: number) => void
}
const defaultSplit = (input: string) => input.split('\n').filter(l => l.trim() !== '')
/** Skeleton co dinh. Buoc kha bien = property co default. */
export function createPipeline<T>(o: PipelineOptions<T>) {
const split = o.split ?? defaultSplit
const write = o.write ?? ((row: T) => console.log(String(row)))
return (input: string): number => {
const rows = split(input)
let kept = 0
for (const raw of rows) {
const row = o.transform(raw)
if (row === null) continue
write(row)
kept++
}
o.summary?.(rows.length, kept)
return kept
}
}
const importUser = createPipeline({
transform: raw => (raw.includes(',') ? raw.split(',')[0] : null),
})Nhiều bên cần cùng một slot: middleware, plugin, interceptor
Inheritance có một giới hạn không sửa được: một class chỉ có một cha. Khi năm team cùng muốn chèn logic vào bước "trước khi ghi", hook một-chỗ là không đủ. Mô hình middleware là Template Method nhân bản: khung vẫn chạy một lượt theo thứ tự cố định, nhưng mỗi slot mở cho N người.
Đây là hình dạng bạn gặp nhiều nhất trong hệ JS: Koa/Express, Nuxt route middleware, Vue plugin, axios interceptor, Apollo/GraphQL middleware. Bạn không extend gì cả, và đó là điều tốt.
type Ctx = { url: string, ms?: number }
type Next = () => Promise<void>
type Middleware = (ctx: Ctx, next: Next) => Promise<void>
/** Skeleton co dinh: middleware chay theo thu tu, roi moi toi handler. */
export function compose(middlewares: Middleware[], handler: Next) {
return async (ctx: Ctx): Promise<void> => {
const dispatch = (i: number): Promise<void> =>
i === middlewares.length ? handler() : middlewares[i](ctx, () => dispatch(i + 1))
return dispatch(0)
}
}
export const logTiming: Middleware = async (ctx, next) => {
const t0 = performance.now()
await next() // <-- khung quyết định khi nào bước sau chạy
ctx.ms = performance.now() - t0
}Nghiệm thu: thêm một loại import mới, không copy vòng lặp
Bài test cuối của refactor này: thêm một loại dữ liệu mới mà chỉ viết phần bước khả biến. Nếu bạn phải copy vòng lặp, skeleton chưa xong.
import { ImportPipeline } from './import-pipeline-v2'
/** Nguon XML: chi khai bao buoc 3 va 5. Khong copy vong lap. */
class XmlImport extends ImportPipeline {
protected transformRow(raw: string): string | null {
if (!raw.startsWith('<row name="') || !raw.endsWith('"/>')) return null
return raw.slice(11, -3)
}
protected summary(total: number, kept: number): void {
console.log(' xong: ' + kept + '/' + total + ' dong XML')
}
}
new XmlImport().execute('<row name="an"/>\n<blank/>\n<row name="linh"/>')doc: 3 dong hop le ghi: an loai: <blank/> ghi: linh xong: 2/3 dong XML
04 — Ai nói chuyện với ai
Cấu trúc
- AbstractClassChứa **skeleton** (`run`/`execute`) liệt kê thứ tự bước một lần duy nhất, cùng default an toàn cho các hook.
- TemplateMethodChính là skeleton. Gọi các bước theo thứ tự, giữ transaction/cleanup/log. Không override.
- PrimitiveOperationBước bắt buộc: `abstract`. Subclass không viết thì không build được.
- HookBước tuỳ chọn, default rỗng hoặc default đúng. Cho metric, audit, cache, reporting chen vao.
- ConcreteClass / CallerOverride đúng các bước của mình (hoặc truyền hook function). Không quyết định flow.
Client ─── execute(input) ───► (khong tu goi tung buoc)
│
┌───────────────────▼──────────────────┐
│ AbstractClass │
│ private run(input) ← SKELETON │ thu tu
│ 1 split() [default] │ bat bien,
│ 2 transformRow() [abstract] │ khong ai
│ 3 write() [default] │ override
│ 4 summary() [hook rong] │
└───────────────────┬──────────────────┘
skeleton goi nguoc xuong (Inversion of Control)
┌───────────────┼────────────────┐
▼ ▼ ▼
┌────────────┐ ┌────────────┐ ┌──────────────┐
│ UserImport │ │ CsvImport │ │ XmlImport │
│ transform │ │ split+ │ │ transform │
│ + summary │ │ transform │ │ + summary │
└────────────┘ └────────────┘ └──────────────┘
override DUNG buoc cua minh, khong copy quy trinh05 — Sửa tuỳ ý, chạy ngay tại đây
Chạy thử: hai import pipeline chia sẻ đúng một skeleton
abstract class ImportPipeline {
/** Template method: thu tu buoc co dinh. Subclass khong sua cai nay. */
run(input: string): number {
const rows = input.split('\n').filter(l => l.trim() !== '')
console.log(' doc: ' + rows.length + ' dòng hợp lệ')
let kept = 0
for (const raw of rows) {
const row = this.transformRow(raw)
if (row === null) { console.log(' loại: ' + raw); continue }
console.log(' ghi: ' + row)
kept++
}
this.summary(rows.length, kept)
return kept
}
/** Buoc kha bien — subclass nao cung dien. */
protected transformRow(raw: string): string | null { return raw.trim() }
/** Hook rong — muon thi override. */
protected summary(total: number, kept: number): void {}
}
class UserImport extends ImportPipeline {
protected transformRow(raw: string): string | null {
const p = raw.split(',')
return p.length < 2 ? null : p[0].toUpperCase() + ' <' + p[1] + '>'
}
protected summary(total: number, kept: number): void {
console.log(' xong: ' + kept + '/' + total + ' dòng')
}
}
class RawImport extends ImportPipeline {} // không override gì, dùng hết default
const csv = 'an,an@x.io\n\nkhong-co-email\nlinh,linh@x.io'
console.log('UserImport:')
new UserImport().run(csv)
console.log('RawImport:')
new RawImport().run(csv)UserImport: doc: 3 dòng hợp lệ ghi: AN <an@x.io> loại: khong-co-email ghi: LINH <linh@x.io> xong: 2/3 dòng RawImport: doc: 3 dòng hợp lệ ghi: an,an@x.io ghi: khong-co-email ghi: linh,linh@x.io
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
- Quy trình nhiều bước, thứ tự quan trọng, và chỉ một vài bước thay đổi theo loại dữ liệu/loại nguồn.
- Có bất biến bắt buộc (luôn release tài nguyên, luôn commit/rollback, luôn có trace id trong log). Đặt trong skeleton thì không ai quên được; đặt trong đầu caller thì sớm muộn cũng quên.
- Caller không nên biết thứ tự gọi. Bạn muốn "framework gọi lại bạn" thay vì "bạn gọi framework".
- Nhiều team/plugin cần chèn hành vi vào cùng một điểm: hãy mở một danh sách hook, đừng mở một điểm
protectedduy nhất. - Bạn đang copy một hàm để sửa hai dòng: skeleton đã tồn tại, chỉ chưa được tách ra.
- Viết framework/SDK/composable cho người khác dùng — họ đáng ra chỉ điền nghiệp vụ, không phải quản lý lifecycle của bạn.
Đừng dùng khi
- Inheritance là xiềng: một class chỉ extend được một skeleton. Cần hai skeleton cùng lúc là thiết kế sai — chuyển sang composition ngay, đừng chữa bằng mixin ba tầng.
- Hook phình to là bệnh riêng: 12 hook nghĩa là 12 chỗ hành vi đổi được ở xa, và không ai còn đoán được chuyện gì chạy lúc nào. In số thứ tự bước khi log và đánh dấu rõ hook nào bắt buộc.
- Debug khó hơn vì stack trace chạy vào base class và người đọc subclass không thấy flow. Comment một dòng ngay đầu subclass: "flow nằm ở run() của base".
- Over-engineering: hai biến thể khác nhau cả thứ tự bước thì skeleton không diễn tả được, ép nó vào skeleton là nói dối. Lúc đó pipeline-array (danh sách bước dựng lúc chạy) hoặc Strategy mới là đúng.
- Đừng để hook đổi được thứ tự bước nếu bạn không cần tới mức đó. Hook
onBefore/afteran toàn hơn hook nhậnnext, vì hook nhậnnextcó quyền không gọi next — và đó là một bug rất khó tìm. abstractlàm cứng API: thêm mộtabstractmới vào base class là phá vỡ mọi subclass hiện có. Thêm hook có default thì an toàn.
07 — Bạn đã gặp nó rồi, chỉ là không gọi tên
Trong code thật
Vue lifecycle hooks
onMounted, onBeforeUnmount, onUpdated... Vue giữ thuật toán mount/update/unmount cố định và gọi hook của bạn đúng lúc nó quyết định. Bạn không gọi onMounted(), nó được gọi — đúng nghĩa inversion of control của Template Method. Và Vue cho nó bằng function, không bằng class.
Node.js stream.Transform
Kế thừa Transform, viết _transform(chunk, enc, cb) và _flush(cb). Buffering, backpressure, thứ tự chunk — Node giữ; bạn chỉ điền một bước. Template Method thuần GoF — ngay trong core API.
Jest/Vitest beforeEach / afterEach
Test runner có skeleton: setup → run test → teardown → báo cáo. Hook của bạn là các bước khả biến. Nếu mỗi test tự lo setup, bạn quay lại đúng bản copy-paste ở phần vấn đề.
Nuxt route middleware & definePageMeta
Router chạy một pipeline cố định (resolve route → chạy middleware → validate → render) và gọi middleware của bạn từng cái một, theo thứ tự. Bạn không tự gọi middleware kế tiếp bằng tay.
Custom Elements
Browser gọi connectedCallback, disconnectedCallback, attributeChangedCallback của class bạn khai báo. Trình điều khiển là framework, flow là của nó — bạn chỉ điền các bước.
08 — Tự tay làm
Bài tập
Tách boilerplate của các background job (log bắt đầu, try/catch, log kết thúc, báo cáo lỗi) thành một skeleton, để thêm job mới **chỉ** viết phần thân. Làm sao để một job không thể quên bước báo cáo lỗi?
Gợi ý, mở từng cái một:
- Skeleton nên là
private(hoặc ít nhất không phải chỗ để override); client đi quaexecute(). - Tách ba hook:
work()bắt buộc (abstract),onSuccess()vàonError()có default. - Viết
onErrordefault là ném tiếp — nếu subclass muốn im lặng thì phải nói rõ, đó là quyết định có chủ đích chứ không phải quên.
Class trừu tượng chứa execute() gọi work() trong try/catch, log trước/sau, và gọi onSuccess/onError. work() là abstract nên compiler ép mỗi job phải viết; onError default ném tiếp nên không job nào "quên" báo cáo lỗi mà không phải viết code một cách có ý thức.
abstract class Job {
constructor(readonly name: string) {}
/** Skeleton: khong job nao duoc phep bo boc bao cao. */
execute(): void {
console.log('[' + this.name + '] bat dau')
try {
this.work()
this.onSuccess()
}
catch (e) {
this.onError(e as Error)
}
console.log('[' + this.name + '] xong')
}
protected abstract work(): void
protected onSuccess(): void { console.log(' ok') }
protected onError(e: Error): void { console.log(' LOI: ' + e.message) }
}
class SyncPrices extends Job {
protected work(): void { console.log(' dong 1280 mat hang') }
}
class SendReport extends Job {
protected work(): void { throw new Error('SMTP khong phan ung') }
}
new SyncPrices('sync-prices').execute()
new SendReport('send-report').execute()09 — Đọc cặp để hiểu bản chất
Pattern liên quan
- StrategyCùng mục đích — cho phép thay một bước của thuật toán — nhưng Template Method làm bằng inheritance (chọn lúc viết code), Strategy bằng composition (chọn lúc chạy). Strategy linh hoạt hơn; Template Method an toàn hơn về thứ tự bước.
- StateCặp bài trùng: skeleton quyết định **khi nào** bước chạy, State quyết định **hành vi nào** đang hợp lệ. Machine trạng thái + Template Method là xương sống của workflow engine.
- CommandCommand biến "việc cần làm" thành object để đưa vào một skeleton (queue, retry, undo). Skeleton lo lifecycle, Command lo nội dung.
- FacadeFacade che một subsystem sau một lối vào đơn giản và **không mở** gì ra; Template Method cũng chốt một lối vào nhưng **mở đúng vài bước** cho người dùng sau.