调停者模式

  调停者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个调停类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。调停者模式属于 行为型模式

如果想了解调停者模式的具体的介绍，菜鸟教程介绍得比较详细↓
菜鸟教程-调停者模式

结构图

优缺点

优点：

1、降低了类的复杂度，将一对多转化成了一对一。
2、各个类之间的解耦。
3、符合迪米特原则

缺点：

调停者会庞大，变得复杂难以维护。

使用场景

1、系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖关系结构混乱而且难以复用该对象。
2、想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。

实现代码

调停者模式和上一章说的外观模式是思想上是很相似的,但是调停者是解决系统内部中的多个对象之间复杂的关系的,所以二者面对的对象是不一样的。
如下图所示:

本来准备介绍的栗子比较简单,然后想想还是仔细介绍一下吧

Mediator模式中Mediator是抽象中介者，提供了同事对象注册与转发同事对象信息的抽象方法;
Colleague是抽象同事类,提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能;
ConcreteMediator是具体中介者对象，实现抽象类的方法，它需要知道所有具体同事类，并从具体同事接收消息，向具体同事对象发出命令,协调各个同事角色之间的交互关系;
ConcreteColleague是具体同事类，每个具体同事只知道自己的行为，而不了解其它同事类的情况，但它们却都认识中介者对象。

这里我们模拟的是,聊天室中当A发送消息时,B、C都能接收到,并且当接收到时,返回收到的信息。B、C同理

代码如下:

public class Main {
    public static void main(String[] args) {
        //构建中介者
        Mediator mediator = new ConcreteMediator();

        //构建具体同事类
        Colleague colleagueA = new ConcreteColleagueA();
        Colleague colleagueB = new ConcreteColleagueB();
        Colleague colleagueC = new ConcreteColleagueC();

        //注册同事
        mediator.register(colleagueA);
        mediator.register(colleagueB);
        mediator.register(colleagueC);

        //发送消息
        colleagueA.send();
        colleagueB.send();
        colleagueC.send();
    }
}

//抽象中介者
public abstract class Mediator {
    abstract void register(Colleague colleague);

    abstract void relay(Colleague colleague);
}

//抽象同事类
public abstract class Colleague {
    protected Mediator mediator;

    public void setMedium(Mediator mediator) {
        this.mediator = mediator;
    }

    abstract void receive();

    abstract void send();
}

//中介者对象
public class ConcreteMediator extends Mediator {
    List<Colleague> colleagues;

    public ConcreteMediator() {
        colleagues = new ArrayList<>();
    }

    @Override
    void register(Colleague colleague) {
        if (!colleagues.contains(colleague)) {
            colleague.setMedium(this);
            colleagues.add(colleague);
        }
    }

    @Override
    void relay(Colleague colleague) {
        colleagues.forEach(c -> {
            if (!c.equals(colleague)){
                c.receive();
            }
        });
        System.out.println("------------");
    }
}

//具体同事类
public class ConcreteColleagueA extends Colleague{
    @Override
    void receive() {
        System.out.println("ColleagueA receive message");
    }

    @Override
    void send() {
        System.out.println("ColleagueA send message");
        mediator.relay(this);
    }
}

public class ConcreteColleagueB extends Colleague{
    @Override
    void receive() {
        System.out.println("ColleagueB receive message");
    }

    @Override
    void send() {
        System.out.println("ColleagueB send message");
        mediator.relay(this);
    }
}

public class ConcreteColleagueC extends Colleague{
    @Override
    void receive() {
        System.out.println("ColleagueC receive message");
    }

    @Override
    void send() {
        System.out.println("ColleagueC send message");
        mediator.relay(this);
    }
}

输出结果:

ColleagueA send message
ColleagueB receive message
ColleagueC receive message
------------
ColleagueB send message
ColleagueA receive message
ColleagueC receive message
------------
ColleagueC send message
ColleagueA receive message
ColleagueB receive message
------------

在注册时

void register(Colleague colleague) {
    if (!colleagues.contains(colleague)) {
        colleague.setMedium(this);
        colleagues.add(colleague);
    }
}

每一个同事角色都知道调停者角色，而且与其它的同事角色通信的时候必须依赖调停住者才能完成,所以这里我们需要将调停者传入

我们在ConcreteMediator中定义一个List来管理同事对象(Colleague)，协调各个同事角色之间的交互关系,在注册时,我们需要将每个同事对象加入

当某个同事对象(Colleague)发送信息(send)时,会去通知调停者,收到信息的用户发送消息。

void send() {
    System.out.println("ColleagueB send message");
    mediator.relay(this);
}

这里的调停者就是我们在register中传入的对象

Mediator模式和Facade模式的思想很相似,一个是降低系统内部的耦合度,一个是降低外部与系统的耦合度
都借用了一个’外观类’/‘调停者’来处理其中复杂的关系

具体在实战中的应用我就不多介绍了,大家感兴趣的话,可以自行了解