Mediator pattern

Overview

The Mediator pattern centralizes communication between objects so they do not refer to each other directly. Instead of every component knowing every other component (n x n links), each talks to the mediator, which coordinates them. Chat rooms, air traffic control, UI dialogs, and elevator dispatchers are classic examples.

Mediators reduce coupling and make interactions easier to change in one place. The risk is the mediator becoming a god object that knows everything; keep it focused on coordination, with business rules in the colleagues.

When to use it

• Many objects interact in complex, tangled ways.
• Components should be reusable without knowing each other.
• Coordination logic changes more often than the components.

Where it shows up in interviews

Where it is used in real software

Key terms

Mediator

Object that coordinates colleagues.

Colleague

Component that talks only to the mediator.

Many-to-many to one-to-many

The coupling reduction mediators provide.

How it works, step by step

1. 1
   Identify interacting components

   Users in a chat, cars in a building.

2. 2
   Define the mediator interface

   send(message, from), requestElevator(floor).

3. 3
   Colleagues hold a mediator reference

   Not references to each other.

4. 4
   Mediator implements coordination rules

   Routing, assignment, enabling.

5. 5
   Keep rules small

   Split into several mediators if it grows.

Coupling with and without a mediator

10 components that interact

Coordination moves to one place; components become independent.

Implementation

1interface ChatMediator {2  join(user: ChatUser): void;3  send(message: string, from: ChatUser, to?: string): void;4}5 6class ChatRoom implements ChatMediator {7  private users = new Map<string, ChatUser>();8  join(user: ChatUser) { this.users.set(user.name, user); }9  send(message: string, from: ChatUser, to?: string) {10    if (to) return this.users.get(to)?.receive(message, from.name);  // direct message11    for (const u of this.users.values()) if (u !== from) u.receive(message, from.name); // broadcast12  }13}14 15class ChatUser {16  readonly inbox: string[] = [];17  constructor(readonly name: string, private room: ChatMediator) { room.join(this); }18  say(message: string, to?: string) { this.room.send(message, this, to); }19  receive(message: string, from: string) { this.inbox.push(`${from}: ${message}`); }20}21 22const room = new ChatRoom();23const ana = new ChatUser("ana", room);24const bo = new ChatUser("bo", room);25ana.say("hi all");26bo.say("hi ana", "ana");

Complexity and performance

Trade-offs

Variants and related techniques

Common mistakes

• Mediator knowing all internal details of colleagues.

  Fix: Communicate through small interfaces.

• Colleagues bypassing the mediator.

  Fix: Enforce that peers never reference each other.

Interview questions

Practice problems