Mediador (patrón de diseño)
La versión actual de la página aún no ha sido revisada por colaboradores experimentados y puede diferir significativamente de la
versión revisada el 16 de marzo de 2014; las comprobaciones requieren
22 ediciones .
Mediator es un patrón de diseño de comportamiento que garantiza la interacción de muchos objetos, al mismo tiempo que forma un vínculo débil y elimina la necesidad de que los objetos se refieran explícitamente entre sí.
Problema
Asegure la interacción de muchos objetos, mientras forma un acoplamiento flexible y elimina la necesidad de que los objetos se refieran explícitamente entre sí.
Solución
Cree un objeto que encapsule cuántos objetos interactúan.
Beneficios
Se elimina la conexión entre "Colegas", se centraliza la gestión.
Estructura
- Mediador - "Intermediario"
- ConcreteMediator - "Mediador concreto"
- Clases de colegas - "Colegas"
Descripción
"Mediador" define una interfaz para intercambiar información con los objetos "Colegas", "Mediador específico" coordina las acciones de los objetos "Colegas". Cada clase "Colegas" conoce su objeto "Mediador", todos los "Colegas" intercambian información solo con el mediador, en su ausencia tendrían que intercambiar información directamente. Los "colegas" envían solicitudes al intermediario y reciben solicitudes de él. El Mediador implementa un comportamiento cooperativo al reenviar cada solicitud a uno o más Colegas.
Ejemplos
Ejemplo de PHP5
Código fuente en
PHP5
<?php
mediador de clase abstracta { función pública abstracta enviar ( $ mensaje , colega $ colega ); }
clase abstracta Colega
{
protected $mediador ;
public function __construct ( Mediador $mediador )
{
$esto -> mediador = $mediador ;
}
public function enviar ( $mensaje )
{
$esto -> mediador -> enviar ( $mensaje , $esto );
}
/**
* El procesamiento del mensaje recibido es implementado por cada * *
sucesor concreto
* @param string mensaje el mensaje recibido
*/
función pública abstracta notificar ( $mensaje ); }
class ConcreteMediator extends Mediator
{
/**
* @var ConcreteColleague1
*/
private $colleague1 ;
/**
* @var ConcreteColega2
*/
private $ colega2 ;
public function setColega1 ( ConcretoColega1 $colega )
{
$esto -> colega1 = $colega ;
}
public function setColega2 ( ConcretoColega2 $colega )
{
$esto -> colega2 = $colega ;
}
public function enviar ( $mensaje , Colega $colega )
{
cambiar ( $colega ) {
case $este -> colega1 :
$este -> colega2 -> notificar ( $mensaje );
romper ;
case $esto -> colega2 :
$esto -> colega1 -> notificar ( $mensaje );
}
}
}
//colega 1
class ConcreteColega1 extiende Colega
{
función pública notificar ( $mensaje ) { echo sprintf ( "Colega1 recibe mensaje: %s \n " , $mensaje ); } }
//colega 2
class ConcreteColega2 extiende Colega
{
función pública notificar ( $mensaje ) { echo sprintf ( "Colega2 recibe mensaje: %s \n " , $mensaje ); } }
$mediador = new ConcreteMediator ();
$colega1 = new ColegaConcreto1 ( $mediador );
$colega2 = new ColegaConcreto2 ( $mediador );
$mediador -> setColega1 ( $colega1 );
$mediador -> setColega2 ( $colega2 );
$colegio1 -> enviar ( '¿Cómo estás?' );
$colegio2 -> enviar ( 'Bien, gracias!' );
Ejemplo de Java
Fuente
Java
colega de clase abstracta pública {
mediador protegido mediador ;
colega público ( mediador mediador ) {
este . mediador = mediador ;
}
Public void enviar ( mensaje de cadena ) { mediador . enviar ( mensaje , esto ); }
notificación de vacío abstracto público ( mensaje de cadena ); }
Mediador de clase abstracta pública {
envío de vacío abstracto público ( mensaje de cadena , remitente de colega ); }
public class ConcreteColleague1 extiende Colega {
public ConcreteColleague1 ( mediador mediador ) {
super ( mediador );
}
@Override
notificación de anulación pública ( Mensaje de cadena ) { System . fuera _ println ( "Colega1 recibe mensaje: " + mensaje ); } }
public class ConcreteColleague2 extiende Colega {
public ConcreteColleague2 ( Mediador mediador ) {
super ( mediador );
}
@Override
notificación de anulación pública ( Mensaje de cadena ) { System . fuera _ println ( "Colega2 recibe mensaje: " + mensaje ); } }
public class ConcreteMediator extiende a Mediator {
privado ConcreteColleague1 colega1 ;
privado ConcreteColleague2 colega2 ;
public void setColleague1 ( colega ConcreteColleague1 ) { this . colega1 = colega ; }
public void setColleague2 ( colega ConcreteColleague2 ) { this . colega2 = colega ; }
@Override
public void send ( mensaje de cadena , colega remitente ) { if ( remitente . es igual a ( colega1 )) { colega2 . notificar ( mensaje ); } más { colega1 . notificar ( mensaje ); } } }
clase pública Principal {
public static void main ( String [] args ) {
ConcreteMediator m = new ConcreteMediator ();
ColegaConcreto1 c1 = new ColegaConcreto1 ( m );
ColegaConcreto2 c2 = new ColegaConcreto2 ( m );
m _ conjuntoColega1 ( c1 );
m _ conjuntocolega2 ( c2 );
c1 . enviar ( "¿Cómo estás?" );
c2 . enviar ( "Bien, gracias" );
}
}
Ejemplo en C#
Texto fuente en
C#
// Patrón de mediador - Ejemplo estructural
usando System ;
espacio de nombres DoFactory.GangOfFour.Mediator.Structural
{
/// <summary>
/// Clase de inicio de MainApp para Structural
/// Patrón de diseño de mediador.
/// </summary>
class MainApp
{
/// <summary>
/// Punto de entrada a la aplicación de consola.
/// </summary>
static void Main ()
{
ConcreteMediator m = new ConcreteMediator ();
ColegaConcreto1 c1 = new ColegaConcreto1 ( m );
ColegaConcreto2 c2 = new ColegaConcreto2 ( m );
m _ Colega1 = c1 ;
m _ Colega2 = c2 ;
c1 . Enviar ( "¿Cómo estás?" );
c2 . Enviar ( "Bien, gracias" );
// Esperar a la
Consola del usuario . Clave de lectura ();
}
}
/// <summary>
/// La clase abstracta 'Mediador'
/// </summary>
abstract class Mediator
{
public abstract void Send ( string message , Colega colega );
}
/// <summary>
/// La clase 'ConcreteMediator'
/// </summary>
class ConcreteMediator : Mediator
{
public ConcreteColleague1 Colleague1 { private get ; conjunto ; }
Public ConcreteColleague2 Colleague2 { private get ; conjunto ; }
public override void Enviar ( mensaje de cadena , Colega colega ) { if ( colega == Colega1 ) { Colega2 . notificar ( mensaje ); } más { Colega1 . notificar ( mensaje ); } } }
/// <summary>
/// La clase abstracta 'Colega'
/// </summary>
clase abstracta Colega { protected Mediator mediator ;
// Constructor
colega público ( mediador mediador ) { este . mediador = mediador ; } }
/// <summary>
/// Una clase 'ConcreteColleague'
/// </summary>
class ConcreteColleague1 : Colleague
{
// Constructor
public ConcreteColleague1 ( Mediator mediator )
: base ( mediator )
{
}
public void Enviar ( mensaje de cadena ) { mediador . Enviar ( mensaje , esto ); }
public void Notificar ( mensaje de cadena ) { Consola . WriteLine ( "Colega1 recibe mensaje: " + mensaje ); } }
/// <summary>
/// Una clase 'ConcreteColleague'
/// </summary>
class ConcreteColleague2 : Colleague
{
// Constructor
public ConcreteColleague2 ( Mediator mediator )
: base ( mediator )
{
}
public void Enviar ( mensaje de cadena ) { mediador . Enviar ( mensaje , esto ); }
public void Notificar ( mensaje de cadena ) { Consola . WriteLine ( "Colega2 recibe mensaje: " + mensaje ); } } }
Salida
Colega2 recibe mensaje : ¿ Cómo estás ? Colega1 recibe mensaje : Bien , gracias
Ejemplo de C++
Texto fuente en
C++
#incluir <iostream>
#incluir <cadena>
colega de clase ;
mediador de clase ;
clase MediadorConcreto ;
clase ColegaConcreto1 ;
clase ColegaConcreto2 ;
mediador de clase
{
público :
virtual void Enviar ( std :: cadena const & mensaje , Colega * colega ) const = 0 ;
};
colega de clase
{
protegido :
mediador * mediador_ ;
público :
Colega explícito ( Mediador * mediador ) : mediator_ ( mediador )
{
}
};
clase ConcreteColleague1 : colega público
{
público :
explícito ConcreteColleague1 ( Mediador * mediador ) : Colega ( mediador )
{
}
void Enviar ( std :: string const & message )
{
mediador_ -> Enviar ( mensaje , esto );
}
void Notify ( std :: string const & message )
{
std :: cout << "Colega1 recibe el mensaje '" << mensaje << "'" << std :: endl ;
}
};
clase ConcreteColleague2 : colega público
{
público :
explícito ConcreteColleague2 ( Mediador * mediador ) : Colega ( mediador )
{
}
void Enviar ( std :: string const & message )
{
mediador_ -> Enviar ( mensaje , esto );
}
void Notify ( std :: string const & message )
{
std :: cout << "Colega2 recibe el mensaje '" << mensaje << "'" << std :: endl ;
}
};
clase ConcreteMediator : mediador público
{
protegido :
ColegaConcreto1 * m_Colega1 ;
ColegaConcreto2 * m_Colega2 ;
público :
void ConjuntoColega1 ( ConcretoColega1 * c )
{
m_Colega1 = c ;
}
void SetColega2 ( ConcretoColega2 * c )
{
m_colega2 = c ;
}
virtual void Enviar ( std :: string const & message , Colega * colega ) const
{
if ( colega == m_Colega1 )
{
m_Colega2 -> Notificar ( mensaje );
}
más si ( colega == m_Colega2 )
{
m_Colega1 -> Notificar ( mensaje );
}
}
};
int principal ()
{
ConcreteMediator m ;
ColegaConcreto1 c1 ( & m );
ConcreteColega2 c2 ( & m );
m _ EstablecerColega1 ( & c1 );
m _ EstablecerColega2 ( & c2 );
c1 . Enviar ( "¿Cómo estás?" );
c2 . Enviar ( "Bien, gracias" );
estándar :: cin . obtener ();
devolver 0 ;
}
Producción
Colega2 recibe el mensaje ' ¿ Cómo estás ? '
Colega1 recibe el mensaje ' Bien , gracias '
Ejemplo de Python
Código fuente en
Python
de abc import ABCMeta , abstractmethod
de debilref importación proxy
importación inspeccionar
class Mediator ( metaclass = ABCMeta ):
"""
Un canal de comunicación abstracto entre colegas
"""
@abstractmethod
def enviar ( self , mensaje : str ) -> Ninguno :
"""
Enviar un mensaje entre pares
"""
pasar
colega de clase ( metaclase = ABCMeta ):
"""
Un trabajador abstracto al que no le importa chatear con sus colegas
"""
def __init__ ( self , mediador : Mediador ) -> Ninguno :
"""
Constructor.
:param mediador: canal de comunicación con colegas
""
" self ._mediator = proxy ( mediador )
@abstractmethod
def enviar ( self , mensaje : str ) -> Ninguno :
"""
Enviar mensaje a través del canal de comunicación
"""
pasar
@abstractmethod
def recibir ( self , mensaje : str ) -> Ninguno :
"""
Recibir mensaje a través del canal de comunicación
"""
pasar
clase SkypeBetweenTwoColleagues ( Mediador ):
"""
Canal de Skype para la comunicación entre dos personas
"""
def __init__ ( self ) -> Ninguno :
"""
Constructor.
"""
self . _first = Ninguno
propio . _segundo = Ninguno
def set_first ( self , first : Colega ) -> Ninguno :
"""
Asigna el primer participante de la conversación
"""
self al canal . _primero = primero
def set_second ( self , second : Colega ) -> Ninguno :
"""
Asocia al segundo participante en la conversación
"""
self con el canal . _segundo = segundo
def enviar ( auto , mensaje : str ) -> Ninguno :
remitente = inspeccionar . cuadro actual () . f_atrás . f_locals [ 'self' ]
receptor = self . _primero si remitente == self . _segundo otro yo . _segundo
receptor . recibir ( mensaje )
clase Bill ( colega ):
def enviar ( self , mensaje : str ) -> Ninguno :
self . _mediador . enviar ( mensaje )
def recibir ( self , mensaje : str ) -> Ninguno :
imprimir ( 'Bill recibió el mensaje: {} ' . formato ( mensaje ))
clase Steve ( colega ):
def enviar ( self , mensaje : str ) -> Ninguno :
self . _mediador . enviar ( mensaje )
def recibir ( self , mensaje : str ) -> Ninguno :
imprimir ( 'Steve leyó el mensaje en Skype: {} ' . formato ( mensaje ))
if __name__ == '__principal__' :
print ( 'SALIDA:' )
skype = SkypeEntreDosColegas ()
bill = Bill ( skype )
steve = Steve ( skype )
skype . set_first ( factura )
skype . set_segundo ( steve ) proyecto de
ley . enviar ( '¡Ponte a trabajar, holgazán!' )
steve . enviar ( 'No' )
'''
SALIDA:
Steve leyó un mensaje de Skype: ¡Ponte a trabajar, holgazán!
Bill recibió el mensaje: No
'''
Ejemplo de Delphi
Texto fuente en
Delphi
programa MediatorExample ;
{$CONSOLA DE TIPO DE APLICACIÓN}
escriba
IColleague = procedimiento de interfaz
Enviar ( AMessage : cadena ) ; procedimiento Notificar ( AMessage : string ) ; fin ;
TMediator = procedimiento de clase
Enviar ( AMessage : string ; ACollegue : IColleague ) ; virtuales ; abstracto ; fin ;
TConcreteMediator = clase ( TMediator )
public
FCollegue1 : IColleague ;
FColega2 : IColega ;
procedimiento Enviar ( AMessage : string ; ACollegue : IColleague ) ; anular ;
fin ;
TColleague = clase ( TInterfacedObject , IColleague )
public
FMediator : TMediator ;
constructor Crear ( AMediator : TMediator ) ;
procedimiento Enviar ( AMessage : string ) ; virtuales ; abstracto ;
procedimiento Notificar ( AMessage : string ) ; virtuales ; abstracto ;
fin ;
ConcreteColleague1 = clase ( TColleague )
procedimiento Send ( AMessage : string ) ; anular ;
procedimiento Notificar ( AMessage : string ) ; anular ;
fin ;
ConcreteColleague2 = clase ( TColleague )
procedimiento Send ( AMessage : string ) ; anular ;
procedimiento Notificar ( AMessage : string ) ; anular ;
fin ;
{ TConcretoMediador }
procedimiento TConcreteMediator . Enviar ( AMessage : string ; ACollegue : IColleague ) ;
comenzar
si ACollegue = FCollegue1 luego
FCollegue2 . Notificar ( AMessage )
else
F Colega1 . Notificar ( AMessage ) ;
fin ;
{Colega}
constructor TColega . Crear ( AMediator : TMediator ) ;
comenzar
FMediator := AMediator ;
fin ;
{ColegaConcreto1}
procedimiento ConcreteColleague1 . Enviar ( AMessage : string ) ;
comenzar
FMediator . Enviar ( AMessage , Self ) ;
fin ;
procedimiento ConcreteColleague1 . Notificar ( AMessage : string ) ;
begin
Writeln ( 'Colega1 recibe mensaje: ' + AMessage ) ;
fin ;
{ColegaConcreto2}
procedimiento ConcreteColleague2 . Enviar ( AMessage : string ) ;
comenzar
FMediator . Enviar ( AMessage , Self ) ;
fin ;
procedimiento ConcreteColleague2 . Notificar ( AMessage : string ) ;
begin
Writeln ( 'Colega2 recibe mensaje: ' + AMessage ) ;
fin ;
var
Mediador : TConcreteMediator ;
Colega1 : ColegaConcreto1 ;
Colega2 : ConcretoColega2 ;
comenzar
Mediador := TConcreteMediator . crear ;
Colega1 := ConcretoColega1 . Crear ( Mediador ) ;
Colega2 := ConcretoColega2 . Crear ( Mediador ) ;
mediador _ FColega1 := Colega1 ;
mediador _ FColega2 := Colega2 ;
colega1 . Enviar ( '¿Cómo estás?' ) ;
colega2 . Enviar ( 'Bien, gracias' ) ;
readln ;
fin _
Enlaces