Design patterns
Bemiddelaar patroon

Voorbeeld van bemiddelaarspatroon in Java

Bemiddelaarpatroon definieert een object (Bemiddelaar) dat inkapselt hoe een set objecten op elkaar inwerken. Het maakt veel-op-veel communicatie mogelijk.

UML-diagram:

Belangrijke onderdelen:

Mediator: definieert een interface voor communicatie tussen collega's.

Colleague : is een abstracte klasse, die de gebeurtenissen definieert die moeten worden gecommuniceerd tussen collega's

ConcreteMediator : implementeert coöperatief gedrag door Colleague objecten te coördineren en Colleague onderhouden

ConcreteColleague : Implementeert de kennisgevingsoperaties die zijn ontvangen via Mediator en die zijn gegenereerd door andere Colleague

Een voorbeeld uit de echte wereld:

U onderhoudt een netwerk van computers in Mesh topologie.

Een mesh-netwerk is een netwerktopologie waarin elk knooppunt gegevens voor het netwerk doorgeeft. Alle mesh-knooppunten werken samen bij de distributie van gegevens in het netwerk.

Als een nieuwe computer wordt toegevoegd of een bestaande computer wordt verwijderd, moeten alle andere computers in dat netwerk op de hoogte zijn van deze twee gebeurtenissen.

Laten we eens kijken hoe het Mediator-patroon erin past.

Codefragment:

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);
    }
}

output:

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

Uitleg:

1. Eagle wordt in eerste instantie aan het netwerk toegevoegd via een registerevenement. Geen meldingen aan andere collega's omdat Eagle de eerste is.
2. Wanneer Ostrich wordt toegevoegd aan het netwerk, krijgt Eagle een melding: regel 1 van uitvoer wordt nu weergegeven.
3. Wanneer Penguin aan het netwerk wordt toegevoegd, zijn zowel Eagle als Ostrich op de hoogte gebracht: regel 2 en regel 3 van uitvoer wordt nu weergegeven.
4. Toen Eagle het netwerk verliet via de registratie van een gebeurtenis, zijn zowel Ostrich als Penguin op de hoogte gebracht. Lijn 4 en lijn 5 van uitvoer worden nu weergegeven.