Gehen wir an einem Beispiel vorbei: Stellen Sie sich vor, Sie möchten zwei Anwendungen erstellen:
- Chat-Anwendung.
- Anwendung des Rettungswagenbetreibers.
Vermittler
Wenn Sie die Chat-Anwendung erstellen, wählen Sie das mediatorEntwurfsmuster aus.
- Die Personen können jederzeit dem Chat beitreten und ihn verlassen. Daher ist es nicht sinnvoll, einen direkten Bezug zwischen zwei Personen zu halten, die sich unterhalten.
- Wir müssen noch die Kommunikation zwischen zwei Personen erleichtern und ihnen ein Gespräch ermöglichen.
Warum werden wir das bevorzugen mediator? Schauen Sie sich nur die Definition an:
Mit dem Mediatormuster wird die Kommunikation zwischen Objekten in einem Mediatorobjekt eingekapselt. Objekte kommunizieren nicht mehr direkt miteinander, sondern über den Mediator. Dies verringert die Abhängigkeiten zwischen kommunizierenden Objekten, wodurch die Kopplung verringert wird.
Wie funktioniert die Magie? Zuerst erstellen wir den Chat-Mediator und lassen die Personenobjekte registrieren, sodass er mit jeder einzelnen Person in zwei Richtungen verbunden ist (die Person kann mithilfe des Chat-Mediators eine Nachricht senden, da sie Zugriff darauf hat, und der Chat-Mediator greift darauf zu die empfangene Methode des Personenobjekts, weil er auch Zugriff darauf hat)
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);
Beobachter
Wenn Sie die 911-Anrufanwendung erstellen, wählen Sie das observerEntwurfsmuster aus.
- Jedes Krankenwagenobjekt
observermöchte informiert werden, wenn ein Notfall vorliegt, damit er die Adresse fahren und Hilfe geben kann.
- Der Notdienstmitarbeiter nimmt
observableBezug auf jeden einzelnen Krankenwagen observersund benachrichtigt ihn, wenn Hilfe benötigt wird (oder ein Ereignis generiert wird).
Warum werden wir das bevorzugen observer? Schauen Sie sich nur die Definition an:
Ein Objekt, das als Subjekt bezeichnet wird, führt eine Liste seiner abhängigen Personen, die als Beobachter bezeichnet werden, und benachrichtigt sie automatisch über Statusänderungen, normalerweise durch Aufrufen einer ihrer Methoden.
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);
Die Unterschiede:
- Der Chat
mediatorverfügt über eine bidirektionale Kommunikation zwischen den Objekten der Person (Senden und Empfangen), wobei der Bediener observablenur über eine bidirektionale Kommunikation verfügt (er weist den Krankenwagen an, observerzu fahren und zu beenden).
- Der Chat
mediatorkann dazu führen, dass die Objekte der Person zwischen ihnen interagieren (auch wenn es sich nicht um eine direkte Kommunikation handelt). Der Krankenwagen observersregistriert sich nur bei den Bedienerereignissen observable.
- Jedes Personenobjekt hat einen Verweis auf den Chat
mediator, und auch der Chat enthält mediatoreinen Verweis auf jede einzelne Person. Während sich der Krankenwagen observernicht auf den Bediener bezieht, bezieht sich observablenur der Bediener observableauf jeden Krankenwagen observer.
Programmers.StackExchangewurde abgelehnt, aber ich habe dort einen ähnlichen Beitrag verfasst, weil ich an der Antwort interessiert war. Vielleicht finden Sie einige der Antworten interessant. :)