Pattern 18/22 · Behavioral

Chain of Responsibility Chuỗi trách nhiệm

Chuyển một request qua nhiều handler nối tiếp: mỗi handler hoặc tự trả lời rồi dừng chuỗi, hoặc gọi `next` để đẩy đi tiếp. Nơi gửi request không cần biết ai sẽ xử lý nó.

Hành vi●●○14 phút đọc8 bướccòn gọi: Chain of Command, Pipeline, Middleware
middlewarepipelineinterceptorvalidatebehavioralpluginnext

01 — Mở đầu bằng code đang hỏng

Vấn đề

Bạn có POST /api/orders. Sau sáu tháng nó chứa, theo đúng thứ tự: kiểm tra JWT, kiểm tra token còn hạn, rate-limit theo IP, validate body bằng zod, check user có quyền trên shop đó không, rồi cuối cùng nghiệp vụ. Tất cả trong một handler 120 dòng, mà phần nghiệp vụ thật nằm dưới đáy hàm.

Sáu bước đó có vòng đời khác nhau hẳn nhau. rateLimit đổi mỗi lần đổi chính sách chống spam. permission đổi mỗi lần thêm role. payload đổi mỗi lần thêm field. Nhưng chúng đang ở chung một hàm, nên mỗi lần đổi một cái là bạn phải scroll qua năm cái kia — và git blame của hàm này có chữ bạn trong sáu tháng liên tục.

Rồi tuyến thứ hai xuất hiện: PATCH /api/orders/:id cần bốn trong sáu bước, theo thứ tự khác, thêm một bước riêng. Bạn copy-paste. Khi phát hiện rateLimit có race condition, bạn sửa một file, rồi phải đi tìm mười một bản copy còn lại trong repo — ba bản trong số đó đã bị sửa tay từ lâu.

Tệ hơn if/else thông thường: mỗi bước ở đây tự quyết định có cho phép đi tiếp hay không, và quyết định đó phân tán. Không có chỗ nào khai báo "tuyến này chạy những bước nào, theo thứ tự nào". Muốn biết /api/orders có bị rate-limit không, bạn phải đọc hết 120 dòng.

Vấn đề thật sự: danh sách bước, thứ tự, và logic "dừng hay đi tiếp" đang bị hard-code tại nơi gọi, trong khi chúng là nghiệp vụ độc lập và thay đổi theo tuyến. Chain of Responsibility tách đúng ba thứ đó ra.

02 — Ý tưởng, chưa động vào code

Giải pháp

Mỗi bước kiểm tra thành một handler độc lập, biết đúng hai việc: tự trả lời (trả về kết quả, chuỗi dừng tại đây), hoặc gọi next(ctx) để đẩy context sang handler kế tiếp. Handler không nhận tham số "tôi là bước mấy", không gọi thẳng handler khác, không biết ai đứng trước hay sau mình.

Phần "ai đứng sau ai" nằm ở một chỗ khác: runner ghép chain. Nó giữ thứ tự và tạo ra hàm next mà handler được nhận. Nhờ vậy, thêm một bước mới = viết thêm một function + thêm một tên vào danh sách; không handler cũ nào bị sửa. Và muốn biết một tuyến chạy những gì, bạn đọc danh sách, không đọc 120 dòng.

Trong TypeScript bạn không cần class cho việc này. Một handler là function (ctx, next). Pattern này đã quen mặt tới mức bạn viết nó hằng ngày: middleware Express/Koa/Nuxt, axios interceptor, stopPropagation() trong DOM event. Chain of Responsibility không phải thứ xa lạ — nó là tên gọi của thứ bạn vẫn gọi là "middleware".

03 — Làm thật, mỗi bước một fragment code

Từng bước một

1

Nhận diện chuỗi: tìm chỗ "nếu ổn thì đi tiếp"

Dấu hiệu không phải là "có nhiều if". Dấu hiệu là một chuỗi guard clause nối tiếp, mỗi cái kiểm tra một mối quan tâm khác nhau, và mỗi cái có quyền chặn request. Nếu bạn thấy mình viết "nếu không có JWT thì trả 401, nếu quá 60 request thì trả 429, nếu body sai thì trả 400..." — đó là một chain đang chờ được khai sinh.

Viết bản xấu ra giấy trước. Nó chưa sai; nó chỉ chưa tách.

tsorders-handler-v1.ts
export async function createOrder(req: Request, res: Response) {
  const user = verifyJwt(req.headers.authorization ?? '')
  if (!user) return res.status(401).json({ error: 'unauthorized' })

  if (!limiter.tryTake(req.ip)) return res.status(429).json({ error: 'rate limited' })

  const parsed = orderSchema.safeParse(req.body)
  if (!parsed.success) return res.status(400).json(parsed.error)

  if (!(await canManage(user, parsed.data.shopId)))
    return res.status(403).json({ error: 'forbidden' })

  // ... 90 dòng nghiệp vụ, nằm dưới đáy hàm, khó test nhất quả đất
}
Sáu mối quan tâm, một hàm, một file. Mỗi tính năng mới sẽ chèn thêm một if vào đây.
ChốtChain of Responsibility đáng cân nhắc khi các bước độc lập nhưng cùng chung một dòng chảy, và bất kỳ bước nào cũng có quyền dừng cuộc chơi.
2

Viết hợp đồng handler: `(ctx, next)`

Toàn bộ sự trừu tượng của pattern này nằm trong ba dòng type. Handler nhận context và một hàm next; trả về kết quả cuối cùng. Chỉ thế là đủ để một handler chặn chuỗi (không gọi next) hoặc mở tiếp (gọi next).

ctx là bộ nhớ chung đi dọc chuỗi: dữ liệu vào, và chỗ để handler sau đọc kết quả của handler trước. Nếu không có ctx, các handler sẽ phải gọi lại verifyJwt — vừa lãng phí vừa dễ lệch.

tshandler.ts
export type Ctx = {
  token: string
  ip: string
  route: string
  body: unknown
  hits: number
  user?: { id: string, role: string }
  order?: { shopId: string }
}

export type Next = (ctx: Ctx) => string
export type Handler = (ctx: Ctx, next: Next) => string
Hợp đồng chung. handler.ts không import handler nào khác — đó là toàn bộ lý do chain ghép lại được.
ChốtHandler chỉ phụ thuộc vào type, không phụ thuộc vào handler cụ thể. Dependency Inversion phiên bản rẻ tiền và hiệu quả.
3

Viết handler: hoặc trả lời, hoặc `next(ctx)`

Mỗi handler một trách nhiệm, một khối if duy nhất. Hai đường ra: trả về chuỗi (dừng) hoặc gọi next (đi tiếp). Không có đường ra thứ ba.

Chú ý handler không hề biết rateLimit tồn tại. Nó chỉ biết "gọi next thì quy trình đi tiếp". Đây là điểm khác biệt cốt lõi với một hàm gọi tuần tự các bước: ở đây, quyền quyết định thứ tự bị lấy khỏi tay handler.

tshandlers.ts
export const auth: Handler = (ctx, next) => {
  if (!ctx.token) return '401 chưa đăng nhập'  // tự trả lời -> chuỗi dừng
  return next(ctx)                             // không có ý kiến -> đi tiếp
}

export const rateLimit: Handler = (ctx, next) => {
  if (ctx.hits > 2) return '429 vượt quota ' + ctx.ip
  return next(ctx)
}

export const payload: Handler = (ctx, next) => {
  if (ctx.body === '') return '400 payload rỗng'
  return next(ctx)
}

export const permission: Handler = (ctx, next) => {
  if (ctx.route === '/admin' && ctx.user?.role !== 'root') return '403 không đủ quyền'
  return next(ctx)
}
ChốtTest một handler là gọi nó với một next giả: auth(ctx, () => "PASSED"). Không cần chain, không cần server.
4

Runner ghép chain — nơi duy nhất biết thứ tự

Runner giữ mảng handler và con trỏ index. Nó gọi handler đầu, và mỗi lần handler gọi next, runner gọi handler kế. Đây chính là Composite: một handler, hay cả chain, đều có cùng hình dạng (ctx) => string nên bạn lồng được chúng.

Bản đệ quy dưới đây là bản dễ nhìn nhất. Trong code thật có state, bạn sẽ muốn thêm một mảng visited để log lại chain đã chạy — nếu không, debug một response 403 sẽ là công việc đoán mò cả buổi.

tschain.ts
export function dispatch(handlers: Handler[], i: number, ctx: Ctx): string {
  if (i === handlers.length) return '200 OK ' + ctx.route  // hết người -> nghiệp vụ
  return handlers[i](ctx, cc => dispatch(handlers, i + 1, cc))
}

export const orderChain: Handler[] = [auth, rateLimit, payload, permission]

export const handleOrder = (ctx: Ctx) => dispatch(orderChain, 0, ctx)
handlers[i](ctx, cc => dispatch(handlers, i + 1, cc)) — một dòng này là toàn bộ pattern.
ChốtThứ tự là dữ liệu (một mảng), không phải code. Đổi thứ tự = đổi mảng, không đụng vào handler nào.
5

Chạy thử và xem dấu vết

Bốn handler, năm request. Column bên phải là chuỗi thực sự đã chạy — đó là thứ bạn sẽ muốn có trong log thật, vì nó trả lời ngay câu "request này bị chặn ở đâu".

Để ý request thứ ba: nó chết ở rate-limit và không chạy payload. Đó là giá trị thật của pattern này, không phải chuyện trang trí: bước rẻ chạy trước, bước đắt (query DB, gọi API) không bị gọi vô ích.

tsmain.ts
function send(user: string, route: string, body: string, hits: number) {
  visited.length = 0
  const res = dispatch(0, { user, ip: '10.0.0.7', route, body, hits })
  console.log(res.padEnd(28) + '| đã chạy: ' + visited.join(' -> '))
}

send('', '/posts', 'xin chào', 1)
send('lam', '/posts', '', 1)
send('lam', '/posts', 'xin chào', 5)
send('lam', '/admin', 'x', 1)
send('root', '/admin', 'x', 1)
console
401 chưa đăng nhập          | đã chạy: auth
400 payload rỗng            | đã chạy: auth -> rate-limit -> payload
429 vượt quota 10.0.0.7     | đã chạy: auth -> rate-limit
403 không đủ quyền          | đã chạy: auth -> rate-limit -> payload -> permission
200 OK /admin               | đã chạy: auth -> rate-limit -> payload -> permission
6

Handler có thể sửa context, hoặc đổi hướng thay vì từ chối

Handler không chỉ "chặn hay cho qua". Nó có thể ghi kết quả vào ctx để handler sau dùng: auth attach user, payload attach object đã parse. Trả về next({ ...ctx, user }) thay vì next(ctx) là đủ — handler sau không biết dữ liệu do ai ghi.

Nó cũng có thể điều hướng thay vì chặn: với request chưa đăng nhập, 302 /login thân thiện với trình duyệt hơn 401. Đây là chỗ CoR tách khỏi một danh sách validate tầm thường: mỗi bước có quyền quyết định số phận của request.

tshandlers-v2.ts
export const auth: Handler = (ctx, next) => {
  const user = verifyJwt(ctx.token)
  if (!user) return '302 /login'        // đổi hướng, không chặn
  return next({ ...ctx, user })         // handler sau được đọc ctx.user
}

export const payload: Handler = (ctx, next) => {
  const parsed = orderSchema.safeParse(ctx.body)
  return parsed.success
    ? next({ ...ctx, order: parsed.data })  // parse MỘT lần, cả chain dùng
    : '400 payload sai'
}
ChốtNếu handler sau phải tính lại thứ mà handler trước đã tính, ctx của bạn đang thiếu field.
7

Bản class với `setNext`: khi handler cần state hoặc cần nối động

Bản function phủ 90% nhu cầu. Nhưng khi handler có cấu hình riêng (danh sách origin được phép, limit theo tenant), hoặc khi bạn muốn nối từng cặp thay vì khai báo một mảng, bản class kinh điển có chỗ của nó.

Mẹo nhỏ của GoF: setNext trả về chính handler vừa được gắn, nên bạn nối được a.setNext(b).setNext(c) thay vì ba dòng rời rạc.

tsmiddleware-class.ts
abstract class Middleware {
  private nextMw: Middleware | null = null

  setNext(mw: Middleware): Middleware {
    this.nextMw = mw
    return mw                      // cho phép nối a.setNext(b).setNext(c)
  }

  protected then(ctx: Ctx): string {
    return this.nextMw ? this.nextMw.handle(ctx) : '200 OK ' + ctx.route
  }

  abstract handle(ctx: Ctx): string
}

class CorsMiddleware extends Middleware {
  constructor(private allowed: string[]) { super() }

  handle(ctx: Ctx): string {
    if (!this.allowed.includes(ctx.origin)) return '403 origin bị chặn'
    return this.then(ctx)
  }
}
ChốtDùng class khi handler có config riêng hoặc phải được nối lúc runtime. Ngược lại, function + mảng gọn hơn, dễ test hơn.
8

Ghép chain từ config — và cái giá của việc thứ tự là dữ liệu

Khi mỗi tuyến cần một tập bước khác nhau, và danh sách đó tới từ admin/DB/tenant config, bạn dựng chain từ tên, không từ code. Route mới, gate mới, plugin của khách: không sửa runner.

Nhưng đây là mặt trái: thứ tự là dữ liệu, và dữ liệu thì TypeScript không kiểm tra được. Đặt permission trước auth thì mọi request đều 403, compiler hoàn toàn im lặng. Chain dựng từ config bắt buộc phải có test (assert thứ tự tới trước), và nên chặn tên lạ ngay lúc build chain chứ không âm thầm bỏ qua.

tsregistry.ts
const registry: Record<string, Handler> = { auth, rateLimit, payload, permission, cors }

export function buildChain(names: string[]): Handler[] {
  return names.map((n) => {
    const h = registry[n]
    if (!h) throw new Error('Không rõ handler: ' + n)   // fail sớm, không âm thầm
    return h
  })
}

// route thường:  buildChain(['auth', 'payload'])
// route admin:   buildChain(['auth', 'rateLimit', 'payload', 'permission'])
Với async, next trả về Promise: Koa viết await next() (vào từ ngoài, ra từ trong), Express dùng next(err) để nhảy sang chuỗi lỗi — một chain thứ hai song song.
ChốtTest chain như test config: một test assert "mọi chain trong registry đều có auth đứng trước permission" rẻ hơn nhiều so với một incident 403 toàn site.

04 — Ai nói chuyện với ai

Cấu trúc

  • HandlerMột bước. Hoặc tự trả lời (chuỗi dừng), hoặc gọi `next(ctx)` để đẩy tiếp. Không biết handler khác tồn tại.
  • ConcreteHandler`auth`, `rateLimit`, `payload`, `permission`. Mỗi cái một mối quan tâm, một file, một khối if.
  • ContextDữ liệu đi dọc chuỗi: input ban đầu + kết quả mỗi handler ghi thêm cho handler sau.
  • RunnerGiữ mảng handler và index, tạo ra `next`. Chỗ duy nhất biết cấu trúc chuỗi.
  • ClientChọn chain cho từng tuyến/loại request, thường bằng một danh sách tên đọc từ config.
  Client ──handle(ctx)──► Runner (giữ thứ tự, tạo next)
                              │
                              ▼
                        ┌───────────┐  ctx.user === null
                        │   auth    │ ───► '401 ...'  (dừng)
                        └─────┬─────┘
                              │ next(ctx)  "tôi không có ý kiến"
                              ▼
                        ┌────────────┐
                        │ rate-limit │ ───► '429 ...'  (dừng)
                        └─────┬──────┘
                              │ next(ctx)
                              ▼
                        ┌─────────┐
                        │ payload │ ───► '400 ...'    (dừng)
                        └─────┬───┘
                              │ next({ ...ctx, order })
                              ▼
                        ┌────────────┐
                        │ permission │ ───► '403 ...'  (dừng)
                        └─────┬──────┘
                              │ next(ctx)
                              ▼
                       '200 OK /orders'   <- hết người, mới tới nghiệp vụ

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

Chạy thử: bốn validator, ai có ý kiến thì trả lời

tsdemo.ts
type Ctx = { user: string, ip: string, route: string, body: string, hits: number }
type Next = (c: Ctx) => string
type Handler = (c: Ctx, next: Next) => string

const visited: string[] = []
const mark = (name: string) => { visited.push(name) }

const auth: Handler = (c, next) => {
  mark('auth')
  return c.user === '' ? '401 chưa đăng nhập' : next(c)
}
const rateLimit: Handler = (c, next) => {
  mark('rate-limit')
  return c.hits > 2 ? '429 vượt quota ' + c.ip : next(c)
}
const payload: Handler = (c, next) => {
  mark('payload')
  return c.body === '' ? '400 payload rỗng' : next(c)
}
const permission: Handler = (c, next) => {
  mark('permission')
  return c.route === '/admin' && c.user !== 'root' ? '403 không đủ quyền' : next(c)
}

const chain: Handler[] = [auth, rateLimit, payload, permission]

function dispatch(i: number, c: Ctx): string {
  if (i === chain.length) return '200 OK ' + c.route
  return chain[i](c, cc => dispatch(i + 1, cc))
}

function send(user: string, route: string, body: string, hits: number) {
  visited.length = 0
  const res = dispatch(0, { user, ip: '10.0.0.7', route, body, hits })
  console.log(res.padEnd(28) + '| đã chạy: ' + visited.join(' -> '))
}

send('', '/posts', 'xin chào', 1)
send('lam', '/posts', '', 1)
send('lam', '/posts', 'xin chào', 5)
send('lam', '/admin', 'x', 1)
send('root', '/admin', 'x', 1)
console
401 chưa đăng nhập          | đã chạy: auth
400 payload rỗng            | đã chạy: auth -> rate-limit -> payload
429 vượt quota 10.0.0.7     | đã chạy: auth -> rate-limit
403 không đủ quyền          | đã chạy: auth -> rate-limit -> payload -> permission
200 OK /admin               | đã chạy: auth -> rate-limit -> payload -> permission

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

  • Nhiều bước kiểm tra/biến đổi độc lập cùng áp dụng cho một request, và bước rẻ nên chặn sớm để bước đắt không phải chạy.
  • Nơi gửi request không nên biết (hoặc không được phép biết) ai xử lý: gateway, SDK, plugin system, tích hợp của bên thứ ba.
  • Mỗi tuyến/loại request cần một tập bước khác nhau, hoặc cần ghép động từ config, DB, feature flag, tenant.
  • Bạn cần thêm/bớt một bước mà không sửa code cũ — đây là Open/Closed Principle dưới dạng dễ thấy nhất.
  • Có nhiều đường trả lời khác nhau (401, 429, 302, cache hit), và việc chọn đường nào là quyết định cục bộ của từng bước.

Đừng dùng khi

  • Over-engineering. Hai bước kiểm tra cố định, một tuyến duy nhất, không ai khác dùng? Viết hai dòng if rồi đi làm việc khác. Chain chỉ đáng giá khi số bước ≥ 4, hoặc thứ tự thay đổi theo tuyến, hoặc người ghép chain không phải người viết handler.
  • Debug khó hơn: bug nằm ở handler thứ tư nhưng biểu hiện ở response cuối. Log danh sách handler đã chạy cho mỗi request ngay từ đầu, đừng đợi tới lúc có sự cố.
  • Thứ tự là dữ liệu, TS không kiểm tra được. permission trước auth = 403 toàn site. Test chain, và fail sớm khi gặp tên handler không tồn tại.
  • Handler quên gọi next (request treo) hoặc gọi next hai lần (nghiệp vụ chạy hai lần). Trong Express, quên next(err) trong catch khiến lỗi lọt xuống handler nghiệp vụ — chuỗi lỗi là một chain thứ hai, phải nối nó.
  • Mỗi handler là một tầng lồng. Bản Koa await next() giữ stack của toàn bộ phần còn lại trong closure: chèn handler nặng (parse lớn, query DB) vào giữa chuỗi làm chậm mọi request đi qua, kể cả request bị chặn ngay sau đó.

07 — Bạn đã gặp nó rồi, chỉ là không gọi tên

Trong code thật

Middleware Express / Koa / Nuxt

Express: app.use((req, res, next) => ...), và next(err) nhảy sang chuỗi error handler. Koa: async (ctx, next) => { ...; await next() } — rõ nhất hình dạng "vào-ngoài-ra" của chain. Nuxt server middleware (defineEventHandler) và route middleware (defineNuxtRouteMiddleware + navigateTo) cũng cùng cấu trúc: hoặc tự trả lời, hoặc cho đi tiếp.

axios interceptor

axios.interceptors.request.use(...) và .response.use(ok, err) xếp thành chuỗi: gắn auth header, refresh token khi 401, retry, chuẩn hoá lỗi. Một interceptor từ chối Promise thì phần còn lại của chuỗi bị nhảy qua — đúng ngữ nghĩa "dừng chuỗi".

DOM event bubbling

Chain ở đây là chính cây DOM: sự kiện đi từ node lên cha, mỗi node có listener là một handler. event.stopPropagation() là next() không được gọi; event.defaultPrevented là "đã có người trả lời, các bạn còn lại biết điều".

Chuỗi xử lý lỗi

try/catch lồng nhau: exception đi tìm catch gần nhất rồi dừng. Promise .catch() cũng vậy — rejection lan xuống .catch gần nhất, .then ở giữa bị bỏ qua. Đây là CoR cho lỗi, và nó giải thích vì sao một .catch cuối chuỗi bắt hết mọi lỗi phía trên.

08 — Tự tay làm

Bài tập

Viết handler `idempotency` cho chain xử lý đơn hàng: nếu header `idempotency-key` đã từng thấy thì trả về kết quả cũ **ngay**, không chạy các handler phía sau. Nếu chưa thấy thì chạy tiếp và lưu kết quả lại. Giải thích vì sao nó phải đứng trước handler ghi DB.

Gợi ý, mở từng cái một:

  1. Handler được phép làm gì với next ngoài việc gọi nó một lần? (Gợi ý: gọi rồi dùng kết quả trả về.)
  2. State của riêng handler (Map key -> response) đặt ở đâu? Closure là đủ, không cần class.
  3. Không có header thì phải làm gì? Đừng chặn — hãy next(ctx).

Handler này bọc quanh next: đọc key, nếu có cache thì trả ngay (chuỗi dừng, DB không bị gọi); nếu không thì gọi next(ctx) một lần, lưu kết quả vào Map, trả về. Nó phải đứng trước handler ghi DB, vì mục đích của nó là đảm bảo phần sau chạy tối đa một lần cho cùng một key — đặt sau DB thì đã ghi xong trước khi kịp chặn.

tsbai-tap.ts
const seen = new Map<string, string>()

export const idempotency: Handler = (ctx, next) => {
  const key = ctx.headers['idempotency-key']
  if (!key) return next(ctx)          // không có key -> không có ý kiến

  const cached = seen.get(key)
  if (cached) return 'REPLAY ' + cached   // dừng: phần sau (DB) không chạy

  const res = next(ctx)               // chạy tiếp ĐÚNG một lần
  seen.set(key, res)
  return res
}

// chain: ['idempotency', 'auth', 'payload', 'createOrder']
// gọi 2 lần cùng key -> 'REPLAY ...', createOrder chỉ chạy 1 lần

09 — Đọc cặp để hiểu bản chất

Pattern liên quan

  • StrategyStrategy: người gọi **chọn** một thuật toán rồi chạy, và biết mình chọn gì. CoR: không ai chọn, request tự chảy và handler thấy không liên quan thì đẩy tiếp.
  • DecoratorCùng là lồng nhau, nhưng decorator **luôn** chạy và bọc để thêm chức năng; handler CoR **có quyền từ chối** và cắt chuỗi. Ngay khi một handler viết code trước và sau `next()`, chỗ đó đã là decorator.
  • ObserverObserver là broadcast: mọi người đăng ký đều được chạy. CoR là đường ống: thường chỉ một người trả lời, số còn lại bị bỏ qua.
  • CommandHay đi cặp: middleware (CoR) quyết định *có cho chạy không*, command là *việc được chạy*. Ghi lại command đã đi qua chain cho phép replay, audit, retry.