Media模式

http://blog.csdn.net/liaoqianchuan00/article/details/8184712

http://www.cnblogs.com/java-my-life/archive/2012/06/20/2554024.html

http://sourcemaking.com/design_patterns/mediator/java/2

《JAVA與模式》之調停者模式

在閻宏博士的《JAVA與模式》一書中開頭是這樣描述調停者（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(); } }

運行結果如下：

調停者模式的優點

● 鬆散耦合

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

● 集中控制交互

多個同事對象的交互，被封裝在調停者對象裡面集中管理，使得這些交互行為發生變化的時候，只需要修改調停者對象就可以了，當然如果是已經做好的系統，那麼就擴展調停者對象，而各個同事類不需要做修改。

● 多對多變成一對多

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

調停者模式的缺點

調停者模式的一個潛在缺點是，過度集中化。如果同事對象的交互非常多，而且比較複雜，當這些複雜性全部集中到調停者的時候，會導致調停者對象變得十分複雜，而且難於管理和維護。

===================================================================================================================================

簡易版本

Mediator design pattern

Create an "intermediary" that decouples "senders" from "receivers"
Producers are coupled only to the Mediator
Consumers are coupled only to the Mediator
The Mediator arbitrates the storing and retrieving of messages

// 1. The "intermediary" class Mediator {   // 4. The Mediator arbitrates   private boolean slotFull = false;   private int number;   public synchronized void storeMessage( int num ) {     // no room for another message     while (slotFull == true) {       try {         wait();       }       catch (InterruptedException e ) { }     }     slotFull = true;     number = num;     notifyAll();   }   public synchronized int retrieveMessage() {     // no message to retrieve     while (slotFull == false)       try {         wait();       }       catch (InterruptedException e ) { }     slotFull = false;     notifyAll();     return number;   } }  class Producer extends Thread {   // 2. Producers are coupled only to the Mediator   private Mediator med;   private int    id;   private static int num = 1;   public Producer( Mediator m ) {     med = m;     id = num++;   }   public void run() {     int num;     while (true) {       med.storeMessage( num = (int)(Math.random()*100) );       System.out.print( "p" + id + "-" + num + "  " );     }   } }  class Consumer extends Thread {   // 3. Consumers are coupled only to the Mediator   private Mediator med;   private int    id;   private static int num = 1;   public Consumer( Mediator m ) {     med = m;     id = num++;   }   public void run() {     while (true) {       System.out.print("c" + id + "-" + med.retrieveMessage() + "  ");     }   } }  class MediatorDemo {   public static void main( String[] args ) {     Mediator mb = new Mediator();     new Producer( mb ).start();     new Producer( mb ).start();     new Consumer( mb ).start();     new Consumer( mb ).start();     new Consumer( mb ).start();     new Consumer( mb ).start();   } }