【设计模式（17）】行为型模式之中介者模式

个人学习笔记分享，当前能力有限，请勿贬低，菜鸟互学，大佬绕道

如有勘误，欢迎指出和讨论，本文后期也会进行修正和补充

前言

相信很多人都对更换手机号有所顾虑，或者体验过了这种麻烦——通知每个人自己手机号变更了，亲友朋友同事上司全都得通知一遍，万一漏了，就失联了，甚至还得确保他们收到且更换了通讯录中你的号码

那么，我们能不能将手机号存在一个中介处，我们只需要告知中介处我们的新手机号。当有人想找我们的时候，他们也只需要询问中介就行了。

比如公司、班级、家庭的通讯录，自己手机号或者地址修改后，也同步修改一下就好了，找人的时候去上面查找即可。

同样的例子，还有人才交流市场、聊天室、房屋中介等等，甚至是前台小姐姐都算是中介者~

那么我们的网状关系结构，就变成了星型关系结构

简而言之，其目的就是为了降低对象之间的耦合性，从而提高其灵活性

1.介绍

适用目的：定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。

主要解决：对象之间存在大量的关联关系，会导致系统结构复杂，若某一个对象发生改变，则需要跟踪处理所有有关的对象。

何时使用：多个指责相似的类相互耦合，形成了网状结构。

如何解决：对象 Colleague 之间的通信封装到一个类中统一处理。

关键代码：定义中介者，用于存储和管理Colleague；定义Colleague持有中介者，并通过中介者相互通讯；

应用实例：聊天室；MVC框架；资源调度系统；

优点：

• 降低了类的复杂度，将一对多转化成了一对一，提高了灵活性，易于扩展和维护
• 各个类之间的解耦，降低了系统的耦合度
• 类之间各司其职，符合迪米特原则

缺点：Colleague越多，则中介者越臃肿，越难以维护

使用场景：

• 系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖关系结构混乱而且难以复用该对象
• 想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。
• 大量相似的类，相互之间若是网状关系则十分混乱

注意事项：不应当在职责混乱的时候使用。

2.结构

中介者模式包含以下主要角色：

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

3.实现步骤

3.1.简单实例：模拟聊天室

业务流程如下：

• 用户进入聊天室时进行注册
• 用户发送消息时，会将消息转发给聊天室的其他用户
• 用户收到消息时，显示消息内容和发送者

代码如下：

1. 定义抽象中介者

   //抽象中介者
   abstract class Mediator {
       public abstract void register(Colleague colleague);
   
       public abstract void relay(Colleague colleague,String msg);
   }
   

2. 定义具体中介者，实现抽象中介者的功能

   class ConcreteMediator extends Mediator {
   
       private Set<Colleague> colleagues = new HashSet<>();
   
       @Override
       public void register(Colleague colleague) {
           if (!colleagues.contains(colleague)) {
               colleagues.add(colleague);
           }
       }
   
       @Override
       public void relay(Colleague colleague,String msg) {
           for (Colleague item : colleagues) {
               if (!Objects.equals(item, colleague)) {
                   item.receive(colleague,msg);
               }
           }
       }
   }
   

   此处使用Set作为容器，也可以使用List、Map、Queue等容器，没啥区别

   转发的行为也可以是存入消息队列、命令池等，视情况而定

   请注意此处用对象比较，不要使用其内部的参数，避免两个不同的人使用相同标识符的情况，也给同事类留出更大的自定义扩展空间

3. 定义抽象同事类

   abstract class Colleague {
   
       protected Mediator mediator;
       public String name;
   
       public Colleague(Mediator mediator, String name) {
           this.mediator = mediator;
           this.name = name;
       }
   
       public abstract void receive(Colleague colleague, String msg);
   
       public abstract void send(String msg);
   }
   

   此处的mediator即中介者，被同事持有，以便于向中介者传递消息，当然也可以使用单例模式或者向接口发送消息等解决方案

   此处的name为同事类的标识符，即用于分辨同事是谁，也可以使用uid等作为标识符

   请注意此处的标识符并不唯一，相当于生活中的姓名，是可能也允许出现重复的

4. 定义具体同事类，实现抽象同事类

   class ConcreteColleague extends Colleague {
   
       public ConcreteColleague(Mediator mediator, String name) {
           super(mediator, name);
       }
   
       @Override
       public void receive(Colleague colleague,String msg) {
           System.out.println(name + " receive message from "+colleague.name+": " + msg);
       }
   
       @Override
       public void send(String msg) {
           System.out.println(name + " send message: " + msg);
           mediator.relay(this,msg);
       }
   }
   

   具体同事类可以定义多个，每个可以自行定义收发消息的行为，也可以存储自定义的信息

   例如：

   • 定义老师类，存储老师的联系方式、教师编号等信息

   • 定义学生类，存储学生的学号、所在班级等信息

   • 定义管理员类，存储联系方式即可

   但存在多种同事类的情况下，建议在抽象同事类中留有类型标记（如int type），以便于中介者识别

测试代码

public class Test {
    public static void main(String[] args) {
        Mediator mediator=new ConcreteMediator();
        Colleague colleagueA=new ConcreteColleague(mediator,"A");
        Colleague colleagueB=new ConcreteColleague(mediator,"B");
        Colleague colleagueC=new ConcreteColleague(mediator,"C");
        mediator.register(colleagueA);
        mediator.register(colleagueB);
        mediator.register(colleagueC);


        colleagueA.send("Hello! I'm A");
        System.out.println("-------------");
        colleagueB.send("Hello! I'm B");
        System.out.println("-------------");
        colleagueC.send("Hello! I'm C");
    }
}

运行结果

3.2.进阶实例：模拟聊天室

模拟业务：

• 建立一个聊天室，有三种类型的人员：学生、老师、GM
• 每种身份均允许多个人参与
• 每个人拥有一个独立的聊天框，显示所有人发送的消息

全部代码：

package com.company.designPattern.mediator.test2;

import javax.swing.*;
import java.awt.*;
import java.util.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;

/**
 * @Description: 聊天室demo代码
 * @Author: Echo
 * @Time: 2021/2/25 10:22
 * @Email: 347110596@qq.com
 */

public class Test {
    public static void main(String[] args) {
        //初始化聊天室
        Medium md = new ChatRoom();
        //初始化参与者
        Colleague member1 = new Student("小明");
        Colleague member2 = new Student("小红");
        Colleague member3 = new Teacher("张老师");
        Colleague member4 = new Manager("GM");
        //注册
        md.register(member1);
        md.register(member2);
        md.register(member3);
        md.register(member4);
    }
}

enum Types {
    Teacher("老师"),
    Student("学生"),
    Manager("管理员"),
    ;

    private final String TypeName;

    public String getTypeName() {
        return TypeName;
    }

    Types(String typeName) {
        TypeName = typeName;
    }
}

//抽象中介者
interface Medium {
    void register(Colleague member); //注册

    void relay(Colleague from, String ad); //转发
}

//具体中介者：房地产中介
class ChatRoom implements Medium {
    private List<Colleague> members = new ArrayList<>();

    public void register(Colleague member) {
        if (!members.contains(member)) {
            members.add(member);
            member.setMedium(this);
        }
    }

    public void relay(Colleague from, String msg) {
        for (Colleague to : members) {
            if (!Objects.equals(from, to)) {
                to.receive(from, msg);
            }
        }
    }
}

//抽象同事类
abstract class Colleague extends JFrame implements ActionListener {
    private static final long serialVersionUID = -7219939540794786080L;
    protected Medium medium;
    protected String name;
    protected Types identify;
    JTextField SentText;
    JTextArea ReceiveArea;

    public Colleague(String name, Types identify) {
        //初始化弹窗标题
        super(name);
        //初始化同事类信息
        this.name = name;
        this.identify = identify;
        //初始化弹窗
        ClientWindow();
    }

    //定义客户端
    void ClientWindow() {
        //初始化容器
        Container cp = this.getContentPane();
        ReceiveArea = new JTextArea(10, 18);
        ReceiveArea.setEditable(false);
        SentText = new JTextField(18);

        // 接收消息模块
        JPanel p1 = new JPanel();
        p1.setBorder(BorderFactory.createTitledBorder("接收内容："));
        p1.add(ReceiveArea);
        // 初始化消息内容
        JScrollPane sp = new JScrollPane(p1);
        // 置顶
        cp.add(sp, BorderLayout.NORTH);

        // 发送消息模块
        JPanel p2 = new JPanel();
        p2.setBorder(BorderFactory.createTitledBorder("发送内容："));
        p2.add(SentText);
        // 置底
        cp.add(p2, BorderLayout.SOUTH);
        // 输入框设置监听
        SentText.addActionListener(this);

        // 设置客户端窗口属性
        this.setLocation(50, 100); // 窗口位置
        this.setSize(250, 330);// 窗口大小
        this.setResizable(false); // 窗口大小不可调整
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 窗口关闭操作-退出
        this.setVisible(true); // 窗口可见
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        // 发送消息
        String tempInfo = SentText.getText().trim();
        this.send(tempInfo);
        // 输入框重置为空
        SentText.setText("");
    }

    @Override
    public String getName() {
        return name;
    }

    public void setMedium(Medium medium) {
        this.medium = medium;
    }

    public abstract void send(String ad);

    public abstract void receive(Colleague from, String ad);
}

//具体同事类
class CommonColleague extends Colleague {
    private static final long serialVersionUID = -1443076716629516027L;

    public CommonColleague(String name, Types identify) {
        super(name, identify);
    }

    public void send(String msg) {
        // 显示消息
        ReceiveArea.append("我: " + msg + "
");
        // 使滚动条滚动到最底端
        ReceiveArea.setCaretPosition(ReceiveArea.getText().length());
        // 转发消息
        medium.relay(this, msg);
    }

    public void receive(Colleague from, String msg) {
        // 获取发送者身份
        String sender = from.name + "（" + from.identify.getTypeName() + "）";
        // 显示消息
        ReceiveArea.append(sender + ": " + msg + "
");
        // 使滚动条滚动到最底端
        ReceiveArea.setCaretPosition(ReceiveArea.getText().length());
    }
}

//具体同事类：学生
class Student extends CommonColleague {
    private String stuNum;// 学号
    private String classId;// 班级编号

    //身份
    private final static Types identify = Types.Student;

    public Student(String name) {
        super(name, identify);
    }
}

//具体同事类：老师
class Teacher extends CommonColleague {
    private String phone;// 手机号

    //身份
    private final static Types identify = Types.Teacher;

    public Teacher(String name) {
        super(name, identify);
    }
}

//具体同事类：管理员
class Manager extends CommonColleague {
    //身份
    private final static Types identify = Types.Manager;

    public Manager(String name) {
        super(name, identify);
    }
}

运行结果:

相关demo地址：https://gitee.com/echo_ye/practice/tree/master/src/main/java/com/company/designPattern/mediator

4.实际使用

在实际开发中，通常并不严格按照上述模式开发，而通过简化来使快速开发，并缩小项目体积

1. 不定义中介者接口，直接使用中介者（不太建议）：效果显而易见，但即便只有一个中介者也不太建议，使项目更简单很重要，但易于扩展同样重要

2. 同事类不持有中介者，使用时直接获取并调用（建议）：相互持有是一个很有风险的事情，避开风险显然有利无害

3. 单例化中介者（建议）：若只有一个中介者，将其单例化可以避免误操作再次实例化；当然多个中介者的话就不能这样了

后记

中介者模式的核心目的是将网状结构转换为星型结构，即从N-N改变为N-1-N，从而降低系统的复杂度

作者：Echo_Ye

WX：Echo_YeZ

Email ：echo_yezi@qq.com

个人站点：在搭了在搭了。。。（右键 - 新建文件夹）