Pattern 15/22 · Structural
Proxy Đại diện
Đặt một vật thay thế đứng trước object thật: client cầm proxy và không phân biệt được, còn proxy quyết định khi nào object thật bị chạm tới, chạm những gì, và có được chạm không.
01 — Mở đầu bằng code đang hỏng
Vấn đề
Trang admin có bảng đơn hàng. Data loader của bạn getOrder(id) kéo một lúc order + 4 bảng liên quan, mất ~60ms. Nhưng 80% lượt mở trang chỉ để xem status trong drawer. Bạn biết điều đó. Code của bạn thì không: nó load hết, ngay, mỗi lần, vì "cần gì thì gọi getOrder".
Vấn đề thứ hai, N+1. Danh sách 200 đơn, mỗi dòng chạm order.customer.address → 200 query. Bạn sửa được bằng cách nhớ viết batch ở từng chỗ dùng. Ai quên một chỗ — và sẽ có người quên — là sập một lần.
Vấn đề thứ ba, quyền. user.passwordHash nằm trong object, một component tình cờ JSON.stringify(user) để log, và hash đi lạc xuống browser. Bạn đã check permission ở 14 chỗ, mỗi chỗ một kiểu; một chỗ thiếu là một lần lộ dữ liệu, và không có chỗ nào để "siết một lần".
Vấn đề thứ tư, reactivity. state.count++ phải kéo theo re-render. Muốn thế, object phải thấy được từng thao tác đọc/ghi. Hoặc là bạn bắt mọi người viết set("count", v) (cả team sẽ chửi), hoặc bạn phải có thứ gì đó đứng giữa và chặn access.
Bốn bài toán trên trông chẳng liên quan, nhưng chung một hình: client cần một object, nhưng object thật không nên bị chạm tới tuỳ tiện, hoặc mỗi lần chạm tới đều phải được ghi lại. Và cách sửa "thêm một if vào đầu mỗi hàm dùng" nhân bản theo số call site — cùng cái bệnh, cùng cái giá.
02 — Ý tưởng, chưa động vào code
Giải pháp
Proxy là: một vật thay thế cùng interface với object thật, client không phân biệt được, nằm giữa client và object thật (gọi là subject/proxyee) để quyết định. Nó giữ reference tới subject, cộng với lý do tồn tại: chưa load gì (virtual), đã load gì (cache), ai được thấy gì (protection), ai cần được báo (logging/reactivity), ở machine nào (remote).
TypeScript/JavaScript cho bạn bản literal nhất của pattern này, không phải bản mô phỏng: new Proxy(target, handler) — engine gọi trap của bạn cho từng phép get, set, has, deleteProperty, ownKeys, apply, construct. Vue 3 hiện thực reactive() đúng bằng Proxy: trap get để track dependency, trap set để trigger effect. Khi bạn viết state.a.b++, có một proxy đứng giữa, và đó chính là Proxy pattern của GoF, bằng API chuẩn.
Cái giá cũng phải nói đủ: mọi access đi qua một trap (chậm hơn access thường, và trong loop nóng thì đo ra chứ không đoán), this trong method khi gọi qua proxy là proxy (đôi khi là thứ bạn muốn, đôi khi là bug), private #field và các object có internal slot (Map, Set, Date, typed array) vỡ khi bọc proxy, và debugger/stack trace khó đọc hơn vì object bạn thấy không phải object bạn tạo. Đặt proxy ở biên giới, đừng rải khắp codebase.
03 — Làm thật, mỗi bước một fragment code
Từng bước một
Gọi tên lý do: bốn loại proxy, đừng nhét chung một file
Trước khi viết trap, chọn một lý do. Virtual proxy: trì hoãn việc tạo/load subject. Caching proxy: giữ kết quả để đừng tính/lấy lại. Protection proxy: quyết định ai được thấy/cái gì. Logging/reactive proxy: ghi lại hoặc phát thông báo mỗi lần access. Remote proxy: subject nằm ở process/host khác (JSON-RPC, tRPC client).
Lý do thứ năm là "cho gọn" — đó là Facade, không phải Proxy. Proxy giữ nguyên interface của subject; nếu bạn đổi interface cho dễ dùng, bạn đang làm pattern khác.
virtual : Order -> gọi DB lần đầu tiên ai đó chạm field (lazy)
caching : fn(sku)-> Map -> chỉ gọi fn khi miss (memoize)
protection : user -> Set -> field nào được lộ (role)
reactive : state -> Set -> ai đọc gì, ai cần chạy lại (signal)
remote : api -> socket -> method name + args đi network
Facade : đổi interface cho ĐƠN GIẢN.
Adapter : đổi interface cho KHỚP.
Proxy : GIỮ interface, thêm quyền quyết định ở giữa.HÌNH DẠNG trap trong JS: new Proxy(target, handler)
handler là object chứa các trap; trap nào bạn không khai báo thì hành vi mặc định đi thẳng tới target. Đây là lý do proxy "trong suốt": 99% thao tác không bị chạm.
Hai ràng buộc hay gặp: trap set phải trả true khi thành công (không thì code ở chế độ strict mode ném TypeError), và trap không được nói dối trắng trợn — invariant của engine cấm get trả khác target với property non-configurable, và cấm has trả false cho property non-configurable đang tồn tại.
const target: Record<string | symbol, unknown> = { role: 'guest', name: 'Khanh' }
const p = new Proxy(target, {
get: (obj, key) => (key in obj ? obj[key] : 'missing'),
set: (obj, key, value) => {
obj[key] = value
return true // quên: không return true -> strict mode throw
},
has: (obj, key) => key !== 'role', // 'role' in p -> false
deleteProperty: () => false, // delete p.name -> throw (strict)
})
p.role // 'guest'
'role' in p // false
delete p.name // TypeError: not allowed
p.age = 3 // target.age === 3: target bị sửa THẬTVirtual proxy: chưa đụng DB cho tới khi thật sự cần
Đây là lời giải cho bài toán 60ms. Client cầm order, code của nó không đổi một dòng, nhưng loadOrderFromDb chỉ chạy khi có ai đó chạm vào một field thật sự cần dữ liệu. Handler chỉ đọc id (thứ đã có) sẽ không trigger query.
Chú ý phần chìm: in, Object.keys, JSON.stringify cũng đi qua trap (has, ownKeys, getOwnPropertyDescriptor). Proxy lazy mà chỉ viết get thì sẽ trả "thiếu field" cho mấy phép đó. Đây là chỗ proxy dễ sai nhất trong đời thực.
function lazyOrder(id: string): Order {
let real: Order | null = null
const load = () => (real ??= loadOrderFromDb(id)) // 60ms, JOIN 4 bảng
return new Proxy({} as Order, {
get: () => load() as Order, // mọi field: load rồi trả
has: (_t, key) => key in load(),
ownKeys: () => Reflect.ownKeys(load()),
getOwnPropertyDescriptor: (_t, key) => Reflect.getOwnPropertyDescriptor(load(), key),
})
}
const order = lazyOrder('DH-01') // 0 query, 0 ms
console.log(order.status) // 1 query, vì bạn thật sự cần statusid thì rẻ, code đọc items thì trả giá. Client không cần biết sự khác biệt.Caching proxy: chặn một hàm đắt, và sống chung với invalidation
Bọc hàm cũng là proxy: trap apply bắt mọi lời gọi. Memoize theo key ở trong trap nghĩa là mọi call site được cache mà không call site nào phải đổi — và không call site nào được phép "tự cache riêng" nữa.
Hai điều bắt buộc nếu không muốn cache thành bug: không cache thất bại (lỗi là trạng thái tạm, cache nó là bạn đóng băng hỏng), và phải có đường invalidate — nếu không, proxy của bạn là một cái memory leak biết trả lời.
const cache = new Map<string, Promise<Product>>()
export const getProduct = new Proxy(fetchProduct, {
apply: (fn, _self, args: [string]) => {
const hit = cache.get(args[0])
if (hit) return hit
const p: Promise<Product> = fn(args[0]).catch((e) => {
cache.delete(args[0]) // lỗi là tạm thời: không được cache vĩnh viễn
throw e
})
cache.set(args[0], p)
return p
},
})
export const invalidate = (sku: string) => cache.delete(sku)Protection proxy: chắn field theo vai trò — và hiểu đúng giới hạn
Muốn "siết một lần" thay vì check ở 14 chỗ: liệt kê field được phép trong một Set, và chặn ở bốn trap — get, has, ownKeys, getOwnPropertyDescriptor — vì JSON.stringify đi qua ownKeys cộng get, còn phép in đi qua has. Chặn một get là chặn hình thức.
Giới hạn, nói thẳng: proxy không phải ranh giới bảo mật trong cùng tiến trình. Code nào cầm được reference tới row gốc thì đi vòng qua bạn, và secret đã nằm trong target thì coi như đã nằm trong RAM của attacker. Proxy kiểu này hợp pháp với tư cách guardrail chống vô tình (log, serialize, render nhầm); muốn chắn thật thì đừng đưa secret vào object: chọn cột ở query, trả projection.
const PUBLIC = new Set(['id', 'name', 'verifiedAt'])
export function asPublic(row: UserRow) {
return new Proxy(row, {
get: (o, k) => (PUBLIC.has(String(k)) ? (o as Record<string | symbol, unknown>)[k] : undefined),
has: (_o, k) => PUBLIC.has(String(k)),
ownKeys: () => [...PUBLIC],
getOwnPropertyDescriptor: (o, k) =>
PUBLIC.has(String(k)) ? Reflect.getOwnPropertyDescriptor(o, k) : undefined,
})
}
JSON.stringify(asPublic(row)) // {"id":..,"name":..,"verifiedAt":..} - không có passwordHashReactive proxy: trap set là nơi sự thật nằm
reactive, signal, $state — tất cả cùng một cơ chế: phát hiện thay đổi tại chỗ ghi. Với proxy, không cần setter, không cần API riêng: phép state.count++ là một trap set.
Vue 3 là ví dụ chuẩn và đáng học: reactive(obj) trả proxy; trap get track (ghi lại effect nào đang đọc field nào), trap set/deleteProperty trigger (chạy lại effect liên quan). Object lồng nhau được wrap lười ngay trong trap get (đó là cách nó deep mà không tốn trước), in đi qua has, và Map/Set có handler riêng vì lý do ở Bước 7. Vue 2 không làm được vậy vì Object.defineProperty không thấy được thêm/xoá key.
const subs = new Set<(key: string) => void>()
export function reactive<T extends object>(target: T): T {
return new Proxy(target, {
set: (obj, key, value) => {
const changed = Reflect.get(obj, key) !== value
const ok = Reflect.set(obj, key, value)
if (ok && changed) subs.forEach(fn => fn(String(key))) // 1 dòng: cả app re-render
return ok
},
deleteProperty: (obj, key) => {
const ok = Reflect.deleteProperty(obj, key)
if (ok) subs.forEach(fn => fn(String(key)))
return ok
},
})
}
export const onChange = (fn: (key: string) => void) => (subs.add(fn), () => subs.delete(fn))Ba cái bẫy kỹ thuật: this, private field, internal slot
Bẫy 1 — this. Gọi p.method() thì bên trong method, this là proxy (thứ mà reactivity cần, nhưng cũng là chỗ sinh bug). Tách method ra khỏi object (const fn = p.method; fn()) thì this thành undefined y như object thường, và method đọc this.x sẽ nổ.
Bẫy 2 — private #field. Private field không phải property; nó là internal slot, nên trap không thấy và brand check thất bại: đọc #pin qua proxy ném TypeError (thông điệp khác nhau tuỳ engine). Bẫy 3 — object có internal slot còn cay hơn: Map, Set, Date, typed array cần slot nội bộ của chính object, nên bọc proxy làm method của chúng hỏng — new Proxy(new Map(), {}).set(...) ném "incompatible receiver". Array thì sống, vì array chỉ là object + length.
class Account {
#pin = '1234'
name = 'bank'
whoami() { return this.name }
readPin() { return this.#pin }
}
const p = new Proxy(new Account(), {})
p.whoami() // 'bank' -> this LÀ proxy, vẫn đúng
const fn = p.whoami // tách method: mất this binding
// fn() // TypeError: không đọc được this.name
// p.readPin() // TypeError: private field không qua được trap
const m = new Proxy(new Map<string, number>(), {})
// m.set('a', 1) // TypeError: không phải Map thật (thiếu internal slot)
const d = new Proxy(new Date(), {})
// d.getTime() // TypeError, tương tu
const a = new Proxy([1, 2, 3], {})
a.push(4) // OK: array không cần internal slot
console.log(a.length) // 4Bước cuối: cân nhắc đừng dùng Proxy
Proxy là công cụ biên giới: một lớp mỏng ở nơi data đi vào/ra, nơi bạn kiểm soát được toàn bộ lưu lượng. Rải reactive()/proxy wrapper khắp 200 module là cách nhanh nhất để profiler của bạn đầy trap và debugger của bạn vô dụng.
Đa số nhu cầu có bản rẻ hơn: cần field tính toán → getter. Cần cache một hàm → một closure memoize, không cần apply trap. Cần N+1 hết → DataLoader/batch loader ở tầng repository. Cần "đừng sửa config" → Object.freeze + type readonly. Cần "đừng import lung tung" → lint rule ở tầng module. Proxy thắng khi bạn cần chặn cả một họ access mà không sửa call site — không thì đừng.
cần gì -> bản rẻ hơn Proxy xứng khi
field tính toán -> getter không có access nào cần chặn
cache 1 hàm -> closure memoize MỌI call site phải đi qua cache
N+1 query -> DataLoader access nằm rải rác, khó kiểm soát
config cấm sửa -> Object.freeze bạn chỉ cần nó đừng bị sửa
kiểm thử/audit access -> Proxy (trap) đây là việc duy nhất trap làm được04 — Ai nói chuyện với ai
Cấu trúc
- Subject (interface)Hình dạng mà client mong đợi. Proxy **phải** giống hệt — đây là điều kiện để client không phân biệt được.
- ProxyVật thay thế: giữ reference tới subject + **lý do** (lazy, cache, role, tracking). Chạm trap mới đi tiếp tới subject.
- Proxyee / RealSubjectObject thật: row từ DB với 4 bảng JOIN, hàm đắt, tài nguyên remote. Chậm, đắt, hoặc nhạy cảm.
- ClientĐọc/ghi qua proxy như đọc object thường. Không biết (và không cần biết) có gì ở giữa.
- Observer(phien bản reactive) Đăng ký nhận thông báo khi trap `set`/`deleteProperty` bắt được thay đổi.
Client Proxy (handler) Proxyee (thật)
------ ----------------- --------------
order.status ──get──► │ get: load nếu chưa có │
order.items ──get──► │ set: ghi + báo subscriber │ 60ms,
'items' in ──has──► │ has/ownKeys: ẩn field nhạy │ 4 JOIN
JSON.stringify ──────► │ apply: memoize theo key │ nhạy cảm
└──────────┬─────────────────┘
│ chỉ đi tiếp khi trap cho phép
▼
trap = điểm can thiệp DUY NHẤT, ở một chỗ,
client không đổi một dòng nào05 — Sửa tuỳ ý, chạy ngay tại đây
Chạy thử: ba trap, ba lý do, trong 40 dòng
const dirty = new Set<string>()
// 1) Reactive proxy: trap set phát hiện thay đổi (bản rút gọn của Vue 3 reactive())
const state = new Proxy({ cart: 0, coupon: '' } as Record<string | symbol, unknown>, {
set: (obj, key, value) => {
const changed = obj[key] !== value
obj[key] = value
if (changed) dirty.add(String(key))
return true
},
})
state.cart = 1
state.cart = 1 // không đổi -> không dirty, key không bị thêm lần nữa
state.coupon = 'SALE50'
// 2) Caching proxy: chặn một hàm đắt, memoize theo argument
let dbCalls = 0
const priceOf = (sku: string) => {
dbCalls++
return sku.length * 10
}
const cache = new Map<string, number>()
const price = new Proxy(priceOf, {
apply: (fn, _self, args: unknown[]) => {
const key = String(args[0])
if (!cache.has(key)) cache.set(key, fn(key))
return cache.get(key)
},
})
// 3) Access-control proxy: khách được thấy field nào, chỉ vậy thôi
const row = { sku: 'A1', cost: 40, margin: 0.6 }
const allowed = new Set(['sku', 'cost'])
const guestView = new Proxy(row, {
get: (o, k) => (allowed.has(String(k)) ? (o as Record<string | symbol, unknown>)[k] : undefined),
has: (_o, k) => allowed.has(String(k)),
})
console.log('dirty: ' + [...dirty].join(','))
console.log('price x3 = ' + [1, 2, 3].map(() => price('A1')).join('/') + ' dbCalls=' + dbCalls)
console.log('guest sku=' + guestView.sku + ' margin=' + guestView.margin + ' hasMargin=' + ('margin' in guestView))dirty: cart,coupon price x3 = 20/20/20 dbCalls=1 guest sku=A1 margin=undefined hasMargin=false
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
- Trì một chi phí lớn cho tới sát lúc cần, và giao diện gọi không được phép đổi (lazy relation, hydrate theo field, lazy row).
- Cần bắt mọi access ở một điểm: cache, audit log, telemetry, permission — mà không sửa hàng chục call site.
- Cần state mà mutation thật (
obj.x = 1) vẫn phát hiện được: reactive store, signal, draft copy-on-write. - Cần một view bớt quyền của object (role, tenant, chế độ preview) thay vì tự tay projection ở mỗi route.
- Subject nằm ở nơi khác (process, network) mà client vẫn muốn gọi như object local — RPC client, tRPC-style stub.
- Cần kiểm chứng access trong test/dev: chặn ghi vào config, phát hiện ai đọc field đã deprecated.
Đừng dùng khi
- Proxy không phải sandbox. Code cùng tiến trình cầm reference tới target là đi vòng qua bạn; secret đã vào target thì đã vào RAM. Chắn thật = projection từ query, không phải trap.
- Object có internal slot vỡ thật:
Map,Set,Date, typed array,WeakMap, Promise (instance gốc) — method của chúng require slot riêng, bọc proxy vào làTypeError. Array sống sót, đừng suy ra quy luật từ array. thislà proxy, nên mỗithis.xtrong method lại đi qua trap (nhanh chậm tuỳ loop), còn method bị tách khỏi object thì mất binding và nổ. Proxy + class nhiều method là nơi bug ở lâu nhất.- Private
#fieldvô hình với trap. Logic của bạn trong trap không thấy chúng, và truy cập chúng qua proxy ném TypeError. Nếu class của bạn sống bằng private state, proxy bọc không phải thiết kế khả thi. - Chỉ viết trap
getlà bug tiềm ẩn:in,Object.keys,JSON.stringify,structuredClone, spread đều đi quahas/ownKeys/getOwnPropertyDescriptor. Thiếu một trap là hành vi lệch âm thầm. - Chi phí thật: mỗi access một trap, và proxy lồng proxy (deep reactive) thì số trap nhân lên. Trong vòng lặp nóng,
Mapthường vẫn nhanh hơn object bọc proxy — đo, đừng tin blog. - Over-engineering. Rải proxy wrapper khắp codebase rồi báo "state giờ reactive" — profiler đầy trap, debugger mù, không ai giải thích được vì sao một phép đọc field chạy tới ba hàm. Getter giải quyết được thì đừng nhân bản proxy.
- Đừng nhầm với HTTP proxy trong config:
routeRules.proxycủa Nuxt hayserver.proxycủa Vite là reverse proxy ở tầng mạng — cùng tinh thần "đứng giữa", khác hẳn pattern object này.
07 — Bạn đã gặp nó rồi, chỉ là không gọi tên
Trong code thật
Vue 3 reactive() / ref()
reactive(obj) trả new Proxy(obj, handler) với trap get (track), set, deleteProperty, has, ownKeys; object lồng nhau được wrap lười trong trap get; Map/Set đi qua collection handler riêng vì internal slot. Vue 2 không làm được vậy vì Object.defineProperty không thấy thao tác thêm/xoá key — chính là lý do API Vue.set tồn tại.
Immer produce()
Immer dựng draft bằng Proxy: trap get trả draft lồng nhau, trap set ghi vào bản copy (copy-on-write), rồi produce trả object bất biến mới. Bạn mutate bình thường, library nghe trộm qua trap để tính diff — Proxy pattern đứng nguyên dưới API.
DataLoader
Một object thay thế đứng trước hàm load, memoize theo key trong phạm vi một request và gộp các load thành một batch. Nó không phải new Proxy, nhưng về hình dạng, đó là caching + batching proxy: call site gọi loader.load(id) và không biết gì ở giữa.
Lazy relation trong ORM
TypeORM cho phép khai báo quan hệ kiểu Promise<Entity> và nó được nạp khi bạn chạm property — virtual proxy bằng getter, không cần new Proxy. Cùng lý do tồn tại, khác cơ chế: khi số field nhỏ và cố định, getter đơn giản hơn.
require() cache của Node
Mỗi lần require, runtime tra Module._cache trước, đụng filesystem chỉ khi miss. Về bản chất đó là caching proxy che một subsystem đắt, và nó cũng dạy luôn bài học invalidate: cache module sống dai, và bạn trả giá đó lúc hot reload.
08 — Tự tay làm
Bài tập
Viết `readonlyGuard(config, "config")` trả về proxy mà mọi attempts `set`, `deleteProperty`, `defineProperty` ném Error ghi rõ **key nào, thao tác gì**. Gắn nó vào config của app trong dev. Sau đó trả lời hai câu: vì sao `config.db.host = "x"` vẫn trót lọt, và vì sao đây không phải cơ chế bảo mật.
Gợi ý, mở từng cái một:
- Cả ba trap phải ném cùng một loại lỗi — hãy viết một helper
deny(op, key)trả vềneverrồi dùng chung. - Trap
setmuốn "chặn" thì ném Error, chứ không chỉ trảfalse(trảfalsechỉ ném ở strict mode và mất thông điệp). - Bản "sâu" (deep) phải wrap tiếp ở trap
get: mỗi lần trả về một object thì bọc nó — đó chính xác là cách Vue 3 reactive xử lý object lồng nhau.
Ba trap gọi chung một deny(), nên thông điệp lỗi nhất quán và bạn không lặp code. Bản wrap-sâu: trong trap get, nếu giá trị là object thì trả readonlyGuard(value) (đừng quên memo theo object gốc để mỗi object chỉ một proxy — đây là flyweight gặp proxy). Còn câu hỏi bảo mật: guard này chặn tai nạn, không chặn người cố tình — họ vẫn còn object gốc trong scope, và proxy không có tác dụng gì với code không đi qua nó.
function readonlyGuard<T extends object>(obj: T, path: string): T {
const deny = (op: string, key: string | symbol): never => {
throw new Error(path + ' is readonly: ' + op + ' "' + String(key) + '"')
}
return new Proxy(obj, {
set: (_t, key) => deny('set', key),
deleteProperty: (_t, key) => deny('delete', key),
defineProperty: (_t, key) => deny('define', key),
// deep: object lồng nhau cũng phải bị giữ
get: (o, key) => {
const value = Reflect.get(o, key)
return value && typeof value === 'object' ? readonlyGuard(value, path + '.' + String(key)) : value
},
})
}
const config = readonlyGuard({ db: { host: 'localhost' }, port: 3000 }, 'config')
config.port = 8080 // Error: config is readonly: set "port"
config.db.host = 'evil' // Error: config.db is readonly: set "host"09 — Đọc cặp để hiểu bản chất
Pattern liên quan
- FacadeCả hai đều "đứng trước" thứ khác nhau. Facade **đổi** interface để subsystem dễ dùng; Proxy **giữ** interface để kiểm soát truy cập. Nếu client của bạn phải học API mới, đó không còn là Proxy.
- DecoratorDecorator thêm hành vi bằng cách bọc **tĩnh và chủ ý** — ai viết code đó đều biết có lớp bọc. Proxy thêm hành vi **trong suốt** — client không phân biệt được. Decorator rẻ và dễ debug hơn, chỉ khi cần chặn toàn bộ access mới tới lượt Proxy.
- AdapterAdapter tồn tại vì interface **không khớp**; Proxy tồn tại vì việc **truy cập** cần bị kiểm soát, và nó cố tình không sửa interface.
- CommandCặp hay gặp ở remote proxy: proxy dịch mỗi lời gọi method thành một Command object, gửi đi, bên kia chạy rồi trả kết quả. RPC client thực chất là proxy sinh command.