Vamos por um exemplo: considere que você deseja construir dois aplicativos:
- Aplicativo de bate-papo.
- Aplicativo para operador de ambulância de emergência.
mediador
Ao construir o aplicativo de chat, você escolherá o mediatorpadrão de design.
- As pessoas podem entrar e sair do chat a qualquer momento, portanto não faz sentido manter uma referência direta entre duas pessoas conversando.
- Ainda precisamos facilitar a comunicação entre duas pessoas e permitir que elas conversem.
Por que vamos preferir o mediator? basta dar uma olhada em sua definição:
Com o padrão de mediador, a comunicação entre objetos é encapsulada em um objeto de mediador. Os objetos não se comunicam mais diretamente uns com os outros, mas se comunicam por meio do mediador. Isso reduz as dependências entre os objetos em comunicação, reduzindo assim o acoplamento.
Como funciona a magia? Primeiro iremos criar o mediador de chat e fazer com que os objetos de pessoas se registrem nele, então ele terá duas conexões direcionais com cada pessoa (a pessoa pode enviar mensagem usando o mediador de chat porque tem acesso a ele, e o mediador de chat irá acessar o método recebido do objeto pessoa porque ele também tem acesso a ele)
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
Ao construir o aplicativo de chamada para o 911, você escolherá o observerpadrão de design.
- Cada ambulância
observer objeto deseja ser informado quando houver um estado de emergência, para que ele possa dirigir até o endereço e dar ajuda.
- O operador de emergência
observablemantém referência a cada um da ambulância observerse os notifica quando ajuda é necessária (ou evento gerador).
Por que vamos preferir o observer? basta dar uma olhada em sua definição:
Um objeto, chamado de assunto, mantém uma lista de seus dependentes, chamados de observadores, e os notifica automaticamente sobre qualquer mudança de estado, geralmente chamando um de seus 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);
As diferenças:
- O chat
mediatortem comunicação bidireccional entre os objectos da pessoa (enviar e receber), enquanto o operador observabletem comunicação apenas unilateral (avisa a ambulância observerpara conduzir e terminar).
- O chat
mediatorpode fazer com que os objetos das pessoas interajam entre si (mesmo que não seja uma comunicação direta), as ambulâncias observerssó se cadastram nos observableeventos da operadora .
- Cada objeto de pessoa tem uma referência ao chat
mediator, e também o chat mediatorguarda referência a cada uma das pessoas. Quando a ambulância observernão mantém referência ao operador observable, apenas o operador observablemantém referência a todas as ambulâncias observer.
Programmers.StackExchangefoi negado, mas fiz uma postagem semelhante porque estava interessado na resposta. Você pode achar algumas das respostas interessantes. :)