中介模式是什麼？

用一箇中介物件來封裝一系列的物件互動。中介者使各物件之間不需要顯示的相互作用，從而使其耦合鬆散，而且可以獨立地改變他們之間的互動。簡而言之就是，將原來兩個直接引用或者依賴的物件拆開，在他們中間加一個‘中介’物件，使得兩頭分別和‘中介’物件引用和依賴。

中介模式的要素

1. 抽象中介者角色：抽象中介者角色定義統一的介面用於各同事之間的通訊。
2. 具體中介角色：具體中介者角色通過協調各同事角色實現協作行為。
3. 同事角色：每一個同事角色都知道對應的具體中介角色，而且與其他的同事角色通訊的時候，一定要通過具體中介角色協作。

例子

package myDesignPatternsTest.mediatorPattern;

/**
 * 抽象同事類
 */
public abstract class AbstractColleague {
    protected AbstractMediator mediator;


    // 在抽象同事類中新增用於與中介者取得聯絡（即註冊）的方法
    public void setMediator(AbstractMediator mediator) {
        this.mediator = mediator;
    }
}

package myDesignPatternsTest.mediatorPattern;

import java.util.HashMap;

/**
 *  抽象中介類
 */
public abstract class AbstractMediator {
    //中介者肯定需要保持有若干同事的聯絡方式
    protected HashMap<String,AbstractColleague> colleagues=new HashMap<String, AbstractColleague>();
    //中介者需要動態的與某個同事建立聯絡
    public void addColleague(String name,AbstractColleague c){
        c.setMediator(this);//設定中介
        this.colleagues.put(name,c);
    }
    //中介者需要動態的撤銷與某個同事之間的聯絡
    public void deleteColleague(String name){
       this.colleagues.remove(name);
    }
    public abstract  void  execute(String name,String method);

}

package myDesignPatternsTest.mediatorPattern;

public class ColleagueA extends AbstractColleague {
    //每個具體同事必然有自己分內的事，沒必要與外界相關聯
    public void self() {
        System.out.println("同事A --> 做好自己分內的事情 ...");
    }

    //每個具體同事總有需要與外界互動的操作，通過中介者來處理這些邏輯並安排工作
    public void out() {
        System.out.println("同事A --> 請求同事B做好分內工作 ...");
        super.mediator.execute("ColleagueB", "self");
    }
}

package myDesignPatternsTest.mediatorPattern;

public class ColleagueB extends AbstractColleague {

    //每個具體同事必然有自己分內的事，沒必要與外界相關聯
    public void self() {
        System.out.println("同事B --> 做好自己分內的事情 ...");
    }

    //每個具體同事總有需要與外界互動的操作，通過中介者來處理這些邏輯並安排工作
    public void out() {
        System.out.println("同事B --> 請求同事B做好分內工作 ...");
        super.mediator.execute("ColleagueA", "self");
    }
}

package myDesignPatternsTest.mediatorPattern;

public class Mediator extends AbstractMediator {
    @Override
    public void execute(String name, String method) {

        if("self".equals(method)){  //各自做好分內事
            if("ColleagueA".equals(name)) {
                ColleagueA colleague = (ColleagueA)super.colleagues.get("ColleagueA");
                colleague.self();
            }else {
                ColleagueB colleague = (ColleagueB)super.colleagues.get("ColleagueB");
                colleague.self();
            }
        }else { //與其他同事合作
            if("ColleagueA".equals(name)) {
                ColleagueA colleague = (ColleagueA)super.colleagues.get("ColleagueA");
                colleague.out();
            }else {
                ColleagueB colleague = (ColleagueB)super.colleagues.get("ColleagueB");
                colleague.out();
            }
        }
    }
}

package myDesignPatternsTest.mediatorPattern;

public class Client {
    public static void main(String[] args) {
        Mediator mediator=new Mediator();
        ColleagueA colleagueA=new ColleagueA();
        ColleagueB colleagueB=new ColleagueB();
        mediator.addColleague("ColleagueA",colleagueA);
        mediator.addColleague("ColleagueB",colleagueB);
        //同事們開始工作
        colleagueA.self();
        colleagueA.out();
        System.out.println("======================合作愉快，任務完成！\n");

        colleagueB.self();
        colleagueB.out();
        System.out.println("======================合作愉快，任務完成！");
    }
}
同事A --> 做好自己分內的事情 ...
同事A --> 請求同事B做好分內工作 ...
同事B --> 做好自己分內的事情 ...
======================合作愉快，任務完成！

同事B --> 做好自己分內的事情 ...
同事B --> 請求同事B做好分內工作 ...
同事A --> 做好自己分內的事情 ...
======================合作愉快，任務完成！

中介模式的優缺點

優點： 1、降低了類的複雜度，將一對多轉化成了一對一。 2、各個類之間的解耦。 3、符合迪米特原則。

缺點：中介者會龐大，變得複雜難以維護。