Mediator Design Pattern
Question:- What
is Mediator Design Pattern?
This
design pattern falls under Behavioral
design pattern.
This(Mediator) pattern is used to reduce communication complexity
between multiple objects or classes. It helps to centralize
communication between objects into a mediator object. With the help
of this pattern communication happens with the help of mediator so we
achieves loose coupling.
As
per GOF:-
“Allows loose coupling by encapsulating the way disparate sets of
objects interact and communicate with each other. Allows for the
actions of each object set to vary independently of one another.”
Question:- When
to use Mediator design pattern?
Answer:-
If we need to centralize complex communications and control between
related objects then this design pattern can be used.
Advantages:-
- It helps to centralize control to manipulate participating objects and it also helps to simplfies maintenance of the system by centralizing control logic.
- It helps to increases the reusability of the objects supported by the Mediator by decoupling them from the system.
In
Mediator Design pattern, the classes that communicate with the
mediator are known as Colleagues. The mediator implementation is
known as the Concrete Mediator. Colleagues know about their mediator,
and the mediator also knows about its colleagues.
Mediator
example in JDK API
- java.lang.reflect.Method#invoke()
- java.util.Timer (all scheduleXXX() methods)
- java.util.concurrent.Executor#execute()
- java.util.concurrent.ExecutorService (the invokeXXX() and submit() methods)
- java.util.concurrent.ScheduledExecutorService (all scheduleXXX() methods)
Live
examples of Mediator design pattern
Mediator
example in Real world :- Air traffic controller (ATC) is a mediator
between multiple flights. It helps in communication between flights
and co-oridates/controls landing & take-off. Two flights need not
interact directly and there should not be any dependency between
them. This dependency is solved by the mediator ATC.
We will see a sample program to implement mediator design pattern.
Messenger Interface as Mediator
package com.gaurav.designpattern.mediator;
/**
* @author Gaurav
*
*/
public interface Messenger {
void addContact(Contact contact);
public void sendMessage(Contact contact, String msg);
}
Contact class as Colleague component
package com.gaurav.designpattern.mediator;
/**
* @author Gaurav
*
*/
public abstract class Contact {
protected Messenger chatMediator;
protected String name;
public Contact(String name, Messenger messenger){
this.chatMediator = messenger;
this.name=name;
}
public abstract void send(String msg);
public abstract void receive(String msg);
}
MessengerImpl class as Concrete Mediator
package com.gaurav.designpattern.mediator;
import java.util.ArrayList;
import java.util.List;
/**
* @author Gaurav
*
*/
public class MessengerImpl implements Messenger{
private List<Contact> contacts;
public MessengerImpl(){
this.contacts=new ArrayList<>();
}
@Override
public void addContact(Contact contact){
this.contacts.add(contact);
}
@Override
public void sendMessage(Contact contact, String msg) {
for(Contact userContact : this.contacts){
if(userContact != contact){
userContact.receive(msg);
}
}
}
}
ContactImpl class as Concrete Colleague
package com.gaurav.designpattern.mediator;
/**
* @author Gaurav
*
*/
public class ContactImpl extends Contact{
public ContactImpl(String name, Messenger messenger) {
super(name, messenger);
}
@Override
public void send(String message) {
System.out.println("Sender "+this.name+" has sent message which is : = "+message);
chatMediator.sendMessage(this, message);
}
@Override
public void receive(String message) {
System.out.println("Receiver "+this.name+" has received message which is : = "+message);
}
}
MediatorDesignPatternDemo class as Caller
package com.gaurav.designpattern.mediator;
/**
* @author Gaurav
*
*/
public class MediatorDesignPatternDemo {
public static void main(String args[]) {
Messenger messenger = new MessengerImpl();
Contact contact1 = new ContactImpl("Gaurav", messenger);
Contact contact2 = new ContactImpl("Sunita", messenger);
Contact contact3 = new ContactImpl("Aaditya", messenger);
Contact contact4 = new ContactImpl("Shivam", messenger);
messenger.addContact(contact1);
messenger.addContact(contact2);
messenger.addContact(contact3);
messenger.addContact(contact4);
contact1.send("Welcome to everyone in chat messenger");
}
}
Result:-
Sender Gaurav has sent message which is : = Welcome to everyone in chat messenger
Receiver Sunita has received message which is : = Welcome to everyone in chat messenger
Receiver Aaditya has received message which is : = Welcome to everyone in chat messenger
Receiver Shivam has received message which is : = Welcome to everyone in chat messenger
