中介者模式

一）故事


二）定義
用一箇中介對象封裝一系列的對象交互，中介者使各對象不需要顯示地相互作用，從而使其耦合鬆散，而且可以獨立地改變它們之間的交互。

三）代碼例子
由四部分組成：1）抽象中介者；2）具體中介者；3）抽象同事類；4）具體同事類（可多個）；
1）抽象中介者：

/**
 *  抽象中介者
 * 
 * @author levovo
 */
public abstract class AbsMediator {
    // 定義同事類
    protected ConcreteColleagua1 c1;
    protected ConcreteColleagua2 c2;
    
    // 通過getter/setter方法把同事類注入進來
    /**
     * @return the c1
     */
    public ConcreteColleagua1 getC1() {
        return c1;
    }

    /**
     * @param c1 the c1 to set
     */
    public void setC1(ConcreteColleagua1 c1) {
        this.c1 = c1;
    }

    /**
     * @return the c2
     */
    public ConcreteColleagua2 getC2() {
        return c2;
    }

    /**
     * @param c2 the c2 to set
     */
    public void setC2(ConcreteColleagua2 c2) {
        this.c2 = c2;
    }
    
    // 中介者的業務邏輯
    public abstract void doSomething1();
    public abstract void doSomething2();
}

2）具體中介者：

/**
 *  具體中介者
 * 
 * @author levovo
 */
public class Mediator extends AbsMediator {
    
    @Override
    public void doSomething1() {
        // doSomething .....
        super.c1.selfMethod1(); // 調用同事類的方法
        // doSomething ......
        super.c2.selfMethod2(); // 調用同事類的方法
        // doSomething .....
    }
    
    @Override
    public void doSomething2() {
        // doSomething .....
        super.c1.selfMethod1(); // 調用同事類的方法
        // doSomething ......
        super.c2.selfMethod2(); // 調用同事類的方法
        // doSomething .....
    }
    
}

3）抽象同事類：

/**
 * 抽象同事類
 * 
 * @author levovo
 */
public abstract class AbsColleague {
    protected AbsMediator mediator;
    public AbsColleague(AbsMediator mediator) {
        this.mediator = mediator;
    }
}

4）具體同事類：

/**
 *  具體同事類1
 * 
 * @author levovo
 */
public class ConcreteColleagua1 extends AbsColleague {
    public ConcreteColleagua1(AbsMediator mediator) {
        super(mediator);
    }
    
    // 自有方法
    public void selfMethod1() {
        // 處理自己的業務邏輯
        System.out.println("ConcreteColleagua1->selfMethod1()");
    }
    
    // 依賴方法
    public void depMethod1() {
        // 處理自己的業務邏輯
         System.out.println("ConcreteColleagua1->depMethod1()");
        // 自己不能處理的業務邏輯，委託給中介者處理
        super.mediator.doSomething1();
    }
}

/**
 * 具體同事類2
 * 
 * @author levovo
 */
public class ConcreteColleagua2 extends AbsColleague {
    public ConcreteColleagua2(AbsMediator mediator) {
        super(mediator);
    }
    
    // 自有方法
    public void selfMethod2() {
        // 處理自己的業務邏輯
         System.out.println("ConcreteColleagua2->selfMethod2()");
    }
    
    // 依賴方法
    public void depMethod2() {
        // 處理自己的業務邏輯
         System.out.println("ConcreteColleagua2->depMethod2()");
        // 自己不能處理的業務邏輯，委託給中介者處理
        super.mediator.doSomething2();
    }
}

場景使用例子：

/**
 *  場景使用例子
 *
 * @author levovo
 */
public class Client {
    public static void main(String[] args) {
        // 中介者
        AbsMediator mediator = new Mediator();
        // 同事類1
        ConcreteColleagua1 c1 = new ConcreteColleagua1(mediator);
        mediator.setC1(c1);
        // 同事類2
        ConcreteColleagua2 c2 = new ConcreteColleagua2(mediator);
        mediator.setC2(c2);
        // 自身的方法
        c1.selfMethod1();
        // 自己不處理，交給中介者
        c1.depMethod1();
        // 自身的方法
        c2.selfMethod2();
        // 自己不處理，交給中介者
        c2.depMethod2();
    }
}

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

五）缺點
中介者會膨脹得很大，而且邏輯複雜，原本N個對象直接的相互依賴關係轉換爲中介者和同事類的依賴關係，同事類越多，中介者的邏輯就越複雜。

六）使用場景
機場調度中心，MVC框架，媒體網關，中介服務（租房中介，出國中介）

如下情況可嘗試使用中介者模式：
1）N個對象之間產生了相互的依賴關係。
2）多個對象有依賴關係，便是依賴的行爲*不確定或者有發生改變的可能，在這種情況下一般建議採用中介者模式，降低變更引起的風險擴散。
3）產品開發。一個明顯的例子就是MVC框架，把中介者模式應用到產品中，可以提升產品的性能和擴展性，但是對於項目開發就未必，因爲項目是以交付投產爲目標，而產品則是以穩定，高效，擴展爲宗旨。

七）注意事項

八）擴展

九）總結
在多個對象依賴的情況下，通過加入中介者角色，取消了多個對象的關聯或依賴關係，減少了對象的耦合性。