Veamos un ejemplo: considere que desea construir dos aplicaciones:
- Aplicación de chat.
- Aplicación de operador de ambulancia de emergencia.
mediador
Al construir la aplicación de chat, elegirá el mediator
patrón de diseño.
- Las personas pueden unirse y salir del chat en cualquier momento, por lo que no tiene ningún sentido mantener una referencia directa entre dos personas que conversan.
- Todavía tenemos que facilitar la comunicación entre dos personas y permitirles charlar.
¿Por qué preferiremos el mediator
? solo eche un vistazo a su definición:
Con el patrón mediador, la comunicación entre objetos se encapsula dentro de un objeto mediador. Los objetos ya no se comunican directamente entre sí, sino que se comunican a través del mediador. Esto reduce las dependencias entre los objetos en comunicación, reduciendo así el acoplamiento.
¿Cómo funciona la magia? Primero crearemos el mediador de chat y haremos que los objetos de las personas se registren en él, por lo que tendrá una conexión bidireccional con cada persona (la persona puede enviar un mensaje usando el mediador de chat porque tiene acceso a él y el mediador de chat accederá el método recibido de la persona objeto porque él también tiene acceso a él)
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);
observador
Al crear la aplicación de llamada al 911, elegirá el observer
patrón de diseño.
- Cada
observer
objeto de la ambulancia desea ser informado cuando hay un estado de emergencia, para poder conducir la dirección y brindar ayuda.
- El operador de emergencia
observable
mantiene la referencia a cada una de las ambulancias observers
y les notifica cuando se necesita ayuda (o evento generador).
¿Por qué preferiremos el observer
? solo eche un vistazo a su definición:
Un objeto, llamado sujeto, mantiene una lista de sus dependientes, llamados observadores, y les notifica automáticamente de cualquier cambio de estado, generalmente llamando a uno de sus métodos.
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);
Las diferencias:
- El chat
mediator
tiene comunicación bidireccional entre los objetos de las personas (enviar y recibir) donde el operador observable
solo tiene comunicación unidireccional (le dice a la ambulancia observer
que conduzca y termine).
- El chat
mediator
puede hacer que los objetos de las personas interactúen entre ellos (incluso si no es una comunicación directa), las ambulancias observers
solo se registran en los observable
eventos del operador .
- Cada objeto de persona tiene una referencia al chat
mediator
, y también el chat mediator
mantiene una referencia a cada una de las personas. Donde la ambulancia observer
no mantiene la referencia al operador observable
, solo el operador observable
mantiene la referencia a cada ambulancia observer
.
Programmers.StackExchange
fue denegada, pero hice una publicación similar allí porque estaba interesado en la respuesta. Puede que algunas de las respuestas te resulten interesantes. :)