有一個叫控制反轉(Inversion of Control，縮寫IoC ) 的東西 ，這個對於計算機的人應該是不陌生的概念，就算你不知道那個Bob大叔。

這個概念簡單說的是下面這樣的事情

原本各個類之間的關係亂七八糟的，看起來頭都暈了。
他們就像齒輪一樣，相互咬合依賴。

如果有一個出問題，那可能整個就崩潰了。

但是，如果有一個人出來承擔大事，負責協調各個類的話！
那麼，他們的關係就可以是像下面圖片這樣的，
各個物件之間可以不感受到對方的“存在”，但整體又運作良好。

舉個可能不恰當的例子：

企業ObjectA要招人，可能要去學校ObjectB開宣講會，去別的企業ObjectC

那麼問題來了，如何用中介者模式來模擬這個招聘流程？

今天我們要聊的這個就中介者就是類似的情況，我們來看下實際的程式碼情況。

程式碼實現

現在來看下我們的公司吧

public class Company extends AbstractColleague {

    public Company(AbstractMediator abstractMediator) {
        super(abstractMediator);
    }

    public void seeResume(String resume) {
        System.out.println("正在看簡歷： " + resume);
    }

    public void startToHunt() {
        abstractMediator.execute(AbstractMediator.Action.START_HIRE);
    }
}
 

我們的公司主要工作就是看簡歷，發通知說我要開始招人了，為了方便說明，就把後續的面試環節剩了。

另外，我們要求實現AbstractColleague,用於對外溝通的地方，是我們的齒輪與IOC發生聯絡的基礎。

public abstract class AbstractColleague {

    AbstractMediator abstractMediator;

    public AbstractColleague(AbstractMediator abstractMediator) {
        this.abstractMediator = abstractMediator;
    }
}
 

然後我們的學生也類似

public class Student extends AbstractColleague {

    public Student(AbstractMediator abstractMediator) {
        super(abstractMediator);
    }

    public String getMyResume() {
        return "我的簡歷很簡單";
    }

    public void findJob() {
        abstractMediator.execute(AbstractMediator.Action.FIND_JOB_SCHOOL, getMyResume());
    }
}

找工作主要通過校招的途徑。

而對於這類的已經在上班的人啊，主要就是社招來跳槽了。

public class Employee extends AbstractColleague {

    public Employee(AbstractMediator abstractMediator) {
        super(abstractMediator);
    }

    public String getMyResume() {
        return "這是我的簡歷,專案經驗很多";
    }

    public void findJob() {
        abstractMediator.execute(AbstractMediator.Action.FIND_JOB_SOCAIL, getMyResume());
    }

    public void refuseOffer() {
        System.out.println("這公司我不去");
    }

}

好了，準備好這麼多，得來看下我們的獵頭了

public abstract class AbstractMediator {

    protected Company mCompany;
    protected Student mStudent;
    protected Employee mEmployee;

    public AbstractMediator() {

        mCompany = new Company(this);
        mStudent = new Student(this);
        mEmployee = new Employee(this);
    }

    public abstract void execute(Action action, Object... objects);

    public enum Action {
        FIND_JOB_SCHOOL, FIND_JOB_SOCAIL,START_HIRE
    }

}

我們抽象出獵頭和學生，公司打交道，所以有這麼幾個內部變數，另外他的基本行為就是幫人找工作，執行特定的行為execute()，但具體怎麼做，就見仁見智了。

例如下面這位，他對好簡歷的要求是最少有10個字。少於十個字的都不幫你交出去，免得丟了自己的招牌。

public class HeadMediator extends AbstractMediator {

    private int GOOD_RESUME = 10;   
    private boolean isCompanyStartToHire = false;

    @Override
    public void execute(Action action, Object... objects) {
        switch (action) {
            case FIND_JOB_SCHOOL:
                findJobBySchool((String) objects[0]);
                break;
            case FIND_JOB_SOCAIL:
                findJobBySocial((String) objects[0]);
                break;
            case START_HIRE:
                isCompanyStartToHire = true;
                break;
        }
    }

    public void findJobBySocial(String resume) {
        if (isCompanyStartToHire && resume.length() > GOOD_RESUME) {
            super.mCompany.seeResume(resume);
        }
    }

    public void findJobBySchool(String resume) {
        if (isCompanyStartToHire && resume.length() > GOOD_RESUME) {
            super.mCompany.seeResume(resume);
        }
    }
}

基本我們準備好了，來看下我們的測試案例

public class Client {

    public static void main(String[] args) {

        AbstractMediator mediator=new HeadMediator();

        Company company=new Company(mediator);
        company.startToHunt();//公司說開始招人人    

        Student student=new Student(mediator);
        student.findJob();//學生開始找工作

        Employee employee=new Employee(mediator);
        employee.findJob();//員工想跳槽，開始找工作    
    }
}

類圖

後記

這個中介者模式到目前位置，在我的開發羨慕中是沒有實際的自己手動寫過。
不過倒是用過不少類似的庫，例如我們的EventBus，OTTO，廣播等。

通過這個中介者模式，具體的活到底是怎樣的流程，我們全部進行了抽象，交給了中介者，各個類需要做的就是專注於自己本身的行為。當然，這樣的高度控制集中化也是有點小小問題的，當涉及到的類多起來，通訊複雜的時候，這個類要寫的內容還是不少的，這可能使他難以維護！

參考資料