摘要：中介者模式的應用中介者模式的優點就是減少類間的依賴，將一對多的依賴變成一對一的依賴，降低耦合，符合迪米特法則。中介者模式適用于多個對象之間出現緊密聯系，類圖成網狀結構，使用中介者模式可以梳理為星型結構，有助于理解其關系。

由于最近瘋狂加班，博客都停更許久，難過~.~

用一個中介對象封裝一系列的對象交互，中介者使各對象不需要顯示地相互作用，從而使其耦合松散，而且可以獨立地改變他們之間的交互。

我們來模仿一個進銷存系統，主要有三個部分，銷售、庫存和進貨。

/**
 * 采購管理，主要負責是否采購糖果
 */
public class CandyPurchase {

    public void buyCandy(int number){
        CandySale candySale = new CandySale();
        CandyStock candyStock = new CandyStock();
        if (candySale.getSaleStauts()>6){
            candyStock.addStock(number);
            System.out.println("采購糖果"+number+"顆");
        }else {
            candyStock.addStock(number/2);
            System.out.println("采購糖果"+number/2+"顆");
        }
        System.out.println("庫存"+CandyStock.stockNum+"顆");
    }

    public void refuseBuyCandy(){
        System.out.println("拒絕進貨");
    }
}

/**
 * 銷售類：
 */
public class CandySale {

    public void saleCandy(int num){
        while (CandyStock.stockNum
//庫存
public class CandyStock {
    //庫存數量
    protected static int stockNum =1000;

    public synchronized void addStock(int num){
        stockNum+=num;
    }

    public synchronized void subtractStock(int num){
        stockNum-=num;
    }

    public void clearStock(){
        System.out.println("馬上年底了，清倉大甩賣了");
        CandyPurchase candyPurchase = new CandyPurchase();
        candyPurchase.refuseBuyCandy();

        CandySale candySale = new CandySale();
        candySale.discountSale();
    }
}
public class Client {
    public static void main(String[] args) {

        System.out.println("-----采購糖果-----");
        CandyPurchase candyPurchase = new CandyPurchase();
        candyPurchase.buyCandy(666);

        System.out.println("-----銷售糖果-----");
        CandySale candySale = new CandySale();
        candySale.saleCandy(20);
        System.out.println("-----清庫處理-----");
        CandyStock candyStock = new CandyStock();
        candyStock.clearStock();
    }
}
測試結果:
-----采購糖果-----
采購糖果666顆
庫存1666顆
-----銷售糖果-----
賣出20顆糖
-----清庫處理-----
馬上年底了，清倉大甩賣了
拒絕進貨
打折銷售糖果1646顆
結果和我們預期的一致，但我們這三者是彼此關聯的，每個類都與其他兩個類發生了關系（純潔點，不要想歪~,~）。迪米特法則認為每個類應只和朋友類交流，而且朋友類并非越多越好，朋友類越多，耦合性越大，修改一個就要從全局考量是否影響到了其他模塊，這不是面向對象設計所期望的。讓我們用中介者模式把其優化下吧,代碼如下：
public abstract class AbstractCandyMediator {
    protected CandyStock candyStock;
    protected CandySale candySale;
    protected CandyPurchase candyPurchase;

    public AbstractCandyMediator() {
        this.candyStock = new CandyStock(this);
        this.candySale = new CandySale(this);
        this.candyPurchase = new CandyPurchase(this);
    }

    public abstract void execute(String type,Object ...objects);

}

public class ConcreteCandyMediator extends AbstractCandyMediator{

    @Override
    public void execute(String type, Object... objects) {
        if (type.equals("buyCandy")){
            this.buyCandy((Integer) objects[0]);
        }else if (type.equals("saleCandy")){
            this.saleCandy((Integer) objects[0]);
        }else {
            this.clearStock();
        }
    }

    private void buyCandy(int num) {
        if (super.candySale.getSaleStauts()>6){
            super.candyStock.addStock(num);
            System.out.println("采購糖果"+ num+"顆");
        }else {
            super.candyStock.addStock(num/2);
            System.out.println("采購糖果"+num /2+"顆");
        }
        System.out.println("庫存"+CandyStock.stockNum+"顆");
    }

    public void saleCandy(int num){
        while (CandyStock.stockNum
public abstract class AbstractColleague {
    public AbstractCandyMediator mediator;

    public AbstractColleague(AbstractCandyMediator mediator) {
        this.mediator = mediator;
    }
}
public class CandyPurchase extends AbstractColleague {

    public CandyPurchase(AbstractCandyMediator abstractCandyMediator) {
        super(abstractCandyMediator);

    }

    public void buyCandy(int number){
        super.mediator.execute("buyCandy",number);
    }

    public void refuseBuyCandy(){
        System.out.println("拒絕進貨");
    }
}
public class CandySale extends AbstractColleague {

    public CandySale(AbstractCandyMediator abstractCandyMediator) {
        super(abstractCandyMediator);

    }

    public void saleCandy(int num){
        super.mediator.execute("saleCandy",num);
    }

    //打折銷售
    public void discountSale(){
        System.out.println("打折銷售糖果"+CandyStock.stockNum+"顆");
    }

    //獲得最近的銷售狀態，0-10，越大越好賣
    public int getSaleStauts(){
        Random random = new Random();
        return random.nextInt(10);
    }
}
public class CandyStock extends AbstractColleague{
    //庫存數量
    protected static int stockNum =1000;

    public CandyStock(AbstractCandyMediator abstractCandyMediator) {
        super(abstractCandyMediator);

    }

    public synchronized void addStock(int num){
        stockNum+=num;
    }

    public synchronized void subtractStock(int num){
        stockNum-=num;
    }

    public void clearStock(){
        super.mediator.execute("123");

    }
}
public class Client {

    public static void main(String[] args) {

        AbstractCandyMediator mediator = new ConcreteCandyMediator();
        CandyPurchase candyPurchase = new CandyPurchase(mediator);
        candyPurchase.buyCandy(666);
        CandySale candySale = new CandySale(mediator);
        candySale.saleCandy(20);
        CandyStock candyStock = new CandyStock(mediator);
        candyStock.clearStock();
    }
}
經過改造，我們發現每個類都只與中介者是朋友類，耦合降低，每個類只處理自己的職責，和其他類有關的統統交給中介者。
中介者模式的應用
中介者模式的優點就是減少類間的依賴，將一對多的依賴變成一對一的依賴，降低耦合，符合迪米特法則。缺點就是中介者會變得異常龐大，邏輯復雜，同事類越多，中介者的邏輯就越復雜。中介者模式適用于多個對象之間出現緊密聯系，類圖成網狀結構，使用中介者模式可以梳理為星型結構，有助于理解其關系。