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.

Hành vi●●●15 phút đọc8 bướccòn gọi: Controller, Broker, Hub, Coordinator
behavioralcomponentformchat roomevent buspinialiên kết

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

1

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.

textrules-inventory.txt
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.
Bảng này chính là đặc tả của mediator. Viết nó xong, code chỉ còn là dịch lại.
ChốtMediator là một danh sách rule có chủ. Nếu bạn không viết được danh sách đó, bạn chưa sẵn sàng viết mediator.
2

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 đó.

tsCountrySelect.vue
<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>
Ba mũi tên trong một handler. VoucherInput import file này, file này import ShippingZone, ShippingZone import VoucherInput — circular.
ChốtDấu hiệu của Mediator: component A gọi method của component B. Một lần là ổn; ba lần là bạn đang xây mạng nhện.
3

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.

tsstores/checkout.ts
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 }
})
Rule nằm hết ở đây. Component sau bước 4 sẽ không còn một dòng if nghiệp vụ nào.
ChốtMediator không phải nơi "đặt code cho tiện". Nó là nơi duy nhất được phép trả lời câu hỏi "field này giờ hợp lệ giá trị nào?".
4

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.

tsCountryField.vue
<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.
ChốtNếu một component phải biết tên của component khác, mediator của bạn chưa xong việc.
5

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

tsutils/checkout-rules.ts
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,
})
Test: expect(derive({ ...base, province: "DN" }).methods).toEqual(["standard"]). Một dòng, không fixture.
ChốtMediator giữ state + rule; component giữ markup. Vạch này càng sắc, refactor càng rẻ.
6

Đừ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.

tsstores/checkout.ts
// 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)
}
Bản đúng vẫn focus được input, nhưng store không biết input là gì. Test store không cần DOM.
ChốtMediator chỉ được nói bằng state. Cứ mỗi lần nó chạm vào instance của colleague, bạn trả lại một mũi tên.
7

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

tscompare.ts
// 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
  }
}
ChốtFacade che giấu, bus vận chuyển, mediator phán quyết. Chọn sai một cái là bạn hoặc thiếu chỗ giữ rule, hoặc có một bus không ai sở hữu.
8

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.

bashself-check.ts
# 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.
Câu 3 là thước đo thật duy nhất. "Thêm field = sửa 5 file" nghĩa là bạn chỉ vừa moving code, chưa đóng được gì.
ChốtMediator thành công khi số file sửa mỗi lần thêm tính năng tiến về 2: mediator và component mới.

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 nhau

05 — Sửa tuỳ ý, chạy ngay tại đây

Chạy thử: chat room — user chỉ nói chuyện với room

tsdemo.ts
// 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')
console
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 dropped

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

  • 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 inject mộ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.vue mớ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ột computed là đủ, đừ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:

  1. 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".
  2. Tách rule dẫn xuất (zone, methods, companyRequired) thành một hàm pure derive(fields) trả về object — component chỉ render cái object đó.
  3. 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.

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