举个例子：假设您要构建两个应用程序：
- 聊天应用程序。
- 紧急救护车操作员申请。
调解员
构建聊天应用程序时，您将选择mediator 设计模式。
- 这些人可能会在任何给定时间加入和离开聊天，因此在两个聊天的人之间保持直接引用没有任何意义。
- 我们仍然需要促进两个人之间的沟通并允许他们聊天。
为什么我们更喜欢mediator？看看它的定义：
使用中介者模式，对象之间的通信是
封装在中介对象中。对象不再通信
直接相互交流，而是通过
调解人。这减少了通信对象之间的依赖关系，
从而减少耦合。
魔法是如何运作的？首先，我们将创建聊天中介并让人员对象注册到它，因此它将与每个人有两个方向连接（该人可以使用聊天中介发送消息，因为它可以访问它，而聊天中介将访问person 对象的接收方法，因为他也可以访问它）
function Person(name) {
let self = this;
this._name = name;
this._chat = null;
this._receive(from, message) {
console.log("{0}: '{1}'".format(from.name(), message));
}
this._send(to, message) {
this._chat.message(this, to, message);
}
return {
receive: (from, message) => { self._receive(from, message) },
send: (to, message) => { self._send(to, message) },
initChat: (chat) => { this._chat = chat; },
name: () => { return this._name; }
}
}
function ChatMediator() {
let self = this;
this._persons = [];
return {
message: function (from, to, message) {
if (self._persons.indexOf(to) > -1) {
self._persons[to].receive(from, message);
}
},
register: function (person) {
person.initChat(self);
self._persons.push(person);
}
unRegister: function (person) {
person.initChat(null);
delete self._persons[person.name()];
}
}
};
//Usage:
let chat = new ChatMediator();
let colton = new Person('Colton');
let ronan = new Person('Ronan');
chat.register(colton);
chat.register(ronan);
colton.send(colton, 'Hello there, nice to meet you');
ronan.send(ronan, 'Nice to meet you to');
colton.send(colton, 'Goodbye!');
chat.unRegister(colton);
观察者
构建 911 呼叫应用程序，您将选择 observer 设计模式。
- 每个救护车
observer对象都希望在出现紧急状态时得到通知，以便他可以驾驶地址并提供帮助。
- 紧急操作员
observable 保持对每辆救护车observers 的引用，并在需要帮助（或发生事件）时通知他们。
为什么我们更喜欢observer？看看它的定义：
一个对象，称为主体，维护一个它的依赖列表，
称为观察者，并自动通知他们任何状态
更改，通常通过调用它们的方法之一。
function AmbulanceObserver(name) {
let self = this;
this._name = name;
this._send(address) {
console.log(this._name + ' has been sent to the address: ' + address);
}
return {
send: (address) => { self._send(address) },
name: () => { return this._name; }
}
}
function OperatorObservable() {
let self = this;
this._ambulances = [];
return {
send: function (ambulance, address) {
if (self._ambulances.indexOf(ambulance) > -1) {
self._ambulances[ambulance].send(address);
}
},
register: function (ambulance) {
self._ambulances.push(ambulance);
}
unRegister: function (ambulance) {
delete self._ambulances[ambulance.name()];
}
}
};
//Usage:
let operator = new OperatorObservable();
let amb111 = new AmbulanceObserver('111');
let amb112 = new AmbulanceObserver('112');
operator.register(amb111);
operator.register(amb112);
operator.send(amb111, '27010 La Sierra Lane Austin, MN 000');
operator.unRegister(amb111);
operator.send(amb112, '97011 La Sierra Lane Austin, BN 111');
operator.unRegister(amb112);
区别：
- 聊天
mediator 在人员对象之间有两种通信方式（发送和接收），而操作员observable 只有一种方式通信（它告诉救护车observer 开车并完成）。
- 聊天
mediator可以让persons对象在他们之间进行交互（即使不是直接通信），救护车observers只注册到运营商observable事件。
- 每个人对象都有对聊天
mediator的引用，并且聊天mediator保持对每个人的引用。其中救护车observer 不保留对操作员observable 的引用，只有操作员observable 保留对每辆救护车observer 的引用。