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.

Hành vi●○○12 phút đọc8 bướccòn gọi: Template, Skeleton, Hook
inheritancehookframeworkinversion of controlbehavioralpipeline

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

1

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.

textpipeline-steps.txt
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.
Nếu bạn không chỉ ra được bước nào khả biến thì hoặc quy trình chưa đủ phức tạp, hoặc bạn chưa hiểu nghiệp vụ đủ để tách.
ChốtTemplate Method chỉ đáng dùng khi bạn chỉ ra được "đúng một vài bước đổi, còn lại là quy trình bắt buộc chạy đủ, theo đúng thứ tự".
2

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.

tsjobs-v1.ts
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)
}
Chỗ khác nhau thực sự là 2 dòng. Phần giống nhau là 10 dòng — và 10 dòng đó sẽ được sửa 3 lần ở 3 nơi khác nhau.
ChốtCopy-paste lần thứ ba không làm bạn chậm đi một giây. Nó khiến bug được sửa ở một bản và đứng yên ở hai bản còn lại.
3

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.

tsimport-pipeline-v1.ts
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 {}
}
ChốtSkeleton không phải để tái sử dụng code cho ngắn — nó là nơi duy nhất bất biến của quy trình được diễn đạt.
4

Đó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.

tsimport-pipeline-v2.ts
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)
  }
}
Sáu hook, một trong số đó bắt buộc. Subclass trung bình override một hoặc hai — phần còn lại dùng default an toàn.
ChốtSkeleton private là cách nói "thứ tự này không thuộc về bạn". Hook là phần còn lại, và chỉ phần đó mới mở.
5

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?

tshooks.ts
  /** 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
  }
Hook tốt là hook có default đúng cho đa số. Hook có default rỗng nên dành cho việc thật sự tuỳ chọn.
Chốtabstract = compiler đòi. {} = subclass được phép lờ đi. Số hook phải nhỏ hơn số người có thể nhớ.
6

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.

tscreate-pipeline.ts
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),
})
ChốtComposition cho phép một job dùng hai skeleton lồng nhau và test bằng cách truyền hook giả. Inheritance không cho bạn cả hai.
7

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.

tsmiddleware.ts
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
}
ChốtKhi số bên cần chèn lớn hơn 1, thiết kế bằng danh sách hook thay vì chuỗi class kế thừa — phần còn lại của pattern giữ nguyên.
8

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.

tsxml-import.ts
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"/>')
console
  doc: 3 dong hop le
  ghi: an
  loai: <blank/>
  ghi: linh
  xong: 2/3 dong XML
Class mới: 10 dòng, không một dòng nào là quy trình. Đó là toàn bộ lợi nhuận của Template Method.
ChốtThêm tính năng mà chỉ tốn phần khả biến, không tốn phần quy trình — bạn đã đưa flow vào framework thành công.

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 trinh

05 — Sửa tuỳ ý, chạy ngay tại đây

Chạy thử: hai import pipeline chia sẻ đúng một skeleton

tsdemo.ts
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)
console
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 protected duy 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/after an toàn hơn hook nhận next, vì hook nhận next có quyền không gọi next — và đó là một bug rất khó tìm.
  • abstract làm cứng API: thêm một abstract mớ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:

  1. Skeleton nên là private (hoặc ít nhất không phải chỗ để override); client đi qua execute().
  2. Tách ba hook: work() bắt buộc (abstract), onSuccess() và onError() có default.
  3. Viết onError default 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.

tsbai-tap.ts
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.