調停者（Mediator）模式

　　調停者模式是對象的行爲模式。調停者模式包裝了一系列對象相互做用的方式，使得這些對象沒必要相互明顯引用。從而使它們能夠較鬆 散地耦合。當這些對象中的某些對象之間的相互做用發生改變時，不會當即影響到其餘的一些對象之間的相互做用。從而保證這些相互做用能夠彼此獨立地變化。

爲何須要調停者

　　以下圖所示，這個示意圖中有大量的對象，這些對象既會影響別的對象，又會被別的對象所影響，所以經常叫作同 事(Colleague)對象。這些同事對象經過彼此的相互做用造成系統的行爲。從圖中能夠看出，幾乎每個對象都須要與其餘的對象發生相互做用，而這種 相互做用表現爲一個對象與另外一個對象的直接耦合。這就是過分耦合的系統。

　　經過引入調停者對象(Mediator)，能夠將系統的網狀結構變成以中介者爲中心的星形結構，以下圖所示。在這個星形結構中，同事對象再也不通 過直接的聯繫與另外一個對象發生相互做用；相反的，它經過調停者對象與另外一個對象發生相互做用。調停者對象的存在保證了對象結構上的穩定，也就是說，系統的 結構不會由於新對象的引入形成大量的修改工做。

　 　一個好的面向對象的設計可使對象之間增長協做性(Collaboration)，減小耦合度(Couping)。一個深思熟慮的設計會把一個系統分解 爲一羣相互協做的同事對象，而後給每個同事對象以獨特的責任，恰當的配置它們之間的協做關係，使它們能夠在一塊兒工做。

若是沒有主板

　　你們都知道，電腦裏面各個配件之間的交互，主要是經過主板來完成的。若是電腦裏面沒有了主板，那麼各個配件之間就必須自行相互交互，以互相傳送數據。並且因爲各個配件的接口不一樣，相互之間交互時，還必須把數據接口進行轉換才能匹配上。

　　所幸是有了主板，各個配件的交互徹底經過主板來完成，每一個配件都只須要和主板交互，而主板知道如何跟全部的配件打交道，這樣就簡單多了。

調停者模式的結構

　　調停者模式的示意性類圖以下所示：

　　調停者模式包括如下角色：

　　●　　抽象調停者(Mediator)角色：定義出同事對象到調停者對象的接口，其中主要方法是一個（或多個）事件方法。

　　●　　具體調停者(ConcreteMediator)角色：實現了抽象調停者所聲明的事件方法。具體調停者知曉全部的具體同事類，並負責具體的協調各同事對象的交互關係。

　　●　　抽象同事類(Colleague)角色：定義出調停者到同事對象的接口。同事對象只知道調停者而不知道其他的同事對象。

　　●　　具體同事類(ConcreteColleague)角色：全部的具體同事類均從抽象同事類繼承而來。實現本身的業務，在須要與其餘同事通訊的時候，就與持有的調停者通訊，調停者會負責與其餘的同事交互。

　　源代碼

　　抽象調停者類

public interface Mediator {
    /**
     * 同事對象在自身改變的時候來通知調停者方法
     * 讓調停者去負責相應的與其餘同事對象的交互
     */
    public void changed(Colleague c);
}

　　具體調停者類

public class ConcreteMediator implements Mediator {
    //持有並維護同事A
    private ConcreteColleagueA colleagueA;
    //持有並維護同事B
    private ConcreteColleagueB colleagueB;    
    
    public void setColleagueA(ConcreteColleagueA colleagueA) {
        this.colleagueA = colleagueA;
    }

    public void setColleagueB(ConcreteColleagueB colleagueB) {
        this.colleagueB = colleagueB;
    }

    @Override
    public void changed(Colleague c) {
        /**
         * 某一個同事類發生了變化，一般須要與其餘同事交互
         * 具體協調相應的同事對象來實現協做行爲
         */
    }

}

　　抽象同事類

public abstract class Colleague {
    //持有一個調停者對象
    private Mediator mediator;
    /**
     * 構造函數
     */
    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }
    /**
     * 獲取當前同事類對應的調停者對象
     */
    public Mediator getMediator() {
        return mediator;
    }
    
}

　　具體同事類

public class ConcreteColleagueA extends Colleague {

    public ConcreteColleagueA(Mediator mediator) {
        super(mediator);
    }
    /**
     * 示意方法，執行某些操做
     */
    public void operation(){
        //在須要跟其餘同事通訊的時候，通知調停者對象
        getMediator().changed(this);
    }
}

public class ConcreteColleagueB extends Colleague {

    public ConcreteColleagueB(Mediator mediator) {
        super(mediator);
    }
    /**
     * 示意方法，執行某些操做
     */
    public void operation(){
        //在須要跟其餘同事通訊的時候，通知調停者對象
        getMediator().changed(this);
    }
}

使用電腦來看電影

　　在平常生活中，咱們常用電腦來看電影，把這個過程描述出來，簡化後假定會有以下的交互過程：

　　（1）首先是光驅要讀取光盤上的數據，而後告訴主板，它的狀態改變了。

　　（2）主板去獲得光驅的數據，把這些數據交給CPU進行分析處理。

　　（3）CPU處理完後，把數據分紅了視頻數據和音頻數據，通知主板，它處理完了。

　　（4）主板去獲得CPU處理事後的數據，分別把數據交給顯卡和聲卡，去顯示出視頻和發出聲音。

　　要使用調停者模式來實現示例，那就要區分出同事對象和調停者對象。很明顯，主板是調停者，而光驅、聲卡、CPU、顯卡等配件，都是做爲同事對象。

　　源代碼

　　抽象同事類

public abstract class Colleague {
    //持有一個調停者對象
    private Mediator mediator;
    /**
     * 構造函數
     */
    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }
    /**
     * 獲取當前同事類對應的調停者對象
     */
    public Mediator getMediator() {
        return mediator;
    }
}

　　同事類——光驅

public class CDDriver extends Colleague{
    //光驅讀取出來的數據
    private String data = "";
    /**
     * 構造函數
     */
    public CDDriver(Mediator mediator) {
        super(mediator);
    }
    /**
     * 獲取光盤讀取出來的數據
     */
    public String getData() {
        return data;
    }
    /**
     * 讀取光盤
     */
    public void readCD(){
        //逗號前是視頻顯示的數據，逗號後是聲音
        this.data = "One Piece,海賊王我當定了";
        //通知主板，本身的狀態發生了改變
        getMediator().changed(this);
    }
}

　　同事類——CPU

public class CPU extends Colleague {
    //分解出來的視頻數據
    private String videoData = "";
    //分解出來的聲音數據
    private String soundData = "";
    /**
     * 構造函數
     */
    public CPU(Mediator mediator) {
        super(mediator);
    }
    /**
     * 獲取分解出來的視頻數據
     */
    public String getVideoData() {
        return videoData;
    }
    /**
     * 獲取分解出來的聲音數據
     */
    public String getSoundData() {
        return soundData;
    }
    /**
     * 處理數據，把數據分紅音頻和視頻的數據
     */
    public void executeData(String data){
        //把數據分解開，前面是視頻數據，後面是音頻數據
        String[] array = data.split(",");
        this.videoData = array[0];
        this.soundData = array[1];
        //通知主板，CPU完成工做
        getMediator().changed(this);
    }
    
}

　　同事類——顯卡

public class VideoCard extends Colleague {
    /**
     * 構造函數
     */
    public VideoCard(Mediator mediator) {
        super(mediator);
    }
    /**
     * 顯示視頻數據
     */
    public void showData(String data){
        System.out.println("您正在觀看的是：" + data);
    }
}

　　同事類——聲卡

public class SoundCard extends Colleague {
    /**
     * 構造函數
     */
    public SoundCard(Mediator mediator) {
        super(mediator);
    }
    /**
     * 按照聲頻數據發出聲音
     */
    public void soundData(String data){
        System.out.println("畫外音：" + data);
    }
}

　　抽象調停者類

public interface Mediator {
    /**
     * 同事對象在自身改變的時候來通知調停者方法
     * 讓調停者去負責相應的與其餘同事對象的交互
     */
    public void changed(Colleague c);
}

　　具體調停者類

public class MainBoard implements Mediator {
    //須要知道要交互的同事類——光驅類
    private CDDriver cdDriver = null;
    //須要知道要交互的同事類——CPU類
    private CPU cpu = null;
    //須要知道要交互的同事類——顯卡類
    private VideoCard videoCard = null;
    //須要知道要交互的同事類——聲卡類
    private SoundCard soundCard = null;
    
    public void setCdDriver(CDDriver cdDriver) {
        this.cdDriver = cdDriver;
    }

    public void setCpu(CPU cpu) {
        this.cpu = cpu;
    }

    public void setVideoCard(VideoCard videoCard) {
        this.videoCard = videoCard;
    }

    public void setSoundCard(SoundCard soundCard) {
        this.soundCard = soundCard;
    }

    @Override
    public void changed(Colleague c) {
        if(c instanceof CDDriver){
            //表示光驅讀取數據了
            this.opeCDDriverReadData((CDDriver)c);
        }else if(c instanceof CPU){
            this.opeCPU((CPU)c);
        }
    }
    /**
     * 處理光驅讀取數據之後與其餘對象的交互
     */
    private void opeCDDriverReadData(CDDriver cd){
        //先獲取光驅讀取的數據
        String data = cd.getData();
        //把這些數據傳遞給CPU進行處理
        cpu.executeData(data);
    }
    /**
     * 處理CPU處理完數據後與其餘對象的交互
     */
    private void opeCPU(CPU cpu){
        //先獲取CPU處理後的數據
        String videoData = cpu.getVideoData();
        String soundData = cpu.getSoundData();
        //把這些數據傳遞給顯卡和聲卡展現出來
        videoCard.showData(videoData);
        soundCard.soundData(soundData);
    }
}

　　客戶端類

public class Client {

    public static void main(String[] args) {
        //建立調停者——主板
        MainBoard mediator = new MainBoard();
        //建立同事類
        CDDriver cd = new CDDriver(mediator);
        CPU cpu = new CPU(mediator);
        VideoCard vc = new VideoCard(mediator);
        SoundCard sc = new SoundCard(mediator);
        //讓調停者知道全部同事
        mediator.setCdDriver(cd);
        mediator.setCpu(cpu);
        mediator.setVideoCard(vc);
        mediator.setSoundCard(sc);
        //開始看電影，把光盤放入光驅，光驅開始讀盤
        cd.readCD();        
    }

}

　　運行結果以下：

調停者模式的優勢

　　●　　鬆散耦合

　　調停者模式經過把多個同事對象之間的交互封裝到調停者對象裏面，從而使得同事對象之間鬆散耦合，基本上能夠作到互補依賴。這樣一來，同事對象就能夠獨立地變化和複用，而再也不像之前那樣「牽一處而動全身」了。

　　●　　集中控制交互

　　多個同事對象的交互，被封裝在調停者對象裏面集中管理，使得這些交互行爲發生變化的時候，只須要修改調停者對象就能夠了，固然若是是已經作好的系統，那麼就擴展調停者對象，而各個同事類不須要作修改。

　　●　　多對多變成一對多

　　沒有使用調停者模式的時候，同事對象之間的關係一般是多對多的，引入調停者對象之後，調停者對象和同事對象的關係一般變成雙向的一對多，這會讓對象的關係更容易理解和實現。

調停者模式的缺點

　　調停者模式的一個潛在缺點是，過分集中化。若是同事對象的交互很是多，並且比較複雜，當這些複雜性所有集中到調停者的時候，會致使調停者對象變得十分複雜，並且難於管理和維護