中介者模式

2021-09-10

一、概述

如果在一个系统中对象之间存在多对多的相互关系，我们可以将对象之间的一些交互行为从各个对象中分离出来，并集中封装在一个中介者对象中，并由该中介者进行统一协调，这样对象之间多对多的复杂关系就转化为相对简单的一对多关系。通过引入中介者来简化对象之间的复杂交互，中介者模式是“迪米特法则”的一个典型应用。

中介者模式(Mediator Pattern)的定义为：用一个中介对象（中介者）来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。

中介者模式结构图为：

二、示例代码

中介者模式主要包括抽象中介者类Mediator、具体中介者类ConcretMediator、抽象同事类Colleague以及具体同事类ConcreteColleague。

中介者模式中，抽象中介者类Mediator的典型代码如下：

public abstract class Mediator {
  protected ArrayList<Colleague> colleagues; //用于存储同事对象
  //注册方法，用于增加同事对象
  public void register(Colleague colleague) {
    colleagues.add(colleague);
  }
  //声明抽象的业务方法
  public abstract void operation();
}

具体中介者类将调用同事类的方法，调用时可以增加一些自己的业务代码，具体中介者类ConcreteMediator典型代码如下：

public class ConcreteMediator extends Mediator {
  //实现业务方法，封装同事之间的调用
  public void operation() {
    ...
    ((Colleague)(colleagues.get(0))).method1();
    ...
  }
}

抽象同事类Colleague的典型代码如下：

public abstract class Colleague {
  protected Mediator mediator;//维持一个抽象中介者的引用
  public Colleague(Mediator mediator) {
    this.mediator = mediator;
  }
  
  public abstract void method1();//声明自身方法，处理自己的行为
  
  //定义以来方法，与中介者进行通信
  public void method2() {
    mediator.operation();
  }
}

具体同事类ConcreColleague实现这些方法，典型代码如下：

public class ConcreteColleague extends Colleague {
  public ConcreteColleague(Mediator mediator) {
    super(mediator);
  }
  
  //实现自身方法
  public void method1() {
    ...
  }
}

三、demo

在一个聊天室里有很多成员一起聊天，成员分为普通会员和钻石会员，普通会员只能发送文字消息，钻石会员能发送文字和图片消息。

抽象中介者类Mediator设计如下：

public abstract class AbstractChatRoom {

    public abstract void register(Member member);

    public abstract void sendText(String from, String to, String message);

    public abstract void sendImage(String from, String to, String message);

}

具体中介者类ConcreteMediator设计如下：

public class ChatGroup extends AbstractChatRoom{

    private Hashtable members = new Hashtable();

    @Override
    public void register(Member member) {
        if (!members.contains(member)) {
            members.put(member.getName(),member);
            member.setChatRoom(this);
        }
    }

    @Override
    public void sendText(String from, String to, String message) {
        Member member = (Member) members.get(to);
        String newMessage = message;
        newMessage = message.replaceAll("日","*");
        member.receiveText(from,newMessage);
    }

    @Override
    public void sendImage(String from, String to, String message) {
        Member member = (Member) members.get(to);
        if (message.length() > 5) {
            System.out.println("图片太大，无法发送");
        }
        else {
            member.receiveImage(to,message);
        }
    }
}

抽象同事类Colleague设计如下：

public abstract class Member {

    protected AbstractChatRoom chatRoom;

    protected String name;

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

    public String getName() {
        return name;
    }

    public void setName() {
        this.name = name;
    }

    public void setChatRoom(AbstractChatRoom chatRoom) {
        this.chatRoom = chatRoom;
    }

    public abstract void sendText(String to, String message);

    public abstract void sendImage(String to, String image);

    public void receiveText(String from, String message) {
        System.out.println(from + "发送文本给" + this.name + "，内容为：" + message);
    }

    public void receiveImage(String from, String image) {
        System.out.println(from + "发送图片给" + this.name + "，内容为：" + image);
    }
}

具体同事类ConcreteColleague设计如下：

public class CommonMember extends Member{

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

    @Override
    public void sendText(String to, String message) {
        System.out.println("普通会员发消息：");
        chatRoom.sendText(name, to, message);
    }

    @Override
    public void sendImage(String to, String image) {
        System.out.println("普通会员不能发图片");
    }
}

public class DiamondMember extends Member{
    public DiamondMember(String name) {
        super(name);
    }

    @Override
    public void sendText(String to, String message) {
        System.out.println("钻石会员发送消息：");
        chatRoom.sendText(name, to, message);
    }

    @Override
    public void sendImage(String to, String image) {
        System.out.println("钻石会员发送图片：");
        chatRoom.sendImage(name, to, image);
    }
}

客户端调用类设计如下：

public static void main(String args[]) {
  AbstractChatRoom happyChat = new ChatGroup();
  Member member1, member2, member3, member4, member5;
  member1 = new DiamondMember("张三");
  member2 = new DiamondMember("李四");
  member3 = new CommonMember("王五");
  member4 = new CommonMember("小芳");
  member5 = new CommonMember("小红");

  happyChat.register(member1);
  happyChat.register(member2);
  happyChat.register(member3);
  happyChat.register(member4);
  happyChat.register(member5);

  member1.sendText("李四","李四，你好！");
  member2.sendText("张三","张三，你好！");
  member1.sendText("李四","今天天气不错，有日！");
  member2.sendImage("张三","一个很大很大的太阳");
  member2.sendImage("张三","太阳");
  member3.sendText("小芳","还有问题吗？");
  member3.sendText("小红","还有问题吗？");
  member4.sendText("王五","没有了，谢谢！");
  member5.sendText("王五","我也没有了！");
  member5.sendImage("王五","谢谢");
}

运行结果如下：

四、总结

1. 优点

中介者模式简化了对象之间的交互，它用中介者和同事的一对多交互代替了原来同事之间的多对多交互，一对多关系更容易理解、维护和扩展，将原本难以理解的网状结构转换成相对简单的星型结构。
中介者模式可将各同事对象解耦。中介者有利于各同事之间的松耦合，我们可以独立的改变和复用每一个同事和中介者，增加新的中介者和新的同事类都比较方便，更好地符合“开闭原则”。
可以减少子类生成，中介者将原本分布于多个对象间的行为集中在一起，改变这些行为只需生成新的中介者子类即可，这使各个同事类可被重用，无须对同事类进行扩展。

2. 缺点

在具体中介者类中包含了大量同事之间的交互细节，可能会导致具体中介者类非常复杂，使得系统难以维护。

3. 适用场景

系统中对象之间存在复杂的引用关系，系统结构混乱且难以理解。
一个对象由于引用了其他很多对象并且直接和这些对象通信，导致难以复用该对象。
想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。可以通过引入中介者类来实现，在中介者中定义对象交互的公共行为，如果需要改变行为则可以增加新的具体中介者类。