Java设计模式（20）：中介者模式

青旅半醒 2022-12-29 02:14 142阅读 0赞

# 20，中介者模式（Mediator） #

## 20.1，问题引入\_租房中介 ##

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

## 20.2，基本介绍 ##

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

## 20.3，类图 ##

![在这里插入图片描述][20201219141712176.png]

*  `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是一个个同事类

[20201219141712176.png]: /images/20221120/2f98a3fbc48c4621a8ab88056fb3833e.png