einführen
Der Mediator -Modus (Mediator) verwendet ein Mediatorobjekt, um eine Reihe von Objektinteraktionen zu verkapulieren. Der Vermittler lässt die Objekte nicht ausdrücklich auf einander verwiesen werden, wodurch sie locker gekoppelt werden und ihre Interaktionen unabhängig ändern kann.
Der Hauptinhalt stammt von: http://www.addyosmani.com/resources/essentialjsdesignPatterns/book/#mediatorPatternjavaScript
Text
In der Softwareentwicklung sind Vermittler ein Verhaltensdesignmuster, mit dem verschiedene Teile des Systems durch Bereitstellung einer einheitlichen Schnittstelle kommunizieren können. Im Allgemeinen muss ein zentraler Steuerpunkt erstellt werden, damit jedes Modul über den zentralen Kontrollpunkt interagiert, wenn das System viele Submodule hat, die direkt kommuniziert werden müssen. Das Vermittlermodell ermöglicht es diesen Submodulen, den Zweck der Entkopplung ohne direkte Kommunikation zu erreichen.
Zum Beispiel ist das gemeinsame Flughafenverkehrskontrollsystem, der Turm, ein Vermittler, der den Start und die Landung des Flugzeugs (Submodul) steuert, da die gesamte Kommunikation aus dem Flugzeug, das an den Turm berichtet wird, abgeschlossen ist, anstatt vor dem Flugzeug miteinander zu kommunizieren. Das zentrale Steuerungssystem ist der Schlüssel zum System, dh die Rolle des Vermittlers bei der Softwaredesign.
Lassen Sie es uns zunächst mit Pseudo-Code verstehen:
Die Codekopie lautet wie folgt:
// Der folgende Code ist Pseudo-Code. Bitte achten Sie nicht zu viel auf den Code
// Hier entspricht der App -Namespace dem Spiel der Rolle eines Vermittlers
var App = App || {};
// AJAX -Anfragen über App Intermediary stellen
app.sendRequest = Funktion (Optionen) {
return $ .ajax ($. Extend ({}, Optionen);
}
// Zeigen Sie nach der Anforderung der URL die Ansicht an
App.PopulateView = Funktion (URL, Ansicht) {
$ .when (app.sendRequest ({url: url, method: 'get'})
.then (function () {
// Inhalt anzeigen
});
}
// Inhalt löschen
app.resetview = function (view) {
view.html ('');
}
In JavaScript sind Vermittler sehr häufig und entsprechen dem Nachrichtenbus im Beobachtermuster. Sie werden jedoch nicht implementiert, indem sie Pub/Sub -Like -Beobachter anrufen, sondern von Vermittlern auf einheitliche Weise verwaltet werden. Lassen Sie uns ein Beispiel geben, das auf dem Beobachter basiert:
Die Codekopie lautet wie folgt:
var mediator = (function () {
// Abonnieren Sie ein Ereignis und geben Sie eine Rückruffunktion an, nachdem das Ereignis ausgelöst wurde
var subskrible = function (Kanal, fn) {
if (! Mediator.Channels [Kanal]) Mediator.Channels [Kanal] = [];
Mediator.Channels [Kanal] .push ({context: this, callback: fn});
gib dies zurück;
},
// Events übertragen
Publish = Funktion (Kanal) {
if (! mediator.channels [Kanal]) false zurückgeben;
var args = array.prototype.slice.call (Argumente, 1);
für (var i = 0, l = mediator.channels [Kanal] .Length; i <l; i ++) {
var subscription = mediator.channels [Kanal] [i];
Abonnement.callback.Apply (Abonnement.Context, Args);
}
gib dies zurück;
};
zurückkehren {
Kanäle: {},
veröffentlichen: veröffentlichen,,
abonnieren: abonnieren,
Installto: Funktion (obj) {
obj.subscribe = abonnieren;
obj.publish = publish;
}
};
} ());
Das Aufrufen des Code ist relativ einfach:
Die Codekopie lautet wie folgt:
(Funktion (Mediator) {
Funktion initialize () {
// Standardwert
Mediator.Name = "DUDU";
// Abonnieren Sie eine Veranstaltung Namechange
// Die Rückruffunktion zeigt Informationen vor und nach der Änderung an
mediator.subscribe ('namechange', function (arg) {
console.log (this.name);
this.name = arg;
console.log (this.name);
});
}
Funktion updateName () {
// Broadcast -Trigger -Ereignis, Parameter sind neue Daten
Mediator.publish ('Namechange', 'Tom'); // Dudu, Tom
}
initialisieren(); // initialisieren
updateName (); // Anruf
})(Vermittler);
Vermittler und Beobachter
Zu diesem Zeitpunkt können jeder verwirrt sein. Der Vermittler und der Beobachter scheinen ähnlich zu sein. Was ist der Unterschied? Es ist eigentlich ein bisschen ähnlich, aber schauen wir uns die spezifische Beschreibung an:
Beobachtermuster, ein einzelnes Objekt, das keine Einschränkungen zusammenfasst. Im Gegenteil, Beobachterbeobachter und konkretes Subjekt arbeiten zusammen, um Einschränkungen aufrechtzuerhalten. Kommunikation interagiert durch mehrere Beobachter und mehrere konkrete Klassen: Jede konkrete Klasse enthält normalerweise mehrere Beobachter, und manchmal ist ein Beobachter in der konkreten Klasse auch die konkrete Klasse eines anderen Beobachters.
Was das Vermittlungsmodell tut, ist nicht nur die Verteilung, sondern es spielt die Rolle der Aufrechterhaltung dieser Einschränkungen.
Vermittlungs- und Aussehensmuster
Viele Menschen können auch über den Unterschied zwischen Vermittlungs- und Erscheinungsmustern verwirrt sein. Beide werden die vorhandenen Module abstrahieren, aber es gibt einige subtile Unterschiede.
Was der Vermittler tut, ist, zwischen Modulen zu kommunizieren, was multidirektional ist. Der Erscheinungsmodus definiert jedoch einfach eine einfache Schnittstelle für ein bestimmtes Modul oder ein bestimmtes System, ohne zusätzliche Funktionen hinzuzufügen. Das Konzept anderer Module im System hat keine direkte Verbindung mit dem Aussehensmodus und kann als Einweg betrachtet werden.
Hier ist ein weiteres vollständiges Beispiel:
Die Codekopie lautet wie folgt:
<! docType html>
<html lang = "en">
<kopf>
<title> JavaScript -Muster </title>
<meta charset = "utf-8">
</head>
<body>
<div ID = "Ergebnisse"> </div>
<Script>
Funktionsspieler (Name) {
this.points = 0;
this.name = name;
}
Player.Prototype.play = function () {
this.points += 1;
Mediator.Played ();
};
var scoreboard = {
// Container zum Anzeigen von Inhalten
Element: Document.GetElementById ('Ergebnisse'),
// Anzeige der Punktzahl aktualisieren
Update: Funktion (Punktzahl) {
var i, msg = '';
für (i in Score) {
if (Score.hasownProperty (i)) {
msg + = '<p> <strong>' + i + '<// strong>:';
MSG += Score [i];
msg += '<// p>';
}
}
this.element.innerhtml = msg;
}
};
var mediator = {
// alle Spieler
Spieler: {},
// Initialisierung
Setup: function () {
var player = this.player;
Spieler.Home = New Player ('Home');
Spieler.Guest = neuer Spieler ('Gast');
},
// Nach dem Spiel aktualisieren Sie die Punktzahl
gespielt: function () {
var player = this.player,
Score = {
Startseite: Spieler.Home.Points,
Gast: Player.Guest.Points
};
Anzeigetafel.Update (Score);
},
// Benutzerschlüsselinteraktion verarbeiten
TastePress: Funktion (e) {
e = e || Fenster.Event; // dh
if (e.Which === 49) {// Zahlenschlüssel "1"
Mediator.players.home.play ();
zurückkehren;
}
if (e.Which === 48) {// Zahlenschlüssel "0"
Mediator.players.guest.play ();
zurückkehren;
}
}
};
// gehen!
Mediator.SetUp ();
window.onkeypress = mediator.keypress;
// enden nach 30 Sekunden
setTimeout (function () {
window.onkeypress = null;
console.log ('game Over!');
}, 30000);
</script>
</body>
</html>
Zusammenfassen
Der Zwischenmodus wird im Allgemeinen in Situationen verwendet, in denen eine Gruppe von Objekten genau definiert wurde, aber auf komplexe Weise kommuniziert. Im Allgemeinen ist der Vermittlermodus im System einfach zu bedienen, aber auch im System leicht zu missbrauchen. Wenn im System eine komplexe Objektgruppe von vielen Interaktionen mit vielen zu vielen Interaktionen erscheint, beeilen Sie sich nicht zuerst im Vermittlermodus, sondern überlegen Sie, ob mit dem Systemdesign etwas nicht stimmt.
Da das Intermediärmodell die Interaktionskomplexität in die Komplexität des Vermittlers selbst verwandelt, ist das Intermediary -Objekt komplexer als jedes andere Objekt.