中介者模式（Mediator）

中介者模式的定义

中介者模式（Mediator Pattern）又称为调解者模式或者调停者模式。
用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示的相互作用，从而使其耦合松散，而且可以独立的改变他们之间的交互。
核心：通过中介者解耦系统各层次对象的直接耦合，层次对象的对外依赖通信统统由中介者转发。
属于行为性模式。

结构与实现

主要的角色

• 抽象中介者（Mediator）角色，它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
• 具体中介者（ConcreteMediator）角色，实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角
  色之间的交互关系，因此他依赖于同事角色。
• 抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
• 具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

中介者模式和代理模式的区别

共同点：都有一个中间角色，类似于牵线搭桥的角色
为什么要代理？

• 因为可能自己没办做，但是又必须要做，那怎么办？找个代理呗

中介者？

• 只要它帮你联系上，就不在管了，后面的事情由自己去做

拿媒婆来说，（代理模式）他首先帮你找到你一个匹配度比较高的异性，然后他可能还要对双方做很多的思想工作，做一些调查，如果双方都愿意的话，可能还要去说服父母，可能还要组织饭局活动等。（中介者）可是中介者呢，他可能只把对方的电话给你，然后就不管了，你自己玩去，他也不管你谈不谈的成......，所以说中介者就是一个不负责任的媒婆，

中介者模式的优缺点

• 减少类间的依赖，将多对多依赖转化成了一对多，降低了类间耦合
• 类间各司其职，符合迪米特法则

具体实现

抽象中介者

/**
 * 抽象中介者
 */
public abstract class Mediator {

    // 注册同事对象
    public abstract void register(Colleague colleague);
    // 转发同事对象信息
    public abstract void relay(Colleague colleague);
}

抽象同事类

/**
 * 抽象同事类
 */
public abstract class Colleague {
    // 持有中介者对象
    protected  Mediator mediator;

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

    /**
     * 提供与同事对象交互的抽象方法
     */
    // 接受消息
    public abstract void receive();
    // 发送消息
    public abstract void send();
}

具体中介者

/**
 * 具体中介者
 */
public class ConcreteMediator extends Mediator {

    // 管理同事对象集合
    private List<Colleague> colleagues = new ArrayList<Colleague>();

    // 注册同事对象
    @Override
    public void register(Colleague colleague) {
        if(!colleagues.contains(colleague)){
            colleagues.add(colleague);
            colleague.setMediator(this);
        }
    }

    // 转发同事对象信息
    @Override
    public void relay(Colleague colleague) {
        for(Colleague ob : colleagues){
            if(!ob.equals(colleague)){
                ob.receive();
            }
        }
    }
}

具体同事类 A B C

/**
 * 具体同事类 A
 */
public class ConcreteColleagueA extends Colleague {

    @Override
    public void receive() {
        System.out.println("具体同事类 A 收到请求");
    }

    @Override
    public void send() {
        System.out.println("具体同事类 A 发出请求");
        // 请中介者转发
        this.mediator.relay(this);
    }
}

/**
 * 具体同事类  B
 */
public class ConcreteColleagueB extends Colleague {

    @Override
    public void receive() {
        System.out.println("具体同事类 B 收到请求");
    }

    @Override
    public void send() {
        System.out.println("具体同事类 B 发出请求");
        // 请求中介者转发
        this.mediator.relay(this);
    }
}

/**
 * 具体同事类 C
 */
public class ConcreteColleagueC extends Colleague {

    @Override
    public void receive() {
        System.out.println("具体同事类 C 收到请求");
    }

    @Override
    public void send() {
        System.out.println("具体同事类 C 发出请求");
        this.mediator.relay(this);
    }
}

测试类

public class MainTest {

    public static void main(String[] args) {
        // 创建具体中介者
        Mediator mediator = new ConcreteMediator();
        // 创建具体同事类
        Colleague c1 = new ConcreteColleagueA();
        Colleague c2 = new ConcreteColleagueB();
        Colleague c3 = new ConcreteColleagueC();
        // 注册具体同事类
        mediator.register(c1);
        mediator.register(c2);
        mediator.register(c3);
        // c1 发送消息
        c1.send();
        System.out.println("==================================");
        // c2 发送消息
        c2.send();
        System.out.println("==================================");
        // c3 发送消息
        c3.send();
    }
}

结果

具体同事类 A 发出请求
具体同事类 B 收到请求
具体同事类 C 收到请求
==================================
具体同事类 B 发出请求
具体同事类 A 收到请求
具体同事类 C 收到请求
==================================
具体同事类 C 发出请求
具体同事类 A 收到请求
具体同事类 B 收到请求