Design patterns
Patrón mediador

Ejemplo de patrón mediador en java

El patrón de mediador define un objeto (mediador) que encapsula cómo interactúa un conjunto de objetos. Permite la comunicación de muchos a muchos.

Diagrama UML:

Componentes clave:

Mediator: define una interfaz para la comunicación entre colegas.

Colleague : es una clase abstracta, que define los eventos que deben comunicarse entre colegas.

ConcreteMediator : implementa el comportamiento cooperativo al coordinar los objetos de los Colleague y mantiene a sus colegas

ConcreteColleague : implementa las operaciones de notificación recibidas a través del Mediator , que ha sido generado por otro Colleague

Un ejemplo del mundo real:

Usted está manteniendo una red de computadoras en la topología de Mesh .

Una red de malla es una topología de red en la que cada nodo transmite datos para la red. Todos los nodos de malla cooperan en la distribución de datos en la red.

Si se agrega una computadora nueva o si se quita la computadora existente, todas las otras computadoras en esa red deben conocer estos dos eventos.

Veamos cómo encaja el patrón de mediador en él.

Fragmento de código:

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

salida:

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

Explicación:

1. Eagle se agrega a la red en primer lugar a través del evento de registro. No hay notificaciones a ningún otro compañero ya que Eagle es el primero.
2. Cuando se agrega Ostrich a la red, se notifica a Eagle : la línea 1 de la salida se procesa ahora.
3. Cuando se agrega Penguin a la red, tanto Eagle como Ostrich han sido notificados: la línea 2 y la línea 3 de la salida se procesan ahora.
4. Cuando Eagle abandonó la red a través del evento de desregistro, se notificó a Ostrich y Penguin . La línea 4 y la línea 5 de salida se representan ahora.