VuiLenDi

The Mediator Pattern is a Behavioral Design Pattern that facilitates communication between objects in a system by providing a central point of control. Rather than having objects communicate directly with each other, they communicate through a mediator, which manages their interactions. This approach reduces the dependencies between objects, making the system easier to maintain and extend.

The Mediator Pattern is particularly useful in scenarios where multiple objects need to interact with each other in a complex way. By centralizing communication through a mediator, it becomes simpler to modify the interactions between objects without altering their individual implementations.

Key Characteristics of Mediator Pattern

1. Centralized Communication:
   • The Mediator Pattern introduces a mediator object that acts as a hub for communication, allowing objects to interact without knowing about each other’s implementations.
2. Reduces Coupling:
   • Objects no longer need to refer to each other directly, reducing dependencies and improving modularity. This decoupling makes it easier to refactor, extend, and test components independently.
3. Simplifies Object Interactions:
   • The pattern simplifies complex interactions by handling them in a single mediator class. This is particularly useful in systems where multiple objects need to interact frequently or conditionally.
4. Adheres to Single Responsibility Principle:
   • The Mediator handles communication logic, allowing individual components to focus on their core responsibilities without managing relationships with other components.
5. Supports Loose Coupling and Extensibility:
   • The Mediator Pattern makes it easy to add or remove components in a system, as they only need to communicate with the mediator. This enables more flexible and scalable architectures.
6. May Lead to Complex Mediator Logic:
   • While the mediator centralizes communication, it can also become complex if too many components interact through it, potentially creating a new point of complexity within the system.

Mediator Pattern in Node.js

In Node.js, the Mediator Pattern is often used in applications that require managing complex interactions between multiple components or modules, such as chat applications, event-driven systems, or task management systems. Let’s explore an example of a chat room where users communicate through a mediator, which handles the broadcasting of messages.

Example Scenario: Chat Room Mediator

In this example, we’ll create a ChatRoomMediator that acts as the central hub for managing communications between multiple users. The mediator will handle broadcasting messages from each user to others in the chat room.

Step 1: Define the Chat Room Mediator

The ChatRoomMediator class will manage the communication between users. It maintains a list of users and provides methods for broadcasting messages to other users in the chat room.

// Mediator: ChatRoomMediator
class ChatRoomMediator {
  constructor() {
    this.users = [];
  }

  addUser(user) {
    this.users.push(user);
    user.setMediator(this);
  }

  sendMessage(message, sender) {
    for (const user of this.users) {
      if (user !== sender) {
        user.receive(message, sender.name);
      }
    }
  }
}

Step 2: Define the User Class

Each user in the chat room can send messages and receive messages. The User class interacts only with the mediator and doesn’t need to know about other users directly.

// Colleague: User
class User {
  constructor(name) {
    this.name = name;
    this.mediator = null;
  }

  setMediator(mediator) {
    this.mediator = mediator;
  }

  send(message) {
    console.log(`${this.name} sends message: "${message}"`);
    this.mediator.sendMessage(message, this);
  }

  receive(message, senderName) {
    console.log(`${this.name} receives message from ${senderName}: "${message}"`);
  }
}

Step 3: Using the Mediator Pattern

Now we can create a chat room, add users, and have them send messages to each other through the mediator.

// Creating the mediator
const chatRoom = new ChatRoomMediator();

// Creating users
const alice = new User("Alice");
const bob = new User("Bob");
const charlie = new User("Charlie");

// Adding users to the chat room
chatRoom.addUser(alice);
chatRoom.addUser(bob);
chatRoom.addUser(charlie);

// Users sending messages
alice.send("Hello, everyone!");
bob.send("Hi, Alice!");
charlie.send("Good to see you all!");

Output:

Alice sends message: "Hello, everyone!"
Bob receives message from Alice: "Hello, everyone!"
Charlie receives message from Alice: "Hello, everyone!"

Bob sends message: "Hi, Alice!"
Alice receives message from Bob: "Hi, Alice!"
Charlie receives message from Bob: "Hi, Alice!"

Charlie sends message: "Good to see you all!"
Alice receives message from Charlie: "Good to see you all!"
Bob receives message from Charlie: "Good to see you all!"

Explanation:

• The ChatRoomMediator class manages communication between users, so each User only needs to interact with the mediator.
• When a user sends a message, the mediator broadcasts it to all other users, allowing communication to flow through a single hub without direct connections between users.

Real-World Examples of Mediator Pattern

1. Messaging and Chat Applications:
   • In chat applications, the Mediator Pattern is used to manage message routing between participants in a chat room. Each participant communicates with the chat room (mediator), which forwards messages to others, reducing dependencies and simplifying the communication flow.
2. Event Management Systems:
   • The Mediator Pattern is used to manage events between multiple modules in event-driven systems. For example, a mediator can control interactions between different components in a calendar or task management system, routing events to relevant modules based on defined conditions.
3. UI Component Communication:
   • In complex UIs with multiple components, the Mediator Pattern helps manage interactions between components. For example, a form manager (mediator) might coordinate input validation across multiple form fields, ensuring that each field’s state affects the overall form without creating dependencies between individual fields.
4. Traffic Control Systems:
   • In air traffic control or network traffic management, the Mediator Pattern is used to coordinate actions among multiple entities. For example, in an air traffic control system, each plane communicates with the control tower (mediator), which coordinates the takeoffs, landings, and movements of all planes, reducing the need for direct communication between planes.
5. E-commerce Order Processing:
   • In e-commerce applications, mediators are used to manage order processing flows, such as inventory checks, payment processing, and shipping. The mediator orchestrates each step, allowing components like inventory and payment services to interact indirectly, reducing dependencies.
6. Game Development:
   • In multiplayer games, mediators are used to coordinate interactions between players, game objects, and game events. For instance, a mediator could control interactions between characters, ensuring that each character only interacts with the mediator rather than directly with other characters, simplifying game logic and interactions.
7. Microservices Communication:
   • In microservices architectures, message brokers or orchestrators often act as mediators between services. This allows services to interact indirectly through a central mediator, simplifying inter-service communication and promoting scalability.

Conclusion

The Mediator Pattern is a powerful tool for managing communication between multiple objects in a system. By centralizing interactions in a single mediator, this pattern reduces dependencies, simplifies code, and improves modularity. The pattern is particularly useful in applications that require complex inter-object communication, such as chat applications, UI component management, or event-driven systems.

In Node.js, the Mediator Pattern is commonly used in event-driven systems, chat applications, and task management systems, where it simplifies communication by acting as a single point of control. The Mediator Pattern promotes a clean and modular architecture, making it easy to add, modify, or remove components without affecting other parts of the system. By centralizing communication, it not only reduces coupling but also enhances scalability and flexibility, making it a valuable tool in modern software design.