设计模式笔记 - 中介者模式（Mediator Pattern）

设计模式

模式定义

中介者模式（Mediator Pattern）用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使耦合松散，而且可以独立地改变它们之间的交互。

中介者模式又称为调停者模式，它是一种对象行为型模式。

模式结构

中介者模式包含如下角色：

  • Mediator - 抽象中介者
  • ConcreteMediator - 具体中介者
  • Colleague - 抽象同事类
  • ConcreteColleague - 具体同事类

img

模式实例

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
/*
 * 本例为建立一个虚拟聊天室。允许会员通过该聊天室进行信息交流，普通会员（Common Member）可以给其他会员发
 * 送文本信息，钻石会员（Diamond Member）除了可以发送文本消息外，还可以发送图片。
 */
// Mediator - 抽象中介者
public abstract class AbstractChatroom {
  	private List<Member> members;
  
  	public AbstractChatroom() {
      	this.members = new ArrayList<Member>();
  	}
  
  	public void register(Member member) {
      	this.members.add(member);
  	}
  	
  	public List<Member> getMembers() {
  		return this.members;
  	}
  
  	public abstract void sendText(String text);
  	public abstract void sendImage(Photo photo);
} 

// ConcreteMediator - 具体中介者
public class ChatGroup extends AbstractChatroom {
  	public void register(Member member) {
      	super.register(member);
      	member.setChatroom(this);
  	}
	
  	public void sendText(String text) {
  		List<Member> members = getMembers();
  		
    	for (Member member: members) {
          	member.receiveText(text);
    	}
    }
  
  	public void sendImage(Photo photo) {
  		List<Member> members = getMembers();
  		
      	for (Member member: members) {
          	member.receiveImage(photo);
    	}
  	}
}

// Colleague - 抽象同事类
public abstract class Member {
  	private String name;
  	private AbstractChatroom chatroom;
  
  	public Member(String name) {
      	this.name = name;
  	}
  
  	public void setChatroom(AbstractChatroom chatroom) {
      	this.chatroom = chatroom;
  	}
  
  	public AbstractChatroom getChatroom() {
      	return this.chatroom;
  	}
  	
  	public void receiveImage(Photo photo) {
      	System.out.println(name + " receive photo: " + photo.getName());
  	}
  
  	public void receiveText(String text) {
      	System.out.println(name + " receive text: " + text);
  	}
  
  	public void sendImage(Photo photo) {
      	throw new IllegalStateException("you don't have an access");
  	}
  
  	public void sendText(String text) {
      	this.chatroom.sendText(text);
  	}
}

// ConcreteColleague - 具体同事类
// 普通会员
public class CommonMember extends Member {
  	public CommonMember(String name) {
      	super(name);
  	}
  	
  	public void sendText(String text) {
      	getChatroom().sendText(text);
  	}
}

// 钻石会员
public class DiamondMember extends Member {
  	public DiamondMember(String name) {
  		super(name);
  	}
  	
  	public void sendText(String text) {
      	getChatroom().sendText(text);
  	}
  
  	public void sendImage(Photo photo) {
      	getChatroom().sendImage(photo);
  	}
}

// 测试类
public class Text {
  	public static void main(String[] args) {
      	AbstractChatroom chatroom = new ChatGroup();
      	Member common = new CommonMember("Peter");
      	Member diamond = new DiamondMember("Mary");
      
      	chatroom.register(common);
      	chatroom.register(diamond);
      	
      	common.sendText("Hello");
      	diamond.sendImage(new Photo("Cool"));
      	
      	System.out.println("END");
  	}
}

模式分析

  • 中介者模式可以使对象之间的关系数量急剧减少。
  • 通过引入中介者对象，可以将系统的网状结构变成以中介者为中心的星型结构，中介者承担了中转作用和协调作用。中介者是中介者模式的核心，它对整个系统进行控制和协调，简化了对象之间的交互，还可以对对象间的交互进行进一步的控制。

中介者模式的优点：

  • 简化对象之间的引用关系，降低对象间的耦合。
  • 集中式管理，以中介者为中心，协调各对象之间的关系。

中介者模式的缺点：

  • 在具体中介者类中包含了同事之间的交互细节，增加了具体中介者的复杂度，如果系统中具有太多的同时，会使得系统变得难以维护。

适用环境

在以下情况下可以使用中介者模式：

  • 系统中对象之间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解。
  • 一个对象由于引用了其他很多对象并且直接和这些对象通信，即耦合程度大，导致难以复用该对象。

参考资料：

[1] https://design-patterns.readthedocs.io/zh_CN/latest/behavioral_patterns/mediator.html