Pattern 17/22 · Structural
Bridge Cầu nối
Tách một class đang gánh hai trục thay đổi độc lập thành hai hệ thống riêng, nối chúng bằng composition (trục này giữ một tham chiếu interface của trục kia), để mỗi bên thêm thành viên mới mà không phải sửa bên còn lại.
01 — Mở đầu bằng code đang hỏng
Vấn đề
Tính năng thông báo bắt đầu rất đơn giản: một class Notification với send(). Tuần sau PM hỏi "cho gửi qua SMS nữa", bạn thêm SmsNotification extends Notification. Tuần sau nữa: "email phải có HTML", bạn thêm EmailHtmlNotification. Sáu tháng sau, thư mục notifications/ có AlertEmailHtmlNotification, AlertSmsTextNotification, DigestEmailMarkdownNotification, và một file notification-factory.ts chứa cây if/else dài hơn cả mấy class cộng lại.
Chuyện đó không phải lỗi của ai. extends là công cụ duy nhất bạn có lúc đó, nên mỗi tổ hợp hợp thành một class. Nhưng hãy nhìn kỹ tên của chúng: mỗi tên là tích của hai danh từ — loại thông báo (Alert, Digest) và cách gửi (Email/HTML, SMS/text). Hai danh từ đó đổi vì hai lý do khác nhau, do hai người khác nhau, theo hai lịch khác nhau.
Con số nói thẳng: 2 loại × 3 kênh × 3 định dạng = 18 class. Thêm định dạng PDF không phải "thêm một file" mà là +6 class, và đoạn render HTML bạn viết trong AlertEmailHtmlNotification phải được copy sang DigestEmailHtmlNotification, vì hai class đó không có người cha chung nào chứa HTML.
Và nó hỏng theo những cách rất cụ thể khi dự án lớn lên: sửa một bug định dạng HTML là sửa 6 file; hai team cùng mở các file ...Notification.ts khác nhau cho hai tính năng khác nhau rồi merge ở cùng một constructor; không test được "HTML render" nếu không dựng kèm một kênh và một loại thông báo; còn "chọn kênh theo cấu hình tenant" thì biến thành switch dựng class — tức là code lại phải đoán tổ hợp nào tồn tại.
Bạn sẽ gặp lại đúng hình dạng này ở chỗ khác: PgDatabase, MysqlDatabase, PgQueryLoggingDatabase; ModalDesktopDark, ModalMobileLight; ExportCsvPg, ExportJsonMysql; hay UI button mà biến thể là variant × size × state × theme. Vấn đề không phải "quá nhiều class" — mà là hai (ba) trục thay đổi độc lập bị hàn cứng thành một bằng extends.
02 — Ý tưởng, chưa động vào code
Giải pháp
Bridge: chọn một trục đưa xuống làm composition. Trục đó trở thành một interface (GoF gọi là Implementor), và class ở trục kia giữ một tham chiếu tới interface thay vì extends nó. AlertNotification không "là một Email"; nó có một channel và gọi channel.deliver(...) đúng lúc.
Toàn bộ giá trị của pattern nằm ở phép tính: 2 + 3 + 3 = 8 thay vì 18, và khi cần PDF bạn thêm đúng một object render, không sửa một class thông báo nào. Hai trục sống độc lập: test độc lập, owner khác nhau, và mọi tổ hợp đều chạy được kể cả tổ hợp chưa ai nghĩ ra — vì không có class tổ hợp nào để mà quên viết.
Trong TypeScript, "hệ thống class" ở trục implementor thường co lại còn một interface cộng vài object literal, nên bản thực tế nhẹ hơn sơ đồ GoF nhiều. Nếu phía abstraction cũng không phân cấp, Bridge của bạn chính là "constructor nhận dependency". Bạn đã viết Bridge nhiều lần, chỉ là chưa gọi tên — và chưa vẽ ma trận class để thấy nó đáng giá cỡ nào.
03 — Làm thật, mỗi bước một fragment code
Từng bước một
Gọi tên hai trục: cái gì đổi, và đổi vì ai
Trước khi sửa code, liệt kê mọi class đang có rồi tách tên thành các danh từ. Với DigestEmailHtmlNotification: Digest (nghiệp vụ), Email (công nghệ gửi), Html (định dạng thể hiện).
Mỗi danh từ là một trục nếu nó trả lời được hai câu: ai yêu cầu thay đổi nó (product hay platform team?) và nó đổi độc lập với các danh từ kia không? Nếu có lúc bạn đổi kênh mà không đổi format, và ngược lại — đó là hai trục thật, không phải hai chi tiết implement.
Notification (nghiệp vụ) x Channel (công nghệ) x Format (thể hiện)
Alert, Digest Email, SMS, Zalo text, HTML, Markdown
Database (nghiệp vụ) x Vendor (backend)
SqlDatabase, MongoDatabase Postgres, MySQL, SQLite
Device (nghiệp vụ) x Driver (nhà sản xuất)
Tv, Radio Sony, LG, PhilipsViết bản kế thừa và đếm số class nó đòi
Đừng refactor vội. Hãy viết bản "ai cũng viết lần đầu" và đếm — con số là thứ thuyết phục reviewer nhanh hơn mọi lý thuyết.
abstract class Notification {
abstract send(to: string, text: string): string
}
// Trục kênh + trục format bị nhét vào hệ thống class của trục nghiệp vụ:
class AlertEmailText extends Notification {
send(to: string, text: string) { return 'SMTP ' + to + ' :: ' + text }
}
class AlertEmailHtml extends Notification {
send(to: string, text: string) { return 'SMTP ' + to + ' :: <p>' + text + '</p>' }
}
class AlertSmsText extends Notification {
send(to: string, text: string) { return 'SMS ' + to + ' :: ' + text }
}
class DigestEmailHtml extends Notification {
send(to: string, text: string) { return 'SMTP ' + to + ' :: <p>Digest: ' + text + '</p>' }
}
// ... còn DigestEmailText, DigestSmsText, và ba cái Zalo chưa ai viếtAlertEmailHtml và DigestEmailHtml giống nhau 90% — không có nơi chung để đặt nó.Vẽ ma trận class trước khi động vào code
Vẽ ô vuông: hàng là trục nghiệp vụ, cột là trục implementor. Mỗi ô là một class bạn phải viết, test và bảo trì. Đây là thứ bạn đưa cho reviewer, không phải UML.
Mục tiêu của refactor được định nghĩa chính xác từ giờ: số ô trở thành số hàng cộng số cột. Ghi lại con số hiện tại để cuối cùng so lại.
TRƯỚC (kế thừa): SAU (bridge):
text html md Alert \
Alert 1 1 1 = 6 Digest >-- Channel (email|sms|zalo)
Digest 1 1 1 (2 class) /
Zalo/Email/SMS đều nhân 3 + Renderer (text|html|md)
6 class hôm nay. +PDF -> 9 class. +Webhook -> 12.
Bridge: 2 + 3 + 3 = 8 object. +PDF -> 9. +Webhook -> 10.Chốt interface cho trục implementation
Chọn làm Implementor cái trục mà bạn đổi vì nhà cung cấp / công nghệ / định dạng: Channel, Renderer, Driver. Nó phải được viết bằng ngôn ngữ của phía abstraction, không phải ngôn ngữ của vendor.
Nghĩa là deliver(to, body) chứ không phải createTransport(options) — interface do bên gọi sinh ra. Nếu bạn chép nguyên API của nodemailer lên làm interface, thì Bridge chưa chạy: abstraction vẫn "biết" về SMTP, và Driver không thể thay bằng SMS một cách vô nghĩa. Chỗ API vendor không khớp, đó là việc của Adapter (đứng sau Implementor).
/** Trục 2a: gửi đi bằng cách nào. Hợp đồng do Notification định nghĩa. */
export interface Channel {
readonly id: string
deliver(to: string, body: string): string
}
/** Trục 2b: trình bày ra sao. Độc lập hoàn toàn với kênh. */
export interface Renderer {
readonly id: string
render(text: string): string
}Abstraction giữ tham chiếu thay vì extends
Lớp abstraction chỉ còn một việc: chạy quy trình nghiệp vụ và uỷ quyền. Nó không new channel nào, không so sánh channel.id === ... nào.
protected vì các class con ở cùng trục sẽ dùng lại; nếu abstraction không có class con thì biến nó thành private và đừng trừu tượng hoá thêm.
import type { Channel, Renderer } from './implementor'
export class Notification {
constructor(
protected channel: Channel,
protected renderer: Renderer,
) {}
/** Quy trình chung: định dạng trước, gửi sau. */
send(to: string, text: string): string {
return this.channel.deliver(to, this.renderer.render(text))
}
}if (kênh === ...). Số dòng của lớp abstraction không đổi khi số kênh tăng.protected channel: Channel đổi phép nhân thành phép cộng.Cài cả hai phía: class nghiệp vụ và object implementor
Trục abstraction vẫn được phép phân cấp — Bridge không cấm gì ở đó. AlertNotification thêm hậu tố, DigestNotification đổi tiêu đề, cả hai gọi super.send() và đều mù về channel.
Phía implementor thì ngược lại: TypeScript kiểm tra cấu trúc, nên một object literal khớp Channel đã là một implementor hợp lệ — không implements, không class. Driver của vendor nào nằm riêng file đó, kể cả file chỉ có 6 dòng. Đó cũng là nơi duy nhất được phép import SDK vendor (nodemailer, axios, Zalo OA...); phần còn lại của codebase không thấy chúng.
Bài kiểm tra nhanh cho cả hai file: ở trục nghiệp vụ không được xuất hiện tên nào như Email hay Sms; ở trục implementor không được xuất hiện tên nào như Alert hay Digest. Có nghĩa là một trong hai trục vẫn còn rò rỉ.
import { Notification } from './notification-v2'
import type { Channel, Renderer } from './implementor'
// --- trục 1: nghiệp vụ, phân cấp thoả mái ---
export class AlertNotification extends Notification {
send(to: string, text: string): string {
return '[ALERT] ' + super.send(to, 'CẦN XỬ LÝ: ' + text)
}
}
export class DigestNotification extends Notification {
send(to: string, text: string): string {
return super.send(to, 'BẢN TIN HÔM NAY — ' + text)
}
}
// --- trục 2: công nghệ, object literal là đủ ---
export const emailChannel: Channel = {
id: 'email',
deliver: (to, body) => 'SMTP -> ' + to + ' :: ' + body, // nodemailer nằm ở đây
}
export const smsChannel: Channel = {
id: 'sms',
deliver: (to, body) => 'SMS ' + to + ' :: ' + body,
}
export const textRenderer: Renderer = { id: 'text', render: t => t }
export const htmlRenderer: Renderer = { id: 'html', render: t => '<p>' + t + '</p>' }Nối cầu ở một chỗ duy nhất, lúc chạy
Tổ hợp nào được dùng là quyết định cấu hình, không phải quyết định kiến trúc. Nó nên nằm ở composition root (một file, một hàm), đọc từ env/config/tenant. Đây là nơi if/else dựng class cũ chết hẳn.
import type { Channel, Renderer } from './implementor'
import { emailChannel, smsChannel, htmlRenderer, textRenderer } from './refined-and-implementors'
import { AlertNotification, DigestNotification } from './refined-and-implementors'
const channels: Record<string, Channel> = { email: emailChannel, sms: smsChannel }
const renderers: Record<string, Renderer> = { text: textRenderer, html: htmlRenderer }
export function createNotification(kind: string, cfg: { channel: string, format: string }) {
const channel = channels[cfg.channel]
const renderer = renderers[cfg.format]
if (!channel || !renderer) throw new Error('cấu hình không hỗ trợ: ' + cfg.channel + '/' + cfg.format)
const Cls = kind === 'digest' ? DigestNotification : AlertNotification
return new Cls(channel, renderer)
}
const n = createNotification('alert', { channel: 'sms', format: 'html' })
console.log(n.send('0912345678', 'đơn A01 đã chạy'))[ALERT] SMS 0912345678 :: <p>CẦN XỬ LÝ: đơn A01 đã chạy</p>
Bản tối giản — và khi nào Bridge là thuốc quá liều
Nếu trục abstraction không phân cấp, đừng giữ abstract class: một function nhận dependency đã là Bridge, và nó trung thực hơn. Bạn chỉ còn một interface cộng các object implementor.
Ngược lại, hãy tự chặn mình bằng một câu hỏi: trục kia có ít nhất hai implementor thật (không phải hai mock để trang trí sơ đồ)? Một implementor duy nhất + không có kế hoạch cái thứ hai = bạn đang trả thuế indirection mà không nhận được hàng. Bắt đầu bằng class thường, refactor khi ô thứ hai xuất hiện.
type Channel = { id: string, deliver: (to: string, body: string) => string }
/** Không abstract class, không file interface: đây vẫn là Bridge. */
export const notify = (to: string, text: string, channel: Channel) =>
channel.deliver(to, text)
notify('0912345678', 'Đơn A01 đã chạy', { id: 'sms', deliver: (t, b) => 'SMS ' + t + ' :: ' + b })
notify('a@b.co', 'Đơn A01 đã chạy', { id: 'email', deliver: (t, b) => 'SMTP -> ' + t + ' :: ' + b })04 — Ai nói chuyện với ai
Cấu trúc
- AbstractionPhần client gọi: giữ một tham chiếu Implementor, chạy quy trình chung (`send()`). Không chứa tên vendor nào.
- RefinedAbstractionTrục nghiệp vụ phân nhánh: `AlertNotification`, `DigestNotification`. Kế thừa Abstraction, vẫn mù về implementor.
- ImplementorInterface của trục thứ hai, do Abstraction định nghĩa: `Channel.deliver(to, body)`.
- ConcreteImplementorMột cách làm cụ thể: email, sms, zalo. Thường là object literal, mỗi vendor một file, là nơi duy nhất import SDK.
- Client / composition rootChọn tổ hợp (kênh + định dạng + loại) ở một chỗ duy nhất, đọc từ config; nối cầu lúc chạy.
Client / composition root
│ new AlertNotification(channels.sms, renderers.html)
▼
┌──────────────────────────────────────────────┐
│ Abstraction: Notification │
│ #channel: Channel #renderer: Renderer │
│ send(to, text) ─► render ─► deliver │
└──────────────────┬───────────────────────────┘
│ dependency (không phải extends)
┌────────────┴─────────────┐
▼ ▼
AlertNotification DigestNotification ← trục 1: nghiệp vụ
(thêm tuỳ ý, 0 ô mới)
dùng hợp đồng Channel / Renderer
┌──────────────┬───────────┴──────┐
▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌──────────┐ ← trục 2: công nghệ
│ email │ │ sms │ │ zalo │ (thêm tuỳ ý, 0 sửa)
└─────────┘ └─────────┘ └──────────┘
nodemailer HTTP API SDK OA05 — Sửa tuỳ ý, chạy ngay tại đây
Chạy thử: Device × Driver — thêm driver mới, 0 class thiết bị mới
// Trục 1: abstraction (thiết bị) — đổi khi thêm loại thiết bị
// Trục 2: implementation (driver) — đổi khi thêm nhà sản xuất
interface Driver {
readonly brand: string
powerOn(): string
volumeUp(step: number): string
}
const sony: Driver = {
brand: 'Sony',
powerOn: () => 'Sony: bật panel',
volumeUp: n => 'Sony: level +' + n,
}
const lg: Driver = {
brand: 'LG',
powerOn: () => 'LG: wake from standby',
volumeUp: n => 'LG: vol +' + n,
}
class Device {
constructor(protected driver: Driver) {}
powerOn(): string { return this.driver.powerOn() }
volumeUp(step: number): string { return this.driver.volumeUp(step) }
}
class Tv extends Device {
watch(): string { return 'TV[' + this.driver.brand + '] ' + this.powerOn() }
}
class Radio extends Device {
play(step: number): string { return 'RADIO[' + this.driver.brand + '] ' + this.volumeUp(step) }
}
// 2 thiết bị × 2 driver: kế thừa đòi 4 class, bridge chỉ cần 2 + 2
console.log(new Tv(sony).watch())
console.log(new Tv(lg).watch())
console.log(new Radio(sony).play(5))
console.log(new Radio(lg).play(3))
// Thêm driver mới: 1 object, 0 class thiết bị mới
const philips: Driver = { brand: 'Philips', powerOn: () => 'Philips: on', volumeUp: n => 'Philips: +' + n }
console.log(new Tv(philips).watch())TV[Sony] Sony: bật panel TV[LG] LG: wake from standby RADIO[Sony] Sony: level +5 RADIO[LG] LG: vol +3 TV[Philips] Philips: on
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
- Bạn đếm được ≥ 2 giá trị ở cả hai trục, và thêm một giá trị ở trục này không liên quan gì đến trục kia.
- Implementation phải chọn lúc build/deploy/chạy (env, tenant, feature flag), không phải lúc viết code — kế thừa khoá quyết định đó lại từ compile time.
- Code phải sống với nhiều vendor/backend/định dạng song song: payment (Stripe, Portal), mail, push, storage, DB dialect, export format.
- Bạn muốn test trục nghiệp vụ mà không dựng vendor, hoặc test một driver mà không dựng cả cây nghiệp vụ.
- SDK vendor cồng kềnh và bạn muốn một file được phép import nó, phần còn lại của codebase chỉ thấy interface.
- Bạn đang sắp viết
class XxxYyyZzz— hãy dừng lại và đếm số ô của ma trận trước đã.
Đừng dùng khi
- Over-engineering. Một implementor duy nhất, không có cái thứ hai trong 12 tháng tới? Bridge lúc đó là ba file rỗng và một lần nhảy định nghĩa. class thường rồi refactor khi ô thứ hai xuất hiện.
- Sai chiều phụ thuộc: nếu interface của bạn mô tả API của vendor (
createTransport,sendRaw) thì bạn vừa viết Adapter, chưa phải Bridge — abstraction vẫn rò rỉ kiến thức SMTP. Interface phải mô tả cái abstraction cần. - Abstraction rỗng: mỗi method của abstraction chỉ gọi đúng một method của driver cùng tên. Đó là "cầu trung chuyển", không thêm giá trị nào — driver đã có thể dùng trực tiếp. Abstraction phải chứa quy trình chung (thứ tự, validation, retry, format).
- Hai chiều tự do làm việc đọc code đắt hơn: lỗi từ vendor bay ngược lên abstraction qua 3 tầng. Chuẩn hoá lỗi ngay trong implementor (
throw new ChannelError(...)) và log kèmchannel.id, nếu không debug lúc 2h sáng sẽ rất dài. - Ba trục không có nghĩa là ba interface nhét vào một constructor.
Notification(channel, renderer, scheduler, template)là dấu hiệu class đã gánh lại nhiều vai — tách ra, mỗi cặp trục một cây.
07 — Bạn đã gặp nó rồi, chỉ là không gọi tên
Trong code thật
TypeORM / Kysely / Prisma: Driver-Dialect
TypeORM khai báo một interface Driver mà PostgresDriver, MysqlDriver, SqliteDriver, MssqlDriver cùng cài; DataSource (abstraction) chạy query builder và gọi driver. Prisma đi xa tới mức tách hẳn driver adapter thành package (@prisma/adapter-pg, @prisma/adapter-libsql) để cùng một query engine chạy trên nhiều backend. Đây là Bridge nguyên nghĩa: abstraction và vendor tăng trưởng độc lập.
Vue: createRenderer và nodeOps
@vue/runtime-core chứa toàn bộ logic component, reactivity, patch — nhưng không biết DOM. Nền tảng cung cấp nodeOps (createElement, insert, patchProp...) qua createRenderer(options). Cùng một abstraction, ba implementation đang chạy ngoài kia: @vue/runtime-dom (browser), @vue/server-renderer (chuỗi HTML cho SSR/Nuxt), và các renderer custom cho Weex/native.
unstorage: defineDriver sau useStorage() trong Nuxt
Bạn gọi useStorage().setItem(key, v) như nhau, còn driver phía sau là fs, redis, cloudflare-kv-binding, http... do config quyết định. API của storage là Abstraction, mỗi driver là một ConcreteImplementor khớp một interface do unstorage (chứ không phải Redis) định nghĩa.
Vite/Rollup: resolver + plugin container
Rollup định nghĩa một nhóm hook (resolveId, load, transform) làm hợp đồng; Vite cài chúng cho dev server, esbuild, SSR. Cùng một pipeline build, phần "lấy module từ đâu" thay đổi độc lập với phần "build ra sao" — hai trục, một hợp đồng.
08 — Tự tay làm
Bài tập
Bạn có 4 class: `ExportCsvPg`, `ExportCsvMysql`, `ExportJsonPg`, `ExportJsonMysql`, mỗi class tự mở kết nối và tự format. Hãy chuyển sang Bridge sao cho thêm định dạng `xlsx` và thêm backend `sqlite` chỉ tốn đúng **2 file mới**, không sửa file cũ. Chỉ rõ ai là Abstraction, ai là Implementor.
Gợi ý, mở từng cái một:
- Trục nào đổi vì product (định dạng file), trục nào đổi vì hạ tầng (DB)? Vẽ ma trận 2×2 trước.
- Implementor nên trả về cái gì để hai bên không dính nhau? Gợi ý:
query(sql): Row[], abstraction không biết gì về cursor/connection. - Đừng quên chỗ nối cầu: một registry
Record<string, X>cho mỗi trục, và một hàm duy nhất dựng object cuối.
Abstraction là Exporter giữ rows: QueryRunner; Implementor là QueryRunner { run(sql): Row[] } (pg, mysql, sqlite), Renderer là Serializer { name, extension, serialize(rows): string } (csv, json, xlsx). exportReport(sql, { db, format }) tra hai registry rồi new Exporter(runner, serializer). Thêm xlsx = 1 object + 1 dòng registry; thêm sqlite = 1 object + 1 dòng registry.
type Row = Record<string, string | number>
interface QueryRunner { readonly db: string, run(sql: string): Row[] }
interface Serializer { readonly format: string, serialize(rows: Row[]): string }
class Exporter {
constructor(private runner: QueryRunner, private serializer: Serializer) {}
export(sql: string): string {
const rows = this.runner.run(sql)
return this.serializer.format + ' · ' + rows.length + ' dòng · ' + this.serializer.serialize(rows)
}
}
const pg: QueryRunner = { db: 'pg', run: () => [{ id: 1 }, { id: 2 }] }
const mysql: QueryRunner = { db: 'mysql', run: () => [{ id: 7 }] }
const csv: Serializer = { format: 'csv', serialize: rows => rows.map(r => String(r.id)).join(',') }
const json: Serializer = { format: 'json', serialize: rows => JSON.stringify(rows) }
const xlsx: Serializer = { format: 'xlsx', serialize: rows => 'BIN(' + rows.length + ')' } // file MỚI
const runners: Record<string, QueryRunner> = { pg, mysql }
const serializers: Record<string, Serializer> = { csv, json, xlsx }
const exportReport = (sql: string, db: string, format: string) =>
new Exporter(runners[db], serializers[format]).export(sql)
console.log(exportReport('SELECT id', 'mysql', 'xlsx'))09 — Đọc cặp để hiểu bản chất
Pattern liên quan
- AdapterAdapter làm một API **đã tồn tại** khớp với API bạn cần; Bridge định nghĩa API trước rồi để nhiều implementation cùng cài. Trong code thật, Bridge thường đứng trước, Adapter đứng sau che SDK vendor.
- Abstract FactoryAbstract Factory dựng **cả họ** object phối hợp nhau; Bridge là nơi họ object đó được dùng. Factory là cách sạch để chọn cặp (channel + renderer) ở composition root.
- StrategyRất dễ nhầm: Strategy thay **một hành vi** (thường là một function), Bridge tách **hai hệ thống class** đều có thể phân cấp. Nếu abstraction của bạn không có class con, thứ bạn viết thực chất là Strategy.
- FacadeNhìn từ ngoài, abstraction của Bridge giống Facade: một API gọn che nhiều thứ. Khác ở chỗ Facade không nhằm mục đích cho hai phía phát triển độc lập, và thường không có nhiều implementation thay thế.