Definition: Kapitulieren Sie eine Reihe von Objektinteraktionen mit einem Mediatorobjekt. Der Mediator lässt jedes Objekt ohne Anzeige interagieren, wodurch die Kopplung gelockert wird und die Wechselwirkung zwischen ihnen unabhängig verändert.
Typ: Verhaltensklassenmusterklassendiagramm:
Die Struktur des Vermittlermodells
Der Zwischenmodus wird auch als Mediatormodus bezeichnet. Aus dem Klassendiagramm ist es in 3 Teile unterteilt:
Zusammenfassung Mediator: Definieren Sie die Schnittstelle zwischen Kollegenklassenobjekten und Mediatorobjekten und wird für die Kommunikation zwischen jeder Kollegenklasse verwendet. Im Allgemeinen enthält es eine oder mehrere abstrakte Ereignismethoden und wird durch Unterklassen implementiert.
Vermittler -Implementierungsklasse: Von abstrakten Mediatoren und implementierten Ereignismethoden, die in abstrakten Mediatoren definiert sind. Empfangen Sie Nachrichten von einer Kollegenklasse und beeinflussen Sie dann andere gleichzeitige Klassen durch die Nachricht.
Kollegenklasse: Wenn ein Objekt andere Objekte beeinflusst und auch von anderen Objekten beeinflusst wird, werden diese beiden Objekte als Kollegenklassen bezeichnet. Im Klassendiagramm gibt es nur eine Kollegenklasse, die tatsächlich eine Auslassung der Realität ist. In praktischen Anwendungen besteht die Kollegenklasse im Allgemeinen aus mehreren und beeinflussen und hängen voneinander ab. Je mehr Kollegen es gibt, desto komplizierter die Beziehungen. Darüber hinaus kann die Kollegenklasse auch als eine Reihe von Implementierungen dargestellt werden, die dieselbe abstrakte Klasse erben. Im Vermittlermodell muss die Nachricht durch Vermittler zwischen Kollegen übertragen werden.
Warum das Vermittlermodell verwenden?
Im Allgemeinen ist die Beziehung zwischen Kollegenklassen relativ komplex. Wenn mehrere Kollegungsklassen korreliert sind, wird ihre Beziehung als komplexe Netzstruktur angezeigt. Dies ist eine übergekoppelte Architektur, dh sie ist der Wiederverwendung der Klassen nicht förderlich und nicht stabil. In der folgenden Abbildung gibt es beispielsweise sechs kollegenähnliche Objekte. Wenn sich Objekt 1 ändert, werden 4 Objekte betroffen. Wenn sich Objekt 2 ändert, werden 5 Objekte betroffen. Mit anderen Worten, das Design der direkten Korrelation zwischen Kollegen ist nicht gut.
Wenn das Vermittlermodell eingeführt wird, wird die Beziehung zwischen Kollegenklassen zu einer Sternstruktur. Aus der Abbildung können wir erkennen, dass die Änderungen in einer Klasse nur die Klasse selbst und den Vermittler beeinflussen, was die Kopplung des Systems verringert. Ein gutes Design wird definitiv nicht alle Objekte-Relations-Verarbeitungslogik in dieser Klasse zusammenfassen, sondern verwenden eine spezielle Klasse, um Verhaltensweisen zu verwalten, die Ihnen nicht gehören.
Beispiel
Das Folgende ist ein spezifisches Codebeispiel. Im Vergleich zum allgemeinen Klassendiagramm werden die AbstractColleague abstrakte Kolleginklasse und der AbstractMediator abstrakte Mediator hinzugefügt. Darüber hinaus gibt es zwei spezifische Kollegenklassen und einen bestimmten Mediator. Es gibt viele Kommentare im Code, und das entsprechende Klassendiagramm wird nicht gegeben, was nicht schwer zu verstehen ist:
Kollegen:
// abstrakte Kollegen Klasse Abstract Class AbstractColleague {Protected AbstractMediator Mediator; /** Da es einen Vermittler gibt, muss jeder bestimmte Kollegen Kontakt mit dem Vermittler haben,*ansonsten müssen in diesem System nicht vorhanden sein. Der Konstruktor hier entspricht der Registrierung eines Vermittlers mit dem System, um sich in Kontakt zu bringen*/ öffentliches AbstractColleague (AbstractMediator Mediator) {this.Mediator = Mediator; } // Fügen Sie eine Methode zur Kontaktaufnahme mit dem Vermittler (d. H. Registrierung) im abstrakten Kollegenklasse Public Void SetMediator (AbstractMediator Mediator) hinzu {this.Mediator = Mediator; }} // Spezifischer Kollege Eine Klassenkollegin erweitert AbstractColleague {// Jeder spezifische Kollegen kontaktiert den Mediator über die übergeordnete Klassenkonstruktor -Kollegin (AbstractMediator Mediator) {Super (Mediator); } // Jeder bestimmte Kollegen muss seine eigenen Aufgaben haben, und es besteht keine Notwendigkeit, mit der Außenwelt öffentliche void self () {System.out.println ("Colleagua -> Ihre eigenen Aufgaben zu erledigen ..."); } // Jeder spezifische Kollegen muss immer mit der Außenwelt interagieren, diese Logik übernehmen und die Arbeit durch den Mediator Public void out () {System.out.println ("Colleaguea-> Anfrage Kollegen B, um seine Teilzeitarbeit zu erledigen ..."); Super.Mediator.execute ("Kollegin", "Selbst"); }} // Spezifischer Kollege B -Klasse ColleagueB erweitert AbstractColleague {public CollegeB (AbstractMediator Mediator) {Super (Mediator); } public void self () {system.out.println ("Kollegin B-> DO IHRE PREISCHAFTE ..."); } public void out () {System.out.println ("Kollegin B-> Anfrage Kollege A, um seine Teilzeitarbeit zu erledigen ..."); Super.Mediator.execute ("Colleaguea", "Self"); }} Zwischenkategorie:
// Abstract Intermediary Abstract Class AbstractMediator {// Der Vermittler muss die Kontaktinformationen mehrerer Kollegen geschützt Hashtable <String, AbstractColleague> Kollegen = neuer Hashtable <String, AbstractColleague> (); // Der Vermittler kann den Kontakt mit einem Kollegen public void addColleague (String -Name, AbstractColleague c) {this.colleAgues.put (Name, c); } // Der Vermittler kann auch den Kontakt mit einem Kollegen public void DeleteColleague (String -Name) {this.colleAgues.remove (Name) dynamisch absagen; } // Der Vermittler muss Operationen haben, um Logik zu erledigen, Aufgaben zuzuweisen und die Kommunikation zwischen Kollegen öffentlicher abstrakter void Execute (String -Name, String -Methode) zu fördern. } // Spezifischer Vermittlerklassenmediator erweitert den AbstractMediator {// Die wichtigste Funktion des Vermittlers besteht darin, zwischen Kollegen public void auszusetzen (String -Name, String -Methode) {if ("self" .equals (methode)) {// Jede Person hat ihre eigenen Pflichten if ("Kollegin". (ColleAguea) Super.ColleAgues.get ("ColleAgua"); Kollegin.self (); } else {CareagueB Careague = (CareagueB) Super.ColleAgues.get ("CareagueB"); Kollegin.self (); }} else {// College mit anderen Kollegen if ("colleAguea" .Equals (name)) {ColleAguea Colleague = (ColleAguea) super.colleAgues.get ("ColleAguea"); Careague.out (); } else {CareagueB Careague = (CareagueB) Super.ColleAgues.get ("CareagueB"); Careague.out (); }}}}} Testklasse:
// Class Public Class Client testen {public static void main (String [] args) {// Erstellen Sie einen intermediären AbstractMediator Mediator = new Mediator (); // zwei Kollegen ColleaGuea ColleaGuea = New ColleaGuea (Mediator) erstellen; ColleagueB ColleagueB = New ColleagueB (Mediator); // Der Vermittler stellt Kontakt mit jedem Kollegen Mediator.Addcolleague ("Colleaguea", Colleaguea) her; Mediator.Addcolleague ("Kollegin", ColleagueB); // Kollegen fangen an, Kollegen zu arbeiten. Colleaguea.out (); System.out.println("========================================================================================================= =================================================================== =================================================================== =================================================================== =================================================================== =================================================================== =================================================================== Testergebnisse:
Kollegin A -> Machen Sie Ihren Beitrag zu Ihren Pflichten ... Kollegen A -> Bitten Sie Kollegin B, Ihren Beitrag zu Ihren Aufgaben zu erledigen ... Kollegen B -> Ihre Rolle bei Ihren Aufgaben beteiligen ... Kollegin B -> Machen Sie Ihren Beitrag zu Ihren Pflichten ... Kollegen B -> Bitten Sie Kollegin A, Ihren Beitrag zu Ihren Aufgaben zu erledigen ... Kollegen A -> Ihre Rolle in Ihren Aufgaben beteiligen ...
Obwohl es im obigen Code nur zwei spezifische Kollegenklassen gibt und in der Testklasse nur zwei Kollegen erstellt werden, können wir diese entsprechend dem Zweck des Vermittlermodells angemessen erweitern, dh bestimmte Kollegenklassen hinzufügen, und dann muss der Vermittler schwerere Aufgaben schultert. Warum? Wir sehen, dass es in der oben genannten Mediatorklasse jetzt eine Reihe langer Beurteilungscodes in der Methode Execute () gibt. Obwohl es in der Mediatorklasse zersetzt und zu anderen privaten Methoden hinzugefügt werden kann, ist eine spezifische Geschäftslogik unverzichtbar.
Während die Entkopplung der Verbindung zwischen Kollegen, ist der Vermittler selbst auch nicht mit übertriebenen Aufgaben überein, da fast die gesamte Geschäftslogik dem Vermittler erklärt wird, was als "sehr erwartete" Rolle beschrieben werden kann. Dies sind die Mängel des Vermittlermodells.
Darüber hinaus ist das obige Codebeispiel ziemlich ideal. Manchmal können wir die Gemeinsamkeiten zwischen "Kollegen" überhaupt nicht extrahieren, um eine abstrakte abstrakte Kollegenklasse zu bilden, die die Schwierigkeit, das Vermittlermodell zu verwenden, erheblich erhöht.
Überarbeiten:
Da die obige Code-Implementierung von "Zwei-Wege-Assoziation, die in der App" ausgesetzt "von Senior Benjielin vorgeschlagen wurde, gemäß der angegebenen Verbesserungsmethode 2 vorhanden sind, ändern Sie den oben genannten Code wie folgt:
Modifizierte Kollegen:
// Abstract Class AbstractColleague {Protected AbstractMediator Mediator; // Hör auf, eine Verbindung mit dem Mediator im Konstruktor herzustellen // Public AbstractColleague (AbstractMediator Mediator) {// This.Mediator = Mediator; //} // der abstrakten Kollegenklasse eine Methode hinzufügen, um den Mediator (d. H. Registrierung) öffentlicher Void -SetMediator (AbstractMediator Mediator) {this.Mediator = Mediator; }} // spezifischer Kollege Eine Klassenkollegin erweitert AbstractColleague {// keine Verbindung mit dem Mediator im Konstruktor // public Collegea (AbstractMediator -Mediator) {// Super (Mediator); //} // Jeder bestimmte Kollegen muss seinen eigenen Teil seines Teils haben, und es besteht keine Notwendigkeit, mit der Außenwelt öffentliche void self () {System.out.println ("ColleAgua -> Mach deinen Teil seines Teils ..."); } // Jeder spezifische Kollegen muss immer mit der Außenwelt interagieren, diese Logik übernehmen und die Arbeit durch den Mediator Public void Out () {System.out.println ("Colleaguea -> Anfrage Kollegin B, um den Teil seines Teils seines Teils zu tun ..."); Super.Mediator.execute ("Kollegin", "Selbst"); }} // spezifischer Kollegin B -Klasse ColleagueB erweitert AbstractColleague {// Hör auf, eine Verbindung mit dem Mediator im Konstruktor // öffentlicher Kollege (AbstractMediator -Mediator) {// Super (Mediator); //} public void self () {system.out.println ("kollegueB -> mach dein Teil ..."); } public void out () {system.out.println ("kollegueB -> Fragen Sie den Kollegen A, um Ihren Teil zu tun ..."); Super.Mediator.execute ("Colleaguea", "Self"); }}
Modifizierter Vermittler:
// Abstract Intermediary Abstract Class AbstractMediator {// Der Vermittler muss die Kontaktinformationen mehrerer Kollegen geschützt Hashtable <String, AbstractColleague> Kollegen = neuer Hashtable <String, AbstractColleague> (); // Der Vermittler kann den Kontakt mit einem Kollegen public void addColleague dynamisch aufbauen (String -Name, AbstractColleague C) {// Hilfe spezifischen Kollegen helfen, Kontakte aus dem Zwischenmediär C.SetMediator (this) zu ermitteln. this.colleAgues.put (Name, c); } // Der Vermittler kann auch den Kontakt mit einem Kollegen public void deleteColleague (String -Name) {this.colleAgues.remove (Name) dynamisch widerrufen; } // Der Vermittler muss Operationen haben, um Logik zu erledigen, Aufgaben zuzuweisen und die Kommunikation zwischen Kollegen öffentlicher abstrakter void Execute (String -Name, String -Methode) zu fördern. } // Die Testklasse öffentliche Klasse Client {public static void main (String [] args) {// Erstellen Sie einen intermediären AbstractMediator Mediator = new Mediator (); // Der Konstruktor wird verwendet, um den Vermittler für bestimmte Kollegen zu registrieren, um sich zu wenden // ColleaGh ColleaGuea = New ColleaGuea (Mediator); // CareagueB ColleagueB = New ColleagueB (Mediator); ColleAguea colleAguea = new ColleAguea (); ColleagueB ColleagueB = New CareagueB (); // Der Vermittler stellt Kontakt mit jedem Kollegen Mediator.Addcolleague ("Colleaguea", Colleaguea) her; Mediator.Addcolleague ("Kollegin", ColleagueB); // Die Kollegen fangen an, Kollegen zu arbeiten. Colleaguea.out (); System.out.println ("================================================= ====================================================================== ====================================================================== ======================================================================= ====================================================================== ====================================================================== ====================================================================== =======================================================================Die Ergebnisse nach dem Test sind die gleichen wie vor der Änderung.