【设计模式(17)】行为型模式之中介者模式

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

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


前言

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

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

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

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

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

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


1.介绍

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

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

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

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

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

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

优点:

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

缺点:Colleague越多,则中介者越臃肿,越难以维护

使用场景

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

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


2.结构

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

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

image-20210224181126223


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作为容器,也可以使用ListMapQueue等容器,没啥区别

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

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

  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");
    }
}

运行结果

image-20210225101254234

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 + "\n");
        // 使滚动条滚动到最底端
        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 + "\n");
        // 使滚动条滚动到最底端
        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);
    }
}

运行结果:

image-20210225115154936


相关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

个人站点:在搭了在搭了。。。(右键 - 新建文件夹)

已标记关键词 清除标记
相关推荐
1) 优秀的程序应该是这样的:阅读时,感觉很优雅;新增功能时,感觉很轻松;运行时,感觉很快速,这就需要设计模式支撑。<br /> <br /> 2) 设计模式包含了大量的编程思想,讲授和真正掌握并不容易,网上的设计模式课程不少,大多讲解的比较晦涩,没有真实的应用场景和框架源码支撑,学习后,只知其形,不知其神。就会造成这样结果: 知道各种设计模式,但是不知道怎么使用到真实项目。本课程针对上述问题,有针对性的进行了升级 (1) 授课方式采用 图解+框架源码分析的方式,让课程生动有趣好理解 (2) 系统全面的讲解了设计模式,包括 设计模式七大原则、UML类图-类的六大关系、23种设计模式及其分类,比如 单例模式的8种实现方式、工厂模式的3种实现方式、适配器模式的3种实现、代理模式的3种方式、深拷贝等<br /> <br /> 3) 如果你想写出规范、漂亮的程序,就花时间来学习下设计模式吧<br /> <br /> 课程内容和目标<br /> <br /> 本课程是使用Java来讲解设计模式,考虑到设计模式比较抽象,授课采用 图解+框架源码分析的方式<br /> <br /> 1) 内容包括: 设计模式七大原则(单一职责、接口隔离、依赖倒转、里氏替换、开闭原则、迪米特法则、合成复用)、UML类图(类的依赖、泛化和实现、类的关联、聚合和组合) 23种设计模式包括:创建模式:单例模式(8种实现)、抽象工厂模式、原模式、建造者模式、工厂模式。结构模式:适配器模式(3种实现)、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式(3种实现)。行为模式:模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式中介者模式、备忘录模式、解释器模式(Interpreter模式)、状态模式、策略模式、职责链模式(责任链模式)<br /> <br /> 2) 学习目标:通过学习,学员能掌握主流设计模式,规范编程风格,提高优化程序结构和效率的能力。<br /> <div> <br /> </div>
<p> 本教程为授权出品教程 </p> <p> <br /> </p> <p> <span style="color:#404040;">1) 优秀的程序应该是这样的:阅读时,感觉很优雅;新增功能时,感觉很轻松;运行时,感觉很快速,这就需要设计模式支撑</span><br /> <span style="color:#404040;">2) 设计模式包含了大量的编程思想,讲授和真正掌握并不容易,网上的设计模式课程不少,大多讲解的比较晦涩,没有真实的应用场景和框架源码支撑,学习后,只知其形,不知其神。就会造成这样结果: 知道各种设计模式,但是不知道怎么使用到真实项目。本课程针对上述问题,有针对性的进行了升级 (1) 授课方式采用 图解+框架源码分析的方式,让课程生动有趣好理解 (2) 系统全面的讲解了设计模式,包括 设计模式七大原则、UML类图-类的六大关系、23种设计模式及其分类,比如 单例模式的8种实现方式、工厂模式的3种实现方式、适配器模式的3种实现、代理模式的3种方式、深拷贝等</span><br /> <span style="color:#404040;">3) 如果你想写出规范、漂亮的程序,就花时间来学习下设计模式吧</span><br /> <br /> <span style="color:#404040;">课程内容和目标</span><br /> <span style="color:#404040;">本课程是使用Java来讲解设计模式,考虑到设计模式比较抽象,授课采用 图解+框架源码分析的方式</span><br /> <span style="color:#404040;">1) 内容包括:设计模式七大原则(单一职责、接口隔离、依赖倒转、里氏替换、开闭原则、迪米特法则、合成复用)、UML类图(类的依赖、泛化和实现、类的关联、聚合和组合) 23种设计模式包括:创建模式:单例模式(8种实现)、抽象工厂模式、原模式、建造者模式、工厂模式。结构模式:适配器模式(3种实现)、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式(3种实现)。行为模式:模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式中介者模式、备忘录模式、解释器模式(Interpreter模式)、状态模式、策略模式、职责链模式(责任链模式)。</span><br /> <span style="color:#404040;">2) 学习目标:通过学习,学员能掌握主流设计模式,规范编程风格,提高优化程序结构和效率的能力。</span> </p>
©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页