Design patterns
Modello del mediatore

Esempio di modello di mediatore in java

Il modello del mediatore definisce un oggetto (mediatore) che incapsula il modo in cui un insieme di oggetti interagisce. Permette la comunicazione many-to-many.

Diagramma UML:

Componenti chiave:

Mediator: definisce un'interfaccia per la comunicazione tra colleghi.

Colleague : è una classe astratta, che definisce gli eventi da comunicare tra colleghi

ConcreteMediator : implementa il comportamento cooperativo coordinando gli oggetti del Colleague e mantenendo i suoi colleghi

ConcreteColleague : implementa le operazioni di notifica ricevute tramite Mediator , che è stata generata da un altro Colleague

Un esempio del mondo reale:

Si sta mantenendo una rete di computer nella topologia Mesh .

Una rete mesh è una topologia di rete in cui ogni nodo trasmette i dati per la rete. Tutti i nodi mesh collaborano alla distribuzione dei dati nella rete.

Se viene aggiunto un nuovo computer o viene rimosso un computer esistente, tutti gli altri computer in tale rete dovrebbero essere a conoscenza di questi due eventi.

Vediamo come si inserisce il modello del mediatore.

Snippet di codice:

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

/* Define the contract for communication between Colleagues. 
   Implementation is left to ConcreteMediator */
interface Mediator{
    void register(Colleague colleague);
    void unregister(Colleague colleague);
}
/* Define the contract for notification events from Mediator. 
   Implementation is left to ConcreteColleague
*/
abstract class Colleague{
    private Mediator mediator;
    private String name;
    
    public Colleague(Mediator mediator,String name){
        this.mediator = mediator;
        this.name = name;
    }
    public String toString(){
        return name;
    }
    public abstract void receiveRegisterNotification(Colleague colleague);
    public abstract void receiveUnRegisterNotification(Colleague colleague);    
}
/*  Process notification event raised by other Colleague through Mediator.   
*/
class ComputerColleague extends Colleague {
    private Mediator mediator;
    
    public ComputerColleague(Mediator mediator,String name){
        super(mediator,name);
    }
    public  void receiveRegisterNotification(Colleague colleague){
        System.out.println("New Computer register event with name:"+colleague+
        ": received @"+this);
        // Send further messages to this new Colleague from now onwards
    }
    public  void receiveUnRegisterNotification(Colleague colleague){
        System.out.println("Computer left unregister event with name:"+colleague+
        ":received @"+this);
        // Do not send further messages to this Colleague from now onwards
    }
}
/* Act as a central hub for communication between different Colleagues. 
   Notifies all Concrete Colleagues on occurrence of an event
*/
class NetworkMediator implements Mediator{
    List<Colleague> colleagues = new ArrayList<Colleague>();
    
    public NetworkMediator(){
    
    }
    
    public void register(Colleague colleague){
        colleagues.add(colleague);
        for (Colleague other : colleagues){
            if ( other != colleague){
                other.receiveRegisterNotification(colleague);
            }
        }
    }
    public void unregister(Colleague colleague){
        colleagues.remove(colleague);
        for (Colleague other : colleagues){
            other.receiveUnRegisterNotification(colleague);
        }
    }
}

public class MediatorPatternDemo{
    public static void main(String args[]){
        Mediator mediator = new NetworkMediator();
        ComputerColleague colleague1 = new ComputerColleague(mediator,"Eagle");
        ComputerColleague colleague2 = new ComputerColleague(mediator,"Ostrich");
        ComputerColleague colleague3 = new ComputerColleague(mediator,"Penguin");
        mediator.register(colleague1);
        mediator.register(colleague2);
        mediator.register(colleague3);
        mediator.unregister(colleague1);
    }
}

produzione:

New Computer register event with name:Ostrich: received @Eagle
New Computer register event with name:Penguin: received @Eagle
New Computer register event with name:Penguin: received @Ostrich
Computer left unregister event with name:Eagle:received @Ostrich
Computer left unregister event with name:Eagle:received @Penguin

Spiegazione:

1. Eagle viene aggiunto alla rete in un primo momento attraverso l'evento di registrazione. Nessuna notifica a nessun altro collega dal momento che Eagle è il primo.
2. Quando Ostrich viene aggiunto alla rete, viene inviata una notifica a Eagle : la riga 1 dell'output viene visualizzata ora.
3. Quando Penguin viene aggiunto alla rete, sia Eagle sia Ostrich sono stati avvisati: la riga 2 e la riga 3 dell'output sono ora renderizzate.
4. Quando Eagle lasciato la rete attraverso un evento di annullamento della registrazione, sia gli Ostrich che i Penguin sono stati avvisati. La riga 4 e la riga 5 dell'output sono ora renderizzate.