本文是設計模式學習筆記的第三篇文章，主要分析的是中介者模式。是清華大學出版社的《研讀設計模式》的讀書筆記。在此感謝原作者。

這次應用的是一個例項去理解中介者模式。

先來看這樣一個例項，電腦播放電影。

我們需要一個DVD，然後放入播放器中，播放器獲得資料傳遞給CPU處理在將資料傳給顯示卡和音效卡，迴圈這個流程。簡單麼？

實際上，如果沒有主機板，各部件要自行互動的話是非常複雜的，而且各個配件的介面不同，還要進行轉化才能匹配，這是多麼煩躁的事情。

所以，我們的電腦上會有主機板，每個配件只需要做自己的本職工作就好，做好的東西給主機板，需要的東西從主機板拿。主機板就是一箇中介者。

在軟體開發上，其實就是解耦

讓我們看看應用中介者模式模擬的電腦播放電影的過程。體驗下中介者所幹的事情。

先準備好CD，在工程下建立一個a.txt檔案，內容如下：

READY?GO!,碾碎他們
~\(≧▽≦)/~,啦啦啦德瑪西亞
~\(≧▽≦)/~~\(≧▽≦)/~,啦啦啦啦德瑪西亞
~\(≧▽≦)/~~\(≧▽≦)/~~\(≧▽≦)/~,德瑪德瑪德瑪西亞
  ╭︿︿︿╮     ,{/ o  o /}
 ( (oo) )  , ︶ ︶︶    
>>>>FIRST BLOOD<<<<,FIRST BLOOD

首先是CD類：

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class CD {

	//設定cd
	private String filePath = null;
	
	private File myFile = null;
	
	public File getFile(){
		return myFile;
	}
	
	public CD(String filePath){
		this.filePath = filePath;
		myFile = new File(filePath);
	}
	
}
 

然後是中介者介面：

public interface Mediator {

	/**
	 * 同時物件在自身改變的時候來通知中介者的方法
	 * 讓中介者去負責相應的與其他同時物件的互動
	 * @param colleague 同時物件自身，好讓中介者物件通過物件例項
	 *                  去獲取同時物件的狀態
	 */
	public void changed(Colleague colleague);
}

然後是實現中介者介面的主機板類：

public class MotherBoard implements Mediator{

	private CDDriver cdDriver = null;
	
	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;
	}
	
	public void changed(Colleague colleague){
		if(colleague == cdDriver){
			//表示光碟機讀取資料了
			this.opeCDDriverReadData((CDDriver)colleague);
		}else if (colleague == cpu) {
			//表示CPU處理完了
			this.opeCPU((CPU)colleague);
		}
	}
	
	/**
	 * 處理光碟機讀取資料後與其他物件的互動
	 * @param cdDriver 光碟機物件
	 */
	public void opeCDDriverReadData(CDDriver cdDriver){
		//1：先獲取光碟機讀取的資料
		String data = cdDriver.getData();
		//2：把這些資料傳遞給CPU進行處理
		this.cpu.executeData(data);
	}
	
	public void opeCPU(CPU cpu){
		//獲取CPU處理後的資料
		String videoData = cpu.getVideoData();
		String soundData = cpu.getSoundData();
		//把這些資料傳遞給顯示卡和音效卡
		this.videoCard.showData(videoData);
		this.soundCard.soundData(soundData);
	}

}

然後是同事（部件）的父類（抽象類）：

public abstract class Colleague {

	private Mediator mediator;
	
	public Colleague(Mediator mediator){
		this.mediator = mediator;
	}
	
	public  Mediator getMediator() {
		return mediator;
	}
}

然後是部件CDDriver類：

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * 光碟機類，一個同事類
 * 
 * @author qian.xu
 * 
 */
public class CDDriver extends Colleague {

	public CDDriver(Mediator mediator) {
		super(mediator);
		// TODO Auto-generated constructor stub
	}

	/**
	 * 光碟機讀出來的資料
	 */
	private String data = "";

	/**
	 * 光碟機讀取出來的資料
	 * 
	 * @return 光碟機讀取出來的資料
	 */
	public String getData() {
		return this.data;
	}

	/**
	 * 讀取光碟機
	 */
	public void readCD(CD cd) {

		try {

			File file = cd.getFile();
			FileReader reader = new FileReader(file);
			BufferedReader br = new BufferedReader(reader);
			while ((data = br.readLine()) != null) {
				this.getMediator().changed(this);
				Thread.sleep(3000);
			}

			br.close();
			reader.close();

		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

然後是部件CPU類：

/**
 * COU，一個同事類
 * @author qian.xu
 *
 */
public class CPU extends Colleague{

	public CPU(Mediator mediator) {
		super(mediator);
		// TODO Auto-generated constructor stub
	}

	/**
	 * 分解出來的視訊資料
	 */
	private String videoData = "";
	/**
	 * 分解出來的音訊資料
	 */
	private String soundData = "";
	
	/**
	 * 獲取分解出來的視訊資料
	 * @return 分解出來的視訊資料
	 */
	public String getVideoData(){
		return videoData;
	}
	
	/**
	 * 獲取分解出來的音訊資料
	 * @return 分解出來的音訊資料
	 */
	public String getSoundData(){
		return soundData;
	}
	
	public void executeData(String data){
		//處理資料，分解視訊流和音訊流
		String[] ss = data.split(",");
		this.videoData = ss[0];
		this.soundData = ss[1];
		//通知主機板，CPU工作完成
		this.getMediator().changed(this);
	}
}

然後是部件顯示卡類：

/**
 * 顯示卡類，一個同事類
 * @author qian.xu
 *
 */
public class VideoCard extends Colleague{

	public VideoCard(Mediator mediator) {
		super(mediator);
		// TODO Auto-generated constructor stub
	}
	
	
	/**
	 * 顯示視訊資料
	 * @param data 被顯示的資料
	 */
	public void showData(String data){
		System.out.println("視訊流："+data);
	}
}

最後是部件音效卡類：

public class SoundCard extends Colleague{

	public SoundCard(Mediator mediator) {
		super(mediator);
		// TODO Auto-generated constructor stub
	}
	
	
	/**
	 * 音效卡工作
	 * @param data 要發出的聲音
	 */
	public void soundData(String data){
		System.out.println("音訊流:"+data);
	}

}

終於完事了，讓我們開啟播放器開電影吧，下面是測試類：

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//創造主機板
		MotherBoard mediator = new MotherBoard();
		//建立各部件
		CD cd = new CD("a.txt");
		CDDriver cdDriver = new CDDriver(mediator);
		CPU cpu = new CPU(mediator);
		VideoCard videoCard = new VideoCard(mediator);
		SoundCard soundCard = new SoundCard(mediator);
		
		//組裝各部件到主機板上	
		mediator.setCdDriver(cdDriver);
		mediator.setCpu(cpu);
		mediator.setVideoCard(videoCard);
		mediator.setSoundCard(soundCard);
		//將CD放入播放器中
		cdDriver.readCD(cd);

	}

輸出結果（為了模仿的更像，加入了執行緒睡眠，有了延遲輸出的效果，所有建議將程式跑起來看下）：

視訊流：READY?GO!
音訊流:碾碎他們
視訊流：~\(≧▽≦)/~
音訊流:啦啦啦德瑪西亞
視訊流：~\(≧▽≦)/~~\(≧▽≦)/~
音訊流:啦啦啦啦德瑪西亞
視訊流：~\(≧▽≦)/~~\(≧▽≦)/~~\(≧▽≦)/~
音訊流:德瑪德瑪德瑪西亞
視訊流：  ╭︿︿︿╮     
音訊流:    {/ o  o /}
視訊流：     ( (oo) )  
音訊流:     ︶ ︶︶    
視訊流：>>>>FIRST BLOOD<<<<
音訊流:FIRST BLOOD

中介者的本質

中介者的本質是封裝互動。中介者的目的，就是用來封裝多個物件的互動，這些互動的處理多在中介者物件裡面實現。因此中介物件的複雜程度，取決於他封裝的互動的複雜程度。

何時選用中介者模式

建議在以下情況時選用中介者模式。

★  如果一組物件之間的通訊方式比較複雜，導致相互依賴、結構混亂。可以採用中介者模式，把這些物件的互動管理起來，各個物件都只需要和中介者互動，從而使得各個物件鬆散耦合，結構也更清晰易懂。

★ 如果一個物件引用很多的物件，並直接跟這些對些物件互動，導致難以複用該物件，可以採用中介者模式，把這個物件跟其他物件的互動封裝到中介者物件裡邊，這個物件只需要和中介者物件互動就好了。

中介者模式的不足

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

廣義中介者

在應用開發中，經常會簡化中介者模式，來使開發變得簡單，比如：

★通常會去掉同事物件的父類，這樣可以讓任意的物件，只需要相互互動，就可以成為同事。

★通常不定義Mediator介面，把具體的中介者物件實現為單例。

★同事物件不再持有中介者，而是在需要的時候直接獲取中介者物件並呼叫，對應的，中介者也不再持有物件同事，而是在具體的處理方法裡去建立，或者讀取。