中介者模式 - 规范 - 设计开发

# 简介

Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.
用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

中介者模式（Mediator Pattern）又称为 调解者模式 或 调停者模式。属于行为型模式。

中介者模式 包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使它们可以松散耦合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。

中介者模式 是用来降低多个对象和类之间的通信复杂性。这种模式通过提供一个中介类，将系统各层次对象间的多对多关系变成一对多关系，中介者对象可以将复杂的网状结构变成以调停者为中心的星形结构，达到降低系统的复杂性，提高可扩展性的作用。

中介者模式 核心：通过中介者解耦系统各层次对象的直接耦合，层次对象的对外依赖通信统统交由中介者转发。

# 主要解决

若系统各层次对象之间存在大量的关联关系，即层次对象呈复杂的网状结构，如果直接让它们紧耦合通信，会造成系统结构变得异常复杂，且其中某个层次对象发生改变，则与其紧耦合的相应层次对象也需进行修改，系统很难进行维护。而通过为该系统增加一个中介者层次对象，让其他各层次需对外通信的行为统统交由中介者进行转发，系统呈现以中介者为中心进行通讯的星形结构，系统的复杂性大大降低。

简单的说：多个类相互耦合，形成了网状结构，则考虑使用 中介者模式 进行优化。

# 优缺点

优点

减少类间依赖，将一对多依赖转化成了一对一，降低了类间耦合；
类间各司其职，符合 迪米特原则 ；

缺点

中介者模式中将原本多个对象直接的相互依赖变成了中介者和多个同事类的依赖关系。当同事类越多时，中介者就会越臃肿，变得复杂且难以维护；

# 使用场景

系统各层次对象之间存在复杂的依赖通讯，导致它们之间的依赖关系结构混乱而且难以维护；此时可以使用中介者模式，将系统从网状结构变为以中介者为中心的星形结构；

# 模式讲解

首先来看下 中介者模式 的通用 UML 类图：

中介者模式

从 UML 类图中，我们可以看到，中介者模式 主要包含三种角色：

抽象中介者（Mediator）：定义统一的接口，用于各同事角色之间的通信；
具体中介者（ConcreteMediator）：从具体的同事对象接收消息，向具体同事对象发出命令，协调各同事间的协作；
抽象同事类（Colleague）：每一个同事对象均需要依赖中介者角色，与其他同事间通信时，交由中介者进行转发协作；
具体同事类（ConcreteColleague）：负责实现自发行为（Self-Method），转发依赖方法（Dep-Method）交由中介者进行协调；

以下是 中介者模式 的通用代码：

	class Client {
	public static void main(String[] args) {
	Mediator mediator = new ConcreteMediator();
	ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
	ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);
	colleagueA.depMethodA();
	System.out.println("-------------------------");
	colleagueB.depMethodB();
	}

	// 抽象同事类
	static abstract class Colleague {
	protected Mediator mMediator;

	public Colleague(Mediator mediator) {
	this.mMediator = mediator;
	}
	}

	// 具体同事类
	static class ConcreteColleagueA extends Colleague {
	public ConcreteColleagueA(Mediator mediator) {
	super(mediator);
	this.mMediator.setColleageA(this);
	}

	// 自有方法：self-Method
	public void selfMethodA() {
	// 处理自己的逻辑
	System.out.println(String.format("%s:self-Method", this.getClass().getSimpleName()));
	}

	// 依赖方法：dep-Method
	public void depMethodA() {
	// 处理自己的逻辑
	System.out.println(String.format("%s:depMethod: delegate to Mediator", this.getClass().getSimpleName()));
	// 无法处理的业务逻辑委托给中介者处理
	this.mMediator.transferA();
	}
	}

	// 具体同事类
	static class ConcreteColleagueB extends Colleague {
	public ConcreteColleagueB(Mediator mediator) {
	super(mediator);
	this.mMediator.setColleageB(this);
	}

	// 自有方法：self-Method
	public void selfMethodB() {
	// 处理自己的逻辑
	System.out.println(String.format("%s:self-Method", this.getClass().getSimpleName()));
	}

	// 依赖方法：dep-Method
	public void depMethodB() {
	// 处理自己的逻辑
	System.out.println(String.format("%s:depMethod: delegate to Mediator", this.getClass().getSimpleName()));
	// 无法处理的业务逻辑委托给中介者处理
	this.mMediator.transferB();
	}
	}

	// 抽象中介者
	static abstract class Mediator {
	protected ConcreteColleagueA mColleagueA;
	protected ConcreteColleagueB mColleagueB;

	public void setColleageA(ConcreteColleagueA colleague) {
	this.mColleagueA = colleague;
	}

	public void setColleageB(ConcreteColleagueB colleague) {
	this.mColleagueB = colleague;
	}

	// 中介者业务逻辑
	public abstract void transferA();

	public abstract void transferB();
	}

	// 具体中介者
	static class ConcreteMediator extends Mediator {
	@Override
	public void transferA() {
	// 协调行为：A 转发到 B
	this.mColleagueB.selfMethodB();
	}

	@Override
	public void transferB() {
	// 协调行为：B 转发到 A
	this.mColleagueA.selfMethodA();
	}
	}
	}

上面代码可以看到，其实抽象同事类 Colleague 的作用只是硬性规定让同事类都依赖于中介者 Mediator ，而且 Mediator 内部直接引用的是具体同事类 ConcreteColleague ，这是因为在真实业务中， ConcreteColleagueA 和 ConcreteColleagueB 这些同事类都是代表不同的具体业务类，因此它们之间是无法进行共性抽象，也就是说 Colleague 在平常的编码中可以忽略，直接在 Mediator 引用真实业务类即可。

上面代码运行结果如下：

	ConcreteColleagueA:depMethod: delegate to Mediator
	ConcreteColleagueB:self-Method
	-------------------------
	ConcreteColleagueB:depMethod: delegate to Mediator
	ConcreteColleagueA:self-Method

# 举个例子

例子：假设我们要构建一个聊天室系统，用户可以向聊天室发送消息，聊天室会向所有的用户显示消息。请用代码进行实现。

分析：本例其实就是用户发信息与聊天室显示的通信过程，不过用户无法直接将信息发给聊天室，而是需要将信息先发到服务器上，然后服务器再将该消息发给聊天室进行显示。

具体代码如下：

	class Client {
	public static void main(String[] args) {
	ChatMediator mediator = new ServerChatMediator();
	ChatRoom room = new ChatRoom(mediator);

	User john = new User("John",mediator);
	User whyn = new User("Whyn",mediator);
	john.sendMessage("Hi! I am John.");
	whyn.sendMessage("Hello! My name is Whyn.");
	}

	static class User {
	private String name;
	private ChatMediator mediator;

	public User(String name, ChatMediator mediator) {
	this.name = name;
	this.mediator = mediator;
	}

	public void sendMessage(String msg) {
	this.mediator.send2ChatRoom(this, msg);
	}
	}

	static class ChatRoom {
	private ChatMediator mediator;

	public ChatRoom(ChatMediator mediator) {
	this.mediator = mediator;
	this.mediator.setChatRoom(this);
	}

	public void showMsg(User user, String msg) {
	System.out.println(String.format("[%s]: %s", user.name, msg));
	}
	}

	static abstract class ChatMediator {
	protected ChatRoom mRoom;

	public void setChatRoom(ChatRoom room) {
	this.mRoom = room;
	}

	public abstract void send2ChatRoom(User user, String msg);
	}

	static class ServerChatMediator extends ChatMediator {

	@Override
	public void send2ChatRoom(User user, String msg) {
	this.mRoom.showMsg(user, msg);
	}
	}
	}

运行结果如下：

	[John]: Hi! I am John.
	[Whyn]: Hello! My name is Whyn.

设计模式 js