🧭 Mediator Design Pattern – Java LLD + UML + Real Use Case

Decouple complex object interactions by introducing a mediator — promoting loose coupling, centralized control, and modularity in communication-heavy systems.

---

🧠 What is the Mediator Pattern?

The Mediator Pattern is a behavioral design pattern that defines an object (Mediator) that encapsulates how a set of objects interact.

Instead of objects referring to each other directly, they communicate via a central mediator object.

---

🧩 Motivation

Problem	Mediator Solves
Many-to-many communication between components	Introduces centralized coordination
Strong coupling between classes	Promotes loose coupling
Hard-to-maintain interdependent code	Simplifies interaction logic

---

✅ Real-World Use Cases

Use Case	Description
📨 Chatroom App	Users send messages via a central chatroom mediator
🛬 Air Traffic Control	Flights communicate via control tower (mediator)
💬 UI Form Field Coordination	Fields affect each other via mediator (e.g., enable/disable)
🎮 Game Entity Coordination	Game objects interact via scene manager

---

🔁 Pattern Components

Component	Responsibility
Mediator	Defines interface for coordinating communication
ConcreteMediator	Implements coordination logic
Colleague	Participates in communication via Mediator
ConcreteColleague	Implements behavior and delegates interaction to Mediator

---

📐 UML Class Diagram

+------------------+
|     Mediator     |  <<interface>>
+------------------+
| +send(msg, user) |
+------------------+
         ▲
         |
+------------------------+
|   ConcreteMediator     |
+------------------------+
| - List<Colleague>      |
| +send(msg, user)       |
+------------------------+
         ▲
         |
  +------------------+
  |    Colleague     |
  +------------------+
  | - mediator       |
  | +send(msg)       |
  | +receive(msg)    |
  +------------------+
         ▲
         |
+---------------------+
| ConcreteColleague   |
+---------------------+

---

💻 Java Implementation — Chatroom Example

✅ ChatMediator.java

public interface ChatMediator {
    void sendMessage(String message, User sender);
    void addUser(User user);
}

---

✅ User.java

public abstract class User {
    protected ChatMediator mediator;
    protected String name;

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

    public abstract void send(String message);
    public abstract void receive(String message);
}

---

✅ ConcreteUser.java

public class ConcreteUser extends User {
    public ConcreteUser(ChatMediator mediator, String name) {
        super(mediator, name);
    }

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

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

---

✅ ChatRoomMediator.java

public class ChatRoomMediator implements ChatMediator {
    private final List<User> users = new ArrayList<>();

    @Override
    public void sendMessage(String message, User sender) {
        for (User user : users) {
            if (user != sender) {
                user.receive(sender.name + ": " + message);
            }
        }
    }

    @Override
    public void addUser(User user) {
        users.add(user);
    }
}

---

✅ Client.java

public class MediatorDemo {
    public static void main(String[] args) {
        ChatMediator mediator = new ChatRoomMediator();

        User alice = new ConcreteUser(mediator, "Alice");
        User bob = new ConcreteUser(mediator, "Bob");
        User charlie = new ConcreteUser(mediator, "Charlie");

        mediator.addUser(alice);
        mediator.addUser(bob);
        mediator.addUser(charlie);

        alice.send("Hi everyone!");
        bob.send("Hello Alice!");
    }
}

---

🧪 Output

📤 Alice sends: Hi everyone!
📩 Bob receives: Alice: Hi everyone!
📩 Charlie receives: Alice: Hi everyone!
📤 Bob sends: Hello Alice!
📩 Alice receives: Bob: Hello Alice!
📩 Charlie receives: Bob: Hello Alice!

---

✨ Benefits

Benefit	Description
✅ Loose Coupling	Participants don’t reference each other directly
✅ Centralized Control	All interaction logic lives in the mediator
✅ Easy to Modify Behavior	Add/remove participants or change rules easily
✅ Improves Maintainability	Simplifies debugging and testing communication

---

⚠️ When Not to Use

• Too few components — overhead not worth it
• Simple one-way communication — Observer may be a better fit
• When performance is critical — centralization may cause latency

---

✅ Summary

Aspect	Value
Pattern Type	Behavioral
Key Intent	Centralized communication control
Java Features Used	Interfaces, Polymorphism, Composition
Real-World Analogy	Control Tower, Chatroom, Form Manager

---

🔧 Want More?

Would you like:

• ✅ Event-driven Mediator with Pub/Sub?
• ✅ UI Form coordination example (enable/disable logic)?
• ✅ Mediator + Observer hybrid design?

Just say the word and I’ll extend it accordingly.