「補課」進行時：設計模式(7)——租房子中的中介者模式

1. 前文匯總

「補課」進行時：設計模式系列

2. 租房子

國內某知名大學著名畢業生隔壁老王同學在近日畢業了，好不容易在大魔都找到一份工作，接下來就需要做另一件大事兒了，租房子。

租過房子的同學應該都知道，最方便最快捷的方式就是找房租中介，如果不找中介的話，就需要自己去聯系一個一個的房東，去約看每一間的房子。

如果恰巧這些房東之間有聯系，都在出租房屋，當客戶 A 看了一號房東的房子，感覺不滿意，一號房東推薦它可以去看看其他幾個房東的房子，這時候，這個房東就需要聯系他的其他幾個房東朋友。

如果這些房東中間恰好有一個人把房子租出來，他就需要自己通知所有的朋友，他的房子租掉了（狀態變了）。

這里就造成了一個問題，當其中一個人發生了變化，需要告訴其他幾個人，牽一發而動全身。

這種情況下，如果能加入一個中介，將會大大的改善這種情況。

這時，如果一個人的狀態變化了，只需要通知中介就行，有任何問題直接找中介進行處理，不再會有剛才的牽一發而動全身的情況出現。

接下來看下示例代碼：

2.1 抽象中介類

public abstract class Mediator {
    public abstract void Common(String type);
}

這里定義了一個同事類之間交互方法。

2.2 抽象房東類

public abstract class Colleague {
    public abstract void showHouse();
}

這里定義一個抽象方法，抽象每個房東都需要做的事情（展示自己的房屋）。

2.3 具體房東類

public class SmallHouseColleague extends Colleague {
    @Override
    public void showHouse() {
        System.out.println("一室一廳便宜整潔");
    }
}

public class TwoHouseColleague extends Colleague {
    @Override
    public void showHouse() {
        System.out.println("兩居室——合適靠譜");
    }
}

public class ThreeHouseColleague extends Colleague {
    @Override
    public void showHouse() {
        System.out.println("三居室——大氣寬松");
    }
}

這里定義了三個具體的房東要做的事情（展示自己的房子）。

2.4 具體房屋中介

public class HouseMediator extends Mediator {
    private SmallHouseColleague smallHouse;
    private TwoHouseColleague twoHouse;
    private ThreeHouseColleague threeHouse;

    public void setSmallHouse(SmallHouseColleague smallHouse) {
        this.smallHouse = smallHouse;
    }

    public void setTwoHouse(TwoHouseColleague twoHouse) {
        this.twoHouse = twoHouse;
    }

    public void setThreeHouse(ThreeHouseColleague threeHouse) {
        this.threeHouse = threeHouse;
    }

    @Override
    public void Common(String type) {
        switch (type) {
            case "單間":
                smallHouse.showHouse();
                System.out.println("如果可以就可以租房了!");
                break;
            case "兩居室":
                twoHouse.showHouse();
                System.out.println("如果可以就可以租房了!");
                break;
            case "三居室":
                threeHouse.showHouse();
                System.out.println("如果可以就可以租房了!");
                break;
            default:
                System.out.println(type + "暫時沒有房源!");
                break;
        }
    }
}

2.5 測試類

public class Test {
    public static void main(String[] args) {
        System.out.println("租客來看房啦！！！");
        //初始化中介
        HouseMediator mediator = new HouseMediator();
        //初始化房屋信息
        SmallHouseColleague smallHouseColleague = new SmallHouseColleague( );
        TwoHouseColleague twoHouseColleague = new TwoHouseColleague( );
        ThreeHouseColleague threeHouseColleague = new ThreeHouseColleague( );

        //中介獲取房屋信息
        mediator.setSmallHouse(smallHouseColleague);
        mediator.setTwoHouse(twoHouseColleague);
        mediator.setThreeHouse(threeHouseColleague);

        // 租戶A需要兩居室、提供看房
        mediator.Common("兩居室");

        // 租戶B需要四居室、暫無房源
        mediator.Common("四居室");
    }
}

最后的執行結果如下：

租客來看房啦！！！
兩居室——合適靠譜
如果可以就可以租房了!
四居室暫時沒有房源!

3. 中介者模式

3.1 定義

中介者模式的定義為：Define an object that encapsulates how a set ofobjects interact.Mediator promotes loose coupling by keeping objects fromreferring to each other explicitly,and it lets you vary their interactionindependently.（用一個中介對象封裝一系列的對象交互，中介者使各對象不需要顯示地相互作用，從而使其耦合松散，而且可以獨立地改變它們之間的交互。）

3.2 通用類圖

從類圖中看，中介者模式由以下幾部分組成：

• Mediator: 抽象中介者角色，定義統一的接口，用於各同事角色之間的通信。
• Concrete Mediator: 具體中介者角色，通過協調各同事角色實現協作行為，因此它必須依賴於各個同事角色。
• Colleague: 同事角色，每一個同事角色都知道中介者角色，而且與其他的同事角色通信的時候，一定要通過中介者角色協作。每個同事類的行為分為兩種：一種是同事本身的行為，比如改變對象本身的狀態，處理自己的行為等，這種行為叫做自發行為（Self-Method），與其他的同事類或中介者沒有任何的依賴；第二種是必須依賴中介者才能完成的行為，叫做依賴方法（Dep-Method）。

3.3 通用抽象中介者

public abstract class Mediator {
    // 定義同事類
    protected ConcreteColleague1 colleague1;
    protected ConcreteColleague2 colleague2;

    // 通過 get/set 將同事注入進來
    public ConcreteColleague1 getC1() {
        return colleague1;
    }

    public void setC1(ConcreteColleague1 colleague1) {
        this.colleague1 = colleague1;
    }

    public ConcreteColleague2 getC2() {
        return colleague2;
    }

    public void setC2(ConcreteColleague2 colleague2) {
        this.colleague2 = colleague2;
    }

    // 中介者模式的業務邏輯
    public abstract void doSomething1();
    public abstract void doSomething2();
}

3.4 通用中介者

public class ConcreteMediator extends Mediator {
    @Override
    public void doSomething1() {
        // 調用同事類的方法
        super.colleague1.selfMethod1();
        super.colleague2.selfMethod2();
    }

    @Override
    public void doSomething2() {
        super.colleague1.selfMethod1();
        super.colleague2.selfMethod2();
    }
}

3.5 抽象同事類

public abstract class Colleague {
    protected Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }
}

3.6 具體同事類

public class ConcreteColleague1 extends Colleague{

    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    public void selfMethod1() {
        // 處理自己的業務邏輯
    }

    public void depMethod1() {
        // 處理自己的業務邏輯
        // 自己處理不了的業務委托中介者進行處理
        super.mediator.doSomething1();
    }
}

public class ConcreteColleague2 extends Colleague {

    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    public void selfMethod2() {
        // 處理自己的業務邏輯
    }

    public void depMethod2() {
        // 處理自己的業務邏輯
        // 自己處理不了的業務委托中介者進行處理
        super.mediator.doSomething2();
    }
}

4. 中介者模式的優缺點

4.1 優點

中介者模式的優點就是減少類間的依賴，把原有的一對多的依賴變成了一對一的依賴，同事類只依賴中介者，減少了依賴，當然同時也降低了類間的耦合。

4.2 缺點

中介者模式的缺點就是中介者會膨脹得很大，而且邏輯復雜，原本N個對象直接的相互依賴關系轉換為中介者和同事類的依賴關系，同事類越多，中介者的邏輯就越復雜。