Achieve Ultimate Excellence

Mediator Design Pattern - Centralizing Communication and Interactions instead of Direct Communication

5 min read

Introduction

In software development, design patterns play a crucial role in improving code maintainability, reusability, and flexibility. One such valuable pattern is the "Mediator design pattern," which promotes loose coupling between components by centralizing communication and interactions. This blog post will delve into the Mediator design pattern, explaining its concept, benefits, and implementation in Java with a practical example.

What is the Mediator Design Pattern?

The Mediator design pattern is a behavioral pattern that promotes communication between multiple objects through a central "Mediator" instead of direct communication between the objects. By doing so, the pattern reduces the complexity of interactions and enhances the maintainability of the codebase. The Mediator acts as a middleman, allowing objects to collaborate without having explicit knowledge of each other.

Key Participants

Mediator: The Mediator interface declares methods for communication between components.
ConcreteMediator: The ConcreteMediator implements the Mediator interface and manages the communication and interactions between ConcreteColleague objects.
Colleague: The Colleague interface defines methods that ConcreteColleague classes must implement. It represents the components that need to communicate with each other.
ConcreteColleague: The ConcreteColleague classes implement the Colleague interface and interact with other colleagues through the Mediator.

Advantages of Mediator Design Pattern

Decoupling: The Mediator pattern promotes loose coupling between components, making it easier to modify, add, or remove components without affecting others.
Centralized Control: The Mediator centralizes communication logic, which improves maintainability by reducing duplicated code.
Simplification: Complex interactions between components are abstracted into the Mediator, making the code easier to understand and manage.
Reusability: The components can be reused in different contexts since their interactions are managed by the Mediator.

Implementing the Mediator Design Pattern in Java

Example Scenario

Let's consider a simple chat application where users can send messages to each other. We'll implement the Mediator design pattern to handle communication between users.

Step 1: Create the Colleague interface

// Colleague.java
public interface Colleague {
    void sendMessage(String message);
    void receiveMessage(String message);
}

Step 2: Implement the ConcreteColleague class

// User.java
public class User implements Colleague {
    private String name;
    private Mediator mediator;

    public User(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }

    @Override
    public void sendMessage(String message) {
        System.out.println(name + " sends: " + message);
        mediator.sendMessage(this, message);
    }

    @Override
    public void receiveMessage(String message) {
        System.out.println(name + " receives: " + message);
    }
}

Step 3: Create the Mediator interface

// Mediator.java
public interface Mediator {
    void sendMessage(Colleague sender, String message);
}

Step 4: Implement the ConcreteMediator class

// ChatRoom.java
public class ChatRoom implements Mediator {
    @Override
    public void sendMessage(Colleague sender, String message) {
        // Assuming all users are in the same chat room
        for (Colleague colleague : users) {
            if (colleague != sender) {
                colleague.receiveMessage(message);
            }
        }
    }
}

Step 5: Putting It All Together

// Main.java
public class Main {
    public static void main(String[] args) {
        Mediator chatRoom = new ChatRoom();

        User user1 = new User("John", chatRoom);
        User user2 = new User("Alice", chatRoom);
        User user3 = new User("Bob", chatRoom);

        chatRoom.addUser(user1);
        chatRoom.addUser(user2);
        chatRoom.addUser(user3);

        user1.sendMessage("Hello, everyone!");
    }
}

Explanation

In this example, the ChatRoom acts as the ConcreteMediator that handles the communication between users. When a user sends a message, the sendMessage method is called on the Mediator, which broadcasts the message to all other users except the sender.

Conclusion

The Mediator design pattern is a powerful approach to managing communication and interactions between components in a decoupled manner. By using a central mediator, the pattern simplifies the codebase, improves maintainability, and fosters reusability. It is particularly useful when dealing with complex systems involving multiple interacting objects. In Java, the Mediator pattern can be seamlessly integrated into various applications, streamlining their communication mechanisms.

Article By,