Java-Designmuster-Mediator-Muster

Mediatormuster

Objektorientiertes Design fördert die Verteilung des Verhaltens zwischen verschiedenen Objekten. Im schlimmsten Fall muss jedes einzelne Objekt vorhanden sein Kennen Sie jedes andere Objekt.

Obwohl die Aufteilung eines Systems in viele Objekte die Wiederverwendbarkeit erhöht, verringert die Verbreitung von Verbindungen zwischen Objekten seine Wiederverwendbarkeit erheblich. Die Verbindungsbeziehung macht es für ein Objekt unmöglich, ohne das zu funktionieren Unterstützung anderer Objekte (das System erscheint als unteilbares Ganzes). Da das Verhalten auf viele Objekte verteilt ist, ist es derzeit sehr schwierig, dies zu tun Definiert, um das Verhalten des Systems anzupassen. Daher haben wir das Mediatorobjekt Mediator eingeführt:

Durch das Mediatorobjekt kann die Netzwerkstruktur in einen Stern umgewandelt werden Struktur mit einem Vermittler als Zentrum hat keine direkte Beziehung mehr zu einem anderen Objekt, sondern wird durch die Einführung des Vermittlerobjekts auch nicht durch die Einführung von beeinflusst Neue Objekte haben viele Änderungen verursacht.

Mediatormuster: Auch als Mediatormuster bekannt, wird ein Mediatorobjekt (Mediator) verwendet, um die Interaktion einer Reihe von Objekten zu kapseln, sodass jedes Objekt mit ihm kommunizieren kann einander, ohne sie zeigen zu müssen, wodurch die Kopplung gelöst wird und die Interaktion zwischen ihnen unabhängig voneinander geändert werden kann:

(Bildquelle: Design Patterns: The Foundation of Wiederverwendbare objektorientierte Software) Tipps: Jeder Kollege kennt nur die Existenz des Mediators und muss nicht wissen, ob andere Kollegen existieren (andernfalls muss er nur die Nachricht an den Mediator senden und dann). Der Mediator leitet es an andere Kollegen weiter (der Mediator speichert alle Kollegenbeziehungen und nur der Mediator weiß, wie viele/welche Kollegen es gibt).

Modusimplementierung

Die Vereinten Nationen leiten Erklärungen verschiedener Länder weiter und vermittelt die Beziehungen zwischen Ländern:
Länder senden und empfangen Nachrichten an den Sicherheitsrat der Vereinten Nationen, der zwischen den Ländern vermittelt. Leiten Sie Anfragen angemessen weiter, um kooperatives Verhalten umzusetzen:

Kollege

Abstrakte Kollegenklasse, definieren Sie die öffentlichen Methoden jedes Kollegen:

/**
 * @author jifang
 * @since 16/8/28 下午4:22.
 */
public abstract class Country {
 
 protected UnitedNations mediator;
 
 private String name;
 
 public Country(UnitedNations mediator, String name) {
  this.mediator = mediator;
  this.name = name;
 }
 
 public String getName() {
  return name;
 }
 
 protected abstract void declare(String msg);
 
 protected abstract void receive(String msg);
}

-------------------------------------- ------------------------- ----------- -------

ConcreteColleague

Concrete Colleague-Klasse:
•Jede Kollegenklasse kennt ihr Vermittlerobjekt
•Jedes Kollegenobjekt kommuniziert bei Bedarf mit seinem Vermittler um mit anderen Kollegen zu kommunizieren

class USA extends Country {
 
 public USA(UnitedNations mediator, String name) {
  super(mediator, name);
 }
 
 @Override
 public void declare(String msg) {
  mediator.declare(this, msg);
 }
 
 @Override
 public void receive(String msg) {
  System.out.println("美国接收到: [" + msg + "]");
 }
}
 
class Iraq extends Country {
 
 public Iraq(UnitedNations mediator, String name) {
  super(mediator, name);
 }
 
 @Override
 public void declare(String msg) {
  mediator.declare(this, msg);
 }
 
 @Override
 public void receive(String msg) {
  System.out.println("伊拉克接收到: [" + msg + "]");
 }
}
 
class China extends Country {
 
 public China(UnitedNations mediator, String name) {
  super(mediator, name);
 }
 
 @Override
 public void declare(String msg) {
  mediator.declare(this, msg);
 }
 
 @Override
 public void receive(String msg) {
  System.out.println("中国接收到: [" + msg + "]");
 }
}

--- -------------------------------- ------------------------------

Mediator

Abstract Mediator: Definiert eine Schnittstelle für die Interaktion mit der Kommunikation zwischen Kollegen:

public abstract class UnitedNations {
 
 protected List<Country> countries = new LinkedList<>();
 
 public void register(Country country) {
  countries.add(country);
 }
 
 public void remove(Country country) {
  countries.remove(country);
 }
 
 protected abstract void declare(Country country, String msg);
}

------------------ ---------------------- -------------- -------------------

ConcreteMediator

Spezifischer Mediator:
•Seine Kollegen verstehen und pflegen;
•Erreichen Kollaboratives Verhalten durch Koordinierung jedes Kollegenobjekts (Empfangen von Nachrichten von Kollegen und Erteilen von Befehlen an bestimmte Kollegen). Wenn keine Erweiterung vorhanden ist, kann der Mediator mit dem ConcreteMediator kombiniert werden.

•Client

class UnitedNationsSecurityCouncil extends UnitedNations {
 
 /**
  * 安理会在中间作出调停
  *
  * @param country
  * @param msg
  */
 @Override
 protected void declare(Country country, String msg) {
  for (Country toCountry : countries) {
   if (!toCountry.equals(country)) {
    String name = country.getName();
    toCountry.receive(name + "平和的说: " + msg);
   }
  }
 }
}

------------- ----------------------------- --------------------- -------------------

public class Client {
 
 @Test
 public void client() {
  UnitedNations mediator = new UnitedNationsSecurityCouncil();
 
  Country usa = new USA(mediator, "美国");
  Country china = new China(mediator, "中国");
  Country iraq = new Iraq(mediator, "伊拉克");
 
  mediator.register(usa);
  mediator.register(china);
  mediator.register(iraq);
 
  usa.declare("我要打伊拉克, 谁管我跟谁急!!!");
  System.out.println("----------");
  china.declare("我们强烈谴责!!!");
  System.out.println("----------");
  iraq.declare("来呀, 来互相伤害呀!!!");
 }
}

Zusammenfassung

Das Aufkommen des Mediators verringert die Kopplung zwischen Kollegen, sodass jeder Kollege und Mediator unabhängig voneinander geändert und wiederverwendet werden kann, die Mediation als unabhängiges Konzept behandelt und in einem Objekt zusammengefasst wird Verhalten der Objekte selbst auf die Interaktion zwischen ihnen.

•Anwendbarkeit
Das Zwischenmodell ist einfach im System anzuwenden Es ist auch leicht, es im System zu missbrauchen. Wenn das System mit komplexen Objektgruppen interagiert, sollten Sie sich nicht beeilen, einen Mediator zu verwenden Da ConcreteMediator die Zentralisierung steuert, wird die Komplexität der Interaktion zum Mediator, wodurch der Mediator komplexer wird als jeder andere ConcreteColleague. Es wird empfohlen, das Mediatormuster in den folgenden Situationen zu verwenden:

◦ Ein Set von Objekten kommunizieren auf klar definierte, aber komplexe Weise. Die daraus resultierenden gegenseitigen Abhängigkeiten sind verwirrend und schwer zu verstehen.

◦Ein Objekt verweist auf viele andere Objekte und kommuniziert direkt mit diesen Objekten, was die Wiederverwendung des Objekts erschwert.
◦Ich möchte ein Verhalten anpassen, das auf mehrere Klassen verteilt ist, ohne zu viele untergeordnete Klassen zu generieren.

•Verwandte Muster
◦Der Unterschied zwischen Facade und Mediator besteht darin, dass es ein Objektsubsystem abstrahiert und somit eine bequemere Schnittstelle bereitstellt. Das Protokoll ist unidirektional, d. h. Facade-Objekt stellt Anforderungen an diese Subsystemklasse. aber nicht umgekehrt. Im Gegenteil, Mediator bietet kollaboratives Verhalten, das nicht von jedem Kollegenobjekt unterstützt wird, und das Protokoll ist multidirektional. ◦Kollege kann das Observer-Muster verwenden, um mit Mediator zu kommunizieren 🎜>
Das Obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass er zum Lernen aller beiträgt. Ich hoffe auch, dass jeder die PHP-Chinesisch-Website unterstützt.

Weitere Artikel zum Zwischenmuster von Java-Designmustern finden Sie auf der chinesischen PHP-Website!

Verwandte Artikel:

Eine detaillierte Einführung in den Code, der das Mediator-Muster in Java implementiert

Eine Einführung in die Chain of Responsibility Muster von Java-Entwurfsmustern

Einführung in den Java-Entwurfsmuster-Proxy-Modus (Proxy-Modus)