1. Gesamtzahl der Zusammenfassung
1. Der Autor spricht kurz darüber
Geben wir ein einfaches Beispiel aus unserem täglichen Leben. Wenn wir zu einer Immobilienbehörde gehen, um ein Haus zu mieten, bildet die Immobilienbehörde einen Vermittler zwischen dem Mieter und dem Vermieter des Vermieters. Der Mieter ist es egal, wen er mietet. Der Vermieter des Vermieters ist es egal, wen er mietet. Diese Transaktion wurde aufgrund der Existenz eines Vermittlers so bequem.
Während des Softwareentwicklungsprozesses wird es zwangsläufig eine Situation geben, in der mehrere Klassen oder Subsysteme miteinander interagieren, und die Interaktion ist sehr kompliziert, was dazu führt, dass jede Klasse die Klassen kennen muss, mit denen sie interagieren müssen, damit ihre Kopplung äußerst leistungsfähig erscheint. Der ganze Körper ist von einer Bewegung betroffen, und die Folgen sind sehr ernst, und der große Bär ist sehr wütend! ~~~~ (> _ <) ~~~~
Okay, da die Frage aufgeworfen wurde, laden Sie bitte unseren Protagonisten in dieses Problem ein - das Vermittlermodell, das erscheint.
Die Funktion des Vermittlers besteht darin, die Wechselwirkung zwischen Objekten zu verringern. Wenn die Operationen eines Objekts Änderungen an anderen verwandten Objekten verursachen und dieses Objekt diese Beziehungen nicht selbst bewältigen möchte, können Sie einen Vermittler finden und diese störenden Beziehungen bewältigen lassen. Siehe das folgende kleine Beispiel:
Die Codekopie lautet wie folgt:
var partizipant = function (name) {
this.name = name;
this.chatroom = null;
};
Teilnehmer.Prototype = {
Senden: Funktion (Nachricht, an) {
this.chatroom.send (Nachricht, dies, zu);
},
Empfangen: Funktion (Nachricht, von) {
log.add (von.name + "zu" + this.name + ":" + message);
}
};
var chatroom = function () {
var Teilnehmer = {};
zurückkehren {
Register: Funktion (Teilnehmer) {
Teilnehmer [Teilnehmer.Name] = Teilnehmer;
Teilnehmer.Chatroom = this;
},
Senden: Funktion (Nachricht von, bis) {
if (zu) {
to.receive (meldung, von);
} anders {
für (Schlüssel in den Teilnehmern) {
if (Teilnehmer [Schlüssel]! == von) {
Teilnehmer [Schlüssel] .Receive (Nachricht, von);
}
}
}
}
};
};
var log = (function () {
var log = "";
zurückkehren {
Hinzufügen: Funktion (msg) {log + = msg + "/n"; },
show: function () {alert (log); log = ""; }
}
}) ();
Funktion run () {
var yoko = neuer Teilnehmer ("yoko");
var John = neuer Teilnehmer ("John");
var paul = neuer Teilnehmer ("Paul");
var ringo = neuer Teilnehmer ("Ringo");
var chatroom = neuer Chatroom ();
Chatroom.register (Yoko);
Chatroom.register (John);
Chatroom.register (Paul);
Chatroom.register (Ringo);
yoko.send ("Alles was du brauchst ist Liebe.");
yoko.send ("Ich liebe dich John.");
John.Send ("Hey, keine Notwendigkeit zu übertragen", Yoko);
Paul.Send ("Ha, ich höre das!");
Ringo.Send ("Paul, was denkst du?", Paul);
log.show ();
}
In dem Beispielcode haben wir vier Teilnehmer, indem wir einen Chat -Sitzungssitzen (Mediasy) registrieren. Vertreter der Teilnehmer für jeden Teilnehmer. Die Teilnehmer senden Nachrichten aneinander und verarbeiten Routen an Chatrooms.
Die Chatroom -Objekte hier spielen die Rolle des Vermittlers, koordinieren andere Objekte, organisieren sie vernünftig und reduzieren die Kopplung.
2. Quellcode -Fallreferenz
Wir sollten uns mit dem MVC-Dreischichtmodellmodell (Modell), der Ansichtspräsentation (Ansicht) und der Kontrollschicht (Steuerung/Mediator) sehr vertraut machen.
Die Kontrollschicht ist der Vermittler zwischen der Präsentationsschicht und der Modellschicht. Im Allgemeinen ist MVC auch eine Anwendung des Vermittlermodells im Rahmendesign.
3. Falleinführung
Die Codekopie lautet wie folgt:
Funktionsspieler (Name) {
this.points = 0;
this.name = name;
}
Player.Prototype.play = function () {
this.points += 1;
Mediator.Played ();
};
var scoreboard = {
Element: Document.GetElementById ('Ergebnisse'),
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 = {
Spieler: {},
Setup: function () {
var player = this.player;
Spieler.Home = New Player ('Home');
Spieler.Guest = neuer Spieler ('Gast');
},
gespielt: function () {
var player = this.player,
Score = {
Startseite: Spieler.Home.Points,
Gast: Player.Guest.Points
};
Anzeigetafel.Update (Score);
},
TastePress: Funktion (e) {
e = e || Fenster.Event;
if (e.Which === 49) {
Mediator.players.home.play ();
zurückkehren;
}
if (e.Which === 48) {
Mediator.players.guest.play ();
zurückkehren;
}
}
};
Mediator.SetUp ();
window.onkeypress = mediator.keypress;
setTimeout (function () {
window.onkeypress = null;
console.log ('game Over!');
}, 30000);
Vier, lasst uns zusammenfassen
Warum Mediator?
Es gibt viele Wechselwirkungen zwischen Objekten. Die Verhaltensoperationen jedes Objekts hängen voneinander ab, um das Verhalten eines Objekts zu ändern, und beinhaltet gleichzeitig das Ändern des Verhaltens vieler anderer Objekte.
Wenn Sie den Mediatormodus verwenden, kann die Kopplung zwischen jedem Objekt gelockert werden. Sie müssen sich nur um die Beziehung zum Mediator kümmern und die vielen zu viele Beziehung in eine Eins-zu-Viele-Beziehung verwandeln.
Es kann die Komplexität des Systems verringern und die veränderbare Skalierbarkeit verbessern.
Anlässe unter Verwendung des Vermittlermodells
1. Ein genau definierter Satz von Objekten, die jetzt eine komplexe Kommunikation erfordern.
2. Passen Sie ein Verhalten an, das in mehreren Klassen verteilt ist, ohne zu viele Unterklassen zu generieren.
Es ist ersichtlich, dass die Mediationsobjekte hauptsächlich zur Kapitulation des Verhaltens verwendet werden, und die Teilnehmer des Verhaltens sind diese Objekte, aber durch den Mediator müssen diese Objekte sich nicht kennen. (Spezifische Umsetzung des Dimit -Gesetzes)
Vorteile der Verwendung des Vermittlermodells:
1. Reduziert die Kopplung zwischen Systemobjekten, wodurch die Objekte leicht wiederverwendet werden können.
2. Verbessern Sie die Flexibilität des Systems und machen Sie das System einfach zu erweitern und zu warten.
Nachteile der Verwendung des Mediatormusters:
Die Nachteile des Vermittlermodells sind offensichtlich, da diese "Vermittler" mehr Verantwortung übernimmt. Sobald es ein Problem mit dem Vermittlerobjekt gibt, wird das gesamte System stark betroffen.