Java设计模式(20):中介者模式

  • 时间:
  • 浏览:
  • 来源:互联网

20,中介者模式(Mediator)

20.1,问题引入_租房中介

  • 在一个租房者去市场上租房的时候,面临的是众多的被租房子,及每一套房子后面的房东
  • 首先,租房者需要跟每一个房东打交道,去确认房子,去议价
  • 其次,房东间可能也会存在沟通,形成一张沟通网
  • 在整个沟通过程中,各方都会很累,没有效率,此时需要一个承上启下的角色存在,就是租房中介
  • 这就可以用中介者模式进行处理

20.2,基本介绍

  • 中介者模式(Mediator Pattern):是行为模式的一种。用一个中介对象,封装一系列的对象交互(发送东)。中介者使各个对象不需要显式的相互引用,从而使其耦合松散,而且可以独立的改变他们之间的交互
  • 比如在MVC模式中,C(Controller)是M(Model)和V(View)的中介者,在前后端交互时候起到了中间人的作用
  • 中介者模式中包括中介者同事类两个基本角色,在MVC中,C表示中介者,MV就是同事类,由一个同事类通过中介者发送数据给一个或者几个同事类

20.3,类图

在这里插入图片描述

  • Mediator:中介者顶层抽象类,定义同事类的注册方式和数据的传递方式
  • ConcreteMediator:具体中介者对象,内部组合了同事类集合,可通过中介者进行消息分发
  • Colleague:同事类顶层抽象类,内部聚合中介者对象
  • XXXColleague:具体同事类对象,定义具体的发送和接收方式

20.4,代码实现

  • Mediator:中介者顶层抽象类

    package com.self.designmode.mediator;
    
    /**
     * 中介者顶层抽象类
     * @author PJ_ZHANG
     * @create 2020-12-16 22:46
     **/
    public abstract class Mediator {
    
        /**
         * 同事类注册
         * @param colleague 注册的同事对象
         */
        abstract void registry(Colleague colleague);
    
        /**
         * 同事类消息传递
         * @param senderType 消息发送者
         * @param receiverType 消息接受者
         * @param msg 消息内容
         */
        abstract void relay(String senderType, String receiverType, String msg);
    
    }
    
  • ConcreteMediator:中介者具体类

    package com.self.designmode.mediator;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * 具体中介者类
     * @author PJ_ZHANG
     * @create 2020-12-16 22:47
     **/
    public class ConcreteMediator extends Mediator {
    
        Map<String, Colleague> colleagueMap = new HashMap<>(16);
    
        @Override
        void registry(Colleague colleague) {
            if (!colleagueMap.containsKey(colleague.getColleagueType())) {
                colleagueMap.put(colleague.getColleagueType(), colleague);
                colleague.setMediator(this);
            }
        }
    
        @Override
        void relay(String senderType, String receiverType, String msg) {
            if (!colleagueMap.containsKey(senderType) || !colleagueMap.containsKey(receiverType)) {
                return;
            }
            colleagueMap.get(receiverType).receiverMsg(senderType, msg);
        }
    }
    
  • Colleague:同事类顶层抽象类

    package com.self.designmode.mediator;
    
    /**
     * @author PJ_ZHANG
     * @create 2020-12-16 22:46
     **/
    public abstract class Colleague {
    
        private Mediator mediator;
    
        private String name;
    
        public Colleague(String name) {
            this.name = name;
        }
    
        public Mediator getMediator() {
            return mediator;
        }
    
        public void setMediator(Mediator mediator) {
            this.mediator = mediator;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        abstract void sendMsg(String receiverType, String msg);
    
        abstract void receiverMsg(String senderType, String msg);
    
        abstract String getColleagueType();
    }
    
  • ConcreteColleagueA:同事类具体类

    package com.self.designmode.mediator;
    
    /**
     * 具体同事类
     * @author PJ_ZHANG
     * @create 2020-12-16 22:54
     **/
    public class ConcreteColleagueA extends Colleague {
    
        public ConcreteColleagueA(String name) {
            super(name);
        }
    
        @Override
        void sendMsg(String receiverType, String msg) {
            System.out.println(getName() + " 发送消息 {" + msg + "} 到 " + receiverType);
            getMediator().relay(getColleagueType(), receiverType, msg);
        }
    
        @Override
        void receiverMsg(String senderType, String msg) {
            System.out.println(getName() + " 接收到" + senderType + " 发送的消息: " + msg);
        }
    
        @Override
        String getColleagueType() {
            return "A";
        }
    
    }
    
  • ConcreteColleagueB:同事类具体类

    package com.self.designmode.mediator;
    
    /**
     * 具体同事类
     * @author PJ_ZHANG
     * @create 2020-12-16 22:54
     **/
    public class ConcreteColleagueB extends Colleague {
    
        public ConcreteColleagueB(String name) {
            super(name);
        }
    
        @Override
        void sendMsg(String receiverType, String msg) {
            System.out.println(getName() + " 发送消息 {" + msg + "} 到 " + receiverType);
            getMediator().relay(getColleagueType(), receiverType, msg);
        }
    
        @Override
        void receiverMsg(String senderType, String msg) {
            System.out.println(getName() + " 接收到" + senderType + " 发送的消息: " + msg);
        }
    
        @Override
        String getColleagueType() {
            return "B";
        }
    
    }
    
  • Client:客户端

    package com.self.designmode.mediator;
    
    /**
     * @author PJ_ZHANG
     * @create 2020-12-16 23:03
     **/
    public class Client {
    
        public static void main(String[] args) {
            // 构建中介者
            Mediator mediator = new ConcreteMediator();
            // 非单例模式可以指定类型, 比如用用户编号制定
            // 构建同事类
            Colleague colleagueA = new ConcreteColleagueA("A");
            Colleague colleagueB = new ConcreteColleagueB("B");
            // 注册同事类到中介者
            mediator.registry(colleagueA);
            mediator.registry(colleagueB);
            // A发送消息给B
            colleagueA.sendMsg(colleagueB.getColleagueType(), "A发送给B");
            // B发送消息给A
            colleagueB.sendMsg(colleagueA.getColleagueType(), "B发送给A");
        }
    
    }
    

20.5,中介者模式的注意事项和细节

  • 多个同事相互耦合,会形成网状结构;使用中介者会将网状结构分解为星状结构,进行解耦
  • 减少类之间依赖关系,进行解耦,符合迪米特法则(最少知道原则)
  • 中介者承担了较多的责任,如果中介者出现问题,整个系统会出现影响
  • 如果涉及不当,中介者对象本身会变得非常复杂,这点应该特别注意
  • 在最近项目中实现即时通讯,通过Netty构建基本框架,类似Spring容器管理对Channel进行管理并进行数据分发,符合中介者模式的基本原则;即Channel容器是一个中介者类,每一个连接Channel是一个个同事类

本文链接http://www.hatan.cn/news/show-69547.html