認真學習設計模式之中介者模式(Mediator Pattern)

【1】概述

中介者模式（Mediator Pattern），用一個中介對象來封裝一系列的對象互動。中介者使各個對象不需要顯式地互相引用，進而使其耦合松散，而且可以獨立地改變它們之間的互動。

中介者模式屬于​

​行為型​

​模式，使代碼易于維護。比如MVC 模式，C（Controller 控制器）是M（Model 模型）和V（View 視圖）的中介者，在前後端互動時起到了中間人的作用。

UML 類圖

對原理類圖的說明-即(中介者模式的角色及職責)

• Mediator 就是抽象中介者,定義了同僚對象到中介者對象的接口
• Colleague 是抽象同僚類
• ConcreteMediator 具體的中介者對象, 實作抽象方法, 他需要知道所有的具體的同僚類,即以一個集合來管理,并接受某個同僚對象消息，完成相應的任務
• ConcreteColleague 具體的同僚類，會有很多, 每個同僚隻知道自己的行為， 而不了解其他同僚類的行為(方法)，但是他們都依賴中介者對象

【2】案例分析

智能家庭項目：

• 智能家庭包括各種裝置，鬧鐘、咖啡機、電視機、窗簾等
• 主人要看電視時，各個裝置可以協同工作，自動完成看電視的準備工作，比如流程為：鬧鈴響起->咖啡機開始做咖啡->窗簾自動落下->電視機開始播放

① 傳統方式解決

傳統方式會如何解決呢？我們可能定義多個對象，然後對象之間保持關系，以進耦合的形式維護一系列動作。

這是存在問題的，當各電器對象有多種狀态改變時，互相之間的調用關系會比較複雜。而且各個電器對象彼此聯系，你中有我，我中有你，不利于松耦合。還有各個電器對象之間所傳遞的消息(參數)，容易混亂。

如果系統增加一個新的電器對象時，或者執行流程改變時，代碼的可維護性、擴充性都不理想。

② 中介者模式

① 定義中介者與實作

public abstract class Mediator {
  //将給中介者對象，加入到集合中
  public abstract void Register(String colleagueName, Colleague colleague);

  //接收消息, 具體的同僚對象發出
  public abstract void GetMessage(int stateChange, String colleagueName);

  public abstract void SendMessage();
}

//具體的中介者類
public class ConcreteMediator extends Mediator {
  //集合，放入所有的同僚對象
  private HashMap<String, Colleague> colleagueMap;
  // 放入類的類型與colleagueName
  private HashMap<String, String> interMap;

  public ConcreteMediator() {
    colleagueMap = new HashMap<String, Colleague>();
    interMap = new HashMap<String, String>();
  }

  @Override
  public void Register(String colleagueName, Colleague colleague) {
    colleagueMap.put(colleagueName, colleague);

    if (colleague instanceof Alarm) {
      interMap.put("Alarm", colleagueName);
    } else if (colleague instanceof CoffeeMachine) {
      interMap.put("CoffeeMachine", colleagueName);
    } else if (colleague instanceof TV) {
      interMap.put("TV", colleagueName);
    } else if (colleague instanceof Curtains) {
      interMap.put("Curtains", colleagueName);
    }

  }

  //具體中介者的核心方法
  //1. 根據得到消息，完成對應任務
  //2. 中介者在這個方法，協調各個具體的同僚對象，完成任務
  @Override
  public void GetMessage(int stateChange, String colleagueName) {
    //處理鬧鐘發出的消息
    if (colleagueMap.get(colleagueName) instanceof Alarm) {
      if (stateChange == 0) {
        ((CoffeeMachine) (colleagueMap.get(interMap
            .get("CoffeeMachine")))).StartCoffee();
        ((TV) (colleagueMap.get(interMap.get("TV")))).StartTv();
      } else if (stateChange == 1) {
        ((TV) (colleagueMap.get(interMap.get("TV")))).StopTv();
      }

    } else if (colleagueMap.get(colleagueName) instanceof CoffeeMachine) {
      ((Curtains) (colleagueMap.get(interMap.get("Curtains"))))
          .UpCurtains();

    } else if (colleagueMap.get(colleagueName) instanceof TV) {//如果TV發現消息

    } else if (colleagueMap.get(colleagueName) instanceof Curtains) {
      //如果是以窗簾發出的消息，這裡處理...
    }

  }

  @Override
  public void SendMessage() {
    
  }
}      

② 定義抽象類Colleague 與實作

//同僚抽象類
public abstract class Colleague {
  private Mediator mediator;
  public String name;

  public Colleague(Mediator mediator, String name) {
    this.mediator = mediator;
    this.name = name;

  }

  public Mediator GetMediator() {
    return this.mediator;
  }

  public abstract void SendMessage(int stateChange);
}

//具體的同僚類
public class Alarm extends Colleague {

  //構造器
  public Alarm(Mediator mediator, String name) {
    super(mediator, name);
    //在建立Alarm 同僚對象時，将自己放入到ConcreteMediator 對象中[集合]
    mediator.Register(name, this);
  }

  public void SendAlarm(int stateChange) {
    SendMessage(stateChange);
  }

  @Override
  public void SendMessage(int stateChange) {
    //調用的中介者對象的getMessage
    this.GetMediator().GetMessage(stateChange, this.name);
  }

}

public class CoffeeMachine extends Colleague {

  public CoffeeMachine(Mediator mediator, String name) {
    super(mediator, name);
    mediator.Register(name, this);
  }

  @Override
  public void SendMessage(int stateChange) {
    this.GetMediator().GetMessage(stateChange, this.name);
  }

  public void StartCoffee() {
    System.out.println("It's time to startcoffee!");
  }

  public void FinishCoffee() {

    System.out.println("After 5 minutes!");
    System.out.println("Coffee is ok!");
    SendMessage(0);
  }
}

public class Curtains extends Colleague {

  public Curtains(Mediator mediator, String name) {
    super(mediator, name);
    mediator.Register(name, this);
  }

  @Override
  public void SendMessage(int stateChange) {
    this.GetMediator().GetMessage(stateChange, this.name);
  }

  public void UpCurtains() {
    System.out.println("I am holding Up Curtains!");
  }

}

public class TV extends Colleague {

  public TV(Mediator mediator, String name) {
    super(mediator, name);
    mediator.Register(name, this);
  }

  @Override
  public void SendMessage(int stateChange) {
    this.GetMediator().GetMessage(stateChange, this.name);
  }

  public void StartTv() {
    System.out.println("It's time to StartTv!");
  }

  public void StopTv() {
    System.out.println("StopTv!");
  }
}      

③ 用戶端測試

public class ClientTest {

  public static void main(String[] args) {
    //建立一個中介者對象
    Mediator mediator = new ConcreteMediator();
    
    //建立Alarm 并且加入到  ConcreteMediator 對象的HashMap
    Alarm alarm = new Alarm(mediator, "alarm");
    
    //建立了CoffeeMachine 對象，并  且加入到  ConcreteMediator 對象的HashMap
    CoffeeMachine coffeeMachine = new CoffeeMachine(mediator,
        "coffeeMachine");
    
    //建立 Curtains , 并  且加入到  ConcreteMediator 對象的HashMap
    Curtains curtains = new Curtains(mediator, "curtains");
    TV tV = new TV(mediator, "TV");
    
    //讓鬧鐘發出消息
    alarm.SendAlarm(0);
    coffeeMachine.FinishCoffee();
    alarm.SendAlarm(1);
  }

}      

It's time to startcoffee!
It's time to StartTv!
After 5 minutes!
Coffee is ok!
I am holding Up Curtains!
StopTv!      

④ 中介者模式的注意事項和細節

• 多個類互相耦合，會形成網狀結構, 使用中介者模式将網狀結構分離為星型結構，進行解耦
• 減少類間依賴，降低了耦合，符合迪米特原則
• ​

  ​中介者承擔了較多的責任，一旦中介者出現了問題，整個系統就會受到影響​

  ​
• 如果設計不當，中介者對象本身變得過于複雜，這點在實際使用時，要特别注意