設計模式之中介者模式

前言

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

中介者模式定義

用一箇中介對象封裝一系列的對象交互，中介者使各對象不須要顯示地相互做用，從而使其耦合鬆散，並且能夠獨立地改變他們之間的交互。

uml類圖

代碼分析

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

/**
 * 採購管理，主要負責是否採購糖果
 */
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<num){
            CandyPurchase candyPurchase = new CandyPurchase();
            candyPurchase.buyCandy(100);
            System.out.println("庫存數量不夠，已購100顆糖 ");
        }
        CandyStock candyStock = new CandyStock();
        candyStock.subtractStock(num);
        System.out.println("賣出"+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 {
    //庫存數量
    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<num){
            buyCandy(100);
            System.out.println("庫存數量不夠，已購100顆糖 ");
        }
        super.candyStock.subtractStock(num);
        System.out.println("賣出"+num+"顆糖");
    }

    public void clearStock(){
        System.out.println("立刻年末了，清倉大甩賣了");
        super.candyPurchase.refuseBuyCandy();
        super.candySale.discountSale();
    }

}

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();
    }
}

通過改造，咱們發現每一個類都只與中介者是朋友類，耦合下降，每一個類只處理本身的職責，和其餘類有關的通通交給中介者。

中介者模式的應用

中介者模式的優勢就是減小類間的依賴，將一對多的依賴變成一對一的依賴，下降耦合，符合迪米特法則。缺點就是中介者會變得異常龐大，邏輯複雜，同事類越多，中介者的邏輯就越複雜。中介者模式適用於多個對象之間出現緊密聯繫，類圖成網狀結構，使用中介者模式能夠梳理爲星型結構，有助於理解其關係。