Közvetítő (tervezési minta)
Az oldal jelenlegi verzióját még nem ellenőrizték tapasztalt közreműködők, és jelentősen eltérhet a 2014. március 16-án áttekintett
verziótól ; az ellenőrzések 22 szerkesztést igényelnek .
A közvetítő egy viselkedési tervezési minta , amely számos objektum interakcióját biztosítja, miközben gyenge láncszemet képez , és kiküszöböli annak szükségességét, hogy az objektumok kifejezetten egymásra utaljanak.
Probléma
Biztosítsa sok objektum interakcióját, miközben laza csatolást hoz létre, és kiküszöböli annak szükségességét, hogy az objektumok kifejezetten egymásra utaljanak.
Megoldás
Hozzon létre egy objektumot, amely magában foglalja , hogy hány objektum működik együtt.
Előnyök
Megszűnik a kapcsolat a „Kollégák” között, központosítják az irányítást.
Szerkezet
- Közvetítő - "Közvetítő"
- ConcreteMediator - "Betonközvetítő"
- Kolléga osztályok - "Kollégák"
Leírás
A "Közvetítő" interfészt definiál a "Kollégák" objektumokkal való információcseréhez, a "Speciális közvetítő" pedig a "Kollégák" objektumok műveleteit koordinálja. Minden osztály "Kollégák" tud a "Közvetítő" objektumáról, minden "Kolléga" csak a közvetítővel cserél információt, ennek hiányában közvetlenül kellene információt cserélniük. A "kollégák" kéréseket küldenek a közvetítőnek, és kéréseket kapnak tőle. A közvetítő együttműködő magatartást valósít meg úgy, hogy minden kérést továbbít egy vagy több kollégának.
Példák
PHP5 példa
Forráskód
PHP5 -ben
<?php
abstract class Közvetítő
{
abstract public function küld ( $üzenet , Kolléga $kolléga );
}
absztrakt osztály Kolléga
{
védett $közvetítő ;
public function __construct ( Mediator $mediator )
{
$this -> mediator = $mediator ;
}
public function küldés ( $üzenet )
{
$this -> mediator -> send ( $message , $this );
}
/**
* A fogadott üzenet feldolgozását minden * * konkrét
utód
* @param string üzenet a fogadott üzenet
*/
absztrakt public function notify ( $üzenet );
}
class ConcreteMediator extends Mediator
{
/**
* @var ConcreteColleague1
*/
private $ kollega1 ;
/**
* @var ConcreteColleague2
*/
privát $ kolléga2 ;
public function setColleague1 ( ConcreteColleague1 $kolléga )
{
$this -> kolléga1 = $ kolléga ; }
public function setColleague2 ( ConcreteColleague2 $kolléga )
{
$this -> kolléga2 = $ kolléga ; }
public function küldés ( $üzenet , Kolléga $kolléga )
{
switch ( $kolléga ) {
case $this -> kolléga1 :
$ez -> kolléga2 -> értesít ( $üzenet );
szünet ;
case $ez -> kolléga2 :
$ez -> kolléga1 -> értesít ( $üzenet );
}
}
}
//kolléga 1
class ConcreteColleague1 extends Kolléga
{
public function notify ( $üzenet )
{
echo sprintf ( "A kolléga1 üzenetet kap: %s \n " , $üzenet );
}
}
//kolléga 2
class ConcreteColleague2 expands Kolléga
{
public function notify ( $üzenet )
{
echo sprintf ( "A kolléga2 üzenetet kap: %s \n " , $üzenet );
}
}
$közvetítő = új ConcreteMediator ();
$kolléga1 = new ConcreteColleague1 ( $közvetítő );
$kolléga2 = new ConcreteColleague2 ( $közvetítő );
$mediator -> setColleague1 ( $ kolléga1 );
$közvetítő -> setColleague2 ( $ kolléga2 );
$kolléga1 -> küld ( 'Hogy vagy?' );
$kolléga2 -> küld ( 'Rendben, köszönöm!' );
Java példa
Java forrás
public abstract class Kolléga {
védett közvetítő közvetítő ;
public Kolléga ( Közvetítő közvetítő ) {
ez . mediátor = közvetítő ;
}
public void küldés ( String message ) {
közvetítő . küldeni ( üzenet , ez );
}
public abstract void notify ( String message );
}
public abstract class Közvetítő {
public abstract void send ( String message , Kolléga küldője );
}
public class ConcreteColleague1 kiterjeszti Kolléga {
public Konkrét Kolléga1 ( Közvetítő közvetítő ) {
szuper ( közvetítő );
}
@Override
public void notify ( String message ) {
System . ki . println ( "1. kolléga üzenetet kap: " + üzenet );
}
}
public class ConcreteColleague2 kiterjeszti Kolléga {
public ConcreteColleague2 ( Közvetítő közvetítő ) {
szuper ( közvetítő );
}
@Override
public void notify ( String message ) {
System . ki . println ( "A 2. kolléga üzenetet kap: " + üzenet );
}
}
public class ConcreteMediator kiterjeszti Mediator {
magán ConcreteColleague1 kolléga1 ;
magán ConcreteColleague2 kolléga2 ;
public void setColleague1 ( ConcreteColleague1 kolléga ) {
this . kolléga1 = kolléga ;
}
public void setColleague2 ( ConcreteColleague2 kolléga ) {
this . kolléga2 = kolléga ;
}
@Override
public void send ( String message , Kolléga feladó ) {
if ( küldő . egyenlő ( kolléga1 ) ) {
kolléga2 . értesíteni ( üzenet );
} else {
kolléga1 . értesíteni ( üzenet );
}
}
}
public class Fő {
public static void main ( String [] args ) {
ConcreteMediator m = new ConcreteMediator ();
ConcreteColleague1 c1 = new ConcreteColleague1 ( m );
ConcreteColleague2 c2 = new ConcreteColleague2 ( m );
m . setKolléga1 ( c1 );
m . kolléga2 ( c2 );
c1 . küld ( "Hogy vagy?" );
c2 . küld ( "Rendben, köszönöm" );
}
}
Példa C#-ban
Forrásszöveg
C# nyelven
// Közvetítő minta - Szerkezeti példa
a rendszer használatával ;
névtér DoFactory.GangOfFour.Mediator.Structural
{
/// <summary>
/// MainApp indítási osztály a Structural számára
/// Mediátor tervezési minta.
/// </summary>
class MainApp
{
/// <summary>
/// Belépési pont a konzolalkalmazásba.
/// </summary>
static void Main ()
{
ConcreteMediator m = new ConcreteMediator ();
ConcreteColleague1 c1 = new ConcreteColleague1 ( m );
ConcreteColleague2 c2 = new ConcreteColleague2 ( m );
m . Kolléga1 = c1 ;
m . Kolléga2 = c2 ;
c1 . Send ( "Hogy vagy?" );
c2 . Küldés ( "Rendben, köszönöm" );
// Várja meg a felhasználói
konzolt . ReadKey ();
}
}
/// <summary>
/// A 'Közvetítő' abstract class
/// </summary>
abstract class Közvetítő
{
public abstract void Küldés ( string message , Kolléga kolléga );
}
/// <summary>
/// A 'ConcreteMediator' osztály
/// </summary>
class ConcreteMediator : Közvetítő
{
public ConcreteColleague1 Kolléga1 { private get ; készlet ; }
public ConcreteColleague2 Kolléga2 { private get ; készlet ; }
public override void Küldés ( karakterlánc üzenet , kolléga kolléga )
{
if ( kolléga == Kolléga1 )
{
Kolléga2 . értesíteni ( üzenet );
}
else
{
Kolléga1 . értesíteni ( üzenet );
}
}
}
/// <summary>
/// A 'kolléga' abstract class
/// </summary>
abstract class Kolléga
{
védett Közvetítő mediátor ;
// Konstruktor
publikus Kolléga ( Közvetítő közvetítő )
{
this . mediátor = közvetítő ;
}
}
/// <summary>
/// A 'ConcreteColleague' osztály
/// </summary>
class ConcreteColleague1 : Kolléga
{
// Constructor
public ConcreteColleague1 ( Közvetítő közvetítő )
: base ( közvetítő )
{
}
public void Küldés ( karakterlánc üzenet )
{
közvetítő . Küldés ( üzenet , ez );
}
public void Értesítés ( karakterlánc üzenet )
{
Konzol . WriteLine ( "1. kolléga üzenetet kap: " + üzenet );
}
}
/// <summary>
/// A 'ConcreteColleague' osztály
/// </summary>
class ConcreteColleague2 : Kolléga
{
// Constructor
public ConcreteColleague2 ( Közvetítő közvetítő )
: base ( közvetítő )
{
}
public void Küldés ( karakterlánc üzenet )
{
közvetítő . Küldés ( üzenet , ez );
}
public void Értesítés ( karakterlánc üzenet )
{
Konzol . WriteLine ( "A kolléga2 üzenetet kap: " + üzenet );
}
}
}
Output
Colleague2 üzenetet kap : Hogy vagy ? _ Az 1. kolléga üzenetet kap : Rendben , köszönöm
C++ példa
Forrásszöveg
C++ nyelven
#include <iostream>
#include <karakterlánc>
osztály Kolléga ;
osztályközvetítő ; _
osztály ConcreteMediator ;
osztály Betonkolléga1 ;
osztály Betonkolléga2 ;
osztályú közvetítő
{
nyilvános :
virtual void Küldés ( std :: string const & message , Kolléga * kolléga ) const = 0 ;
};
osztályú Kolléga
{
védett :
mediátor * közvetítő_ ;
nyilvános :
explicit kolléga ( közvetítő * közvetítő ) : mediátor_ ( közvetítő )
{
}
};
osztály ConcreteColleague1 : nyilvános Kolléga
{
nyilvános :
explicit ConcreteColleague1 ( közvetítő * közvetítő ) : Kolléga ( közvetítő )
{
}
void Küldés ( std :: string const & message )
{
mediátor_ -> Küldés ( üzenet , ez );
}
void Notify ( std :: string const & message )
{
std :: cout << "1 kolléga '" üzenetet kap << üzenet << "'" << std :: endl ;
}
};
osztály ConcreteColleague2 : nyilvános Kolléga
{
nyilvános :
explicit ConcreteColleague2 ( közvetítő * közvetítő ) : Kolléga ( közvetítő )
{
}
void Küldés ( std :: string const & message )
{
mediátor_ -> Küldés ( üzenet , ez );
}
void Notify ( std :: string const & message )
{
std :: cout << "2. kolléga '" üzenetet kap << üzenet << "'" << std :: endl ;
}
};
osztály ConcreteMediator : nyilvános Közvetítő
{
védett :
ConcreteColleague1 * m_Colleague1 ;
ConcreteColleague2 * m_Colleague2 ;
nyilvános :
érvénytelen SetColleague1 ( ConcreteColleague1 * c )
{
m_Kolléga1 = c ;
}
érvénytelen SetColleague2 ( ConcreteColleague2 * c )
{
m_kolléga2 = c ;
}
virtuális void Küldés ( std :: string const & message , Kolléga * kolléga ) const
{
if ( kolléga == m_kolléga1 )
{
m_Kolléga2 -> Értesítés ( üzenet );
}
else if ( kolléga == m_kollega2 )
{
m_Kolléga1 -> Értesítés ( üzenet );
}
}
};
int main ()
{
ConcreteMediator m ;
ConcreteColleague1 c1 ( & m );
ConcreteColleague2 c2 ( & m );
m . SetColleague1 ( & c1 );
m . SetColleague2 ( & c2 );
c1 . Send ( "Hogy vagy?" );
c2 . Küldés ( "Rendben, köszönöm" );
std :: cin . kap ();
return 0 ;
}
Kimenet
A 2. kolléga üzenetet kap : " Hogy vagy ? " '
1. kolléga a " Rendben , köszönöm " üzenetet kap
Python példa
Forráskód
Pythonban
abc importból ABCMeta , abstractmethod from gyengeref import proxy import inspect _
osztály Közvetítő ( metaclass = ABCMeta ):
"""
Absztrakt kommunikációs csatorna a kollégák között
"""
@abstractmethod
def send ( self , message : str ) -> None :
"""
Üzenet küldése társak között
"""
pass
osztály Kolléga ( metaclass = ABCMeta ):
"""
Absztrakt munkás, aki nem bánja, ha cseveg a kollégáival
"""
def __init__ ( self , mediator : Mediator ) -> None :
"""
Constructor.
:param mediátor: kommunikációs csatorna a kollégákkal
""
" self ._mediator = proxy ( mediátor )
@abstractmethod
def send ( self , message : str ) -> None :
"""
Üzenet küldése a
"""
kommunikációs csatornán keresztül
@abstractmethod
def Receive ( self , message : str ) -> None : """ Üzenet fogadása a """ kommunikációs csatornán keresztül
osztály SkypeBetweenTwoColleagues ( közvetítő ):
"""
Skype-csatorna két ember közötti kommunikációhoz
"""
def __init__ ( self ) -> None :
"""
Konstruktor.
"""
self . _first = Egyik
sem . _second = Nincs
def set_first ( self , first : Kolléga ) -> None :
""" A beszélgetés
""" első résztvevőjét hozzárendeli a
csatornához . _first = első
def set_second ( self , second : Kolléga ) -> None :
"""
A beszélgetés második résztvevőjét
"" "
társítja a csatornához . _second = másodperc
def send ( self , message : str ) -> None :
sender = inspect . aktuális keret () . f_back . f_locals [ 'self' ]
Receiver = self . _first if sender == self . _second else én . _második
vevő . fogadni ( üzenet )
osztály Bill ( kolléga ):
def send ( self , message : str ) -> None :
self . _közvetítő . küld ( üzenet )
def Receive ( self , message : str ) - > None :
print ( 'Számla megkapta az üzenetet: {} ' . format ( üzenet ))
osztály Steve ( kolléga ):
def send ( self , message : str ) -> None :
self . _közvetítő . küld ( üzenet )
def Receive ( self , message : str ) - > None :
print ( 'Steve elolvasta az üzenetet Skype-on: {} ' . formátum ( üzenet ))
if __name__ == '__main__' :
print ( 'OUTPUT:' )
skype = SkypeBetweenTwoColleagues ()
bill = Bill ( skype )
steve = Steve ( skype )
skype . set_first ( bill )
skype . set_second ( steve )
bill . küld ( 'Munkára, laza!' )
steve . küld ( 'Nem' )
'''
KIMENET:
Steve felolvasott egy Skype-üzenetet: Kezdj dolgozni, lomha!
Bill megkapta az üzenetet: Nem
'''
Delphi példa
Forrásszöveg
Delphiben
program KözvetítőPélda ;
{$APPTYPE CONSOLE}
típus
IColleague = interfész
eljárás Küldés ( Üzenet : string ) ;
eljárás Értesítés ( Üzenet : string ) ;
vége ;
TMediator = osztályeljárás
Küldés ( Üzenet : string ; ACollegue : IColleague ) ; _ virtuális ; absztrakt ; vége ;
TConcreteMediator = osztály ( TMediator )
public
FCkollega1 : Ikollega ;
FCollegue2 : ICollegue ;
eljárás Küldés ( Üzenet : string ; ACollegue : IColleague ) ; felülbírálni ; vége ;
TColleague = osztály ( TInterfacedObject , IColleague )
public
FMediátor : TMediator ;
konstruktor Létrehozás ( AMediator : TMediator ) ;
eljárás Küldés ( Üzenet : string ) ; virtuális ; absztrakt ;
eljárás Értesítés ( Üzenet : string ) ; virtuális ; absztrakt ;
vége ;
ConcreteColleague1 = osztály ( TColleague )
eljárás Küldés ( Üzenet : string ) ; felülbírálni ;
eljárás Értesítés ( Üzenet : string ) ; felülbírálni ;
vége ;
ConcreteColleague2 = osztály ( TColleague )
eljárás Küldés ( Üzenet : string ) ; felülbírálni ;
eljárás Értesítés ( Üzenet : string ) ; felülbírálni ;
vége ;
{ TConcreteMediator }
eljárás TConcreteMediator . Küldés ( Üzenet : string ; ACollegue : IColleague ) ; kezdődik , ha ACollegue = FCollegue1, akkor FCollegue2 . Értesítés ( Üzenet ) else F Kolléga1 . Értesítés ( Üzenet ) ; vége ;
{TCkollega}
kivitelező TColleague . Létrehozás ( AMediator : TMediator ) ;
begin
FMediator := AMediator ;
vége ;
{ConcreteColleague1}
eljárás ConcreteColleague1 . Küldés ( Üzenet : string ) ;
indítsa el
az FMediator programot . Küldés ( Üzenet , Saját ) ;
vége ;
eljárás ConcreteColleague1 . Értesítés ( Üzenet : string ) ;
begin
Writeln ( 'A kolléga1 üzenetet kap: ' + Üzenet ) ; vége ;
{ConcreteColleague2}
eljárás ConcreteColleague2 . Küldés ( Üzenet : string ) ;
indítsa el
az FMediator programot . Küldés ( Üzenet , Saját ) ;
vége ;
eljárás ConcreteColleague2 . Értesítés ( Üzenet : string ) ;
begin
Writeln ( 'A kolléga2 üzenetet kap: ' + Üzenet ) ; vége ;
var
Közvetítő : TConcreteMediator ;
Kolléga1 : Konkrét Kolléga1 ;
Kolléga2 : Konkrét Kolléga2 ;
begin
Mediator := TConcreteMediator . létrehozni ;
Kolléga1 := Konkrét Kolléga1 . Létrehoz ( közvetítő ) ;
Kolléga2 := Konkrét Kolléga2 . Létrehoz ( közvetítő ) ;
közvetítő . FCkollega1 := Kolléga1 ;
közvetítő . FCkollega2 := Kolléga2 ;
Kolléga 1 . Send ( 'Hogy vagy?' ) ;
Kolléga 2 . Send ( 'Rendben, köszönöm' ) ;
readln ;
vége .
Linkek