Pattern 05/22 · Creational
Singleton Đơn bản
Bảo đảm cả tiến trình chỉ có đúng một instance và mở ra một cửa duy nhất để lấy nó. Trong JS, phần "một instance" thì ES module đã làm sẵn, nên giá trị thật của pattern nằm ở chỗ khác: kiểm soát instance ra đời *lúc nào*, *bằng tham số nào*, và *ai được phép thay nó khi test*.
01 — Mở đầu bằng code đang hỏng
Vấn đề
Bạn có utils/db.ts: export const prisma = new PrismaClient(). Ai cần thì import { prisma }. Chạy tốt nửa năm. Rồi bạn viết test unit đầu tiên cho OrderService.cancel() — và test của bạn kết nối thật vào dev DB, vì chỉ cần import là module body chạy, không ai xin phép. Để nó ngừng chạy, bạn thêm vi.mock("~/utils/db"), và từ đó hành vi của test phụ thuộc vào đường dẫn module dạng chuỗi: ai đổi tên file là test im lặng test một thứ không tồn tại.
Có người "cải tiến" cho chuyên nghiệp: class DB { private static inst; static get(cfg) { return this.inst ??= new DB(cfg) } }. Tinh vi. Và bug mới xuất hiện: getInstance(config) nhận tham số, nhưng chỉ tham số của lần gọi đầu tiên được dùng. File A import trước với DSN staging, file B import sau với DSN prod — B im lặng nhận staging. Không exception, không warning, không log. Thứ duy nhất bị phớt lờ là đối số bạn tưởng là có hiệu lực.
Trên server thì nặng hơn. Bạn đặt let currentUser ở module scope của một Nuxt server route, gán trong middleware, đọc ở handler. Một request: đúng. Hai request đồng thời: handler của user A đọc đúng cái currentUser mà request của user B vừa ghi đè. Đây không phải bug hiệu năng, đây là bug bảo mật, và nó tồn tại vì module scope của Node sống suốt tiến trình, còn request thì chỉ sống vài chục ms.
Vòng đời dev và prod cũng không giống nhau. Bật HMR/nodemon, module bị eval lại, client cũ vẫn giữ connection pool trong khi client mới mở thêm pool nữa → hết connection (Prisma phải khuyến cáo cất client vào globalThis trong dev). Serverless thì ngược lại: tiến trình ấm và module state sống dai qua nhiều lần gọi, nên cái Map bạn đặt ở module scope "để cache tạm" hoá ra thành cache vĩnh viễn — và nếu key của nó thiếu tenant id, nó phục vụ dữ liệu của khách này cho khách khác.
Pattern không phải thủ phạm. Thủ phạm là dependency ẩn: chỗ dùng không khai báo trong chữ ký hàm, nên bạn không nhìn thấy nó khi đọc code, không grep ra được ai dùng gì, không đổi được nó khi test, và không di chuyển được nó khi refactor. Chốt lại: "một instance" là yêu cầu chính đáng; "mọi người đều tự đi lấy được từ global" mới là thứ khiến nó đắt.
02 — Ý tưởng, chưa động vào code
Giải pháp
Dáng GoF: constructor private để không ai new được, một static field giữ instance, và một static method getInstance() tạo nó nếu chưa có. Trong TypeScript đúng ba chi tiết đó là đủ, và nó làm đúng hai việc: cấm tạo bản thứ hai, và hoãn việc tạo tới lúc thật sự cần.
Nhưng ở JS ta phải nói thẳng một điều: ES module đã là singleton. Lần import đầu tiên chạy module body, kết quả được lưu trong module registry, mọi importer khác dùng chung đúng object đó. export const prisma = new PrismaClient() là Singleton, ngắn hơn, có type, và không cần ai nhớ gọi getInstance(). Viết thêm class + getInstance lên trên nó chỉ mua thêm một cửa global để truy cập, thứ mà ta sắp bỏ đi.
Nên cách dùng đáng tiền là tách đôi pattern: giữ phần lifecycle (một instance, tạo lười, tạo ở một chỗ duy nhất), bỏ phần global access (không ai import để dùng lén). Instance nằm trong một module, được khởi tạo tại composition root — entrypoint của app, Nuxt plugin, server entry — rồi chảy vào code nghiệp vụ dưới dạng tham số. Server vẫn có một pool; test thì truyền fake vào; và OrderService khai báo đúng thứ nó cần ngay trong chữ ký hàm.
03 — Làm thật, mỗi bước một fragment code
Từng bước một
Viết bản GoF trước, để biết nó thật ra mua gì
private constructor chặn new từ bên ngoài. Static field giữ instance. getInstance() tạo nếu chưa có. Tám dòng, và đó là toàn bộ những gì Singleton cho bạn.
Hãy viết nó một lần cho đủ hình, rồi ta sẽ chỉ ra ngay chỗ nào trong tám dòng này là thừa ở JS.
export class DB {
private static inst: DB | undefined
private constructor(private readonly dsn: string) {}
static getInstance(dsn: string): DB {
this.inst ??= new DB(dsn)
return this.inst
}
query(sql: string) { return this.dsn + ' :: ' + sql }
}
DB.getInstance('dsn://staging')
DB.getInstance('dsn://prod') // <-- dsn này bị BỎ QUA, không lỗiNói thẳng: ES module vốn đã là singleton
Module registry của JS map (specifier, realm) → module record. Module body chỉ chạy một lần; các import sau đọc từ cache. Nghĩa là export const x = new Thing() đã bảo đảm "một instance duy nhất" mạnh hơn cả getInstance(): không ai có thể tạo cái thứ hai vì không ai gọi constructor.
Nó còn có type tĩnh. DB.getInstance() trả DB vì bạn tự hứa vậy; import { db } trả DB vì compiler biết.
// logger.ts
class Logger {
private lines: string[] = []
log(msg: string) { this.lines.push(msg); return this }
dump() { return this.lines.length }
}
export const logger = new Logger() // module body chạy ĐÚNG MỘT LẦN
// a.ts: import { logger } from './logger' <- lần đầu: chạy body, lưu registry
// b.ts: import { logger } from './logger' <- các lần sau: đọc registry
// nên l1 === l2 luôn đúng, trong cùng một module record + cùng một realm.
// Cái bạn KHÔNG tạo ra được bằng cách này: bản thứ hai. Không ai gọi constructor.export const không tăng độ an toàn — nó chỉ thêm một đường để truy cập toàn cục.Lười hoá: đừng chạy khởi tạo lúc import
Cái export const prisma = new ... có một giá phải trả: import là chạy. Trong SSR, bundle bị load để render một trang /about cũng mở luôn connection pool. Serverless trả thêm tiền và thêm cold-start time cho thứ request đó không dùng. Và nếu module khác import ngược lại (circular), nó thấy module chưa khởi tạo xong: undefined hoặc TDZ error lúc 3 giờ sáng.
Chỗ này Singleton thật sự có lãi: getInstance() tạo instance tại lần dùng đầu, tức là sau khi env đã được đọc, config đã validate, và request đầu tiên đã chứng minh là code này cần chạy.
class DB {
private constructor(readonly dsn: string) {}
private static inst: DB | undefined
static get(): DB {
// env chỉ chắc chắn đọc được sau khi app boot, không phải lúc import
if (!this.inst) {
const dsn = process.env.DSN
if (!dsn) throw new Error('DSN chưa được cấu hình')
this.inst = new DB(dsn)
}
return this.inst
}
}
// so với: export const db = new DB(process.env.DSN!) <- chạy ngay lúc import
export const useDb = () => DB.get()Composition root: một file duy nhất biết tham số khởi tạo
Singleton có tham số khởi tạo thì phải có người trả lời câu hỏi "ai truyền, truyền lúc nào". Câu trả lời đúng là: một file — entrypoint của app. Nuxt plugin, server/utils/* init, main.ts, hoặc bin/cli.ts. Ngoài file đó, không ai được biết DSN, API key, hay tên bảng.
Quy tắc hệ quả: code nghiệp vụ không được init. Nó chỉ lấy, và nếu chưa init thì thất bại sớm với thông điệp rõ ràng.
let db: DB | undefined
/** Chỉ được gọi từ entrypoint / plugin, đúng một lần. */
export function initDb(config: { dsn: string, pool: number }): void {
if (db) throw new Error('initDb gọi 2 lần')
db = new DB(config.dsn)
}
/** Code nghiệp vụ chỉ "lấy", không "tạo". */
export function getDb(): DB {
if (!db) throw new Error('initDb chưa được gọi — kiểm tra plugin bootstrap')
return db
}
// nuxt plugin bootstrap.ts: initDb({ dsn: useRuntimeConfig().dbDSN, pool: 5 })new tài nguyên dùng chung, bạn không có Singleton — bạn có race.Cắt phần độc hại: biến nó thành tham số
Đây là bước duy nhất biến "Singleton khó test" thành "Singleton an toàn". Thay vì OrderService tự import { db }, nó nhận db từ bên ngoài, qua constructor hoặc qua tham số của factory. Chữ ký hàm bây giờ khai báo đầy đủ những gì nó cần — nhìn signature là biết dependency, không cần đọc thân hàm.
Type của tham số nên là giao diện nhỏ (DbClient với đúng 2-3 method service dùng), không phải class driver 60 method. Giao diện nhỏ nghĩa là fake dễ viết và driver đổi được.
export interface DbClient {
findOne(sql: string, id: string): Promise<any>
exec(sql: string, ...args: unknown[]): Promise<void>
}
export function createOrderService(db: DbClient) {
return {
async cancel(id: string) {
await db.exec('update orders set status = $1 where id = $2', 'cancel', id)
},
}
}
// Wiring duy nhất, ở composition root:
// const orders = createOrderService(getDb())createOrderService(db) không biết Prisma, không biết Postgres, không import gì để dùng lén.Test fake, bỏ vi.mock
Khi dependency là tham số, test chỉ cần một object cùng shape. Không mock theo tên module, không resetModules(), không lo thứ tự test, không cần DB, không cần Docker. Test chạy nhanh tới mức bạn còn muốn viết thêm test.
Đây là điểm mà Singleton "nguyên bản" (mọi người tự đi getInstance()) thua rõ nhất: để test nó, bạn phải dọn global state, và dọn global state thì hai test chạy song song không còn độc lập nữa.
interface DbClient {
exec(sql: string, ...args: unknown[]): Promise<void>
}
const createOrderService = (db: DbClient) => ({
cancel: (id: string) => db.exec('update orders set status = $1 where id = $2', 'cancel', id),
})
const calls: string[] = []
const fakeDb: DbClient = {
exec: async (sql, ...args) => { calls.push(sql + ' | ' + args.join(',')) },
}
await createOrderService(fakeDb).cancel('o1')
console.log(calls.join(' -> '))
// so với bản Singleton: phải vi.mock("~/utils/db") + mockReset + lo thứ tự testupdate orders set status = $1 where id = $2 | cancel,o1
vi.mock đường dẫn module để chạy được, đó là dấu hiệu dependency đang đi đường vòng thay vì đi qua chữ ký hàm.Không đặt state per-request ở module scope
Rule dứt khoát: module scope chỉ chứa thứ không đổi theo request (pool, client, clock, logger). Bất cứ thứ gì thuộc về một request/user — user hiện tại, quota, tenant, language, request id — phải nằm trong object của request: event.context (Nitro/Nuxt), req.locals (Express), hoặc AsyncLocalStorage.
Vue cũng vậy và tài liệu chính thức cảnh báo: ref() đặt ở module scope của một composable được mọi component dùng chung — tiện cho global state, nhưng trên SSR nó chia sẻ giữa các request, tức là user A nhận trạng thái của user B. Bản an toàn là tạo ref() bên trong function setup/composable, hoặc khai báo rõ nó là global có chủ đích.
const profile = (user?: string) => 'profile của ' + (user ?? 'KHÔNG RÕ')
// ✗ Sai: module scope sống suốt tiến trình, request thì chồng lấn lên nhau
let currentUser: string | undefined
async function handlerA(user: string) { currentUser = user; return profile(currentUser) }
async function handlerB() { return profile(currentUser) } // đọc lộn của người khác
;(async () => {
const p = Promise.all([handlerA('user-A'), handlerB()])
console.log((await p).join(' | '))
})()
// ✓ Đúng: state đi cùng đối tượng của request
async function handler(event: { context: any, user: string }) {
event.context.user = event.user // Nitro: event.context sống 1 request
return profile(event.context.user)
}profile của user-A | profile của user-A
Kiểm tra vòng đời: HMR, warm lambda, dual package
Ba chuyện thật xảy ra với "single" instance. (1) HMR/nodemon: module bị eval lại, instance mới ra đời, instance cũ chưa đóng → pool phình; thuốc là cất instance vào globalThis có điều kiện trong dev, chính xác là cách Prisma khuyến cáo. (2) Warm lambda: state không bị reset giữa hai lần gọi, nên cache module-scope là cache thật — phải có TTL và key đủ ngữ cảnh (tenant, env). (3) Dual package hazard: package bị cài hai bản (ESM + CJS) nghĩa là có hai module record, hai "singleton", và a instanceof B trả false khó hiểu.
Nghiệp vụ phải phòng vệ bằng assert khi init và bằng cách không dựa vào identity của class để quyết định logic.
class DB { constructor(readonly dsn: string) {} }
// dev: HMR/nodemon eval lại module, nhưng globalThis thì không bị reset
const isDev = "prerender" !== 'production'
const g = globalThis as unknown as { __db?: DB }
let prodInstance: DB | undefined
function getDb(dsn: string): DB {
if (isDev) return (g.__db ??= new DB(dsn)) // Prisma khuyến cáo đúng kiểu này
return (prodInstance ??= new DB(dsn))
}
console.log('HMR-safe, cùng instance:', getDb('dsn://a') === getDb('dsn://a'))
// Cache module-scope trên server: key PHẢI đủ ngữ cảnh, và phải có hạn dùng
const cacheKey = (tenant: string, id: string) => tenant + ':' + id
console.log('key đủ ngữ cảnh:', cacheKey('t1', 'u1') !== cacheKey('t2', 'u1'))HMR-safe, cùng instance: true key đủ ngữ cảnh: true
??= trên globalThis là một Singleton "cho phép dev restart". Nó cũng là bằng chứng Singleton có thể chỉ để chữa một vấn đề của môi trường, không phải của thiết kế.04 — Ai nói chuyện với ai
Cấu trúc
- SingletonClass giữ static field + `getInstance()`. Constructor private để `new` từ ngoài là lỗi biên dịch.
- InstanceĐúng một object sống suốt vòng đời module/tiến trình: pool, client, reporter, clock.
- CompositionRootEntrypoint (plugin Nuxt, server entry, main.ts) khởi tạo instance với config thật và truyền xuống.
- ClientCode nghiệp vụ. Nhận instance **làm tham số**, không import để tự đi lấy.
- TestDoubleFake cùng interface, truyền vào đúng chỗ Client nhận — thay cho mock theo tên module.
✗ Bản phổ biến (dependency ẩn)
┌───────────────────────────────────────────┐
│ OrderService ──import──► utils/db.ts │ test import là
│ CartService ──import──► (new Client) │ nối DB thật
└───────────────────────────────────────────┘
✓ Bản giữ lifecycle, bỏ global access
Composition root (plugin / entry)
│ initDb(config) tạo lười, đúng 1 lần
▼
┌────────────────────┐ private constructor
│ module "db" │ ┌──────────────────────┐
│ let db: DB │──►│ DB instance (1) │
│ initDb() getDb() │ └──────────────────────┘
└─────────┬──────────┘
│ createOrderService(db) ← dependency nằm trong chữ ký
▼
┌──────────────────────────────┐
│ OrderService(db: DbClient) │ test: createOrderService(fakeDb)
└──────────────────────────────┘05 — Sửa tuỳ ý, chạy ngay tại đây
Chạy thử: singleton có kiểm soát, fake cho test, và state per-request
interface KV {
get(k: string): string
set(k: string, v: string): void
}
class Store implements KV {
static created = 0
private m = new Map<string, string>()
constructor() { Store.created++ }
get(k: string) { return this.m.get(k) ?? '<null>' }
set(k: string, v: string) { this.m.set(k, v) }
}
// getInstance: lần đầu mới tạo, các lần sau trả lại đúng object cũ
class Registry {
private static self: Store | undefined
static get(): Store {
if (!Registry.self) Registry.self = new Store()
return Registry.self
}
}
Registry.get().set('a', '1')
console.log('1 same object =', Registry.get() === Registry.get(), '| Store đã tạo =', Store.created)
// Dependency Injection: hàm nhận KV, không tự đi lấy singleton
const dump = (kv: KV, keys: string[]) => keys.map(k => k + '=' + kv.get(k)).join(' ')
const store = Registry.get()
store.set('b', '2')
console.log('2 prod :', dump(store, ['a', 'b']))
// Test fake: singleton thành đối số -> test không phải dọn global state
const fake: KV = { get: k => 'FAKE:' + k, set: () => {} }
console.log('3 test fake :', dump(fake, ['a', 'b']))
// Server: module sống suốt tiến trình -> state phải tạo per-request
const perRequest = () => { const s = new Store(); s.set('user', 'u'); return s.get('user') }
console.log('4 per-request :', perRequest(), perRequest(), '| tổng Store đã tạo =', Store.created)1 same object = true | Store đã tạo = 1 2 prod : a=1 b=2 3 test fake : a=FAKE:a b=FAKE:b 4 per-request : u u | tổng Store đã tạo = 3
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
- Tài nguyên tạo đắt và dùng chung có lợi: DB pool, driver, connection WebSocket, client SDK đã authenticate, thread/worker pool.
- Tài nguyên chỉ được phép tồn tại một theo semantic: một
AudioContextcho một tab, một sequence phát sinh ID, một reporter gom metric theo lô, một console writer để log không xen kẽ dòng. - Cần lazy: việc khởi tạo đắt hoặc phụ thuộc config, và app có thể chạy cả ngày mà không chạm tới nó (admin, export, payment).
- Cần một điểm khởi tạo duy nhất để kiểm soát vòng đời: bật/tắt, đổi config lúc boot, đóng gracefully khi tiến trình nhận SIGTERM.
- Trình duyệt: bạn thật sự chỉ có một
document, mộtlocalStorage, mộtperformance— Singleton ở đó là hiện thực khách quan, không phải lựa chọn.
Đừng dùng khi
- Dependency ẩn là chi phí thật: caller không khai báo trong chữ ký, nên đọc code không thấy, grep không ra, đổi implementation phải sửa mọi nơi import, và refactor module thành package khác là công trình.
- Test: instance sống dai làm test phụ thuộc thứ tự — test A ghi, test B đọc được dữ liệu của A. Bạn sẽ thêm
reset()/clearCache()"chỉ để test", tức là vừa mở thêm một cửa phá vỡ tính đóng gói. Chữa bằng DI + fake, không chữa bằng--isolated. - Server: module scope chia sẻ giữa mọi request trong cùng tiến trình. State per-request (user, tenant, quota, language) đặt ở đó là rò rỉ dữ liệu giữa người dùng; cache module-scope không TTL là OOM từ từ. Serverless làm cả hai khó thấy hơn vì tiến trình ấm không đoán được.
getInstance(config)bỏ qua config của lần gọi thứ 2 im lặng. Nếu hai caller hợp lệ có thể đòi config khác nhau, đó không phải Singleton — đó là Factory, và bạn đang che một bug bằng một pattern.- Over-engineering:
export const config = loadConfig()đã là Singleton. Đừng dựngclass Config { static getInstance() }cho đủ bộ — bạn chỉ thêm một global accessor. Tương tự, đừng DI hoá một hàm thuần tuý 5 dòng không I/O: DI mua khả năng test/swap, không mua điểm thiết kế. - Hai module record là hai "singleton" (dual package ESM/CJS, hai copy trong
node_modules, worker cùng realm).instanceofvàMapkey-based identity bắt đầu sai. Dựa vào interface, đừng dựa vào identity của class để rẽ nhánh.
07 — Bạn đã gặp nó rồi, chỉ là không gọi tên
Trong code thật
Prisma client singleton (khuyến cáo chính thức)
Docs của Prisma khuyên tạo một PrismaClient rồi export, và trong dev thì cất nó trên globalThis vì nodemon/ts-node-dev eval lại module khiến pool connection tăng tới mức hết limit. Đây chính là Singleton, và cũng chính là ví dụ "vòng đời dev khác prod".
axios default export
import axios from "axios" cho bạn một instance dùng chung. axios.defaults.headers.common.Authorization = ... ảnh hưởng tới mọi call trong tiến trình — tiện một cách nguy hiểm. Đó là lý do docs luôn khuyên axios.create(...) khi bạn cần config riêng: thoát Singleton khi Singleton thành global mutable.
Composable Vue: ref() ở module scope
Tài liệu Vue ("Sharing Composables State") chỉ đúng pattern này: ref() đặt ngoài function thì mọi component dùng chung state. Kèm cảnh báo SSR: state đó chia sẻ giữa các request, nên code an toàn là tạo ref() bên trong composable. Singleton là thứ bạn phải chọn có ý thức, không phải mặc định.
Nuxt/Nitro server: event.context và useRuntimeConfig
Nitro giữ đồ nặng (driver, pool) ở module scope để tái dùng giữa các request, nhưng mọi thứ thuộc về một request phải nằm trong event.context; useRuntimeConfig() là singleton của config, đọc lúc boot. Đúng ranh giới này thì HMR không phá, sai thì leak giữa người dùng.
Browser: AudioContext, localStorage, performance
Môi trường chỉ cung cấp một phiên bản, nên các lib audio giữ đúng một AudioContext trong module của họ (trình duyệt giới hạn số context đồng thời và sẽ cảnh báo). navigator.clipboard, window.matchMedia cũng một mình một chợ — Singleton không phải lựa chọn ở đây, nó là hợp đồng của platform.
08 — Tự tay làm
Bài tập
`orderService.ts` đang `import { db } from "~/utils/db"` rồi dùng `db.exec(...)`; test của nó bắt buộc `vi.mock("~/utils/db")` và hay fail khi chạy cả file. Refactor: service nhận dependency qua tham số với interface tối giản, giữ **default** là instance thật ở composition root, rồi viết lại test dùng fake mà không mock module nào.
Gợi ý, mở từng cái một:
- Liệt kê đúng những gì service gọi trên
db— thường chỉ 2 method. Khai báointerface DbClientvới đúng 2 method đó (interface segregation, và fake ngắn hơn nhiều). - Chuyển từ
class OrderService+ import sangfunction createOrderService(db: DbClient). Muốn "ai cũng gọi được không cần truyền", cho tham số một default:db = getDb(). Wiring mặc định ở production, còn test thì truyền fake. - Test: dựng
const calls: string[] = [], fakeexecchỉpushvàocalls, rồi assertcalls. Nếu bạn vẫn cầnvi.mock, nghĩa là còn chỗ nào đó tựimportđể dùng lén.
Tách interface nhỏ, đưa dependency vào tham số của factory function, giữ default getDb() cho production. Production không đổi một dòng wiring nào; test mất toàn bộ mock và mất luôn sự phụ thuộc vào thứ tự chạy.
// db.ts — composition root giữ phần "một instance"
export interface DbClient {
exec(sql: string, ...args: unknown[]): Promise<void>
}
let real: DbClient | undefined
export function initDb(client: DbClient): void {
if (real) throw new Error('initDb gọi 2 lần')
real = client
}
export function getDb(): DbClient {
if (!real) throw new Error('initDb chưa được gọi')
return real
}
// order-service.ts — không import gì để dùng lén (đọc DbClient/getDb từ db.ts)
export const createOrderService = (db: DbClient = getDb()) => ({
async cancel(id: string) {
await db.exec('update orders set status = $1 where id = $2', 'cancel', id)
},
})
// test — không vi.mock, không reset, chạy độc lập
const calls: string[] = []
const fake: DbClient = { exec: async (sql, ...a) => { calls.push(sql + ' [' + a.join(',') + ']') } }
await createOrderService(fake).cancel('o1') // test: tự truyền dependency
initDb(fake) // wiring: đúng MỘT lần, ở entry
await createOrderService().cancel('o2') // không truyền -> lấy getDb()
console.log('số lệnh đã ghi:', calls.length, '| instance duy nhất:', getDb() === getDb())09 — Đọc cặp để hiểu bản chất
Pattern liên quan
- FacadeRất hay đi cặp: module singleton thường đi kèm một số function exported dễ dùng, thành Facade. Facade lo "API dễ gọi", Singleton lo "đúng một instance" — hai vấn đề khác nhau, đừng lẫn.
- FlyweightCùng là "dùng chung instance", nhưng Flyweight dùng chung **nhiều** object nhỏ chia sẻ state bất biến, còn Singleton dùng chung **một** object cả đời. Flyweight tối ưu bộ nhớ; Singleton quản lifecycle.
- ProxyProxy là chỗ tự nhiên để gói một singleton lười: `getInstance()` bên trong handler, lần gọi đầu tiên mới tạo instance thật. Virtual Proxy và lazy Singleton khác nhau chủ yếu ở tên gọi.
- Abstract FactoryAbstract Factory chọn **họ** object theo môi trường (dev/test/prod), Singleton quyết định thứ được chọn tồn tại **một lần**. Cặp này hay gặp: driver thật cho prod, driver fake cho test, mỗi cái một instance.