Prenons un exemple: considérez que vous souhaitez créer deux applications:
- Application de chat.
- Application d'opérateur d'ambulance d'urgence.
médiateur
Construire l'application de chat, vous choisirez le mediatormodèle de conception.
- Les personnes peuvent rejoindre et quitter le chat à un moment donné, il n'est donc pas logique de garder une référence directe entre deux personnes qui discutent.
- Nous devons encore faciliter une communication entre deux personnes et leur permettre de discuter.
Pourquoi préférerons-nous le mediator? jetez un œil à sa définition:
Avec le modèle médiateur, la communication entre les objets est encapsulée dans un objet médiateur. Les objets ne communiquent plus directement les uns avec les autres, mais communiquent par le biais du médiateur. Cela réduit les dépendances entre les objets communicants, réduisant ainsi le couplage.
Comment fonctionne la magie? Tout d'abord, nous allons créer le médiateur de chat et faire en sorte que les objets de personnes s'y inscrivent, afin qu'il ait une connexion bidirectionnelle avec chaque personne (la personne peut envoyer un message en utilisant le médiateur de chat car elle y a accès, et le médiateur de chat y aura accès. la méthode reçue de l'objet personne car il y a également accès)
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);
observateur
En construisant l'application d'appel 911, vous choisirez le observermodèle de conception.
- Chaque
observerobjet ambulance souhaite être informé de l'état d'urgence, afin de pouvoir conduire l'adresse et apporter son aide.
- L'opérateur d'urgence
observablegarde une référence à chacun des ambulances observerset les informe lorsqu'une aide est nécessaire (ou génère un événement).
Pourquoi préférerons-nous le observer? jetez un œil à sa définition:
Un objet, appelé le sujet, maintient une liste de ses dépendants, appelés observateurs, et les notifie automatiquement de tout changement d'état, généralement en appelant l'une de leurs méthodes.
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);
Les différences:
- Le chat
mediatora une communication bidirectionnelle entre les objets personnes (envoi et réception) où l'opérateur observablen'a qu'une communication à sens unique (il indique à l'ambulance observerde conduire et de terminer).
- Le chat
mediatorpeut faire interagir les objets personnes entre eux (même s'il ne s'agit pas d'une communication directe), les ambulances observersne s'enregistrent qu'aux observableévénements de l'opérateur .
- Chaque objet personne a une référence au chat
mediator, et le chat mediatorgarde également une référence à chacune des personnes. Là où l'ambulance observerne garde pas la référence à l'opérateur observable, seul l'opérateur observablegarde la référence à chaque ambulance observer.
Programmers.StackExchangeété refusée, mais j'ai publié un message similaire parce que j'étais intéressé par la réponse. Vous pourriez trouver certaines des réponses intéressantes. :)