**定義**:用一個中介對象封裝一系列的對象交互，中介者使各對象不需要顯示地相互交互，從而使其耦合松散，而且可以獨立地改變他們之間的交互。 中介者就是將蜘蛛網狀的用戶關系模型改變成星形的用戶關系模型。 ## 中介者的通用模型  **Mediator抽象中介者角色** --|抽象中介者角色定義統一的接口，用于各同事角色直接的通信。 **Concrete Mediator 具體中介者角色** --|具體中介者角色通過協調各同事角色實現協作行為，因此必須依賴于各個同事角色。 **Colleague 同事角色** --|每個同事角色都知道中介者角色，而且與其他同事角色通信時，一定要通過中介者角色協。 同事類行為分為兩種： --|自發行為（self-Method）：一種同事本身的行為，例如改變對象本身的狀態，處理自己的行為等。與其他同事類或中介者沒有任何。 --|依賴方法(Dep-Method)：必須依賴中介者才能完成的行為。 ~~~ public class MediatorTest { public static void main(String[] args) { //創建出中介者，并執行邏輯操作。 Mediator mediator = new ConcreteMediator(); mediator.setC1(new Colleague1(mediator)); mediator.setC2(new Colleague2(mediator)); mediator.doSomething1(); } } abstract class Mediator{ //定義同事類 protected Colleague1 c1; protected Colleague2 c2; public Colleague1 getC1() { return c1; } public void setC1(Colleague1 c1) { this.c1 = c1; } public Colleague2 getC2() { return c2; } public void setC2(Colleague2 c2) { this.c2 = c2; } //中介者需要去完成的方法。 public abstract void doSomething1(); public abstract void doSomething2(); } class ConcreteMediator extends Mediator{ @Override public void doSomething1() { //調用同事類的方法，只要是public的方法都可以調用。 super.c1.depMethod(); super.c2.depMethod(); } @Override public void doSomething2() { super.c1.selfMethod(); super.c2.selfMethod(); } } abstract class Colleague{ //同事類需要與其他同事類進行交互的，就交給中介者來處理。 protected Mediator mediator; public Colleague(Mediator mediator) { this.mediator = mediator; } } class Colleague1 extends Colleague{ //通過構造函數，傳遞中介者。 public Colleague1(Mediator mediator) { super(mediator); } public void selfMethod(){ System.out.println("colleague1 所特有的方法..."); } public void depMethod(){ System.out.println("colleague1 需要中介者完成的方法..."); } } class Colleague2 extends Colleague{ //通過構造函數，傳遞中介者。 public Colleague2(Mediator mediator) { super(mediator); } public void selfMethod(){ System.out.println("colleague2 所特有的方法..."); } public void depMethod(){ System.out.println("colleague2 需要中介者完成的方法..."); } } ~~~ ## 一個例子: 一個公司有采購部門、銷售部門、存貨部門。他們之間存在著緊密的聯系。 采購部門(Purchase)：根據銷售情況、庫存情況，負責采購不同的產品。 ??? --|void buyIBMComputer(int number) ??? --|void refuseBuyIBM(); 銷售部門(sale)：銷售部門要反饋銷售情況，暢銷就多采購，滯銷就不采購。 ?? --|void sellIBMComputer(int number); ?? --|int getSaleStatus(); ?? --|void offSale(); 存貨部門(Stock)：根據銷售情況，已經自身庫存的數量，決定是否需要采購。 ?? --|void increase(int number) ?? --|void decrease(int number) ?? --|int getStockNumber() ?? --|void clearStock(); **中介者模式的優點：** 減少類間的依賴，把原有的一堆多的依賴變成了一對一的依賴，同事類只依賴中介者，減少了依賴。同時降低了類間的耦合。  ~~~ public class MediatorT { public static void main(String[] args) { //創建中介者 AbstractMediator mediator = new ComMediator(); //銷售者進行銷售,100臺電腦 Sale sale = new Sale(mediator); sale.sellIBMComputer(100); //獲取庫存狀態 Stock stock = new Stock(mediator); System.out.println("庫存狀態.."+stock.getStock()); //采購者進行采購 Purchase purchase = new Purchase(mediator); purchase.buyIBMComputer(1000); //獲取庫存狀態 System.out.println("庫存狀態.."+stock.getStock()); } } //抽象中介者類，用于將 abstract class AbstractMediator{ //庫存部門 protected Stock stock = null; //銷售部門 protected Sale sale = null; //采購部門。 protected Purchase purchase = null; public AbstractMediator() { this.sale = new Sale(this); this.purchase = new Purchase(this); this.stock = new Stock(this); } //定義一個中介者執行方法。共子類實現 public abstract void execute(String type,Object ...objects); } class ComMediator extends AbstractMediator{ @Override public void execute(String type, Object... objects) { //采購電腦，銷售電腦，折價銷售電腦，清倉處理 if(type.equalsIgnoreCase("purchase.buy")){ this.buyIBMComputer((Integer)objects[0]); }else if(type.equalsIgnoreCase("sale.sell")){ saleComputer((Integer)objects[0]); }else if(type.equalsIgnoreCase("sale.offSale")){ offSell(); }else if(type.equalsIgnoreCase("stock.clear")){ clearStock(); } } //清空倉庫 private void clearStock(){ //清空倉庫中的所有電腦。 super.stock.clearStock(); } //購買電腦 private void buyIBMComputer(int number){ //首先獲取銷售類，如果銷售狀態>80，就可以進行采購 int saleStatus = super.sale.getSaleStatus(); if(saleStatus > 80){ super.purchase.buyIBMComputer(number); //購買完成后，庫存增加一定的電腦 super.stock.increase(number); }else{ //效益不好，折半采購 int buyNumber = number / 2; System.out.println("采購IBM電腦："+buyNumber+"臺."); super.stock.increase(buyNumber); } } //銷售電腦 private void saleComputer(int number){ //檢查庫存量 if(super.stock.getStock()<number){ //庫存量不足，通知采購電腦 super.purchase.buyIBMComputer(number); } //將庫存減去相應的電腦數 super.stock.decrease(number); } //折半銷售電腦 private void offSell(){ System.out.println("折半銷售電腦："+super.stock.getStock()+"臺"); } } abstract class AbstractColleague{ //抽象的同事類，使得通過構造函數將中介者實例化 protected AbstractMediator abstractMediator; public AbstractColleague(AbstractMediator abstractMediator){ this.abstractMediator = abstractMediator; } } //庫存部門 class Stock extends AbstractColleague{ //庫存默認有10臺電腦。 private static int COMPUTER_NUMBER = 100; public Stock(AbstractMediator abstractMediator) { super(abstractMediator); } //增加庫存 public void increase(int number){ COMPUTER_NUMBER += number; } //獲得庫存量 public int getStock(){ return COMPUTER_NUMBER; } //減少庫存 public void decrease(int number){ COMPUTER_NUMBER -= number; } //清空庫存 public void clearStock(){ System.out.println("清空了倉庫里的"+COMPUTER_NUMBER+"臺電腦..."); COMPUTER_NUMBER = 0; } } //銷售部門 class Sale extends AbstractColleague{ public Sale(AbstractMediator abstractMediator) { super(abstractMediator); } //購買電腦 public void sellIBMComputer(int number){ //通知中介者銷售產品 super.abstractMediator.execute("sale.sell", number); System.out.println("銷售了"+number+"臺電腦。"); } //獲取銷售狀態 public int getSaleStatus(){ //隨機生成一個數字，表示銷售狀態 Random random = new Random(); int saleStatus = random.nextInt(100); return saleStatus; } //打折銷售 public void offSale(){ //通知中介者打折銷售 super.abstractMediator.execute("sale.offSale"); } } //采購部門 class Purchase extends AbstractColleague{ public Purchase(AbstractMediator abstractMediator) { super(abstractMediator); } //購買電腦。屬于同事類的自身方法。無需借助Mediator。 public void buyIBMComputer(int number){ //通知中介者，購買number臺電腦。 super.abstractMediator.execute("purchase.buy", number); } //拒絕購買電腦 public void refuseBuyIBM(){ System.out.println("拒絕購買電腦..."); } } ~~~