这是我参与8月更文挑战的第26天，活动详情查看：8月更文挑战

中介者模式

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

结构

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

演示

模拟一个聊天群，负责添加用户和转发用户提交的消息

1、抽象中介者

public abstract class Mediator {
    List<Colleague> list = new ArrayList<>();
    public void add(Colleague colleague) {
        if (list.contains(colleague)) {
            System.out.println("当前用户已存在！");
        } else {
            colleague.setMedium(this);
            list.add(colleague);
        }
    }
    public abstract void forward(Colleague colleague, String message);
}

2、具体中介者

public class ChatGroup extends Mediator {
    @Override
    public void forward(Colleague colleague, String message) {
        for (Colleague item : list) {
            if (!item.equals(colleague)) {
                System.out.println(item.getClass().getSimpleName() 
                 + "接收" + colleague.getClass().getSimpleName() + "发送的消息：" + message);
            }
        }
    }
}

3、抽象同事类

public abstract class Colleague {
    protected Mediator mediator;
    public void setMedium(Mediator mediator) {
        this.mediator = mediator;
    }
    public abstract void send(String message);
}

4、具体同事类

public class UserOne extends Colleague{
    @Override
    public void send(String message) {
        System.out.println(this.getClass().getSimpleName() + "发送消息：" + message);
        this.mediator.forward(this, message);
    }
}

public class UserTwo extends Colleague {
    @Override
    public void send(String message) {
        System.out.println(this.getClass().getSimpleName() + "发送消息：" + message);
        this.mediator.forward(this, message);
    }
}

5、客户端

public class Client {
    public static void main(String[] args) {
        Mediator group = new ChatGroup();
        Colleague user1 = new UserOne();
        Colleague user2 = new UserTwo();
        group.add(user1);
        group.add(user2);
        user1.send("hello");
        // UserOne发送消息：hello
        // UserTwo接收UserOne发送的消息：hello
    }
}

总结

优点

1、各类之间只关注自己的职责，如上面代码，用户只负责发送消息，符合迪米特法则。

2、降低对象之间的耦合，使对象便于独立复用

3、将对象的多对多关系转变成一对一关系，提高系统灵活性，便于维护和扩展

缺点

1、中介者负责与各对象交互，同事类越多，中介者就会越来越臃肿，越复杂