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.

Cấu trúc●●○14 phút đọc8 bướccòn gọi: Handle/Body, Abstraction-Implementation
structuralcompositionkế thừadriverpluginbùng nổ class

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

1

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.

texttruong-hop-dang-gap.txt
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, Philips
Ba bài toán khác domain, một hình dạng: tên class là tích của hai danh từ đổi độc lập.
ChốtMỗi tên class chứa hai danh từ đổi vì hai lý do khác nhau là một bằng chứng bạn đang kế thừa trên hai trục cùng lúc.
2

Viế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.

tsnotification-v1.ts
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ết
Đoạn render HTML ở AlertEmailHtml và DigestEmailHtml giống nhau 90% — không có nơi chung để đặt nó.
ChốtKế thừa hard-code mọi tổ hợp: thêm một giá trị ở trục này buộc bạn phải sinh class mới ở trục kia.
3

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.

texttruoc.txt
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ốtKế thừa làm số class nhân lên; Bridge làm số class cộng thêm. Đó là toàn bộ lý do pattern này tồn tại.
4

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).

tsimplementor.ts
/** 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
}
Hai interface, hai lý do thay đổi. SMS không cần biết HTML, HTML không cần biết SMTP.
ChốtImplementor là interface mà abstraction viết ra để phục vụ chính nó — chiều phụ thuộc ngược với Adapter.
5

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.

tsnotification-v2.ts
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))
  }
}
Không còn if (kênh === ...). Số dòng của lớp abstraction không đổi khi số kênh tăng.
ChốtBridge = "has-a" thay cho "is-a". Một dòng protected channel: Channel đổi phép nhân thành phép cộng.
6

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ỉ.

tsrefined-and-implementors.ts
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>' }
Bốn implementor = 4 object. Không file nào biết file khác tồn tại.
ChốtNghiệp vụ phân nhánh bằng class, công nghệ phân nhánh bằng object. Hai file khác nhau, hai lý do thay đổi khác nhau.
7

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.

tswire.ts
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'))
console
[ALERT] SMS 0912345678 :: <p>CẦN XỬ LÝ: đơn A01 đã chạy</p>
Tenant B dùng webhook + markdown? Thêm 2 dòng registry. Không class nghiệp vụ nào bị sửa.
8

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.

tsminimal-bridge.ts
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 })
ChốtBridge đáng giá khi CẢ HAI trục đều có ≥ 2 thành viên thật và lịch thay đổi của chúng khác nhau. Một chiều duy nhất thì đây là over-engineering.

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 OA

05 — 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

tsdemo.ts
// 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())
console
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èm channel.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:

  1. 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.
  2. 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.
  3. Đừ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.

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