設計模式(8)-中介模式

定義

將多個對象之間的雜亂的調用關係,封裝進中介對象中,以減少對象之間的耦合.

---

示例

進銷存系統:
銷售員賣貨後庫存要減少.
銷售員從庫存獲取庫存量,發現不夠要通知採購購買.
採購員購買後庫存要增加.
採購員從銷售處獲得銷售報告,評分高足量採購,評分低半量採購.
倉儲員需要增加庫存,減少庫存.
倉儲員發現庫存積壓時,需要通知採購員不要再採購,通知銷售員儘快銷售.

---

傳統方式

public class Sale {
    //銷售要看是否有庫存,庫存不夠要通知採購購買
    public void sell(int number){
        Stock stock = new Stock();
        Purchase purchase = new Purchase();
        //如果庫存不足
        if(stock.getStock() < number){
            purchase.buy(number);
        }
        System.out.println("銷售賣出了"+number+"臺貨!!!");
        stock.decrease(number);
    }

    //儘快賣貨
    public void sellFast(){
        System.out.println("儘快賣貨!!!");
    }

    //反饋銷售情況
    public int report(){
        return new Random().nextInt(100);
    }
}

public class Purchase {
    public void buy(int number){
        Sale sale = new Sale();
        int report = sale.report();
        //銷售情況大於50分,情況良好,足量採購
        if(report>50){
            System.out.println("採購購買"+number+"臺貨!!!");
            Stock stock = new Stock();
            stock.increase(number);
        }else{//銷售情況<=50分,情況不好,半數採購
            System.out.println("採購購買"+number/2+"臺貨!!!");
            Stock stock = new Stock();
            stock.increase(number/2);
        }

    }

    public void dontBuy(){
        System.out.println("不要再購買了!!!");
    }
}

public class Stock {
    public static int STOCK_NUMBER=100;
    //增加庫存
    public void increase(int number){
        System.out.println("新增庫存"+number+"臺!!!");
        STOCK_NUMBER += number;
    }

    //減少庫存
    public void decrease(int number){
        System.out.println("減少庫存"+number+"臺!!!");
        STOCK_NUMBER -= number;
    }

    //獲得庫存數量
    public int getStock(){
        System.out.println("當前庫存爲"+STOCK_NUMBER+"臺!!!");
        return STOCK_NUMBER;
    }

    //庫存壓力大時,做清倉處理,通知採購不要再買,通知銷售儘快賣
    public void clear(){
        Purchase purchase = new Purchase();
        Sale sale  = new Sale();

        purchase.dontBuy();
        sale.sellFast();
    }
}

    public static void main(String[] args) {
        Sale sale = new Sale();
        sale.sell(120);
    }

輸出:

當前庫存爲100臺!!!
採購購買60臺貨!!!
新增庫存60臺!!!
銷售賣出了120臺貨!!!
減少庫存120臺!!!

各個類之間的耦合程度極高,隨着角色類的增多,關係將會變得越發複雜.

---

改造爲中介模式

---

1.抽象中介類

public abstract class AbstractMediator {
    protected Sale sale;
    protected Purchase purchase;
    protected Stock stock;

    //此處的this代表自己的子類實現
    public AbstractMediator(){
        this.sale = new Sale(this);
        this.purchase = new Purchase(this);
        this.stock = new Stock(this);
    }

    //最重要的方法,所有發生對象之間調用的方法都要在此處實現
    public abstract void execute(String str,Object... objects );
}

---

2.中介實現類

public class Mediator extends AbstractMediator{
    //所有需要對象之間相互調用的方法,在中介裏面實現
    @Override
    public void execute(String str, Object... objects) {
        if(str.equals("purchase.buy")){ //採購員購買
            this.buy((Integer)objects[0]);
        }else if(str.equals("sale.sell")){  //銷售員賣貨
            this.sell((Integer)objects[0]);
        }else if(str.equals("stock.clear")){    //倉儲員清倉
            this.clear();
        }
    }

    //購買
    public void buy(int number){
        int report = super.sale.report();
        //銷售情況大於50分,情況良好,足量採購
        if(report>50){
            System.out.println("採購購買"+number+"臺貨!!!");
            super.stock.increase(number);
        }else{//銷售情況<=50分,情況不好,半數採購
            System.out.println("採購購買"+number/2+"臺貨!!!");
            super.stock.increase(number/2);
        }
    }

    //銷售
    public void sell(int number){
        //如果庫存不足
        if(super.stock.getStock() < number){
            super.purchase.buy(number);
        }
        System.out.println("銷售賣出了"+number+"臺貨!!!");
        super.stock.decrease(number);
    }

    //清倉
    public void clear(){        
        super.purchase.dontBuy();
        super.sale.sellFast();
    }
}

---

3.抽象同事類

public abstract class AbstractColleague {
    protected AbstractMediator mediator;

    public AbstractColleague(AbstractMediator mediator){
        this.mediator = mediator;
    }
}

---

4.同事實現類

public class Sale extends AbstractColleague{
    public Sale(AbstractMediator mediator) {
        super(mediator);
    }

    //銷售要看是否有庫存,庫存不夠要通知採購購買
    public void sell(int number){
        super.mediator.execute("sale.sell", number);
    }

    //儘快賣貨
    public void sellFast(){
        System.out.println("儘快賣貨!!!");
    }

    //反饋銷售情況
    public int report(){
        return new Random().nextInt(100);
    }
}

public class Purchase extends AbstractColleague{
    public Purchase(AbstractMediator mediator) {
        super(mediator);
    }

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

    public void dontBuy(){
        System.out.println("不要再購買了!!!");
    }
}

public class Stock extends AbstractColleague{
    public Stock(AbstractMediator mediator) {
        super(mediator);
    }

    public static int STOCK_NUMBER=100;
    //增加庫存
    public void increase(int number){
        System.out.println("新增庫存"+number+"臺!!!");
        STOCK_NUMBER += number;
    }

    //減少庫存
    public void decrease(int number){
        System.out.println("減少庫存"+number+"臺!!!");
        STOCK_NUMBER -= number;
    }

    //獲得庫存數量
    public int getStock(){
        System.out.println("當前庫存爲"+STOCK_NUMBER+"臺!!!");
        return STOCK_NUMBER;
    }

    //庫存壓力大時,做清倉處理,通知採購不要再買,通知銷售儘快賣
    public void clear(){
        super.mediator.execute("stock.clear");
    }
}

---

5.運行

    public static void main(String[] args) {
        Sale sale = new Sale(new Mediator());
        sale.sell(120);
    }

輸出:

當前庫存爲100臺!!!
採購購買60臺貨!!!
新增庫存60臺!!!
銷售賣出了120臺貨!!!
減少庫存120臺!!!

---

總結

將對象之間的相互調用封裝進中介類,需要用時調用中介的execute方法.

中介模式亦有缺點,當耦合關係複雜時,中介會膨脹很快,所以需要根據實際情況定義多箇中介.

闡述中介模式時,諸如聊天室,飛機調度臺,網絡交換機的例子並不是十分準確,都不如進銷存更能說明問題.