The Mediator Pattern of Java Design Patterns

Mediator pattern (Mediator): Use a mediator object to encapsulate a series of object interactions. Mediators decouple objects from needing to refer to each other explicitly, making them loosely coupled and can independently alter the interactions between them.

This mode can be simply analogized to the star structure. The mediator is the center, and the interaction of other objects is through the mediator of the center instead of direct interaction, which avoids the confusion of the relationship caused by the direct interaction of objects, which is not easy to maintain. Shortcomings.

The UML diagram is as follows: 

abstract class Mediator //Abstract mediator class
{
    public abstract void Send(String message,Colleague colleague)
}

//Abstract colleague class
abstract class Colleague
{
    protected Mediator mediator;
    public Colleauge (Mediator mediator)
    {
        this.mediator = mediator;
    }
}

//Concrete mediator class
class ConcreteMediator extends Mediator
{
        private ConcreteColleague1 concreteColleague1;
	private ConcreteColleague2 concreteColleague2;


	@Override
	public void send(String message, Colleague colleague) {
		if(colleague==concreteColleague1) {
			concreteColleague2.doNotify(message);
		}else {
			concreteColleague1.doNotify(message);
		}
		
	}


	public ConcreteColleague1 getConcreteColleague1() {
		return concreteColleague1;
	}


	public void setConcreteColleague1(ConcreteColleague1 concreteColleague1) {
		this.concreteColleague1 = concreteColleague1;
	}


	public ConcreteColleague2 getConcreteColleague2() {
		return concreteColleague2;
	}


	public void setConcreteColleague2(ConcreteColleague2 concreteColleague2) {
		this.concreteColleague2 = concreteColleague2;
	}
}

//The specific colleague class ConcreteColleague2 is similar
class ConcreteColleague1 extends Colleague
{
    public ConcreteColleague1(Mediator mediator){
        super (mediator);
    }
    public void send(string message)
    {
        mediator.send(message,this);
    }
    public void doNotify(String message)
    {
        System.out.println(message+", Colleague 1 received a message");
    }
}
class ConcreteColleague2 extends Colleague
{
    public ConcreteColleague2(Mediator mediator){super(mediator);}
    public void send(String message)
    {
        mediator.send(message,this);
    }
    public void doNotify(String message)
    {
        System.out.println(message+", Colleague 2 received a message");
    }
}
//test
public static void Main(String[] args)
{
    ConcreteMediator mediator = new ConcreteMediator();
    ConcreteColleague1 c1 = new ConcreteColleague1(mediator);
    ConcreteColleague2 c2 = new ConcreteColleague2(mediator);
    mediator.setConcreteColleague1(c1);
    mediator.setConcreteColleague2(c2);
		
    c1.send("Colleague 1 sends message 1;");
    c2.send("Colleague 2 sends message 2;");
}

Advantages and disadvantages of the mediator model

advantage:

• It simplifies the relationship between objects, encapsulates the relationship between various objects in the system, and decouples each colleague class, making the system loosely coupled.
• Provide the flexibility of the system, making each colleague object independent and easy to reuse.

shortcoming:

• In the mediator model, the role of the mediator assumes more responsibilities, so once there is a problem with the mediator object, the entire system will be significantly affected.
• When a new colleague class is added, the abstract mediator class and the concrete mediator class have to be modified. At this time, the observer pattern and the state pattern can be used to solve this problem.

Applicable scenarios of the mediator pattern

The mediator pattern can be considered in the following situations:

• A set of well-defined objects that are now going to communicate complexly with each other.
• Want to encapsulate behavior in multiple classes through an intermediate class without generating too many subclasses.