Java设计模式14——中介者(Mediator)模式
2017-08-01 11:50
246 查看
转:http://blog.csdn.net/xu__cg/article/details/53133134
用一个中介对象封装一系列对象的交互,中介者是多个对象不需要显示的相互作用,而且可以独立的改变他们的交互。
通过上述定义可能不好理解,下面举一个例子,假如在一个没有总经理的公司中,有三个部门:财务部、市场部、研发部。那么财务部负责发工资,需要和市场部及研发部都通气;市场部负责接新项目,需要研发部处理技术、需要财务部出资金;虽然只有三个部门,但关系非常乱,就像下图:
但是实际上,公司都有总经理,各个部门的事情都需要汇报给总经理,总经理再通知各个相关部门:
这就是一个典型的“中介者模式”,总经理起到一个中介、协调的作用。
如果一个系统中的对象之间的联系呈现网状结构,对象之间存在大量多对多的关系,将导致关系极其复杂,这些对象称为“同事关系”,而我们可以 引进一个中介者对象,使各个同事对象只跟中介者对象打交道,将复杂的网络结构化解为如下星形结构:
中介者模式结构图:
抽象中介者(Mediator):定义了同事对象到中介者对象的接口。
具体中介者(ConcreteMediator):具体中介者对象,实现了抽象类方法,它需要知道所有具体同事类,并从具体同事对象接收消息,向其他同事类发送命令。
抽象同事类(Colleague):定义抽象同事类中方法。
具体同事类(ConcreteColleague):具体同事类,每个具体同事类只知道自己的行为,而不了解其他同事的情况,但他们都认识中介者对象。
示例代码:
抽象中介者(Mediator):
2
3
4
1
2
3
4
具体中介者(ConcreteMediator):
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
抽象同事类(Colleague):
2
3
4
5
6
7
1
2
3
4
5
6
7
具体同事类(ConcreteColleague):
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
客户端:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1.中介者模式本质:
解耦多个同事对象之间的交互关系。每个对象都持有中介者对象的引用,只跟中介者对象打交道。我们通过中介者对象统一管理这些交互关系。
2.开发中常见场景:
MVC模式(其中的C,控制器就是一个中介者对象。M和V都和他打交道)。
窗口游戏程序,窗口软件开发中窗口对象也是一个中介对象。
3.注意事项:
在面向对象编程中,一个类必然会与其他的类发生依赖关系,完全独立的类是没有意义的。一个类同时依赖多个类的情况也相当普遍,既然存在这样的情况,说明,一对多的依赖关系有它的合理性,适当的使用中介者模式可以使原本凌乱的对象关系清晰,但是如果滥用,则可能会带来反的效果。一般来说,只有对于那种同事类之间是网状结构的关系,才会考虑使用中介者模式。可以将网状结构变为星状结构,使同事类之间的关系变的清晰一些。 滥用中介者模式,可能让事情变的更复杂。
一、定义
用一个中介对象封装一系列对象的交互,中介者是多个对象不需要显示的相互作用,而且可以独立的改变他们的交互。
二、举例
通过上述定义可能不好理解,下面举一个例子,假如在一个没有总经理的公司中,有三个部门:财务部、市场部、研发部。那么财务部负责发工资,需要和市场部及研发部都通气;市场部负责接新项目,需要研发部处理技术、需要财务部出资金;虽然只有三个部门,但关系非常乱,就像下图:但是实际上,公司都有总经理,各个部门的事情都需要汇报给总经理,总经理再通知各个相关部门:
这就是一个典型的“中介者模式”,总经理起到一个中介、协调的作用。
三、模式核心
如果一个系统中的对象之间的联系呈现网状结构,对象之间存在大量多对多的关系,将导致关系极其复杂,这些对象称为“同事关系”,而我们可以 引进一个中介者对象,使各个同事对象只跟中介者对象打交道,将复杂的网络结构化解为如下星形结构:
四、模式结构
中介者模式结构图:抽象中介者(Mediator):定义了同事对象到中介者对象的接口。
具体中介者(ConcreteMediator):具体中介者对象,实现了抽象类方法,它需要知道所有具体同事类,并从具体同事对象接收消息,向其他同事类发送命令。
抽象同事类(Colleague):定义抽象同事类中方法。
具体同事类(ConcreteColleague):具体同事类,每个具体同事类只知道自己的行为,而不了解其他同事的情况,但他们都认识中介者对象。
示例代码:
抽象中介者(Mediator):
public interface Mediator { void register(String name,Department d);//记录所有同事类 void command(String name);//发出命令 }1
2
3
4
1
2
3
4
具体中介者(ConcreteMediator):
//中介者:总经理 public class President implements Mediator{ private Map<String,Department> map=new HashMap<String,Department>(); @Override public void register(String name, Department d) { map.put(name, d); } @Override public void command(String name) { map.get(name).ownWork(); } }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
抽象同事类(Colleague):
/** * 抽象同事类:部门 */ public interface Department { void ownWork();//本部门自己的工作 void outWork();//需要其他部门配合的工作 }1
2
3
4
5
6
7
1
2
3
4
5
6
7
具体同事类(ConcreteColleague):
/** * 研发部 */ public class Development implements Department{ private Mediator m;//持有中介者对象引用 public Development(Mediator m){ this.m=m; m.register("development", this); } @Override public void ownWork() { System.out.println("研发部:负责研发工作!"); } @Override public void outWork() { System.out.println("研发部:请求财务部配合!"); m.command("finacial"); } } /** * 市场部 */ public class Market implements Department{ private Mediator m;//持有中介者对象引用 public Market(Mediator m){ this.m=m; m.register("market", this); } @Override public void ownWork() { System.out.println("市场部:负责项目承接工作!"); } @Override public void outWork() { System.out.println("市场部:请求研发部门配合!"); m.command("development"); } } /** * 财务部 */ public class Finacial implements Department{ private Mediator m;//持有中介者对象引用 public Finacial(Mediator m){ this.m=m; m.register("finacial", this); } @Override public void ownWork() { System.out.println("财务部:负责财务工作!"); } @Override public void outWork() { System.out.println("财务部:请求市场部配合!"); m.command("market"); } }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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
客户端:
public class Client { public static void main(String[] args) { Mediator president=new President(); Development devp=new Development(president); Finacial fin=new Finacial(president); Market mar=new Market(president); devp.ownWork(); devp.outWork(); } } //输出结果 研发部:负责研发工作! 研发部:请求财务部配合! 财务部:负责财务工作!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
五、总结
1.中介者模式本质:解耦多个同事对象之间的交互关系。每个对象都持有中介者对象的引用,只跟中介者对象打交道。我们通过中介者对象统一管理这些交互关系。
2.开发中常见场景:
MVC模式(其中的C,控制器就是一个中介者对象。M和V都和他打交道)。
窗口游戏程序,窗口软件开发中窗口对象也是一个中介对象。
3.注意事项:
在面向对象编程中,一个类必然会与其他的类发生依赖关系,完全独立的类是没有意义的。一个类同时依赖多个类的情况也相当普遍,既然存在这样的情况,说明,一对多的依赖关系有它的合理性,适当的使用中介者模式可以使原本凌乱的对象关系清晰,但是如果滥用,则可能会带来反的效果。一般来说,只有对于那种同事类之间是网状结构的关系,才会考虑使用中介者模式。可以将网状结构变为星状结构,使同事类之间的关系变的清晰一些。 滥用中介者模式,可能让事情变的更复杂。
相关文章推荐
- JAVA设计模式(14):行为型-中介者模式(Mediator)
- JAVA设计模式(14):行为型-中介者模式(Mediator)
- Java设计模式14——中介者(Mediator)模式
- java设计模式-中介者模式(Mediator)
- java设计模式-Mediator(中介者)模式
- 中介者模式(Mediator)(对象行为型模式)
- 设计模式(19)-中介者模式(Mediator)
- 步步为营 .NET 设计模式学习笔记 二十、Mediator(中介者模式)
- 设计模式 ( 十五 ) 中介者模式Mediator(对象行为型)
- 极速理解设计模式系列:15.中介者模式(Mediator Pattern)
- 【HeadFirst 设计模式学习笔记】17 中介者(Mediator)模式拾零
- 23种设计模式--中介者模式-Mediator Pattern
- Mediator 中介者模式
- [设计模式-行为型]中介者模式(Mediator)
- 中介者模式(Mediator)
- C#设计模式之十七中介者模式(Mediator Pattern)【行为型】
- 设计模式——行为型模式之通过中介者模式(Mediator Pattern)实现各模块之间的解耦(二)
- Java开发中的23种设计模式之二十二:中介者模式(Mediator)
- 中介者模式(Mediator Pattern)
- Net设计模式实例之中介者模式(Mediator Pattern)