java-設計模式-中介者模式

設計模式-中介者模式
    用一箇中介對象來封裝一些了的對象交互。各對象不需要顯示的相互引用。
    中介就是所有的調和者,符合最小知道原則，把交互功能幾種在中介者身上。
    優點：
        靈活性高，因爲將同事類進行了解耦，使其不必有關聯性；
        降低了類的複雜度，將一對多轉化成了一對一；
    缺點：
        過度集中化，這是中介者模式潛在的缺點。如果同事對象多了，交互也複雜了。
        那麼這些交互全部集中到中介者對象中，會導致中介者對象十分臃腫，難以管理和維護。
    典型例子：
        電腦主板（主線） 與 CPU、銀盤、內存等的交互。

來個類圖：

中介需要知道所有的同事，同事也需要知道中介，同事有什麼事情就告訴中介，中介會協調另外同事進行動作。

 

下面是一個 模擬現實買房的例子來舉例中介者模式：

1：先聲明個房地產中介的接口

這個中介接口中 定義了很多同事類還有很多動作

/**
 * 房地產中介 - 中介者
 * 中介就一個功能，溝通
 */
public abstract class RealtyMediator {
    //中介者都有同事者的信息
    //同事類 - 銀行
    protected BankColleague bankColleague;
    //同事類 - 買房者
    protected BuyerColleague buyerColleague;
    //同事類 - 業主
    protected OwnerColleague ownerColleague;




    /**
     * 想售樓
     */
    abstract void wantToSale();

    /**
     * 想買樓
     */
    abstract void wantToBuy();

    /**
     * 同意賣樓
     */
    abstract void agreeToSale();

    /**
     * 想要貸款
     */
    abstract void wantToBorrow();

    /**
     * 同意貸款
     */
    abstract void agreeToBorrow();

    //get and set

    public BankColleague getBankColleague() {
        return bankColleague;
    }

    public void setBankColleague(BankColleague bankColleague) {
        this.bankColleague = bankColleague;
    }

    public BuyerColleague getBuyerColleague() {
        return buyerColleague;
    }

    public void setBuyerColleague(BuyerColleague buyerColleague) {
        this.buyerColleague = buyerColleague;
    }

    public OwnerColleague getOwnerColleague() {
        return ownerColleague;
    }

    public void setOwnerColleague(OwnerColleague ownerColleague) {
        this.ownerColleague = ownerColleague;
    }

}

2：具體的中介 - 某鏈J中介公司

此類實現了幾個動作，比如 wantToSale（）想賣房方法是業主調用的，調用之後，是去通知買房的人的wantToBuy()方法

/**
 * 某鏈J房地產中介公司
 */
public class LjRealtyMediator extends RealtyMediator {

    @Override
    void wantToSale() {
        System.out.println("中介：有房源了，看看買房者想不想買");
        buyerColleague.wantToBuy();
    }

    @Override
    void wantToBuy() {
        System.out.println("中介：買房者想買了，再向業主確認下價格，看看賣不賣");
        ownerColleague.agreeToSale();
    }

    @Override
    void agreeToSale() {
        System.out.println("中介：業主同意賣方了，告訴買房者，讓他準備錢");
        buyerColleague.wantToBorrow();
    }

    @Override
    void wantToBorrow() {
        System.out.println("中介：買房者想貸款，我去和銀行說說");
        bankColleague.agreeToBorrow();
    }

    @Override
    void agreeToBorrow() {
        System.out.println("中介： 銀行同意貸款了，告訴買房者準備材料");
        buyerColleague.ready();
    }
}

3：同事類-接口

此接口就一個構造函數

/**
 * 中介者同事類
 */
public abstract class Colleague {
    protected RealtyMediator realtyMediator;
    Colleague(RealtyMediator realtyMediator){
        this.realtyMediator = realtyMediator;
    }

}

4：具體的同事類：

銀行同事類

有個同意貸款的方法，通知中介 銀行這邊已經同意貸款了

/**
 * 銀行 中介者模式同事類
 */
public class BankColleague extends Colleague {
    BankColleague(RealtyMediator realtyMediator) {
        super(realtyMediator);
        System.out.println("銀行 和 中介 一直都是合作方，他們很早就認識了");
        realtyMediator.setBankColleague(this);
    }

    /**
     * 同意貸款
     */
    public void agreeToBorrow(){
        System.out.println("銀行：同意貸款");
        realtyMediator.agreeToBorrow();
    }
}

業主同事類

有想賣房和同意賣房兩個動作，都要告訴中介，讓中介進行下一步

/**
 * 房屋出售的業主 - 中介者同事類
 */
public class OwnerColleague extends Colleague{
    OwnerColleague(RealtyMediator realtyMediator) {
        super(realtyMediator);
        System.out.println("業主 想賣房 ，認識了中介");
        realtyMediator.setOwnerColleague(this);
    }

    //業主的動作

    /**
     *  想售樓
     */
    public void wantToSale(){
        System.out.println("業主： 想要賣房");
        realtyMediator.wantToSale();
    }

    /**
     * 同意賣房
     */
    public void agreeToSale(){
        System.out.println("業主： 同意賣房");
        realtyMediator.agreeToSale();
    }

}

買房人的同事類

/**
 * 購買者 - 中介者模型同事類
 */
public class BuyerColleague extends Colleague {

    BuyerColleague(RealtyMediator realtyMediator) {
        super(realtyMediator);
        System.out.println("買房者:想買房 ，認識了中介");
        realtyMediator.setBuyerColleague(this);
    }

    /**
     * 想要買
     */
    public void wantToBuy(){
        System.out.println("買房者:想要買房");
        realtyMediator.wantToBuy();
    }

    /**
     * 想要貸款
     */
    public void wantToBorrow(){
        System.out.println("買房者:想要貸款");
        realtyMediator.wantToBorrow();
    }

    /**
     * 準備
     */
    public void ready(){
        System.out.println("買房者:材料正在準備中...");
    }
}

 

以上都聲明完了，接下來，就是緊張的測試了，看看怎麼用吧。

 public static void main(String[] args) {
        System.out.println("角色初始化...");
        //聲明一個房地產中介
        RealtyMediator realtyMediator = new LjRealtyMediator();
        //銀行
        Colleague bank = new BankColleague(realtyMediator);
        //買房者
        Colleague buyer = new BuyerColleague(realtyMediator);
        //業主 賣房者
        Colleague owner = new OwnerColleague(realtyMediator);
        System.out.println();
        System.out.println("------------故事要發生了---------------");
        System.out.println();
        //業主想賣房
        ((OwnerColleague) owner).wantToSale();
    }

運行結果：

角色初始化...
銀行 和 中介 一直都是合作方，他們很早就認識了
買房者:想買房 ，認識了中介
業主 想賣房 ，認識了中介

------------故事要發生了---------------

業主： 想要賣房
中介：有房源了，看看買房者想不想買
買房者:想要買房
中介：買房者想買了，再向業主確認下價格，看看賣不賣
業主： 同意賣房
中介：業主同意賣方了，告訴買房者，讓他準備錢
買房者:想要貸款
中介：買房者想貸款，我去和銀行說說
銀行：同意貸款
中介： 銀行同意貸款了，告訴買房者準備材料
買房者:材料正在準備中...

例子已經演示完了，通過這個例子，我們也可以看到，同事類，其實也是我們的業務類，他只負責他自己的業務，他知道有個中介在那裏，具體中介後面的操作，他也不關心，要他做的時候，中介自然會叫他做，

但是這個中介真的太辛苦了，太多事情要做了，如果他們的通訊種類再多幾個的話，中介就太臃腫了，這也是中介者模式的弊端。

設計模式是種思路，它不一定很完美，但它真的很美。