Mediator Pattern

Mediator Pattern 就类似现实生活中的中介（中间人），房屋中介、媒婆中介、权利寻租中介... ，现实中为什么需要中介，在现实中的原因主要是两个 一为了保护双方当事人的安全，只要中介人不泄密，他们双方就可以秘密的把交易完成，并且双方都是安全的。二是买卖双方并不信任双方，但是他们都共同的信任同一个中介人，那么通过中介人就能促成这笔交易（类似淘宝平台）。

在计算世界中为什么需要中介呢？计算机的 Mediator Pattern，通过引入一个中介者对象，将系统中多个对象之间的复杂交互关系转化为多个对象与中介者之间的简单交互关系。它的目标是促进对象之间的松耦合，减少对象之间的直接依赖关系，从而提高系统的可维护性和可扩展性。

中介者模式的核心思想是将复杂的交互逻辑集中到中介者对象中，各个对象只需要与中介者对象进行简单的通信即可。这样可以降低系统的复杂度，提高系统的可维护性和可扩展性。中介者模式常用于大型系统中，特别是当系统中对象之间存在复杂的交互关系时，可以通过中介者模式将交互关系的管理集中到中介者对象中，简化系统的设计和维护。

Key Elements

• 中介人 抽象接口
• 中介人 具体实现
• 买方 抽象接口（或抽象）
• 卖方 抽象接口（或抽象）
• 买方 具体实现
• 卖方 具体实现
• Client(平台)

Example

下面以一个两个陌生同事需要交流的场景进行演示：

中介

// 抽象中介者
interface Mediator {
    void sendMessage(String message, Colleague colleague);
}

// 具体中介者
class ConcreteMediator implements Mediator {
    private Colleague colleague1;
    private Colleague colleague2;

    public void setColleague1(Colleague colleague1) {
        this.colleague1 = colleague1;
    }

    public void setColleague2(Colleague colleague2) {
        this.colleague2 = colleague2;
    }

    @Override
    public void sendMessage(String message, Colleague colleague) {
        if (colleague == colleague1) {
            colleague2.receiveMessage(message);
        } else if (colleague == colleague2) {
            colleague1.receiveMessage(message);
        }
    }
}

同事

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

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void sendMessage(String message);

    public abstract void receiveMessage(String message);
}

// 具体同事类1
class ConcreteColleague1 extends Colleague {
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendMessage(String message) {
        mediator.sendMessage(message, this);
    }

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

// 具体同事类2
class ConcreteColleague2 extends Colleague {
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendMessage(String message) {
        mediator.sendMessage(message, this);
    }

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

Client

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建中介者
        ConcreteMediator mediator = new ConcreteMediator();

        // 创建具体同事类
        ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
        ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);

        // 设置中介者的同事对象
        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);

        // 同事类之间进行通信
        colleague1.sendMessage("Hello from Colleague1");
        colleague2.sendMessage("Hi from Colleague2");
    }
}

在上述示例中，存在两个具体同事类 ConcreteColleague1 和 ConcreteColleague2，它们之间的通信通过中介者 ConcreteMediator 进行。中介者实现了 Mediator 接口，其中的 sendMessage 方法根据具体同事对象的不同，将消息传递给另一个同事对象。具体同事类中的 sendMessage 方法通过中介者对象的引用调用 sendMessage 方法，实现了同事对象之间的间接通信。客户端代码创建了中介者对象和具体同事对象，并设置了中介者对象的同事对象。最后，通过具体同事对象的 sendMessage 方法发送消息，中介者对象负责将消息转发给接收方。

这个简单的示例展示了中介者模式的基本结构和使用方式。通过中介者模式，同事对象之间的通信被解耦，彼此之间不再直接依赖，而是通过中介者进行交互，从而提高了系统的可维护性和扩展性。