設計模式_中介者模式

定義

Define an object that encapsulates how a set of objects interact.  Mediator promptes loose coupling by keeping objects from referring to each other explicitly,and it lets you vary their interaction independently.(用一箇中介對象封裝一系列的對象交互，中介者使各對象不需要顯示地相互作用，從而使其耦合鬆散，而且可以獨立地改變它們之間的交互) 

不認識的單詞

encapsulates: 總結；扼要概括；囊括

a set of :一系列

interact:相互作用；互相影響；互動

loose: 鬆的，寬的；模糊的；散漫的；自由的

coupling: 耦合

referring :提到( refer的現在分詞 )；針對；關係到；請教

explicitly:明白地，明確地

vary:變化；不同，偏離；[生]變異

舉例

例如下面的圖

採購管理，銷售管理，存貨管理.....多個模塊之間有交流，如果需要維護修改什麼的，誰願意去當那個程序猿？   

根據網絡拓撲結構，有三種類型，總線型，環形，星型。 

根據這個設計出如下

類圖 

分析類圖:三個子模塊繼承AbstractColleague，Mediator繼承AbstractMediator，其父類有三個子模塊的實例，還有一個統一處理的execute方法()，完成特定的任務，需要三個子模塊中獨立的方法。 

public abstract class AbstractColleague {
 
 protected AbstractMediator mediator; //爲何是protected:只對子類公開
 
 public AbstractColleague(AbstractMediator mediator){
  this.mediator=mediator;
 }
}

public abstract class AbstractMediator {
 protected Purchase purchase;
 protected Sale sale;
 protected Stock stock;
 
 public AbstractMediator(){
  purchase=new Purchase(this);
  sale=new Sale(this);
  stock=new Stock(this);
 }
 public abstract void execute(String str,Object...objects);
}

三個同事，各做各的事

public class Purchase extends AbstractColleague {
 public Purchase(AbstractMediator mediator) {
  super(mediator);
 }
 
 public void buyIBMcomputer(int number){
  super.mediator.execute("purchase.buy",number);
 }
 public void refuseBuyIBM(){
  System.out.println("不再採購IBM電腦");
 }
}

public class Sale extends AbstractColleague {
 public Sale(AbstractMediator mediator) {
  super(mediator);
 }
 
 public void sellIBMComputer(int number){
  super.mediator.execute("sale.sell",number);
  System.out.println("銷售電腦:"+number+"臺");
 }
 
 //反饋，0~100變化
 public int getSaleStatus(){
  Random rand=new Random(System.currentTimeMillis());
  int saleStatus=rand.nextInt(100);
  System.out.println("IBM電腦的銷售情況爲:"+saleStatus);
  return saleStatus;
 }
 public void offSale(){
  super.mediator.execute("sale.offsell");
 }
}

public class Stock extends AbstractColleague {
 public Stock(AbstractMediator mediator) {
  super(mediator);
 }
 
 private static int COMPUTER_NUMBER=100;
 
 public void increase(int number){
  COMPUTER_NUMBER+=number;
  System.out.println("庫存數量:"+COMPUTER_NUMBER);
 }
 public void decrease(int number){
  COMPUTER_NUMBER-=number;
  System.out.println("庫存數量:"+COMPUTER_NUMBER);
 }
 public int getStockNumber(){
  return COMPUTER_NUMBER;
 }
 public void clearStock(){
  System.out.println("清理存貨數量:"+COMPUTER_NUMBER);
  super.mediator.execute("stock.clear");
 }
}

中介者，處理複雜的業務，調用三個同事中一個或多個方法。

public class Mediator extends AbstractMediator {
 @Override
 public void execute(String str, Object... objects) {
  if(str.equals("purchase.buy")){           //採購電腦
   this.buyComputer((Integer)objects[0]);
  }else if(str.equals("sale.sell")){       //銷售電腦
   this.sellComputer((Integer)objects[0]);
  }else if(str.equals("sale.offsell")){  //折價銷售
   this.offSell();
  }else if(str.equals("stock.clear")){  //清倉處理
   this.clearStock();
  }
 }
 private void buyComputer(Integer number) {
  int saleStatus=super.sale.getSaleStatus();
  if(saleStatus>80){	 //銷售狀態好
   System.out.println("採購IBM電腦:"+number+"臺");
   super.stock.increase(number);
  }else{	 //銷售狀態不好
   int buyNumber=number/2;
   System.out.println("採購IBM電腦:"+buyNumber+"臺");
  }
 }
 private void sellComputer(Integer number) {
  if(super.stock.getStockNumber()<number){ //庫存不足不夠銷售
   super.purchase.buyIBMcomputer(number);
  }
  super.stock.decrease(number);
 }
 //折價銷售
 private void offSell() {
  System.out.println("折價銷售IBM電腦"+stock.getStockNumber()+"臺");
 }
 //清倉處理
 private void clearStock() {
  super.sale.offSale();
  super.purchase.refuseBuyIBM();
 }
}

測試

public static void main(String[] args) {
  AbstractMediator mediator=new Mediator();   //一箇中介者
  System.out.println("------------採購人員採購電腦--------------");
  Purchase purchase=new Purchase(mediator);  //查看其抽象類的構造方法就知道
  purchase.buyIBMcomputer(100);
  System.out.println("-------------銷售人員銷售電腦-------------");
  Sale sale=new Sale(mediator);
  sale.sellIBMComputer(1);
  System.out.println("------------庫房管理人員清庫處理--------------");
  Stock stock=new Stock(mediator);
  stock.clearStock();
 }

說明 

 public abstract void execute(String str,Object...objects);  可變參數數組,具體可訪問 http://blog.csdn.net/testcs_dn/article/details/38920323

悟:多個模塊之間有耦合，需要交流時，業務寫的很雜很亂，這時候需要一箇中介來管理麻煩事。

通用寫法

public abstract class Mediator {
//定義同事類
protected ConcreteColleague1 c1;
protected ConcreteColleague2 c2;
//通過getter/setter方法把同事類注入進來
public ConcreteColleague1 getC1() {
return c1;
}
public void setC1(ConcreteColleague1 c1) {
this.c1 = c1;
}
public ConcreteColleague2 getC2() {
return c2;
}
public void setC2(ConcreteColleague2 c2) {
this.c2 = c2;
}
//中介者模式的業務邏輯
public abstract void doSomething1();
public abstract void doSomething2();
}

public abstract class Colleague {
protected Mediator mediator;
public Colleague(Mediator _mediator){
this.mediator = _mediator;
}
}

public class ConcreteMediator extends Mediator {
@Override
public void doSomething1() {
//調用同事類的方法，只要是public方法都可以調用
super.c1.selfMethod1();
super.c2.selfMethod2();
}
public void doSomething2() {
super.c1.selfMethod1();
super.c2.selfMethod2();
}
}

public class ConcreteColleague1 extends Colleague {
//通過構造函數傳遞中介者
public ConcreteColleague1(Mediator _mediator){
super(_mediator);
}
//自有方法 self-method
public void selfMethod1(){
//處理自己的業務邏輯
}
//依賴方法 dep-method
public void depMethod1(){
//處理自己的業務邏輯
//自己不能處理的業務邏輯，委託給中介者處理
super.mediator.doSomething1();
}
}

各個同事單一的任務，各幹各的事，而中介者ConcreteMediator 這個項目經理需要調動各部分完成一件事。

優點

    降低了耦合，減少了依賴

缺點

    同事類越多，越複雜，適合小系統

使用場景

    在類圖中出現了蜘蛛網網狀結構

實際應用舉例

    機場調度中心

    MVC框架:　Ｃ(Controller) 就是一箇中介者，前端控制器，就是把M(Model，業務邏輯)和V(Viw,視圖)隔離開 

    中介服務 

同事 ：  abstract  

兄弟 ：  interface

這個比喻有點逗

我是菜鳥，我在路上。