Mediátor (designový vzor)
Aktuální verze stránky ještě nebyla zkontrolována zkušenými přispěvateli a může se výrazně lišit od
verze recenzované 16. března 2014; kontroly vyžadují
22 úprav .
Mediátor je behaviorální designový vzor , který zajišťuje interakci mnoha objektů a zároveň tvoří slabý článek a eliminuje potřebu, aby na sebe objekty explicitně odkazovaly.
Problém
Zajistěte interakci mnoha objektů a zároveň vytvořte volné spojení a eliminujte potřebu objektů na sebe explicitně odkazovat.
Řešení
Vytvořte objekt, který zapouzdří , kolik objektů interaguje.
Výhody
Odpadá spojení mezi „Kolegy“, řízení je centralizované.
Struktura
- Zprostředkovatel - "Zprostředkovatel"
- ConcreteMediator - "Konkrétní mediátor"
- Kolegové třídy - "Kolegové"
Popis
„Mediátor“ definuje rozhraní pro výměnu informací s objekty „Kolegové“, „Konkrétní prostředník“ koordinuje akce objektů „Kolegové“. Každá třída "Kolegové" ví o svém objektu "Mediátor", všichni "Kolegové" si vyměňují informace pouze s mediátorem, v jeho nepřítomnosti by si museli vyměňovat informace přímo. „Kolegové“ posílají požadavky zprostředkovateli a přijímají od něj požadavky. Mediátor zavádí kooperativní chování předáváním každého požadavku jednomu nebo více kolegům.
Příklady
Příklad PHP5
Zdrojový kód v
PHP5
<?php
abstraktní třída Mediátor
{
abstract public function send ( $message , Kolega $kolega );
}
abstraktní třída Kolega
{
chráněn $mediátor ;
public function __construct ( Mediator $mediator )
{
$this -> mediator = $mediator ;
}
public function send ( $message )
{
$this -> mediator -> send ( $message , $this );
}
/**
* Zpracování přijaté zprávy je realizováno každým * * konkrétním
následníkem
* @param string zprávou přijatou zprávou
*/
abstract public function notify ( $message );
}
class ConcreteMediator extends Mediator
{
/**
* @var ConcreteColleague1
*/
private $colleague1 ;
/**
* @var ConcreteColleague2
*/
private $colleague2 ;
public function setColleague1 ( ConcreteColleague1 $kolega )
{
$this -> kolega1 = $kolega ;
}
public function setColleague2 ( ConcreteColleague2 $kolega )
{
$this -> kolega2 = $kolega ;
}
public function send ( $message , Collague $colleague )
{
switch ( $kolega ) {
case $this -> kolega1 :
$this -> kolega2 -> upozornit ( $message );
zlomit ;
case $this -> kolega2 :
$this -> kolega1 -> upozornit ( $message );
}
}
}
//kolega 1
class ConcreteColleague1 extends Kolega
{
public function notify ( $message )
{
echo sprintf ( "Kolega1 dostane zprávu: %s \n " , $message );
}
}
//kolega 2
class ConcreteColleague2 extends Kolega
{
public function notify ( $message )
{
echo sprintf ( "Kolega2 dostane zprávu: %s \n " , $message );
}
}
$mediator = new ConcreteMediator ();
$collegue1 = new ConcreteColleague1 ( $mediator );
$collegue2 = new ConcreteColleague2 ( $mediator );
$mediator -> setColleague1 ( $ collegue1 );
$mediator -> setColleague2 ( $ collegue2 );
$collegue1 -> send ( 'Jak se máš?' );
$collegue2 -> send ( 'Fajn, díky!' );
Příklad Java
Zdroj
Java
public abstract class Kolega {
chráněný mediátor mediátor ;
veřejný kolega ( mediátor mediátor ) {
this . mediátor = prostředník ;
}
public void send ( String message ) {
mediátor . odeslat ( zpráva , toto );
}
public abstract void notify ( String message );
}
public abstract class Mediátor {
public abstract void send ( String message , Kolega odesílatel );
}
public class ConcreteColleague1 rozšiřuje Kolega {
public ConcreteColleague1 ( Mediátor mediátor ) {
super ( mediátor );
}
@Override
public void notify ( String message ) {
System . ven . println ( "Kolega1 dostane zprávu: " + zpráva );
}
}
public class ConcreteColleague2 rozšiřuje Kolega {
public ConcreteColleague2 ( Mediátor mediátor ) {
super ( mediátor );
}
@Override
public void notify ( String message ) {
System . ven . println ( "Kolega2 dostane zprávu: " + zpráva );
}
}
public class ConcreteMediator rozšiřuje Mediator {
soukromý ConcreteColleague1 kolega1 ;
soukromý ConcreteColleague2 kolega2 ;
public void setColleague1 ( ConcreteColleague1 kolega ) {
this . kolega1 = kolega ;
}
public void setColleague2 ( kolega ConcreteColleague2 ) { this . kolega2 = kolega ; }
@Override
public void send ( String message , Colleague Sender ) {
if ( sender . rovno ( kolega1 )) {
kolega2 . oznámit ( zpráva );
} else {
kolega1 . oznámit ( zpráva );
}
}
}
public class Hlavní {
public static void main ( String [] args ) {
ConcreteMediator m = new ConcreteMediator ();
ConcreteColleague1 c1 = new ConcreteColleague1 ( m );
ConcreteColleague2 c2 = nový ConcreteColleague2 ( m );
m . setColleague1 ( c1 );
m . setcolleague2 ( c2 );
c1 . poslat ( "Jak se máš?" );
c2 . odeslat ( "Fajn, díky" );
}
}
Příklad v C#
Zdrojový text v
C#
// Vzor prostředníka – Strukturální příklad
pomocí System ;
jmenný prostor DoFactory.GangOfFour.Mediator.Structural
{
/// <summary>
/// Spouštěcí třída MainApp pro Structural
/// Vzor návrhu Mediator.
/// </summary>
class MainApp
{
/// <summary>
/// Vstupní bod do konzolové aplikace.
/// </summary>
static void Main ()
{
ConcreteMediator m = new ConcreteMediator ();
ConcreteColleague1 c1 = new ConcreteColleague1 ( m );
ConcreteColleague2 c2 = nový ConcreteColleague2 ( m );
m . Kolega1 = c1 ;
m . Kolega2 = c2 ;
c1 . Odeslat ( "Jak se máš?" );
c2 . Odeslat ( "Fajn, díky" );
// Počkejte na uživatelskou
konzoli . ReadKey ();
}
}
/// <summary>
/// Abstraktní třída 'Mediátor'
/// </summary>
abstract class Mediátor
{
public abstract void Send ( string message , kolega kolega );
}
/// <summary>
/// Třída 'ConcreteMediator'
/// </summary>
class ConcreteMediator : Mediátor
{
public ConcreteColleague1 Colleague1 { private get ; nastavit ; }
public ConcreteColleague2 Kolega2 { private get ; nastavit ; }
public override void Odeslat ( string message , kolega kolega )
{
if ( kolega == kolega1 )
{
kolega2 . oznámit ( zpráva );
}
else
{
Kolega1 . oznámit ( zpráva );
}
}
}
/// <summary>
/// Abstraktní třída 'Kolega'
/// </summary>
abstract class Kolega
{
protected Mediátor mediátor ;
// Konstruktor
public Kolega ( Mediátor mediátor )
{
this . mediátor = prostředník ;
}
}
/// <summary>
/// Třída 'ConcreteColleague'
/// </summary>
class ConcreteColleague1 : Colleague
{
// Constructor
public ConcreteColleague1 ( Mediator mediator )
: base ( mediator )
{
}
public void Odeslat ( řetězcová zpráva )
{
mediátor . Odeslat ( zpráva , toto );
}
public void Upozornit ( řetězcová zpráva )
{
Console . WriteLine ( "Kolega1 dostane zprávu: " + zpráva );
}
}
/// <summary>
/// Třída 'ConcreteColleague'
/// </summary>
class ConcreteColleague2 : Colleague
{
// Constructor
public ConcreteColleague2 ( Mediator mediator )
: base ( mediator )
{
}
public void Odeslat ( řetězcová zpráva )
{
mediátor . Odeslat ( zpráva , toto );
}
public void Upozornit ( řetězcová zpráva )
{
Console . WriteLine ( "Kolega2 dostane zprávu: " + zpráva );
}
}
}
Output
Colleague2 dostane zprávu : Jak se máš ?
Kolega1 dostane zprávu : Dobře , děkuji
Příklad C++
Zdrojový text v
C++
#include <iostream>
#include <řetězec>
třídní kolega ;
třídní mediátor ;
třída ConcreteMediator ;
třída ConcreteColleague1 ;
třída ConcreteColleague2 ;
třídní mediátor
{
veřejnost :
virtual void Odeslat ( std :: string const & message , Kolega * kolega ) const = 0 ;
};
třídní kolega
{
chráněno :
mediátor * mediátor_ ;
veřejnost :
explicitní kolega ( mediátor * mediátor ) : mediátor_ ( mediátor )
{
}
};
třída ConcreteColleague1 : veřejný kolega
{
veřejnost :
explicitní ConcreteColleague1 ( Mediátor * mediátor ) : Kolega ( mediátor )
{
}
void Odeslat ( std :: string const & message )
{
mediátor_ -> Odeslat ( zpráva , toto );
}
void Notify ( std :: string const & message )
{
std :: cout << "Kolega1 dostane zprávu '" << zpráva << "'" << std :: endl ;
}
};
třída ConcreteColleague2 : veřejný kolega
{
veřejnost :
explicitní ConcreteColleague2 ( Mediátor * mediátor ) : Kolega ( mediátor )
{
}
void Odeslat ( std :: string const & message )
{
mediátor_ -> Odeslat ( zpráva , toto );
}
void Notify ( std :: string const & message )
{
std :: cout << "Kolega2 dostane zprávu '" << zpráva << "'" << std :: endl ;
}
};
třída ConcreteMediator : veřejný Mediátor
{
chráněno :
ConcreteColleague1 * m_Colleague1 ;
ConcreteColleague2 * m_Colleague2 ;
veřejnost :
void SetColleague1 ( ConcreteColleague1 * c )
{
m_Kolega1 = c ;
}
void SetColleague2 ( ConcreteColleague2 * c )
{
m_kolega2 = c ;
}
virtual void Odeslat ( std :: string const & message , Kolega * kolega ) const
{
if ( kolega == m_Colleague1 )
{
m_Kolega2 -> Upozornit ( zpráva );
}
else if ( kolega == m_Colleague2 )
{
m_Kolega1 -> Upozornit ( zpráva );
}
}
};
int main ()
{
ConcreteMediator m ;
ConcreteColleague1 c1 ( & m );
ConcreteColleague2 c2 ( & m );
m . SetColleague1 ( & c1 );
m . SetColleague2 ( & c2 );
c1 . Odeslat ( "Jak se máš?" );
c2 . Odeslat ( "Fajn, díky" );
std :: cin . získat ();
návrat 0 ;
}
Výstup
Kolega2 dostane zprávu ' Jak se máš ? '
Kolega1 dostane zprávu ' Dobře , děkuji '
Příklad Pythonu
Zdrojový kód v
Pythonu
from abc import ABCMeta , abstractmethod
from slabéref import proxy
import inspect
class Mediátor ( metaclass = ABCMeta ):
"""
Abstraktní komunikační kanál mezi kolegy
"""
@abstractmethod
def send ( self , message : str ) -> None :
"""
Odeslání zprávy mezi vrstevníky
"""
pass
třídní kolega ( metaclass = ABCMeta ):
"""
Abstraktní pracovník, kterému nevadí chatovat s kolegy
"""
def __init__ ( self , mediátor : Mediátor ) -> Žádný :
"""
Konstruktor.
:param mediátor: komunikační kanál s kolegy
""
" self ._mediator = proxy ( mediátor )
@abstractmethod
def send ( self , message : str ) -> None :
"""
Odeslat zprávu přes komunikační kanál
"""
pass
@abstractmethod
def příjem ( self , message : str ) -> None :
"""
Příjem zprávy přes komunikační kanál
"""
pass
třída SkypeBetweenTwoColleagues ( Mediátor ):
"""
Skype kanál pro komunikaci mezi dvěma lidmi
"""
def __init__ ( self ) -> None :
"""
Konstruktor.
"""
self . _first = Žádné
já . _second = Žádný
def set_first ( self , first : Collague ) -> None :
"""
Přiřadí prvního účastníka konverzace
"""
self ke kanálu . _first = první
def set_second ( self , second : Collague ) -> None :
""" Přidruží
druhého účastníka konverzace
"""
self ke kanálu . _second = sekunda
def send ( self , message : str ) -> None :
sender = inspect . aktuální snímek () . f_back . f_locals [ 'self' ]
receiver = self . _first if sender == self . _druhý jiný já . _druhý
přijímač . přijímat ( zpráva )
třídní Bill ( kolega ):
def send ( self , message : str ) -> None :
self . _prostředník . poslat ( zpráva )
def příjem ( self , message : str ) -> None :
print ( 'Bill obdržel zprávu: {} ' . format ( message ))
třída Steve ( kolega ):
def send ( self , message : str ) -> None :
self . _prostředník . poslat ( zpráva )
def příjem ( self , message : str ) -> None :
print ( 'Steve si přečetl zprávu na Skype: {} ' . format ( message ))
if __name__ == '__main__' :
print ( 'OUTPUT:' )
skype = SkypeBetweenTwo Colleagues ()
bill = Bill ( skype )
steve = Steve ( skype )
skype . set_first ( bill )
skype . set_second ( steve )
bill . poslat ( 'Dej se do práce, lenochu!' )
steve . odeslat ( 'Ne' )
'''
VÝSTUP:
Steve si přečetl zprávu přes Skype: Pusť se do práce, lenochu!
Bill obdržel zprávu: Ne
'''
Příklad Delphi
Zdrojový text v
Delphi
program MediatorExample ;
{$APPTYPE KONZOLE}
type
IColleague = interface
procedure Send ( AMessage : string ) ;
procedura Notify ( AMessage : string ) ;
konec ;
TMediator = class
procedure Send ( AMessage : string ; ACollegue : IColleague ) ; virtuální ; abstraktní ;
konec ;
TConcreteMediator = class ( TMediator )
public
FCollegue1 : IColleague ;
FCollegue2 : IColeague ;
procedura Send ( AMessage : string ; ACollegue : IColleague ) ; přepsat ;
konec ;
TColleague = class ( TInterfacedObject , IColleague )
public
FMediator : TMediator ;
konstruktor Create ( AMediator : TMediator ) ;
procedura Send ( AMessage : string ) ; virtuální ; abstraktní ;
procedura Notify ( AMessage : string ) ; virtuální ; abstraktní ;
konec ;
ConcreteColleague1 = class ( TColleague )
procedure Send ( AMessage : string ) ; přepsat ;
procedura Notify ( AMessage : string ) ; přepsat ;
konec ;
ConcreteColleague2 = class ( TColleague )
procedure Send ( AMessage : string ) ; přepsat ;
procedura Notify ( AMessage : string ) ; přepsat ;
konec ;
{ TConcreteMediator }
postup TConcreteMediator . Odeslat ( AMessage : string ; AKolega : IKolega ) ;
begin
if ACollegue = FCollegue1 then
FCollegue2 . Upozornit ( AMessage )
jinak
F Kolega1 . Upozornit ( AMessage ) ;
konec ;
{TColleague}
konstruktor Tkolega . Vytvořit ( AMediator : TMediator ) ;
begin
FMediator := AMediator ;
konec ;
{ConcreteColleague1}
postup ConcreteColleague1 . Odeslat ( AMessage : string ) ;
spusťte
FMediator . Odeslat ( AMessage , Self ) ;
konec ;
postup ConcreteColleague1 . Notify ( AMessage : string ) ;
begin
Writeln ( 'Kolega1 dostane zprávu: ' + AMessage ) ;
konec ;
{ConcreteColleague2}
postup ConcreteColleague2 . Odeslat ( AMessage : string ) ;
spusťte
FMediator . Odeslat ( AMessage , Self ) ;
konec ;
postup ConcreteColleague2 . Notify ( AMessage : string ) ;
begin
Writeln ( 'Kolega2 dostane zprávu: ' + AMessage ) ;
konec ;
var
Mediátor : TConcreteMediator ;
Kolega1 : ConcreteColleague1 ;
Kolega2 : ConcreteColleague2 ;
begin
Mediátor := TConcreteMediator . vytvořit ;
Kolega1 := ConcreteColleague1 . Vytvořit ( Mediátor ) ;
Kolega2 := ConcreteColleague2 . Vytvořit ( Mediátor ) ;
zprostředkovatel . FCkolega1 := Kolega1 ;
zprostředkovatel . FCkolega2 := Kolega2 ;
Kolega1 . Odeslat ( 'Jak se máš?' ) ;
Kolega2 . Odeslat ( 'Fajn, děkuji' ) ;
readln ;
konec .
Odkazy