Mediator Ontwerppatroon in Java

Het Mediator-ontwerppatroon is een van de gedragsontwerppatronen, dus het gaat over het gedrag van objecten. Het Mediator-ontwerppatroon wordt gebruikt om een gecentraliseerd communicatiemiddel te bieden tussen verschillende objecten in een systeem.

Mediator-ontwerppatroon

Volgens GoF, is het doel van het mediatorpatroon:

Maakt losse koppeling mogelijk door de manier waarop verschillende sets objecten met elkaar interageren en communiceren, in te kapselen. Hierdoor kunnen de acties van elke objectenset onafhankelijk van elkaar variëren.

Het Mediator-ontwerppatroon is zeer nuttig in een bedrijfstoepassing waar meerdere objecten met elkaar interageren. Als de objecten rechtstreeks met elkaar interageren, zijn de systeemcomponenten sterk gekoppeld, wat leidt tot hogere onderhoudskosten en moeilijkheden bij het uitbreiden. Het Mediator-patroon richt zich op het bieden van een bemiddelaar tussen objecten voor communicatie en helpt bij het implementeren van losse koppeling tussen objecten. Een luchtverkeersleider is een uitstekend voorbeeld van het Mediator-patroon, waar de luchthavencontrolekamer fungeert als bemiddelaar voor communicatie tussen verschillende vluchten. De bemiddelaar fungeert als een router tussen objecten en kan zijn eigen logica hebben om de communicatieweg te bieden. De systeemobjecten die met elkaar communiceren, worden Colleagues genoemd. Meestal hebben we een interface of abstracte klasse die het contract voor communicatie definieert, en vervolgens hebben we concrete implementaties van bemiddelaars. Voor ons voorbeeld zullen we proberen een chattoepassing te implementeren waar gebruikers groepsgesprekken kunnen voeren. Elke gebruiker wordt geïdentificeerd aan de hand van zijn naam en ze kunnen berichten verzenden en ontvangen. Het bericht dat door een gebruiker wordt verzonden, moet worden ontvangen door alle andere gebruikers in de groep.

Mediator Patroon Interface

Allereerst zullen we een Mediator-interface maken die het contract zal definiëren voor concrete bemiddelaars. ChatMediator.java

package com.journaldev.design.mediator;

public interface ChatMediator {

	public void sendMessage(String msg, User user);

	void addUser(User user);
}

Collega-interface voor Mediatorpatroon

Gebruikers kunnen berichten verzenden en ontvangen, dus we kunnen een gebruikersinterface of een abstracte klasse hebben. Ik maak User aan als abstracte klasse zoals hieronder. 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);
}

Let op dat User een referentie heeft naar het mediatorobject, dit is vereist voor de communicatie tussen verschillende gebruikers.

Concrete Mediator

Nu zullen we een concrete mediatorklasse maken, deze zal een lijst van gebruikers in de groep hebben en logica bieden voor de communicatie tussen de gebruikers. 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){
			//het bericht mag niet worden ontvangen door de gebruiker die het verzendt
			if(u != user){
				u.receive(msg);
			}
		}
	}

}

Concrete collega van het Mediator-ontwerppatroon

Nu kunnen we concrete User-klassen maken die door het clientsysteem worden gebruikt. 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);
	}

}

Let op dat de send() methode de mediator gebruikt om het bericht naar de gebruikers te sturen en dat het geen idee heeft hoe het door de mediator zal worden afgehandeld.

Voorbeeld van een Mediator Patroon Client Programma Code

Laten we onze chattoepassing testen met een eenvoudig programma waarin we een mediator zullen maken en gebruikers aan de groep zullen toevoegen, en waarbij een van de gebruikers een bericht zal verzenden. 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");
		
	}

}

Merk op dat het clientprogramma erg eenvoudig is en geen idee heeft hoe het bericht wordt afgehandeld en of de mediator wel of geen gebruiker krijgt. De uitvoer van het voorbeeldprogramma voor het mediatorpatroon is:

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

Klasse Diagram van het Mediator Patroon

Voorbeeld van het Mediator Patroon in JDK

• java.util.Timer-klasse scheduleXXX() methoden
• Java Concurrency Executor execute() methode.
• java.lang.reflect.Method invoke() methode.

Belangrijke punten van het Mediator Ontwerppatroon

• Het Mediator-patroon is handig wanneer de communicatielogica tussen objecten complex is, we kunnen een centraal communicatiepunt hebben dat de communicatielogica regelt.
• Java Message Service (JMS) maakt gebruik van het Mediator-patroon samen met het Observer-patroon om applicaties in staat te stellen zich te abonneren op en gegevens te publiceren naar andere applicaties.
• We moeten het mediatorpatroon niet alleen gebruiken om losse koppeling te bereiken, want als het aantal mediators toeneemt, wordt het moeilijk om ze te onderhouden.

Dat is alles voor het Mediator-ontwerppatroon en de implementatie ervan in Java.