定義：用一個中介者對象封裝一系列的對象交互，中介者使各對象不需要顯示地相互作用，從而使耦合松散，而且可以獨立地改變它們之間的交互。
類型：行為類模式
類圖：
中介者模式的結(jié)構(gòu)
中介者模式又稱為調(diào)停者模式，從類圖中看，共分為3部分：
抽象中介者：定義好同事類對象到中介者對象的接口，用于各個同事類之間的通信。一般包括一個或幾個抽象的事件方法，并由子類去實現(xiàn)。
中介者實現(xiàn)類：從抽象中介者繼承而來，實現(xiàn)抽象中介者中定義的事件方法。從一個同事類接收消息，然后通過消息影響其他同時類。
同事類：如果一個對象會影響其他的對象，同時也會被其他對象影響，那么這兩個對象稱為同事類。在類圖中，同事類只有一個，這其實是現(xiàn)實的省略，在實際應(yīng)用中，同事類一般由多個組成，他們之間相互影響，相互依賴。同事類越多，關(guān)系越復(fù)雜。并且，同事類也可以表現(xiàn)為繼承了同一個抽象類的一組實現(xiàn)組成。在中介者模式中，同事類之間必須通過中介者才能進(jìn)行消息傳遞。
為什么要使用中介者模式
一般來說，同事類之間的關(guān)系是比較復(fù)雜的，多個同事類之間互相關(guān)聯(lián)時，他們之間的關(guān)系會呈現(xiàn)為復(fù)雜的網(wǎng)狀結(jié)構(gòu)，這是一種過度耦合的架構(gòu)，即不利于類的復(fù)用，也不穩(wěn)定。例如在下圖中，有六個同事類對象，假如對象1發(fā)生變化，那么將會有4個對象受到影響。如果對象2發(fā)生變化，那么將會有5個對象受到影響。也就是說，同事類之間直接關(guān)聯(lián)的設(shè)計是不好的。
如果引入中介者模式，那么同事類之間的關(guān)系將變?yōu)樾切徒Y(jié)構(gòu)，從圖中可以看到，任何一個類的變動，只會影響的類本身，以及中介者，這樣就減小了系統(tǒng)的耦合。一個好的設(shè)計，必定不會把所有的對象關(guān)系處理邏輯封裝在本類中，而是使用一個專門的類來管理那些不屬于自己的行為。
例
下面給出具體的代碼例子，對比通用類圖增加了AbstractColleague抽象同事類和AbstractMediator抽象中介者，另外就是兩個具體同事類和一個具體中介者，代碼中有較多注釋，相應(yīng)類圖也不給出了，應(yīng)該不難理解的：
同事類族：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
//抽象同事類 abstract class AbstractColleague { protected AbstractMediator mediator; /**既然有中介者，那么每個具體同事必然要與中介者有聯(lián)系， * 否則就沒必要存在于 這個系統(tǒng)當(dāng)中，這里的構(gòu)造函數(shù)相當(dāng) * 于向該系統(tǒng)中注冊一個中介者，以取得聯(lián)系 */ public AbstractColleague(AbstractMediator mediator) { this.mediator = mediator; } // 在抽象同事類中添加用于與中介者取得聯(lián)系（即注冊）的方法 public void setMediator(AbstractMediator mediator) { this.mediator = mediator; } } //具體同事A class ColleagueA extends AbstractColleague { //每個具體同事都通過父類構(gòu)造函數(shù)與中介者取得聯(lián)系 public ColleagueA(AbstractMediator mediator) { super(mediator); } //每個具體同事必然有自己分內(nèi)的事，沒必要與外界相關(guān)聯(lián) public void self() { System.out.println("同事A --> 做好自己分內(nèi)的事情 ..."); } //每個具體同事總有需要與外界交互的操作，通過中介者來處理這些邏輯并安排工作 public void out() { System.out.println("同事A --> 請求同事B做好分內(nèi)工作 ..."); super.mediator.execute("ColleagueB", "self"); } } //具體同事B class ColleagueB extends AbstractColleague { public ColleagueB(AbstractMediator mediator) { super(mediator); } public void self() { System.out.println("同事B --> 做好自己分內(nèi)的事情 ..."); } public void out() { System.out.println("同事B --> 請求同事A做好分內(nèi)工作 ..."); super.mediator.execute("ColleagueA", "self"); } } |
中介者類族：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
//抽象中介者 abstract class AbstractMediator { //中介者肯定需要保持有若干同事的聯(lián)系方式 protected Hashtable<String, AbstractColleague> colleagues = new Hashtable<String, AbstractColleague>(); //中介者可以動態(tài)地與某個同事建立聯(lián)系 public void addColleague(String name, AbstractColleague c) { this.colleagues.put(name, c); } //中介者也可以動態(tài)地撤銷與某個同事的聯(lián)系 public void deleteColleague(String name) { this.colleagues.remove(name); } //中介者必須具備在同事之間處理邏輯、分配任務(wù)、促進(jìn)交流的操作 public abstract void execute(String name, String method); } //具體中介者 class Mediator extends AbstractMediator{ //中介者最重要的功能，來回奔波與各個同事之間 public void execute(String name, String method) { if("self".equals(method)){ //各自做好分內(nèi)事 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(); } } } } |
測試類：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
//測試類 public class Client { public static void main(String[] args) { //創(chuàng)建一個中介者 AbstractMediator mediator = new Mediator(); //創(chuàng)建兩個同事 ColleagueA colleagueA = new ColleagueA(mediator); ColleagueB colleagueB = new ColleagueB(mediator); //中介者分別與每個同事建立聯(lián)系 mediator.addColleague("ColleagueA", colleagueA); mediator.addColleague("ColleagueB", colleagueB); //同事們開始工作 colleagueA.self(); colleagueA.out(); System.out.println("======================合作愉快，任務(wù)完成！\n"); colleagueB.self(); colleagueB.out(); System.out.println("======================合作愉快，任務(wù)完成！"); } } |
測試結(jié)果：
|
1
2
3
4
5
6
7
8
9
|
同事A --> 做好自己分內(nèi)的事情 ... 同事A --> 請求同事B做好分內(nèi)工作 ... 同事B --> 做好自己分內(nèi)的事情 ... ======================合作愉快，任務(wù)完成！ 同事B --> 做好自己分內(nèi)的事情 ... 同事B --> 請求同事A做好分內(nèi)工作 ... 同事A --> 做好自己分內(nèi)的事情 ... ======================合作愉快，任務(wù)完成！ |
雖然以上代碼中只有兩個具體同事類，并且測試類中也只是創(chuàng)建了兩個同事，但是這些我們都可以根據(jù)中介者模式的宗旨進(jìn)行適當(dāng)?shù)財U展，即增加具體同事類，然后中介者就得擔(dān)負(fù)更加重的任務(wù)了。為啥？我們看到上面具體中介者類Mediator中的execute()方法中現(xiàn)在就有一堆冗長的判斷代碼了。雖然可以把它分解并增加到Mediator類中的其它private方法中，但是具體的業(yè)務(wù)邏輯是少不了的。
所以，在解耦同事類之間的聯(lián)系的同時，中介者自身也不免任務(wù)過重，因為幾乎所有的業(yè)務(wù)邏輯都交代到中介者身上了，可謂是“萬眾期待”的一個角色了。這就是中介者模式的不足之處了 。
此外，上面這個代碼例子是相當(dāng)理想的了，有時候我們根本抽取不了“同事”之間的共性來形成一個AbstractColleague抽象同事類，這也大大增加了中介者模式的使用難度。
修改：
由于上面代碼實現(xiàn)中存在 benjielin 前輩提出的“雙向關(guān)聯(lián)暴露在App中”的不足之處，根據(jù)給出的改進(jìn)方法2，修改上面代碼，如下：
修改后的同事類族：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
//抽象同事類 abstract class AbstractColleague { protected AbstractMediator mediator; //舍去在構(gòu)造函數(shù)中建立起與中介者的聯(lián)系 // public AbstractColleague(AbstractMediator mediator) { // this.mediator = mediator; // } // 在抽象同事類中添加用于與中介者取得聯(lián)系（即注冊）的方法 public void setMediator(AbstractMediator mediator) { this.mediator = mediator; } } //具體同事A class ColleagueA extends AbstractColleague { //舍去在構(gòu)造函數(shù)中建立起與中介者的聯(lián)系 // public ColleagueA(AbstractMediator mediator) { // super(mediator); // } //每個具體同事必然有自己分內(nèi)的事，沒必要與外界相關(guān)聯(lián) public void self() { System.out.println("同事A --> 做好自己分內(nèi)的事情 ..."); } //每個具體同事總有需要與外界交互的操作，通過中介者來處理這些邏輯并安排工作 public void out() { System.out.println("同事A --> 請求同事B做好分內(nèi)工作 ..."); super.mediator.execute("ColleagueB", "self"); } } //具體同事B class ColleagueB extends AbstractColleague { //舍去在構(gòu)造函數(shù)中建立起與中介者的聯(lián)系 // public ColleagueB(AbstractMediator mediator) { // super(mediator); // } public void self() { System.out.println("同事B --> 做好自己分內(nèi)的事情 ..."); } public void out() { System.out.println("同事B --> 請求同事A做好分內(nèi)工作 ..."); super.mediator.execute("ColleagueA", "self"); } } |
修改后的中介者：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
//抽象中介者 abstract class AbstractMediator { //中介者肯定需要保持有若干同事的聯(lián)系方式 protected Hashtable<String, AbstractColleague> colleagues = new Hashtable<String, AbstractColleague>(); //中介者可以動態(tài)地與某個同事建立聯(lián)系 public void addColleague(String name, AbstractColleague c) { // 在中介者這里幫助具體同事建立起于中介者的聯(lián)系 c.setMediator(this); this.colleagues.put(name, c); } //中介者也可以動態(tài)地撤銷與某個同事的聯(lián)系 public void deleteColleague(String name) { this.colleagues.remove(name); } //中介者必須具備在同事之間處理邏輯、分配任務(wù)、促進(jìn)交流的操作 public abstract void execute(String name, String method); } //測試類 public class Client { public static void main(String[] args) { //創(chuàng)建一個中介者 AbstractMediator mediator = new Mediator(); //不用構(gòu)造函數(shù)為具體同事注冊中介者來取得聯(lián)系了 // ColleagueA colleagueA = new ColleagueA(mediator); // ColleagueB colleagueB = new ColleagueB(mediator); ColleagueA colleagueA = new ColleagueA(); ColleagueB colleagueB = new ColleagueB(); //中介者分別與每個同事建立聯(lián)系 mediator.addColleague("ColleagueA", colleagueA); mediator.addColleague("ColleagueB", colleagueB); //同事們開始工作 colleagueA.self(); colleagueA.out(); System.out.println("======================合作愉快，任務(wù)完成！\n"); colleagueB.self(); colleagueB.out(); System.out.println("======================合作愉快，任務(wù)完成！"); } } |
測試之后的結(jié)果與修改前一樣。
