java設計模式之中介者模式

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

二、代碼實現

/**
 * 抽象中介者
 */
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 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(int 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+ "臺");
            super.stock.increase(buyNumber);
        }
    }
    //銷售電腦
    private void sellComputer(int number){
        if(super.stock.getStockNumber()<number){ //庫存數量不夠銷售
            super.purchase.buyIBMcomputer(number);
        }
        super.stock.decrease(number);
    }
    //折價銷售電腦
    private void offSell(){
        System.out.println("折價銷售IBM電腦"+super.stock.getStockNumber()+"臺");
    }
    //清倉處理
    private void clearStock(){
        //要求清倉銷售
        super.sale.offSale();
        //要求採購人員不要採購
        super.purchase.refuseBuyIBM();
    }
    
}

 

/**
 * 抽象同事類
 */
public abstract class AbstractColleague {

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

 

/**
 * 採購管理
 * Purchase類處理本身的職責， 與外界有關係的事件處理則交給了中介者來完成
 */
public class Purchase extends AbstractColleague {

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

 

/**
 * 銷售管理
 */
public class Sale extends AbstractColleague {

    public Sale(AbstractMediator _mediator) {
        super(_mediator);
    }
    //銷售ibm電腦
    public void sellIBMComputer(int number){
        super.mediator.execute("sale.sell", number);
        System.out.println("銷售IBM電腦"+number+"臺");
    }
    //反饋銷售狀況， 0～100之間變化， 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);
    }
    //剛開始有100臺電腦
    private static int COMPUTER_NUMBER = 100;
    
    //庫存增長
    public void increase(int number) {
        COMPUTER_NUMBER = COMPUTER_NUMBER + number;
        System.out.println("庫存數量爲：" + COMPUTER_NUMBER);
    }
    //庫存減小
    public void decrease(int number) {
        COMPUTER_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 Client {

    public static void main(String[] args) {
        AbstractMediator mediator = new Mediator();
        //採購人員採購電腦
        System.out.println("------採購人員採購電腦--------");
        mediator.purchase.buyIBMcomputer(100);
        //銷售人員銷售電腦
        System.out.println("\n------銷售人員銷售電腦--------");
        mediator.sale.sellIBMComputer(1);
        //庫房管理人員管理庫存
        System.out.println("\n------庫房管理人員清庫處理--------");
        mediator.stock.clearStock();
    }
}

多個對象相互依賴的狀況下，經過增長中介者，每一個對象只處理本身的行爲，與本身無關的丟給中介者處理，下降對象的耦合性，提示代碼質量。

三、主要由3部分組成：
抽象中介者：抽象中介者角色定義統一的接口，用於各同事角色之間的通訊。
具體中介者：具體中介者角色經過協調各同事角色實現協做行爲，所以它必須依賴於各個同事角色。
同事角色：每個同事角色都知道中介者角色，並且與其餘的同事角色通訊的時候，必定要經過中介者角色協做。
同事類必須有中介者，而中介者卻能夠只有部分同事類。
四、優勢
減小類間的依賴， 把原有的一對多的依賴變成了一對一的依賴，同事類只依賴中介者，減小了依賴，固然同時也下降了類間的耦合。
五、缺點
中介者會膨脹得很大，並且邏輯複雜，本來N個對象直接的相互依賴關係轉換爲中介者和同事類的依賴關係，同事類越多，中介者的邏輯就越複雜。
六、使用場景
中介者模式適
用於多個對象之間緊密耦合的狀況，緊密耦合的標準是：在類圖中出現了蜘蛛網狀結構。在這種狀況下必定要考慮使用中介者模式，這有利於把蜘蛛網梳理爲星型結構，使本來複雜混
亂的關係變得清晰簡單。