Java 中介者模式

一、定义

定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。

当对象与对象之间存在大量且复杂关联关系时，会导致系统的结构变的更复杂，一个类发生改变时，也要修改相关联的类，牵一发而动全身，当遇到这种情况时就可以使用中介者模式。

主要角色：

抽象中介者：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。

具体中介者：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。

抽象同事类：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。

具体同事类：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

二、代码实现

举例：在微信中我需要向很多人发送消息，但是这样太麻烦了，所以我们创建一个群聊，群聊在这里就是指中介者，群聊中的用户就是指具体同事类，这时候我只要利用群聊发送一次消息就可以了，接下来看代码实现；

抽象中介者：

abstract class Mediator {
    //注册同事类
    public abstract void register(WechatUser wechatUser);
    //转发消息
    public abstract void send(WechatUser wechatUser);
}

具体中介者：群聊

class WechatGroup extends Mediator{
    //存储同事类
    private List<WechatUser> list = new ArrayList<>();

    @Override
    public void register(WechatUser wechatUser) {
        list.add(wechatUser);
    }

    @Override
    public void send(WechatUser wechatUser) {
        for (WechatUser user : list){
            if (!user.equals(wechatUser)){
                user.receive();
            }
        }
    }
}

抽象同事类：

abstract class WechatUser {
    //持有中介者（群聊）
    protected Mediator mediator;

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

    public String name;

    public WechatUser(String name) {
        this.name = name;
    }

    //接收
    abstract void receive();
    //发送
    abstract void send();
}

具体同事类：

class User extends WechatUser {

    public User(String name) {
        super(name);
    }

    @Override
    void receive() {
        //中介者调用
        System.out.println(name+"收到了消息");
    }

    @Override
    void send() {
        System.out.println(name+"发送了消息");
        //通过中介者发送
        mediator.send(this);
    }
}

使用：

public static void main(String[] args) {
        //群聊
        WechatGroup wechatGroup = new WechatGroup();

        //创建用户
        User zhangsan = new User("张三");
        User lisi = new User("李四");
        User laowu = new User("老五");

        //用户加入群聊
        wechatGroup.register(zhangsan);
        wechatGroup.register(lisi);
        wechatGroup.register(laowu);

        //用户持有中介者
        zhangsan.setMediator(wechatGroup);
        lisi.setMediator(wechatGroup);
        laowu.setMediator(wechatGroup);

        zhangsan.send();
    }

输出：

张三发送了消息
李四收到了消息
老五收到了消息

三、总结

优点：

1. 类之间各司其职，符合迪米特法则。
2. 降低了对象之间的耦合性，使得对象易于独立地被复用。
3. 将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。

缺点：

1. 当同事类越来越多时，中介者类会变的越来越臃肿难以维护。

使用场景：

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

四、扩展

由于中介者模式写起来较为复杂，而且难以理解，所以在实际开发中我们可以用简化的方式来实现中介者模式，主要实现为以下两点：

1. 不定义抽象中介者，而是直接创建一个具体观察者的单例。
2. 同事对象不再持有中介者，而是通过观察者单例直接调用对应方法。