@ cdc 很好地解释了意图上的差异。

我会在上面添加更多的信息。

Observer : 允许将一个对象中的事件通知给不同的对象集(不同类的实例)

Mediator : 集中从特定类创建的一组对象之间的通信。

Structure of Mediator pattern from 工厂:

Mediator : 定义用于同事间通信的接口。

Colleague: Is an abstract class, which defines the events to be communicated between Colleagues

ConcreteMediator : 通过协调 同事对象并维护其同事来实现合作行为

ConcreteColleague: Implements the notification operations received through Mediator, which has been generated by other Colleague

现实生活中的一个例子:

您正在使用 Mesh拓扑维护计算机网络。如果添加了新计算机或删除了现有计算机，则该网络中的所有其他计算机都应该知道这两个事件。

让我们看看调解人模式是如何与之匹配的。

代码片段:

import java.util.List;
import java.util.ArrayList;


/* Define the contract for communication between Colleagues.
Implementation is left to ConcreteMediator */
interface Mediator{
public void register(Colleague colleague);
public void unregister(Colleague colleague);
}
/* Define the contract for notification events from Mediator.
Implementation is left to ConcreteColleague
*/
abstract class Colleague{
private Mediator mediator;
private String name;


public Colleague(Mediator mediator,String name){
this.mediator = mediator;
this.name = name;
}
public String toString(){
return name;
}
public abstract void receiveRegisterNotification(Colleague colleague);
public abstract void receiveUnRegisterNotification(Colleague colleague);
}
/*  Process notification event raised by other Colleague through Mediator.
*/
class ComputerColleague extends Colleague {
private Mediator mediator;


public ComputerColleague(Mediator mediator,String name){
super(mediator,name);
}
public  void receiveRegisterNotification(Colleague colleague){
System.out.println("New Computer register event with name:"+colleague+
": received @"+this);
// Send further messages to this new Colleague from now onwards
}
public  void receiveUnRegisterNotification(Colleague colleague){
System.out.println("Computer left unregister event with name:"+colleague+
":received @"+this);
// Do not send further messages to this Colleague from now onwards
}
}
/* Act as a central hub for communication between different Colleagues.
Notifies all Concrete Colleagues on occurrence of an event
*/
class NetworkMediator implements Mediator{
List<Colleague> colleagues = new ArrayList<Colleague>();


public NetworkMediator(){


}


public void register(Colleague colleague){
colleagues.add(colleague);
for (Colleague other : colleagues){
if ( other != colleague){
other.receiveRegisterNotification(colleague);
}
}
}
public void unregister(Colleague colleague){
colleagues.remove(colleague);
for (Colleague other : colleagues){
other.receiveUnRegisterNotification(colleague);
}
}
}


public class MediatorPatternDemo{
public static void main(String args[]){
Mediator mediator = new NetworkMediator();
ComputerColleague colleague1 = new ComputerColleague(mediator,"Eagle");
ComputerColleague colleague2 = new ComputerColleague(mediator,"Ostrich");
ComputerColleague colleague3 = new ComputerColleague(mediator,"Penguin");
mediator.register(colleague1);
mediator.register(colleague2);
mediator.register(colleague3);
mediator.unregister(colleague1);
}
}

产出:

New Computer register event with name:Ostrich: received @Eagle
New Computer register event with name:Penguin: received @Eagle
New Computer register event with name:Penguin: received @Ostrich
Computer left unregister event with name:Eagle:received @Ostrich
Computer left unregister event with name:Eagle:received @Penguin

说明:

1. Eagle is added to network at first through register event. No notifications to any other colleagues since Eagle is the first one.
2. 将 鸵鸟添加到网络时，会通知 老鹰: 现在呈现输出的第1行。
3. When 企鹅 is added to network, both 老鹰 and 鸵鸟 have been notified : Line 2 and Line 3 of output is rendered now.
4. When Eagle left the network through unregister event, both 鸵鸟 and 企鹅 have been notified. Line 4 and Line 5 of output is rendered now.

虽然它们都用于有组织的方式告诉状态变化，但它们在结构和语义上略有不同。

观察器用于从对象本身广播特定对象的状态更改。因此，变化发生在中心对象，它也负责发出信号。然而，在中介中，状态更改可以发生在任何对象中，但是它是通过中介进行广播的。所以流程是不同的。但是，我不认为这会影响我们的代码行为。我们可以用这个或那个来实现同样的行为。另一方面，这种差异可能会对代码的概念理解产生一些影响。

看，使用模式的主要目的是在开发人员之间创建一种共同的语言。因此，当我看到一个中介时，我个人理解多个元素试图通过一个代理/中心进行通信，以减少通信噪音(或促进 SRP) ，每个对象在发出状态更改信号的能力方面同样重要。例如，想象多架飞机接近一个机场。每个人都应该通过桥塔(中间人)进行沟通，而不是彼此之间进行沟通。(想象一下1000架飞机在着陆时相互通信——那将是一团糟)

但是，当我看到一个观察者时，它意味着有一些我可能关心的状态更改，并且应该注册/订阅以监听特定的状态更改。有一个负责发送状态更改信号的中心对象。例如，如果我在从 A 到 B 的路上关心一个特定的机场，我可以登记到那个机场去观看一些广播的事件，比如是否有一条空跑道或者类似的东西。

希望没人。

这个解释怎么样 观察者和中介者在技术上是相同的，用于为组件通信提供解耦方式，但用法不同。

而 obeserver 通知 订阅组件的状态变化(例如创建新的数据库记录) ，mediator 命令 注册的组件做一些与业务逻辑流相关的事情(发送电子邮件给用户进行密码重置)。

观察者

• 通知使用者负责订阅以接收通知
• 通知处理不是业务流程的一部分

调解员

• 连接“发布者”和“消费者”所需的显式注册
• 通知处理是特定业务流程的一部分

让我们举一个例子: 假设您想要构建两个应用程序:

1. 聊天软件。
2. Emergency ambulance operator application.

调解员

构建聊天应用程序时，您将选择 mediator设计模式。

• 人们可能在任何时间加入和离开聊天，所以保持两个人之间的直接联系是没有意义的。
• 我们仍然需要促进两个人之间的沟通，并允许他们进行交谈。

Why will we prefer the mediator? just have a look at its definition:

使用中介模式，对象之间的通信是 封装在中介对象中。对象不再通信 直接交流，而不是通过 这减少了通信对象之间的依赖关系, thereby reducing coupling.

魔法是怎么起作用的？首先我们将创建聊天中介，并使人对象注册到它，这样它将与每个人有两个方向的连接(人可以使用聊天中介发送消息，因为它有访问它的权限，聊天中介将访问人对象的接收方法，因为他也有访问它的权限)

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(ronan, 'Hello there, nice to meet you');
ronan.send(colton, 'Nice to meet you to');


colton.send(ronan, 'Goodbye!');
chat.unRegister(colton);

观察者

构建911呼叫应用程序时，您将选择 observer设计模式。

• 每个救护车 observer对象希望被告知当有一个紧急状态，所以他可以驱动的地址和提供帮助。
• 应急操作员 observable保持参考每辆救护车 observers，并通知他们，当需要帮助(或发生事件)。

为什么我们更喜欢 observer? 看看它的定义:

An object, called the subject, maintains a list of its dependents, 调用观察员，并自动通知他们任何状态 通常通过调用它们的一个方法来更改。

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);

区别:

1. 聊天 mediator在人物对象(发送和接收)之间有双向通信，其中操作者 observable只有单向通信(它告诉救护车 observer开车和完成)。
2. The chat mediator can make the persons objects interact between them (even if it not a direct communication), the ambulances observers only registers to the operator observable events.
3. 每个人物对象都有一个对聊天 mediator的引用，而且聊天 mediator保持对每个人物的引用。如果救护车 observer没有参考操作员 observable，只有操作员 observable参考每辆救护车 observer。