Pattern 20/22 · Behavioral
Mediator Bộ điều phối
Gom toàn bộ logic liên-lạc giữa một nhóm đối tượng vào đúng một chỗ duy nhất, để các đối tượng chỉ nói chuyện với chỗ đó, không phải với nhau.
01 — Mở đầu bằng code đang hỏng
Vấn đề
Form checkout của một shop có bảy field: country, province, shipping method, delivery date, voucher, gift wrap, address note. Ngày đầu mọi thứ ổn: CountrySelect đổi thì ProvinceSelect đổi danh sách. Bạn viết handler trong CountrySelect.vue: gọi API lấy tỉnh, rồi gán thẳng vào component kia qua ref. Một mũi tên, ba dòng code. Rẻ.
Rồi voucher xuất hiện. SHIP20 giảm 20k, chỉ cho đơn nội tỉnh, và khi đã dùng voucher thì delivery date phải lùi tối thiểu 2 ngày. Bạn mở VoucherInput.vue, thêm ref tới ShippingMethod.vue để tắt lựa chọn "standard", thêm ref tới DeliveryDate.vue để đổi min. Hai tuần sau: khách tự tay bật lại "standard" thì voucher phải tự huỷ — nên ShippingMethod.vue phải import VoucherInput.vue. Vòng tròn khép lại.
Đếm mũi tên: n component nói chuyện trực tiếp với nhau tạo thành n(n-1)/2 cặp. Bảy field là 21 mũi tên; thêm field thứ tám là 28; mười field là 45. Không ai nhớ nổi 45 mũi tên, và mỗi mũi tên đều không có chủ — nó nằm nhờ trong file của component phía phát. Hệ quả thấy ngay: import vòng tròn khiến một phía nhận undefined lúc runtime, và bundler chỉ warning chứ không chặn.
Test và tái sử dụng chết trước tiên. Muốn test VoucherInput một mình, bạn phải mount ba component kia hoặc mock ba cái ref — 60 dòng fixture cho một rule 4 dòng. Muốn bê CountrySelect sang form địa chỉ? Nó kéo theo ProvinceSelect và ShippingZone, dù form đó không có ship. Và mấy bug kiểu "voucher không reset khi đổi province" sống rất lâu trên production, vì rule nằm rải ở ba file, không file nào sai cả — chỉ tổ hợp của chúng sai.
Gốc vấn đề không phải "component này viết tệ". Gốc vấn đề: logic điều phối giữa các component đang nằm rải rác bên trong chính các component, và mỗi component phải biết danh tính của những component khác. Chi phí vì thế tăng theo số cặp, không theo số field — mà tính năng mới thì luôn được tính bằng field.
02 — Ý tưởng, chưa động vào code
Giải pháp
Mediator: nhét toàn bộ logic liên-lạc vào một object duy nhất. Các component (gọi là colleague) không còn nhìn nhau nữa. Chúng chỉ báo "field của tôi đổi rồi" lên mediator, và đọc phần đã được suy ra từ mediator. n component → n mũi tên, tất cả cùng trỏ về một điểm.
Mediator giữ state của cả nhóm và suy ra phần còn lại: danh sách tỉnh đang hợp lệ, method nào đang được phép, ngày giao sớm nhất, field nào bắt buộc. Component bị rút gọn thành "chip": hiển thị một field, phát một event. Thêm field mới = thêm state + thêm rule trong mediator; không component cũ nào bị sửa.
Tin tốt: trong Vue bạn đã có sẵn vật này. Một Pinia store miền nghiệp vụ, hay một composable domain như useCheckout(), chính là mediator — state chung, getter suy ra, action đổi state, và component chỉ đi một chiều vào nó. Pattern này không bắt bạn thêm thư viện hay thêm class; nó bắt bạn đặt logic điều phối vào đúng một chỗ có tên và giữ cho mũi tên đi một chiều: component → mediator, không bao giờ component → component.
03 — Làm thật, mỗi bước một fragment code
Từng bước một
Liệt kê mũi tên trước khi viết component
Trước khi tạo file .vue đầu tiên, viết danh sách ai cần biết ai. Mỗi dòng một rule: "country đổi → province reset", "voucher đổi → method bị khoá", "province đổi → zone đổi → method bị khoá". Đừng code, hãy đếm.
Bảy dòng rule nghĩa là mediator có bảy dòng logic — chấp nhận được. Nếu bạn đếm ra 20 dòng và chúng phụ thuộc chiều (A → B → C → A), bạn không cần một pattern, bạn cần chạy ngay, vì mediator cũng không cứu được một tập rule mâu thuẫn.
country đổi -> province reset + load lại options
province đổi -> tính lại zone (noi-thanh / ngoai-thanh)
zone đổi -> method: ngoai-thanh thi tat "express"
voucher đổi -> method: tat "standard"; deliveryDate.min = +2 ngay
method đổi -> huy voucher neu voucher dung "standard"
deliveryDate -> hien dong "giao som nhat la ..."
tickets > 10 -> company bat buoc nhap
=> 7 rule, 7 field. Mũi tên nếu để component tự gọi nhau: 7*6/2 = 21.Viết bản "bad smell" để thấy rõ ref xuyên component
Đây là code mà ai cũng viết lần đầu, và nó trông hoàn toàn hợp lệ. Hãy nhìn đúng chỗ thối: component này giữ ref tới component khác và gọi method của component đó.
<script setup lang="ts">
// CountrySelect biết tên, biết API, biết cả method nội bộ của 2 component khác
const provinceRef = ref<InstanceType<typeof ProvinceSelect>>()
const zoneRef = ref<InstanceType<typeof ShippingZone>>()
async function onCountryChange(code: string) {
const list = await $fetch('/api/provinces?country=' + code)
provinceRef.value?.setOptions(list) // mui ten 1
provinceRef.value?.clear() // mui ten 2
zoneRef.value?.recalc(code, provinceRef.value?.value) // mui ten 3
}
</script>
<template>
<select :value="country" @change="onCountryChange( ($event.target as HTMLSelectElement).value )">
<option v-for="c in countries" :key="c">{{ c }}</option>
</select>
<ProvinceSelect ref="provinceRef" />
<ShippingZone ref="zoneRef" />
</template>VoucherInput import file này, file này import ShippingZone, ShippingZone import VoucherInput — circular.Khai báo mediator: state chung nằm ở một store
Mediator là một Pinia store miền nghiệp vụ (hoặc một composable dùng reactive cấp module). Nó giữ state của cả nhóm và hàm set() — con đường duy nhất để đổi state.
Chú ý nó không import component nào, không biết ProvinceSelect tồn tại. Dependency chỉ đi một chiều: component → store.
import { defineStore } from 'pinia'
import { derive } from '~/utils/checkout-rules'
export const useCheckoutStore = defineStore('checkout', () => {
const fields = ref({
country: 'VN',
province: '',
method: 'standard' as 'standard' | 'express',
voucher: '',
tickets: 1,
company: '',
})
/** Mọi thay đổi đi qua đây: mediator là chỗ duy nhất biết rule reset. */
function set<K extends keyof Fields>(key: K, value: Fields[K]) {
fields.value[key] = value
if (key === 'country') fields.value.province = ''
if (key === 'province' && !derive(fields.value).methods.includes(fields.value.method))
fields.value.method = 'standard'
if (key === 'method' && fields.value.voucher === 'SHIP20' && value !== 'express')
fields.value.voucher = ''
}
return { fields, derived: computed(() => derive(fields.value)), set }
})if nghiệp vụ nào.Rút component về "chip": đọc field của mình, gọi set()
Bây giờ component chỉ còn biết một field. Nó không import ai, không giữ ref tới ai, không biết có voucher tồn tại. Toàn bộ "không khí" của pattern nằm ở bước này: component dumb đi một cách chủ động.
<script setup lang="ts">
const form = useCheckoutStore()
const read = (e: Event) => (e.target as HTMLSelectElement).value
</script>
<template>
<select :value="form.fields.country" @change="form.set('country', read($event))">
<option v-for="c in form.derived.countries" :key="c" :value="c">{{ c }}</option>
</select>
</template>ProvinceField.vue dài y hệt, chỉ khác tên field. Không file nào import file nào.Ép mọi suy luận vào một hàm pure
Phần "tính ra" (options, field bị khoá, ngày sớm nhất, field bắt buộc) gom vào một hàm thuần: đầu vào là fields, đầu ra là phần dẫn xuất. Không await, không DOM, không store. Đây là phần bạn test được bằng expect, không cần mount gì cả.
Quan trọng hơn với về sau: vì mọi rule là dữ liệu trả về của một hàm, bạn có thể log nó, snapshot nó, cho phép dev khác chạy một rule với inputs giả. Rule rải trong computed của 6 component thì không làm được.
export type Fields = {
country: string, province: string, method: 'standard' | 'express', voucher: string, tickets: number, company: string
}
export const derive = (f: Fields) => ({
countries: ['VN', 'US', 'JP'],
provinces: PROVINCES[f.country] ?? [],
zone: f.province === 'HCM' || f.province === 'HN' ? 'noi-thanh' : 'ngoai-thanh',
methods: f.province && f.zone === 'ngoai-thanh' ? (['standard'] as const) : (['standard', 'express'] as const),
minDeliveryDays: f.voucher === 'SHIP20' ? 2 : 1,
companyRequired: f.tickets > 10,
})expect(derive({ ...base, province: "DN" }).methods).toEqual(["standard"]). Một dòng, không fixture.Đừng để mediator với ngược vào component
Bẫy phổ biến nhất: bạn chuyển hết logic lên store, rồi store vẫn giữ ref component để "gọi cho nhanh". Bạn đã đổi chỗ chứa ref, chưa bỏ ref. Store không được biết đến InstanceType<typeof ProvinceSelect>, không được gọi setOptions, focus(), hay validate() của component.
Nguyên tắc: mediator trả về dữ liệu; component tự lo việc biến dữ liệu thành DOM. Muốn focus input khi có lỗi? Store set fields.touched.company = true, component watch cái đó rồi focus. Vẫn một chiều.
// SAI: mediator nắm refs, vẫn là mạng nhện, chỉ khác địa chỉ
const componentRefs = new Map<string, ComponentPublicInstance>()
function focusError(field: string) {
componentRefs.get(field)?.$el.querySelector('input')?.focus()
}
// ĐÚNG: mediator chỉ đổi state, component tự phản ứng
const focusRequest = ref<string | null>(null)
function scrollToFirstError() {
focusRequest.value = firstInvalidField(fields.value)
}Phân biệt mediator với facade và event bus
Facade cũng gom nhiều object sau một API, nhưng quan hệ là một chiều và không có hội thoại: khách gọi facade.checkout(), facade không giữ state của khách, các object bên trong không biết facade. Mediator thì có state chung của cả nhóm và hai chiều: colleague báo lên, mediator suy ra, colleague đọc xuống.
Event bus là observer đội lốt mediator: nó forward message chứ không quyết định. Bus không giữ state, không có rule, không có owner. Bạn dùng bus cho cart:add thì 6 tháng sau không ai biết ai đang nghe, xoá một listener là run tay — đó là cách một "kiến trúc sự kiện" thoái hoá thành bãi rác. Mediator khác ở chỗ nó sở hữu luật: nó có thể từ chối, biến đổi, hoặc nói "method này giờ không hợp lệ".
Cặp so sánh gọn: facade = "tôi làm API đơn giản cho anh"; bus = "tôi chuyển hộ tin nhắn"; mediator = "tôi là người chia chác, và tôi nhớ hết".
// Facade: 1 chiều, stateless, khách không bị gọi ngược
class CheckoutFacade {
async placeOrder(cart: Cart) {
const fee = await shipping.quote(cart)
return orders.create(cart, fee)
}
}
// Event bus: forward, không state, không quyết định, không owner
bus.emit('cart:add', sku) // ai nghe? Compile không biết. Grep thì ra 7 chỗ, 3 trong số đó là typo.
// Mediator: state + quyết định + gọi ngược lại bằng data
class CheckoutForm {
set(key: keyof Fields, value: unknown) {
this.fields[key] = value
const next = derive(this.fields) // suy luận tập trung
if (!next.methods.includes(this.fields.method)) this.fields.method = 'standard'
return next // colleague đọc cái này để render
}
}Bài kiểm tra cuối: chiều của mũi tên
Refactor xong, chạy ba câu hỏi. Nếu trả lời "không" cho câu nào, làm lại bước tương ứng.
# 1. Có component nào import component-đồng-cấp của nó không?
grep -rn "^import.*Field" components/checkout/ | grep -v index
# 2. Có chỗ nào gọi method của component khác không?
grep -rn "\.value\?\.\(set\|clear\|focus\|validate\|recalc\)" components/
# 3. Thêm một field MỚI: bạn sửa bao nhiêu file cũ?
# Đạt: mediator + rules + 1 component mới. Không file component cũ nào.
# 4. Test logic điều phối có cần mount component không? Đạt: không.04 — Ai nói chuyện với ai
Cấu trúc
- MediatorMột object (store/composable) giữ state chung của cả nhóm, chứa rule, và là nơi duy nhất được đổi state.
- ColleagueMột component/field. Chỉ biết mediator và field của chính nó. Không import, không gọi, không giữ ref tới colleague khác.
- DerivedStateKết quả suy ra từ fields: options, field bị khoá, min/max, bắt buộc. Thường là một hàm pure `derive(fields)`.
- ClientNgười dùng tương tác với một field bất kỳ; hoặc trang cha dựng mediator và gắn các colleague vào.
TRƯỚC: n component tự gọi nhau -> n(n-1)/2 mũi tên, không mũi tên nào có chủ
Country <----> Province Voucher <----> Shipping
| \ | | \ |
| \ | | \ |
v v v v v v
Zone Date <---- Company Date Zone Company
(21 mũi tên cho 7 field, 45 cho 10 field)
SAU: mọi colleague chỉ biết mediator -> n mũi tên
user sửa 1 field
|
v
+-----------------------------------+
| Mediator (checkout store) |
| fields: country, province, ... |
| set(key, value) <- viết |
| derived = derive(fields) -> đọc |
+----+----------+------------+------+
đọc | | | đọc
v v v
+----------+ +---------+ +----------+
| Country | | Voucher | | Delivery | chip: chỉ biết 1 field
+----------+ +---------+ +----------+ không import nhau05 — Sửa tuỳ ý, chạy ngay tại đây
Chạy thử: chat room — user chỉ nói chuyện với room
// Before: n users need n*(n-1)/2 direct links (3 users = 3, 20 users = 190).
// After: n users need n links to ONE mediator.
class ChatRoom {
private members = new Map<string, (line: string) => void>()
join(name: string, inbox: (line: string) => void) {
this.members.set(name, inbox)
}
/** The only place that knows who receives what. */
send(from: string, to: string, text: string) {
const line = from + ': ' + text
if (to === '*') {
const targets = [...this.members.keys()].filter(n => n !== from)
console.log(from + ' broadcast -> ' + targets.length + ' people')
for (const name of targets) this.members.get(name)!(line)
return
}
if (!this.members.has(to)) {
console.log(' ! ' + to + ' is not in the room, message dropped')
return
}
console.log(from + ' -> ' + to)
this.members.get(to)!(line)
}
}
const inbox = (name: string) => (line: string) => console.log(' [' + name + '] ' + line)
const room = new ChatRoom()
room.join('an', inbox('an'))
room.join('bin', inbox('bin'))
room.join('cuong', inbox('cuong'))
room.send('an', '*', 'chao moi nguoi')
room.send('bin', 'cuong', 'gap sau nhe')
room.send('cuong', 'khach', 'ai day vay')an broadcast -> 2 people
[bin] an: chao moi nguoi
[cuong] an: chao moi nguoi
bin -> cuong
[cuong] bin: gap sau nhe
! khach is not in the room, message droppedCù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
- Form nhiều field phụ thuộc nhau (country → province, start → end, voucher → method) và số rule đã vượt quá số bạn giữ được trong đầu — thực tế khoảng 5 rule cross-field là bắt đầu nhức.
- Wizard/stepper nhiều bước, nơi bước sau phụ thuộc tổng hợp các bước trước chứ không phải một field kề trước.
- Bạn đang bị circular import giữa các sibling component, hoặc đang
injectmột ref component để "gọi hàm của em nó". - Dashboard/game UI: nhiều widget cùng phản ứng với một hành động (board, minimap, HUD, log panel). Broker thay vì refs.
- Bạn cần test logic điều phối mà không mount component nào: mediator là object thường, rule là hàm pure.
- Hub thật sự ở tầng server: chat room, message broker, matchmaking — nơi người gửi không hề biết người nhận là ai.
Đừng dùng khi
- Mediator hoá bãi rác. Bạn gom logic liên-lạc, rồi tiện tay nhét luôn API client, format tiền, check quyền, gửi email vào store. 700 dòng sau đó bạn có một
App.vuemới, chỉ khác là nó không render. Mediator chỉ chứa phối hợp giữa các field; rule của một mình một field thì để ở field đó. - Mediator với ngược vào colleague (giữ ref, gọi
setOptions(),validate(),focus()). Trông như mediator, thực chất vẫn là mạng nhện, chỉ đổi chỗ chứa. Mediator trả về data, không trả về DOM operation. - Dùng event bus toàn cục thay cho mediator. Bus không state, không rule, không owner — nó chỉ chuyển thư. Sau 6 tháng không ai biết ai nghe
cart:add, và mỗi lần refactor là một canh bạc. Nếu buộc phải có bus: đặt tên event vào một map có type, và gọi nó là bus chứ đừng gọi là kiến trúc. - Over-engineering. Hai field, một rule, một form duy nhất, xác suất đổi thấp?
@change+ mộtcomputedlà đủ, đừng dựng store. Mediator trả tiền trước bằng một tầng trừu tượng; nó có lãi chỉ khi số rule còn tăng. - Mediator + async: hai rule cùng ghi một field, hoặc hai request tỉnh/thành về lộn thứ tự → state sai mà code đúng. Mediator là chỗ duy nhất được
await, và nên guard kết quả bằng request token.
07 — Bạn đã gặp nó rồi, chỉ là không gọi tên
Trong code thật
Pinia store theo miền nghiệp vụ
Một store useCheckoutStore() giữ state cross-field, có getter derived và action set(); các field component inject nó thay vì giữ ref lẫn nhau. Đây chính là Mediator, và nó là cách được khuyến nghị trong tài liệu Vue khi sibling cần chia sẻ state.
Composable domain + provide/inject
Trang cha gọi const form = useCheckoutForm() một lần rồi provide(formKey, form); mọi field component inject lấy. Một instance duy nhất, logic điều phối nằm trong composable. createSharedComposable (VueUse) làm đúng việc chia sẻ instance này mà không cần DI key.
Redux / Vuex
Cả kiến trúc là Mediator đóng gói: component không dispatch sang component khác, chỉ gửi action lên store; reducer (nơi duy nhất có rule) trả state mới. Redux DevTools cho bạn thấy toàn bộ "cuộc hội thoại" đi qua mediator — thứ mà event bus không bao giờ cho xem được.
Socket.IO room / message broker
Server giữ danh sách room và quyết định ai nhận message nào; client chỉ biết socket của mình, không biết gì về client khác. RabbitMQ/Kafka exchange với routing key là phiên bản backend của cùng ý tưởng: người gửi không address người nhận.
08 — Tự tay làm
Bài tập
Form đăng ký event có bốn field: `country`, `province`, `method`, `tickets`, `company`. Rule: `country` đổi → `province` reset và load lại options; `province` ngoài thành → tắt `express`; `tickets > 10` → `company` bắt buộc. Dựng mediator (composable hoặc Pinia store) sao cho **bốn component field không import lẫn nhau** và thêm rule mới chỉ sửa mediator + file rules.
Gợi ý, mở từng cái một:
- Viết 3 dòng rule ra giấy trước. Mỗi dòng có dạng "field A đổi → field B ra sao".
- Tách rule dẫn xuất (
zone,methods,companyRequired) thành một hàm purederive(fields)trả về object — component chỉ render cái object đó. - Rule reset (country đổi thì province mất giá trị) không phải dẫn xuất, nó là mutation: đặt nó trong
set(), là chỗ duy nhất được đổi state.
Mediator = state + set() + derived. set() chứa rule reset; derive() chứa rule dẫn xuất. Component chỉ đọc derived và gọi set(field, value). Thêm rule mới = sửa 2 file (rules, mediator), không sửa file component nào.
// composables/useSignupForm.ts — mediator, không import component nào
type Fields = { country: string, province: string, method: 'standard' | 'express', tickets: number, company: string }
export const derive = (f: Fields) => {
const zone = f.province === 'HCM' || f.province === 'HN' ? 'noi-thanh' : 'ngoai-thanh'
return {
zone,
provinces: PROVINCES[f.country] ?? [],
methods: f.province && zone === 'ngoai-thanh' ? (['standard'] as const) : (['standard', 'express'] as const),
companyRequired: f.tickets > 10,
}
}
export function useSignupForm() {
const fields = ref<Fields>({ country: 'VN', province: '', method: 'standard', tickets: 1, company: '' })
const derived = computed(() => derive(fields.value))
function set<K extends keyof Fields>(key: K, value: Fields[K]) {
fields.value[key] = value
if (key === 'country') fields.value.province = ''
if (key === 'province' && !derive(fields.value).methods.includes(fields.value.method))
fields.value.method = 'standard'
}
return { fields, derived, set }
}
// ProvinceField.vue: const form = useSignupForm()
// <select :value="form.fields.province" @change="form.set('province', read($event))">
// <option v-for="p in form.derived.provinces" :key="p">{{ p }}</option>
// </select>09 — Đọc cặp để hiểu bản chất
Pattern liên quan
- FacadeCùng gom nhiều object sau một cửa, nhưng facade là API một chiều cho khách bên ngoài; mediator là trọng tài có state chung cho các thành viên bên trong.
- ObserverMediator thường dùng Observer bên trong: colleague phát event lên mediator, mediator notify xuống. Khác biệt: mediator còn giữ rule và có quyền từ chối.
- Chain of ResponsibilityCả hai cắt quan hệ "người gọi biết người nhận". Chain thả request chạy qua nhiều handler cho tới khi có người xử lý; mediator tập trung xử lý vào một chỗ.
- CommandMediator + Command: colleague không gọi thẳng action của nhau mà gửi command object lên mediator, nhờ đó có undo, queue và log cho toàn bộ luồng phối hợp.