Mediator-Entwurfsmuster in Java

Das Mediator-Designmuster ist eines der Verhaltensmuster, daher beschäftigt es sich mit dem Verhalten von Objekten. Das Mediator-Designmuster wird verwendet, um ein zentrales Kommunikationsmedium zwischen verschiedenen Objekten in einem System bereitzustellen.

Mediator-Designmuster

Laut GoF besteht die Absicht des Mediator-Musters darin:

Ermöglicht eine lose Kopplung, indem es die Art und Weise, wie unterschiedliche Objektgruppen miteinander interagieren und kommunizieren, kapselt. Ermöglicht es den Aktionen jeder Objektgruppe, unabhängig voneinander zu variieren.

Das Mediator-Entwurfsmuster ist in einer Unternehmensanwendung sehr hilfreich, in der mehrere Objekte miteinander interagieren. Wenn die Objekte direkt miteinander interagieren, sind die Systemkomponenten eng miteinander gekoppelt, was zu höheren Wartungskosten führt und die Erweiterung erschwert. Das Mediator-Muster konzentriert sich darauf, einen Vermittler zwischen Objekten für die Kommunikation bereitzustellen und beim Implementieren einer lockeren Kopplung zwischen den Objekten zu helfen. Ein Fluglotsencontroller ist ein großartiges Beispiel für das Mediator-Muster, bei dem der Flughafenkontrollraum als Vermittler für die Kommunikation zwischen verschiedenen Flügen fungiert. Der Mediator fungiert als Router zwischen Objekten und kann eine eigene Logik haben, um die Kommunikation zu ermöglichen. Die Systemobjekte, die miteinander kommunizieren, werden Kollegen genannt. Normalerweise haben wir eine Schnittstelle oder abstrakte Klasse, die den Vertrag für die Kommunikation bereitstellt, und dann haben wir konkrete Implementierungen von Vermittlern. Für unser Beispiel werden wir versuchen, eine Chat-Anwendung zu implementieren, in der Benutzer Gruppenchats durchführen können. Jeder Benutzer wird durch seinen Namen identifiziert und sie können Nachrichten senden und empfangen. Die von einem Benutzer gesendete Nachricht sollte von allen anderen Benutzern in der Gruppe empfangen werden.

Vermittlermuster-Schnittstelle

Zunächst erstellen wir eine Mediator-Schnittstelle, die den Vertrag für konkrete Vermittler definiert. ChatMediator.java

package com.journaldev.design.mediator;

public interface ChatMediator {

	public void sendMessage(String msg, User user);

	void addUser(User user);
}

Mediator-Muster Kollegen-Schnittstelle

Benutzer können Nachrichten senden und empfangen, daher können wir eine Benutzerschnittstelle oder eine abstrakte Klasse haben. Ich erstelle den Benutzer als abstrakte Klasse wie unten gezeigt. User.java

package com.journaldev.design.mediator;

public abstract class User {
	protected ChatMediator mediator;
	protected String name;
	
	public User(ChatMediator med, String name){
		this.mediator=med;
		this.name=name;
	}
	
	public abstract void send(String msg);
	
	public abstract void receive(String msg);
}

Beachten Sie, dass der Benutzer eine Referenz auf das Mediator-Objekt hat. Dies ist für die Kommunikation zwischen verschiedenen Benutzern erforderlich.

Konkreter Mediator

Jetzt erstellen wir eine konkrete Mediator-Klasse. Sie wird eine Liste von Benutzern in der Gruppe haben und die Logik für die Kommunikation zwischen den Benutzern bereitstellen. ChatMediatorImpl.java

package com.journaldev.design.mediator;

import java.util.ArrayList;
import java.util.List;

public class ChatMediatorImpl implements ChatMediator {

	private List users;
	
	public ChatMediatorImpl(){
		this.users=new ArrayList<>();
	}
	
	@Override
	public void addUser(User user){
		this.users.add(user);
	}
	
	@Override
	public void sendMessage(String msg, User user) {
		for(User u : this.users){
			//Die Nachricht sollte nicht vom Benutzer empfangen werden, der sie sendet
			if(u != user){
				u.receive(msg);
			}
		}
	}

}

Mediator-Entwurfsmuster Konkreter Kollege

Jetzt können wir konkrete Benutzerklassen erstellen, die vom Client-System verwendet werden. UserImpl.java

package com.journaldev.design.mediator;

public class UserImpl extends User {

	public UserImpl(ChatMediator med, String name) {
		super(med, name);
	}

	@Override
	public void send(String msg){
		System.out.println(this.name+": Sending Message="+msg);
		mediator.sendMessage(msg, this);
	}
	@Override
	public void receive(String msg) {
		System.out.println(this.name+": Received Message:"+msg);
	}

}

Beachten Sie, dass die send() -Methode den Mediator verwendet, um die Nachricht an die Benutzer zu senden, und sie keine Ahnung hat, wie sie vom Mediator behandelt wird.

Beispielprogrammcode für das Vermittlermuster

Testen wir unsere Chat-Anwendung mit einem einfachen Programm, in dem wir einen Vermittler erstellen und Benutzer zur Gruppe hinzufügen. Einer der Benutzer wird dann eine Nachricht senden. ChatClient.java

package com.journaldev.design.mediator;

public class ChatClient {

	public static void main(String[] args) {
		ChatMediator mediator = new ChatMediatorImpl();
		User user1 = new UserImpl(mediator, "Pankaj");
		User user2 = new UserImpl(mediator, "Lisa");
		User user3 = new UserImpl(mediator, "Saurabh");
		User user4 = new UserImpl(mediator, "David");
		mediator.addUser(user1);
		mediator.addUser(user2);
		mediator.addUser(user3);
		mediator.addUser(user4);
		
		user1.send("Hi All");
		
	}

}

Beachten Sie, dass das Client-Programm sehr einfach ist und keine Ahnung hat, wie die Nachricht behandelt wird und ob der Vermittler den Benutzer erhält oder nicht. Die Ausgabe des Beispielprogramms für das Vermittlermuster lautet:

Pankaj: Sending Message=Hi All
Lisa: Received Message:Hi All
Saurabh: Received Message:Hi All
David: Received Message:Hi All

Klassendiagramm des Vermittlermusters

Beispiel für das Vermittlermuster in JDK

• java.util.Timer-Klasse scheduleXXX() -Methoden
• Java Concurrency Executor execute() -Methode.
• java.lang.reflect.Method invoke() -Methode.

Wichtige Punkte des Mediator-Entwurfsmusters

• Das Mediator-Muster ist nützlich, wenn die Kommunikationslogik zwischen Objekten komplex ist. Wir können einen zentralen Kommunikationspunkt haben, der sich um die Kommunikationslogik kümmert.
• Die Java Message Service (JMS) verwendet das Mediator-Muster zusammen mit dem Beobachtermuster, um Anwendungen zu ermöglichen, sich anzumelden und Daten an andere Anwendungen zu veröffentlichen.
• Wir sollten das Mediator-Muster nicht nur verwenden, um lose Kopplung zu erreichen, denn wenn die Anzahl der Mediatoren wächst, wird es schwierig, sie zu pflegen.

Das ist alles zum Mediator-Entwurfsmuster und seiner Implementierung in Java.