23 Konstruktionsmodi 20: Java -Vermittlermodell
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: Verhaltensmuster
Klassendiagramm:
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.
Lassen Sie uns ein Beispiel verwenden, um zu veranschaulichen, was eine Kollegenklasse ist: Es gibt zwei Klassen A und B, von denen jede eine Zahl hat, und wir müssen sicherstellen, dass die Zahlen in der Klasse B immer 100 -mal die Zahlen in Klasse A sind. Wenn Sie die Anzahl der Klasse A ändern, multiplizieren Sie die Zahl mit 100 und zuweisen. Der Code ist wie folgt:
Abstract Class AbstractColleague {Protected Int -Nummer; public int getNumber () {Rückgabenummer; } public void setNumber (int nummer) {this.number = number; } // Abstract -Methode, das zugehörige Objekt gleichzeitig ändern, wenn die Zahlen public abstract void setNumber (int nummer, AbstractColleague Coll) geändert werden; } class ColleaGua erweitert AbstractColleague {public void setNumber (int nummer, collcolleague coll) {this.number = number; Coll.SetNumber (Nummer*100); }} Klasse ColleagueB erweitert AbstractColleague {public void setNumber (int nummer, collcolleague coll) {this.number = number; Coll.SetNumber (Nummer/100); }} public class Client {public static void main (String [] args) {AbstractColleague Colla = new ColleAguea (); AbstractColleague Collb = neuer Kollegin (); System.out.println ("================================================= ====================================================================== ====================================================================== ======================================================================= ====================================================================== ====================================================================== ====================================================================== ======================================================================= System.out.println ("Collbs Zahlenwert:"+collb.getNumber ()); Im obigen Code werden die Klasse A und B durch direkte Vereinigung verwandt. Wenn wir das Vermittlermodell verwenden möchten, können die Klasse A und B nicht direkt miteinander verbunden sein. Sie müssen einen Vermittler verwenden, um den Zweck der Vereinigung zu erreichen.
Abstract Class AbstractColleague {Protected Int -Nummer; public int getNumber () {Rückgabenummer; } public void setNumber (int nummer) {this.number = number; } // Beachten Sie, dass die Parameter hier keine Kollegen mehr sind, sondern ein intermediäres öffentliches abstraktes Void -SetNumber (int -Nummer, AbstractMediator AM); } class ColleaGua erweitert AbstractColleague {public void setNumber (int nummer, AbstractMediator am) {this.number = number; am.aaffectb (); }} class CareagueB erweitert AbstractColleague {@Override public void setNumber (int nummer, AbstractMediator am) {this.number = number; am.baffeecta (); }} Abstract Class AbstractMediator {Protected AbstractColleague A; geschützte AbstractColleague B; public AbstractMediator (AbstractColleague A, AbstractColleague b) {a = a; B = B; } public abstract void Aaffectb (); öffentliche abstrakte void baffecta (); } Klasse -Mediator erweitert AbstractMediator {public mediator (AbstractColleague A, AbstractColleague b) {Super (a, b); } // Die Auswirkungen von a auf b public void Aaffectb () {int number = a.getNumber (); B.SetNumber (Nummer*100); } // Die Auswirkungen von B auf eine öffentliche void baffecta () {int number = b.getNumber (); A.SetNumber (Nummer/100); }} public class Client {public static void main (String [] args) {AbstractColleague Colla = new ColleAguea (); AbstractColleague Collb = neuer Kollegin (); AbstractMediator AM = neuer Mediator (Colla, Collb); System.out.println ("======================= Effekt durch Einstellung =========================================================ieben =========================================================ieben =======================================================ieben System.out.println ("Collas Zahlenwert ist:"+Colla.getNumber ()); B======================================================================================== ===============================================================================ieben ==============================================================================ieben ===============================================================================ieben System.out.println ("Collbs Zahlenwert ist:"+collb.getNumber ());Obwohl der Code relativ lang ist, ist er immer noch relativ leicht zu verstehen. Tatsächlich soll der Code, der ursprünglich Objektbeziehungen in eine Vermittlungsklasse umgeht, neu verpackt und die Beziehung zwischen Objekten durch diese Mediationsklasse behandelt.
Vorteile des Vermittlermodells
1. Die angemessene Verwendung des Vermittlermodells kann eine übermäßige Kopplung zwischen Kollegenklassen vermeiden, sodass jede Kollegenklasse relativ unabhängig verwendet werden kann.
2. Die Verwendung des Mediator-Musters kann Eins-zu-Viele-Beziehungen zwischen Objekten in Einzelbeziehungen verwandeln, wodurch die Beziehungen zwischen Objekten leicht zu verstehen und aufrechtzuerhalten.
3. Die Verwendung des Vermittlermodells kann das Verhalten und die Zusammenarbeit von Objekten abstrahieren und die Interaktionen zwischen Objekten flexibler umgehen.
Anwendbare Szenarien
In der objektorientierten Programmierung hängt eine Klasse unweigerlich von anderen Klassen ab, und völlig unabhängige Klassen sind bedeutungslos. Es ist auch weit verbreitet, dass sich eine Klasse gleichzeitig auf mehrere Klassen verlassen kann. Da eine solche Situation existiert, bedeutet dies, dass die Eins-zu-Viele-Abhängigkeit ihre Rationalität hat. Die angemessene Verwendung des Mediatormusters kann die ursprünglich unordentliche Objektbeziehung klar machen, aber wenn es missbraucht wird, kann es negative Auswirkungen haben. Im Allgemeinen wird das Mediatormodell nur für die Beziehung zwischen Kollegenklassen berücksichtigt, in denen eine Netzstruktur vorliegt. Die Netzstruktur kann in eine Sternstruktur umgewandelt werden, um die Beziehung zwischen Kollegen klarer zu machen.
Das Vermittlermodell ist ein relativ häufiges Modell und ein relativ leicht zu missbrauchtes Modell. In den meisten Fällen wird die Beziehung zwischen Kollegenklassen nicht zu einer chaotischen Netzstruktur kompliziert. Daher ist es in den meisten Fällen in Ordnung, die Abhängigkeiten zwischen Objekten innerhalb der Kollegenklasse zu verkapulieren, und es besteht keine Notwendigkeit, das Vermittlungsmodell einzuführen. Der Missbrauch des Vermittlermodells wird die Dinge nur komplizierter machen.
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.