Modello di design Mediatore in Java

Il design pattern Mediator è uno dei design pattern comportamentali, quindi si occupa dei comportamenti degli oggetti. Il design pattern Mediator viene utilizzato per fornire un mezzo di comunicazione centralizzato tra diversi oggetti in un sistema.

Design Pattern Mediator

Secondo GoF, l’intento del pattern Mediator è:

Consente un accoppiamento debole incapsulando il modo in cui insiemi disparati di oggetti interagiscono e comunicano tra loro. Consente alle azioni di ciascun insieme di oggetti di variare indipendentemente l’una dall’altra.

Il design pattern del Mediatore è molto utile in un’applicazione aziendale in cui interagiscono più oggetti. Se gli oggetti interagiscono direttamente tra loro, i componenti del sistema sono strettamente accoppiati tra loro, il che comporta costi di manutenzione più elevati e non è facile da estendere. Il pattern Mediatore si concentra sulla fornitura di un mediatore tra gli oggetti per la comunicazione e aiuta nell’implementazione di un accoppiamento lento tra gli oggetti. Il controllore del traffico aereo è un ottimo esempio di pattern del mediatore in cui la sala di controllo dell’aeroporto funge da mediatore per la comunicazione tra i diversi voli. Il Mediatore funziona come un router tra gli oggetti e può avere la propria logica per fornire un modo di comunicazione. Gli oggetti del sistema che comunicano tra loro sono chiamati Colleghi. Di solito abbiamo un’interfaccia o una classe astratta che fornisce il contratto per la comunicazione e poi abbiamo l’implementazione concreta dei mediatori. Per il nostro esempio, proveremo a implementare un’applicazione di chat in cui gli utenti possono fare chat di gruppo. Ogni utente sarà identificato dal proprio nome e possono inviare e ricevere messaggi. Il messaggio inviato da qualsiasi utente dovrebbe essere ricevuto da tutti gli altri utenti nel gruppo.

Interfaccia del Pattern del Mediatore

Prima di tutto creeremo l’interfaccia del Mediatore che definirà il contratto per i mediatori concreti. ChatMediator.java

package com.journaldev.design.mediator;

public interface ChatMediator {

	public void sendMessage(String msg, User user);

	void addUser(User user);
}

Interfaccia del Pattern Mediatore per i Colleghi

Gli utenti possono inviare e ricevere messaggi, quindi possiamo avere un’interfaccia Utente o una classe astratta. Sto creando l’utente come classe astratta come segue. 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);
}

Nota che l’Utente ha un riferimento all’oggetto mediatore, è necessario per la comunicazione tra utenti diversi.

Mediatore Concreto

Ora creeremo una classe mediatore concreta, avrà una lista di utenti nel gruppo e fornirà la logica per la comunicazione tra gli utenti. 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){
			// Il messaggio non dovrebbe essere ricevuto dall'utente che lo invia
			if(u != user){
				u.receive(msg);
			}
		}
	}

}

Pattern di Progettazione Mediatore Colleghi Concreti

Ora possiamo creare classi Utente concrete da utilizzare dal sistema client. 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);
	}

}

Nota che il metodo send() sta utilizzando il mediatore per inviare il messaggio agli utenti e non ha idea di come verrà gestito dal mediatore.

Esempio di Codice del Programma Client del Pattern Mediatore

Testiamo questa nostra applicazione di chat con un programma semplice dove creeremo un mediatore e aggiungeremo utenti al gruppo e uno degli utenti invierà un messaggio. 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");
		
	}

}

Nota che il programma client è molto semplice e non ha idea di come il messaggio venga gestito e se il mediatore sta ottenendo l’utente o meno. L’output dell’esempio di programma del pattern mediatore è:

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

Diagramma delle Classi del Pattern Mediatore

Esempio del Pattern Mediatore in JDK

• La classe java.util.Timer con i metodi scheduleXXX()
• L’Executor di Concorrenza di Java con il metodo execute().
• Il metodo invoke() della classe java.lang.reflect.Method.

Punti importanti del design pattern Mediator

• Il pattern Mediator è utile quando la logica di comunicazione tra gli oggetti è complessa, possiamo avere un punto centrale di comunicazione che si occupa della logica di comunicazione.
• Il servizio di messaggistica Java (JMS) utilizza il pattern Mediator insieme al pattern Observer per consentire alle applicazioni di sottoscriversi e pubblicare dati ad altre applicazioni.
• Non dovremmo utilizzare il pattern Mediator solo per ottenere un accoppiamento scarso perché se il numero di mediatori aumenterà, diventerà difficile mantenerli.

E questo è tutto per il design pattern Mediator e la sua implementazione in Java.