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 mediator
padrã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 observer
padrã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
observable
mantém referência a cada um da ambulância observers
e 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
mediator
tem comunicação bidireccional entre os objectos da pessoa (enviar e receber), enquanto o operador observable
tem comunicação apenas unilateral (avisa a ambulância observer
para conduzir e terminar).
- O chat
mediator
pode fazer com que os objetos das pessoas interajam entre si (mesmo que não seja uma comunicação direta), as ambulâncias observers
só se cadastram nos observable
eventos da operadora .
- Cada objeto de pessoa tem uma referência ao chat
mediator
, e também o chat mediator
guarda referência a cada uma das pessoas. Quando a ambulância observer
não mantém referência ao operador observable
, apenas o operador observable
mantém referência a todas as ambulâncias observer
.
Programmers.StackExchange
foi negado, mas fiz uma postagem semelhante porque estava interessado na resposta. Você pode achar algumas das respostas interessantes. :)