Mediator (model de design)
Versiunea actuală a paginii nu a fost încă examinată de colaboratori experimentați și poate diferi semnificativ de
versiunea revizuită la 16 martie 2014; verificările necesită
22 de modificări .
Mediatorul este un model de design comportamental care asigură interacțiunea multor obiecte, formând în același timp o legătură slabă și eliminând nevoia ca obiectele să se refere în mod explicit unele la altele.
Problemă
Asigurați interacțiunea multor obiecte, formând în același timp cuplaje libere și eliminând nevoia ca obiectele să se refere în mod explicit unele la altele.
Soluție
Creați un obiect care să încapsuleze câte obiecte interacționează.
Beneficii
Legătura dintre „Colegi” este eliminată, managementul este centralizat.
Structura
- Mediator - „Intermediar”
- ConcreteMediator - „Mediator concret”
- Cursuri pentru colegi - „Colegi”
Descriere
„Mediator” definește o interfață pentru schimbul de informații cu obiectele „Colegi”, „Mediator specific” coordonează acțiunile obiectelor „Colegi”. Fiecare clasă „Colegii” știe despre obiectul său „Mediator”, toți „Colegii” schimbă informații doar cu mediatorul, în lipsa acestuia ar trebui să schimbe informații direct. „Colegii” trimit cereri intermediarului și primesc cereri de la acesta. Mediatorul implementează un comportament cooperant prin înaintarea fiecărei cereri către unul sau mai mulți Colegi.
Exemple
Exemplu PHP5
Cod sursă în
PHP5
<?php
abstract class Mediator
{
abstract public function send ( $mesaj , Coleg $coleg );
}
clasa abstracta Colega
{
protected $mediator ;
public function __construct ( Mediator $mediator )
{
$this -> mediator = $mediator ;
}
public function send ( $mesaj )
{
$this -> mediator -> send ( $mesaj , $this );
}
/**
* Procesarea mesajului primit este implementată de fiecare * *
succesor concret
* @param șir mesaj mesajul primit
*/
abstract public function notify ( $message );
}
class ConcreteMediator extinde Mediator
{
/**
* @var ConcreteColleghe1
*/
private $ coleg1 ;
/**
* @var ConcreteColleague2
*/
private $ coleg2 ;
public function setColeg1 ( ConcreteCollegue1 $coleg )
{
$acest -> coleg1 = $coleg ;
}
public function setColega2 ( ConcreteCollegue2 $coleg )
{
$acest -> coleg2 = $coleg ;
}
funcţia publică trimite ( $mesaj , Coleg $coleg )
{
comuta ( $coleg ) {
caz $aceasta -> coleg1 :
$acest -> coleg2 -> notificare ( $mesaj );
rupe ;
caz $this -> coleg2 :
$this -> coleg1 -> notify ( $mesaj );
}
}
}
//colegul 1
clasă ConcreteCollega1 extinde Coleg
{
public function notify ( $mesaj )
{
echo sprintf ( "Colegul1 primește mesaj: %s \n " , $mesaj );
}
}
//colegul 2
clasa ConcreteCollega2 extinde Coleg
{
public function notify ( $mesaj )
{
echo sprintf ( "Colegul2 primește mesaj: %s \n " , $mesaj );
}
}
$mediator = new ConcreteMediator ();
$coleg1 = nou ConcreteCollegue1 ( $mediator );
$coleg2 = nou ConcreteCollegue2 ( $mediator );
$mediator -> setColeg1 ( $ coleg1 );
$mediator -> setColeg2 ( $ coleg2 );
$coleg1 -> trimite ( 'Ce mai faci?' );
$coleg2 -> trimite ( 'Bine, mulțumesc!' );
Exemplu Java
Sursa
Java
clasă public abstract coleg {
mediator protejat mediator ;
public Coleg ( Mediator mediator ) {
this . mediator = mediator ;
}
public void send ( String message ) {
mediator . trimite ( mesaj , asta );
}
public abstract void notify ( mesaj șir ); }
clasa public abstract Mediator {
public abstract void send ( mesaj șir , expeditor coleg ); }
clasa publică ConcreteColleague1 extinde Coleg {
public ConcreteColleghe1 ( Mediator mediator ) {
super ( mediator );
}
@Override
public void notify ( Mesaj șir ) { System . afară . println ( "Colega1 primește mesaj: " + mesaj ); } }
clasa publică ConcreteColleague2 extinde Coleg {
public ConcreteColleghe2 ( Mediator mediator ) {
super ( mediator );
}
@Override
public void notify ( Mesaj șir ) { System . afară . println ( "Colegul2 primește mesaj:" + mesaj ); } }
clasa publică ConcreteMediator extinde Mediator {
privat ConcreteColeghe1 coleg1 ;
privat ConcreteColeghe2 coleg2 ;
public void setColleghe1 ( Coleg Concrete1 ) { this . coleg1 = coleg ; }
public void setColleghe2 ( Coleg Concrete2 ) { this . coleg2 = coleg ; }
@Override
public void trimite ( Mesaj de tip șir , expeditor coleg ) { dacă ( expeditor . este egal cu ( coleg1 )) { coleg2 . notifica ( mesaj ); } else { coleg1 . notifica ( mesaj ); } } }
clasă publică principală {
public static void main ( String [] args ) {
ConcreteMediator m = new ConcreteMediator ();
ConcreteColleague1 c1 = nou ConcreteColleague1 ( m );
ConcreteColleague2 c2 = nou ConcreteColleghe2 ( m );
m . setColeg1 ( c1 );
m . setcolleague2 ( c2 );
c1 . trimite ( "Ce mai faci?" );
c2 . trimite ( "Bine, mulțumesc" );
}
}
Exemplu în C#
Text sursă în
C#
// Model mediator - Exemplu structural
folosind System ;
namespace DoFactory.GangOfFour.Mediator.Structural
{
/// <summary>
/// Clasa de pornire MainApp pentru Structural
/// Mediator Design Pattern.
/// </summary>
class MainApp
{
/// <summary>
/// Punct de intrare în aplicația consolă.
/// </summary>
static void Main ()
{
ConcreteMediator m = new ConcreteMediator ();
ConcreteColleague1 c1 = nou ConcreteColleague1 ( m );
ConcreteColleague2 c2 = nou ConcreteColleghe2 ( m );
m . Coleg1 = c1 ;
m . Coleg2 = c2 ;
c1 . Trimite ( "Ce mai faci?" );
c2 . Trimite ( „Bine, mulțumesc” );
// Așteptați
Consola utilizatorului . ReadKey ();
}
}
/// <summary>
/// The 'Mediator' abstract class
/// </summary>
abstract class Mediator
{
public abstract void Trimite ( șir de mesaje , Coleg coleg );
}
/// <summary>
/// Clasa 'ConcreteMediator'
/// </summary>
class ConcreteMediator : Mediator
{
public ConcreteCollegue1 Coleg1 { private get ; set ; }
public ConcreteColeghe2 Coleg2 { private get ; set ; }
public override void Trimite ( șir de mesaje , Coleg coleg )
{
if ( coleg == Coleg1 )
{
Coleg2 . notifica ( mesaj );
}
else
{
Coleg1 . notifica ( mesaj );
}
}
}
/// <summary>
/// Clasa abstractă „Coleg”
/// </summary>
clasa abstractă Coleg { protejat Mediator mediator ;
// Constructor
public Coleg ( Mediator mediator )
{
this . mediator = mediator ;
}
}
/// <summary>
/// A 'ConcreteColleague' class
/// </summary>
class ConcreteColleague1 : Coleg
{
// Constructor
public ConcreteColleague1 ( Mediator mediator )
: base ( mediator )
{
}
public void Trimite ( șir mesaj )
{
mediator . Trimite ( mesaj , asta );
}
public void Notificare ( șir de mesaje )
{
Consolă . WriteLine ( "Colega1 primește mesaj: " + mesaj );
}
}
/// <summary>
/// O clasă 'ConcreteColleague'
/// </summary>
class ConcreteColleague2 : Coleg
{
// Constructor
public ConcreteColleague2 ( Mediator mediator )
: bază ( mediator )
{
}
public void Trimite ( șir mesaj )
{
mediator . Trimite ( mesaj , asta );
}
public void Notificare ( șir de mesaje )
{
Consolă . WriteLine ( "Colega2 primește mesaj: " + mesaj );
}
}
}
Ieșire
Colegul2 primește mesajul : Ce mai faci ?
Colegul1 primește mesajul : Bine , mulțumesc
Exemplu C++
Text sursă în
C++
#include <iostream>
#include <șir>
coleg de clasa ;
mediator de clasă ;
clasa ConcreteMediator ;
clasa ConcreteColega1 ;
clasa ConcreteColega2 ;
mediator de clasă
{
public :
virtual void Trimitere ( std :: string const & mesaj , Coleg * coleg ) const = 0 ;
};
coleg de clasă
{
protejat :
mediator * mediator_ ;
public :
explicit Coleg ( Mediator * mediator ) : mediator_ ( mediator )
{
}
};
clasa ConcreteColega1 : coleg public
{
public :
explicit ConcreteColleghe1 ( Mediator * mediator ) : Coleg ( mediator )
{
}
void Trimitere ( std :: string const & message )
{
mediator_ -> Trimite ( mesaj , asta );
}
void Notify ( std :: string const & message )
{
std :: cout << "Colegul1 primește mesajul '" << mesaj << "'" << std :: endl ;
}
};
clasa ConcreteColleague2 : coleg public
{
public :
explicit ConcreteColleague2 ( Mediator * mediator ) : Coleg ( mediator )
{
}
void Trimitere ( std :: string const & message )
{
mediator_ -> Trimite ( mesaj , asta );
}
void Notify ( std :: string const & message )
{
std :: cout << "Colegul2 primește mesajul '" << mesaj << "'" << std :: endl ;
}
};
clasa ConcreteMediator : Mediator public
{
protejat :
ConcreteColega1 * m_Colega1 ;
ConcreteColega2 * m_Colega2 ;
public :
void SetColleague1 ( ConcreteColleague1 * c )
{
m_Coleg1 = c ;
}
void SetColleague2 ( ConcreteColleague2 * c )
{
m_colegă2 = c ;
}
virtual void Trimite ( std :: string const & message , Coleg * coleg ) const
{
dacă ( coleg == m_Coleg1 )
{
m_Colega2 -> Notificare ( mesaj );
}
else if ( coleg == m_Colega2 )
{
m_Colega1 -> Notificare ( mesaj );
}
}
};
int main ()
{
ConcreteMediator m ;
ConcreteColega1 c1 ( & m );
ConcreteColleague2 c2 ( & m );
m . SetColega1 ( & c1 );
m . SetColega2 ( & c2 );
c1 . Trimite ( "Ce mai faci?" );
c2 . Trimite ( „Bine, mulțumesc” );
std :: cin . obține ();
returnează 0 ;
}
Ieșire
Colega2 primește mesajul „ Cum mai faci ? '
Colegul1 primește mesajul „ Bine , mulțumesc ”
Exemplu Python
Cod sursă în
Python
de la abc import ABCMeta , abstractmethod
de la weakref import proxy
import inspect
mediator de clasă ( metaclass = ABCMeta ):
"""
Un canal de comunicare abstract între colegi
"""
@abstractmethod
def send ( self , message : str ) -> None :
"""
Trimiterea unui mesaj între egali
"""
trece
Coleg de clasă ( metaclass = ABCMeta ):
"""
Un lucrător abstract căruia nu-i deranjează să discute cu colegii săi
"""
def __init__ ( self , mediator : Mediator ) -> None :
"""
Constructor.
:param mediator: canal de comunicare cu colegii
""
" self ._mediator = proxy ( mediator )
@abstractmethod
def send ( self , message : str ) -> None :
"""
Trimite mesaj prin canalul de comunicare
"""
pass
@abstractmethod
def receive ( self , message : str ) -> None :
"""
Primire mesaj prin canalul de comunicare
"""
pass
clasa SkypeBetweenTwoColleghes ( Mediator ):
"""
Canal Skype pentru comunicarea intre doua persoane
"""
def __init__ ( self ) -> None :
"""
Constructor.
"""
self . _first = None
self . _second = Nici unul
def set_first ( self , first : Coleg ) -> None :
"""
Atribuie primul participant al conversației
"""
self canalului . _primul = primul
def set_second ( self , second : Coleg ) -> None :
"""
Asociază cel de-al doilea participant la conversația
"""
self cu canalul . _secundă = secundă
def send ( self , message : str ) -> None :
sender = inspect . cadru curent () . f_back . f_locals [ 'self' ]
receiver = self . _primul dacă expeditorul == self . _al doilea alt sine . _al doilea
receptor . primi ( mesaj )
clasa Bill ( Coleg ):
def trimite ( self , mesaj : str ) -> None :
self . _mediator . trimite ( mesaj )
def receive ( self , message : str ) -> None :
print ( 'Bill a primit mesajul: {} ' . format ( mesaj ))
clasa Steve ( Coleg ):
def trimite ( self , mesaj : str ) -> None :
self . _mediator . trimite ( mesaj )
def receive ( self , message : str ) -> None :
print ( 'Steve a citit mesajul pe Skype: {} ' . format ( mesaj ))
if __name__ == '__main__' :
print ( 'OUTPUT:' )
skype = SkypeBetweenTwoCollegues ()
bill = Bill ( skype )
steve = Steve ( skype )
skype . set_first ( factura )
skype . set_second ( steve )
bill . trimite ( „Pune la treabă, leneş!' )
steve . trimite ( 'Nu' )
Ieșire: Steve
a citit un mesaj Skype: Treci la treabă, leneș!
Bill a primit mesajul: Nu
'''
Exemplu Delphi
Text sursă în
Delphi
program MediatorExample ;
{$APPTYPE CONSOLE}
tip
IColleague = procedura de interfață
Trimitere ( AMessage : șir ) ; procedura Notificare ( AMessage : string ) ; sfârşitul ;
TMediator = procedura de clasă
Trimitere ( AMessage : șir ; ACollegue : IColleague ) ; virtual ; abstract ; sfârşitul ;
TConcreteMediator = clasa ( TMediator )
public
FCCollegue1 : IColleague ;
FCCollegue2 : IColeg ;
procedura Trimitere ( AMessage : șir ; ACegue : IColeg ) ; suprascrie ;
sfârşitul ;
TColleague = clasă ( TInterfacedObject , IColleague )
public
FMediator : TMediator ;
constructor Create ( AMediator : TMediator ) ;
procedura Trimitere ( AMessage : șir ) ; virtual ; abstract ;
procedura Notificare ( AMessage : string ) ; virtual ; abstract ;
sfârşitul ;
ConcreteCollega1 = procedura de clasă ( TColleague )
Trimitere ( AMessage : șir ) ; suprascrie ; procedura Notificare ( AMessage : string ) ; suprascrie ; sfârşitul ;
ConcreteCollega2 = procedura de clasă ( TColleague )
Trimitere ( AMessage : șir ) ; suprascrie ; procedura Notificare ( AMessage : string ) ; suprascrie ; sfârşitul ;
{ TConcreteMediator }
procedura TConcreteMediator . Trimite ( AMessage : șir ; ACegue : IColleague ) ;
începe
dacă ACollegue = FCollegue1 apoi
FCollegue2 . Notifică ( AMesaj )
altfel
F Colegul1 . Notifică ( AMessage ) ;
sfârşitul ;
{TCleg}
constructor TColeague . Creare ( AMediator : TMediator ) ;
începe
FMediator := AMediator ;
sfârşitul ;
{ConcreteCollega1}
procedura ConcreteColega1 . Trimite ( AMessage : șir ) ;
începe
FMediator . Trimite ( AMessage , Self ) ;
sfârşitul ;
procedura ConcreteColega1 . Notifică ( AMessage : șir ) ;
începe
Writeln ( 'Colega1 primește mesajul: ' + AMessage ) ;
sfârşitul ;
{ConcreteColleghe2}
procedura ConcreteColega2 . Trimite ( AMessage : șir ) ;
începe
FMediator . Trimite ( AMessage , Self ) ;
sfârşitul ;
procedura ConcreteColega2 . Notifică ( AMessage : șir ) ;
începe
Writeln ( 'Colega2 primește mesajul: ' + AMessage ) ;
sfârşitul ;
var
Mediator : TConcreteMediator ;
Colega1 : Colega Beton1 ;
Colega2 : ConcreteColega2 ;
începe
Mediator := TConcreteMediator . a crea ;
Colega1 := Colega Beton1 . Creare ( Mediator ) ;
Colega2 := Colega Beton2 . Creare ( Mediator ) ;
mediator . FCCollegue1 := Coleg1 ;
mediator . FCCollegue2 := Coleg2 ;
Colegul 1 . Trimite ( 'Ce mai faci?' ) ;
Colegul2 . Trimite ( „Bine, mulțumesc” ) ;
readln ;
sfârşitul .
Link -uri