介绍

  1. 中介者模式（Mediator Pattern），用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互
  2. 中介者模式属于行为型模式，使代码易于维护
  3. 比如MVC模式，C（Controller控制器）是M（Model模型）和V（View视图）的中介者，在前后端交互时起到了中间人的作用

原理

image-20201014213528095.png
对原理类图的说明-即(中介者模式的角色及职责)

  1. Mediator 就是抽象中介者,定义了同事对象到中介者对象的接口
  2. Colleague 是抽象同事类
  3. ConcreteMediator具体中介对象，实现抽象方法，他需要知道所有具体的同事类，即以一个HashMap集合来管理，并接受某个同事对象的消息（getMessage方法），完成相应任务。
  4. ConcreteColleague具体的同事类，会有很多，每个同事只知道自己的行为，不了解其他同事的行为（方法），但他们都依赖中介对象（作用是：使用构造器构建同事对象时，把自身添加到中介类的管理集合上）

案例

智能家庭项目：

  1. 智能家庭包括各种设备，闹钟、咖啡机、电视机、窗帘等
  2. 主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流程为：闹铃响起->咖啡机开始做咖啡->窗帘自动落下->电视机开始播放

image-20201014214245511.png

  1. //抽象中介类
  2. public interface Mediator {
  3.     public void resister(String name,Colleague colleague);
  4.     public void getMessage(int stateChange,String name);
  5. }
  7. //抽象同事类
  8. public abstract class Colleague {
  9.     private String name;
  10.     private Mediator mediator;
  12.     public Colleague(String name, Mediator mediator) {
  13.         this.name = name;
  14.         this.mediator = mediator;
  15.     }
  17.     public Mediator getMediator() {
  18.         return mediator;
  19.     }
  21.     public String getName() {
  22.         return name;
  23.     }
  25.     public abstract void sendMessage(int stateChange);
  26. }
  1. //具体同事类TV
  2. public class TV extends Colleague{
  3.     public TV(String name, Mediator mediator) {
  4.         super(name, mediator);
  5.         mediator.resister(name,this);
  6.     }
  8.     public void SendTV(int stateChange){
  9.         sendMessage(stateChange);
  10.     }
  12.     @Override
  13.     public void sendMessage(int stateChange) {
  14.         this.getMediator().getMessage(stateChange,this.getName());
  15.     }
  17.     public void openTV(){
  18.         System.out.println("电视正在打开---------");
  19.     }
  21.     public void closeTV(){
  22.         System.out.println("电视正在关闭---------");
  23.     }
  24. }
  26. //具体同事类咖啡机
  27. public class CoffeeMa extends Colleague{
  28.     public CoffeeMa(String name, Mediator mediator) {
  29.         super(name, mediator);
  30.         mediator.resister(name,this);
  31.     }
  33.     public void SendCoffeeMa(int stateChange){
  34.         sendMessage(stateChange);
  35.     }
  37.     @Override
  38.     public void sendMessage(int stateChange) {
  39.         this.getMediator().getMessage(stateChange,this.getName());
  40.     }
  42.     public void openCoffeeMa(){
  43.         System.out.println("咖啡机正在打开煮咖啡---------");
  44.     }
  45. }
  1. //中介类具体实现类
  2. public class ConcreteMediator implements Mediator{
  3.     private HashMap<String,Colleague> colleagues;
  6.     public ConcreteMediator(){
  7.         colleagues = new HashMap<>();
  8.     }
  11.     @Override
  12.     public void resister(String name, Colleague colleague) {
  13.         colleagues.put(name,colleague);
  14.     }
  16.     @Override
  17.     public void getMessage(int stateChange, String name) {
  18.         if (colleagues.containsKey(name)&&colleagues.get(name) instanceof TV){
  19.             if (stateChange==1)
  20.             {
  21.                 ((TV) colleagues.get(name)).openTV();
  22.                 ((CoffeeMa)colleagues.get("CoffeeMa")).openCoffeeMa();
  23.             }
  24.             if (stateChange==2)
  25.             {
  26.                 ((TV) colleagues.get(name)).closeTV();
  27.             }
  29.         }
  30.     }
  32. }
  1. //客户实现类
  2. public class Client {
  3.     public static void main(String[] args) {
  4.         //创建中介类
  5.         Mediator Mediator = new ConcreteMediator();
  6.         //创建同事类
  7.         TV tv = new TV("TV", Mediator);
  8.         CoffeeMa coffeeMa = new CoffeeMa("CoffeeMa", Mediator);   
  9.          //将同事注册到中介上
  10.         Mediator.resister(tv.getName(),tv);
  11.         Mediator.resister(coffeeMa.getName(),coffeeMa);
  12.         //同事类发送消息给中介
  13.         System.out.println("tv发送指令1");
  14.         tv.sendMessage(1);
  15.         System.out.println("tv发送指令2");
  16.         tv.sendMessage(2);
  17.     }
  18. }

image-20201014224329952.png

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

  1. 多个类相互耦合，会形成网状结构, 使用中介者模式将网状结构分离为星型结构， 进行解耦
  2. 减少类间依赖，降低了耦合，符合迪米特原则
  3. 中介者承担了较多的责任，一旦中介者出现了问题，整个系统就会受到影响
  4. 如果设计不当，中介者对象本身变得过于复杂，这点在实际使用时，要特别注意

个人总结
此模式，所有的同事类（中介类管理的类）在初始化时都需要在中介类中注册；

中介类使用一个集合管理同事类；同事类所有行为由中介类控制；

同事类需要做的是实现sendMessage方法，给中介类发信息，中介类根据信息调用同事类的方法实现交互；