Sijainen (suunnittelukuvio)

Kokeneet kirjoittajat eivät ole vielä tarkistaneet sivun nykyistä versiota, ja se voi poiketa merkittävästi 10. heinäkuuta 2018 tarkistetusta versiosta . tarkastukset vaativat 9 muokkausta .
Sijainen
välityspalvelin
Tyyppi rakenteellinen
Tarkoitus Tarjoaa korvikeobjektin, joka hallitsee pääsyä toiseen objektiin.
Plussat
  •  kauko-korvike;
  •  virtuaalinen välityspalvelin voi suorittaa optimoinnin;
  •  suojaava korvike;
  • "älykäs" linkki;
Miinukset
  • vasteajan dramaattinen nousu.
Kuvattu suunnittelukuvioissa Joo

Välityspalvelin ( Eng.  Proxy ) on rakenteellinen suunnittelumalli, joka tarjoaa objektin , joka hallitsee pääsyä toiseen objektiin ja sieppaa kaikki puhelut (suorittaa säiliön toiminnon ).

Tarkoitus

Ongelma

Pääsyä kohteeseen on valvottava muuttamatta asiakkaan käyttäytymistä. 

Objektiin on päästävä siten, että todellisia objekteja ei luoda suoraan, vaan toisen objektin kautta, jolla voi olla lisätoimintoja.

Ratkaisu

Luo korvike oikealle esineelle. Välityspalvelin tallentaa viitteen, jonka avulla Proxy voi viitata todelliseen subjektiin (Proxy-luokan objekti voi viitata Subject-luokan objektiin, jos Real Subjectin ja Subjektin rajapinnat ovat samat). Koska "Real Subject" -käyttöliittymä on identtinen "Aihe"-liittymän kanssa, joten "Korvaaja" voidaan korvata "Oikea aihe", hallitsee pääsyä "Real Subject", voi olla vastuussa "Oikean aiheen" luomisesta tai poistamisesta. Todellinen aihe". "Aihe" määrittelee yhteisen rajapinnan "todellisen aiheen" ja "välityspalvelimen" välillä, jotta "välityspalvelinta" voidaan käyttää kaikkialla, missä "Real Subject" odotetaan. Tarvittaessa "varamies" voi välittää pyynnöt "todelliselle aiheelle".

Laji

Edut ja haitat

Edut

Haitat

Laajuus

Välityspalvelinkuviota voidaan käyttää työskennellessäsi verkkoyhteyden, valtavan objektin muistissa (tai levyllä) tai minkä tahansa muun vaikeasti tai vaikeasti kopioitavan resurssin kanssa. Tunnettu käyttötapaus on objekti, joka laskee viitteiden määrän.

Välityspalvelin ja siihen liittyvät kuviot [1]

Toteutusesimerkkejä

Java

Toteutusesimerkki public class Main { public static void main ( Merkkijono [] args ) { // Luo matemaattinen välityspalvelin IMath p = uusi MathProxy (); // Tee matemaattinen järjestelmä . ulos . println ( "4 + 2 = " + p . add ( 4 , 2 )); Järjestelmä . ulos . println ( "4 - 2 = " + p . sub ( 4 , 2 )); Järjestelmä . ulos . println ( "4 * 2 = " + p . mul ( 4 , 2 )); Järjestelmä . ulos . println ( "4/2 =" + p . div ( 4 , 2 )); } } /** * "Aihe" */ julkinen käyttöliittymä IMath { public double add ( double x , double y ); julkinen kaksoisali ( double x , double y ) ; public double mul ( double x , double y ); public double div ( double x , double y ); } /** * "Real Subject" */ public class Math toteuttaa IMath { public double add ( double x , double y ) { return x + y ; } public double sub ( double x , double y ) { return x - y ; } public double mul ( double x , double y ) { return x * y ; } public double div ( double x , double y ) { return x / y ; } } /** * "Välityspalvelin" */ public class MathProxy toteuttaa IMath { yksityinen matematiikka matematiikka ; public double add ( double x , double y ) { lazyInitMath (); palauta matematiikka . lisää ( x , y ); } public double sub ( double x , double y ) { lazyInitMath (); palauta matematiikka . ala ( x , y ); } public double mul ( double x , double y ) { lazyInitMath (); palauta matematiikka . mul ( x , y ); } public double div ( double x , double y ) { lazyInitMath (); palauta matematiikka . div ( x , y ); } yksityinen void lazyInitMath () { if ( matematiikka == null ) { matematiikka = uusi matematiikka (); } } }

scala

Toteutusesimerkki object Main extends App { val p : IMath = uusi MathProxy System . ulos . println ( " 4 + 2 = " + p . add ( 4 , 2 )) Järjestelmä . ulos . println ( " 4 - 2 = " + p . sub ( 4 , 2 ) ) Järjestelmä . ulos . println ( " 4 * 2 = " + p . mul ( 4 , 2 ) ) Järjestelmä . ulos . println ( " 4/2 = " + p . div ( 4 , 2 )) } /** * "Aihe" */ ominaisuus IMath { def add ( x : Double , y : Double ): Double def sub ( x : Double , y : Double ): Double def mul ( x : Double , y : Double ): Double def div ( x : Double , y : Double ): Double } /** * "Real Subject" */ luokka Math laajentaa IMath { def add ( x : Double , y : Double ) = x + y def sub ( x : Double , y : Double ) = x - y def mul ( x : Double , y : Double ) = x * y def div ( x : tupla , y : tupla ) = x / y } /** * "Välityspalvelin" */ luokka MathProxy laajentaa IMath { yksityinen laiska val math = uusi Math def add ( x : Double , y : Double ) = matematiikka . lisää ( x , y ) def sub ( x : Double , y : Double ) = matematiikka . ala ( x , y ) def mul ( x : Double , y : Double ) = matematiikka . mul ( x , y ) def div ( x : Double , y : Double ) = matematiikka . div ( x , y ) }

C++

Toteutusesimerkki /** * "Aihe" */ luokka IMath { julkinen : virtuaalinen tuplalisäys ( double , double ) = 0 ; _ virtuaalinen kaksoisali ( double , double ) = 0 ; _ virtuaalinen kaksoismul ( double , double ) = 0 ; _ virtuaalinen kaksoisdiv ( double , double ) = 0 ; _ }; /** * "Oikea aihe" */ luokka Matematiikka : julkinen IMath { julkinen : virtuaalinen tuplalisäys ( double x , double y ) { _ paluu x + y _ } virtuaalinen kaksoisali ( double x , double y ) { _ palauttaa x - y ; } virtuaalinen kaksoismul ( double x , double y ) { _ palauta x * y _ } virtuaalinen double div ( double x , double y ) { palauta x / v _ } }; /** * "Välityspalvelin" */ luokka MathProxy : julkinen IMath { julkinen : MathProxy () { matematiikka = uusi matematiikka (); } virtuaalinen ~ MathProxy () { poista matematiikka ; } virtuaalinen tuplalisäys ( double x , double y ) { _ return math -> add ( x , y ); } virtuaalinen kaksoisali ( double x , double y ) { _ return matematiikka -> ali ( x , y ); } virtuaalinen kaksoismul ( double x , double y ) { _ return matematiikka -> mul ( x , y ); } virtuaalinen double div ( double x , double y ) { return matematiikka -> div ( x , y ); } yksityinen : IMath * matematiikka ; }; #include <iostream> käyttäen std :: cout ; käyttäen std :: endl ; int main () { // Luo matemaattinen välityspalvelin IMath * välityspalvelin = uusi MathProxy (); // Tee matemaattinen lasku << "4 + 2 = " << välityspalvelin -> add ( 4 , 2 ) << endl ; cout << "4 - 2 = " << välityspalvelin -> sub ( 4 , 2 ) << endl ; cout << "4 * 2 = " << välityspalvelin -> mul ( 4 , 2 ) << endl ; cout << "4 / 2 = " << välityspalvelin -> div ( 4 , 2 ) << endl ; poista välityspalvelin ; paluu 0 ; }

C#

Toteutusesimerkki käyttäen System ; käyttäen System.Threading ; class MainApp { static void Main () { // Luo matemaattinen välityspalvelin IMath p = uusi MathProxy (); // Tee matematiikan konsoli . WriteLine ( " 4 + 2 = " + p . Lisää ( 4 , 2 )); konsoli . WriteLine ( "4 - 2 = " + p . Sub ( 4 , 2 )); konsoli . WriteLine ( "4 * 2 = " + p . Mul ( 4 , 2 )); konsoli . WriteLine ( "4/2 = " + p . Div ( 4 , 2 )); // Odota käyttäjän konsolia . lue (); } } /// <summary> /// Aihe - aihe /// </summary> /// <remarks> /// <li> /// <lu> määrittelee yhteisen sanalle <see cref="Math"/> ja <katso cref="Välityspalvelin"/> käyttöliittymä, joten luokkaa /// <katso cref="Välityspalvelin"/> voidaan käyttää missä tahansa <katso cref="Math"/></lu> /// </ li> / // </remarks> julkinen käyttöliittymä IMath { double Add ( double x , double y ); double Sub ( double x , double y ); double Mul ( double x , double y ); double Div ( double x , double y ); } /// <summary> /// RealSubject - todellinen objekti /// </summary> /// <remarks> /// <li> /// <lu>määrittää välityspalvelimen edustaman todellisen objektin</lu> // / </li> /// </remarks> class Math : IMath { public Math () { Konsoli . WriteLine ( "Luo objekti Math. Odota..." ); lanka . uni ( 1000 ); } public double Add ( double x , double y ){ return x + y ;} public double Sub ( double x , double y ){ return x - y ;} public double Mul ( double x , double y ){ return x * y ; } public double Div ( double x , double y ){ return x / y ;} } /// <summary> /// Välityspalvelin on välityspalvelin /// </summary> /// <remarks> /// <li> /// <lu> tallentaa viitteen, jonka avulla välityspalvelin voi viitata todelliseen /// aihe . Luokkaobjekti <katso cref="MathProxy"/> voi viitata luokkaobjektiin /// <katso cref="IMath"/>, jos luokkarajapinnat <katso cref="Math"/> ja <katso cref="IMath"/> ovat samat;</lu> /// <lu>tarjoaa käyttöliittymän, joka on identtinen <see cref="IMath"/>:n kanssa, joten välityspalvelin /// voidaan aina tarjota oikean kohteen sijaan;</ lu> /// < lu>valvoo pääsyä todelliseen kohteeseen ja saattaa olla vastuussa /// luomisesta ja sen poistamisesta;</lu> /// <lu>muut tehtävät riippuvat välityspalvelimen tyypistä: /// < li> /// <lu><b >etävälityspalvelin</b> vastaa pyynnön ja sen argumenttien koodaamisesta /// ja koodatun pyynnön lähettämisestä todelliselle subjektille /// eri osoiteavaruudessa;</lu > /// <lu><b>virtuaalinen välityspalvelin</b> voi tallentaa välimuistiin /// lisätietoja todellisesta kohteesta, mikä viivyttää sen luomista.</lu> /// <lu><b>välityspalvelimen suojaaminen</b > tarkistaa, onko soittajalla /// tarvittavat luvat tehdä pyyntö; </lu> /// </li> /// </lu> /// </li> /// < /huomautukset> class MathProxy : IMath { Math math ; public MathProxy () { matematiikka = null ; } /// <summary> /// Nopea toiminta - ei vaadi oikeaa aihetta /// </summary> /// <param name="x"></param> /// <param name="y" >< /param> /// <returns></returns> public double Add ( double x , double y ) { return x + y ; } public double Sub ( double x , double y ) { return x - y ; } /// <summary> /// Hidas toiminta - vaatii oikean subjektin luomisen /// </summary> /// <param name="x"></param> /// <param name="y" >< /param> /// <returns></returns> public double Mul ( double x , double y ) { if ( math == null ) math = new Math (); palauta matematiikka . Mul ( x , y ); } public double Div ( double x , double y ) { if ( math == null ) math = new Math (); palauta matematiikka . Div ( x , y ); } }

JavaScript

Toteutusesimerkki /* Aihe */ luokka IMath { add ( x , y ) {} sub ( x , y ) {} } /* Oikea aihe */ luokka RMath laajentaa IMath { add ( x , y ) { return x + y ; } sub ( x , y ) { return x - y ; } } /* Välityspalvelin */ luokka MathProxy laajentaa IMath { math = new RMath () add ( x , y ) { return this . matematiikka . add ( x , y ) } sub ( x , y ) { return this . matematiikka . ala ( x , y ) } } const testi = uusi MathProxy ( ) hälytys ( test . add ( 3 , 2 )) // 5 hälytys ( testi . sub ( 3 , 2 )) // 1

Ruby

Toteutusesimerkki moduuli ProxyPattern # Välityspalvelimella on sama käyttöliittymä kuin Real Subjectilla # Oikea oppiaineluokka Tili attr_reader : balance def alustus ( saldo = 0 ) @tasapaino = saldon loppu def deposit ( summa ) @saldo += summa loppu def nosto ( summa ) @saldo -= summa loppu loppu moduulin suojaus # Lisätoiminto, jolla ohjataan pääsyä realSubjectiin # Välityspalvelinluokka AccountProxy def alustus ( aihe , nykyinen_käyttäjä ) @subject = aihe @nykyinen_user = nykyinen_käyttäjä @saldo = 0 loppu def deposit ( summa ) @subject . talletus ( summa ) , jos valtuutus päättyy def nostaa ( summa ) @subject . nostaa ( summa ) , jos lupa loppuu def balance @subject . tasapaino loppu yksityinen def authorize asettaa 'pääsy estetty', ellei @current_user == ' admin ' @current_user == 'admin' loppupää itsevarmasti . _ run laittaa '=> Proxy::Protection' laittaa 'as user' protected_account = Tilivälityspalvelin . uusi ( Tili . uusi , 'käyttäjä' ) suojattu_tili . talletus ( 20 ) suojattu_tili . nollaa ( 10 ) asettaa suojatun_tilin . saldo laittaa 'as admin' protected_account = Tilivälityspalvelin . uusi ( Tili . uusi , 'admin' ) suojattu_tili . talletus ( 20 ) suojattu_tili . nollaa ( 10 ) asettaa suojatun_tilin . saldo laittaa ' ' lopun moduuli Virtuaalinen # Viive realSubjectin latausta (laiska lataus) # Välityspalvelinluokka AccountProxy def alustus ( local_balance = 0 ) @local_balance = local_balance end def deposit ( summa ) @local_balance += summa loppu def nosto ( summa ) @local_balance -= summa loppu def balance aihe . tasapaino loppu def subject @subject ||= Tili . uusi ( @local_balance ) _ _ itsevarmasti . _ run laittaa '=> Proxy::Virtual' local_account = Tilivälityspalvelin . uusi paikallinen_tili . talletus ( 20 ) local_account . nosta ( 10 ) local_account . talletus ( 15 ) local_account . visszavon ( 5 ) asettaa "Ei vielä oikeaa tiliä:" asettaa local_account . tarkastaa paikallinen_tili . saldo laittaa "Todellinen tili luotiin:" asettaa local_account . tarkastaa laittaa ' ' lopun itsevarmasti . _ suorita suojaus . runVirtual . _ juoksu loppu loppu

PHP5

Toteutusesimerkki <?php /// Aihe - aihe /// määrittelee matematiikan ja "välityspalvelimen" välillä yhteisen rajapinnan, joten /// "Välityspalvelin"-luokkaa voidaan käyttää missä tahansa rajapinnassa IMath { function Add ( $x , $y ); funktio Sub ( $x , $y ); funktio Mul ( $x , $y ); funktio Div ( $x , $y ); } /// RealSubject - todellinen objekti /// määrittelee välityspalvelimen edustaman todellisen objektin class Math toteuttaa IMath { public function __construct () { print ( "Luo objekti Math. Odota..." ); nukkua ( 5 ); } julkinen funktio Lisää ( $x , $y ){ return $x + $y ;} public function Sub ( $x , $y ){ return $x - $y ;} public function Mul ( $x , $y ){ return $x * $y ;} julkinen funktio Div ( $x , $y ){ return $x / $y ;} } /// Välityspalvelin - välityspalvelin /// tallentaa linkin, jonka avulla välityspalvelin voi viitata todelliseen /// aiheeseen. "MathProxy"-luokan objekti voi käyttää "Math" /// -luokkaobjektia, jos "Math"- ja "IMath"-luokkien rajapinnat ovat samat; /// tarjoaa käyttöliittymän, joka on identtinen "IMath"-rajapinnan kanssa, joten välityspalvelin /// voidaan aina tarjota oikean kohteen tilalle; /// hallitsee pääsyä todelliseen aiheeseen ja voi olla vastuussa sen luomisesta /// ja poistamisesta; /// muut tehtävät riippuvat välityspalvelimen tyypistä: /// etävälityspalvelin vastaa pyynnön ja sen argumenttien koodaamisesta /// ja koodatun pyynnön lähettämisestä todelliselle subjektille /// eri osoiteavaruudessa; /// Virtuaalinen välityspalvelin voi tallentaa /// lisätietoa todellisesta aiheesta viivyttääkseen sen luomista. /// suojaava välityspalvelin tarkistaa, onko soittajalla /// tarvittavat oikeudet pyynnön suorittamiseen; luokka MathProxy toteuttaa IMath { suojattu $math ; julkinen funktio __construct () { $this -> matematiikka = null ; } /// Nopea toiminta - ei vaadi reaaliaiheen julkista funktiota Add ( $x , $y ) { return $x + $y ; } public function Sub ( $x , $y ) { return $x - $y ; } /// Hidas toiminta - vaatii reaalisubjektin julkisen funktion luomisen Mul ( $x , $y ) { if ( $this -> math == null ) $this -> math = new Math (); palauttaa $this -> matematiikka -> Mul ( $x , $y ); } julkinen funktio Div ( $x , $y ) { if ( $this -> matematiikka == nolla ) $this -> matematiikka = uusi Math (); palauttaa $this -> matematiikka -> Div ( $x , $y ); } } $p = uusi MathProxy ; // Tee matemaattinen tulos ( "4 + 2 = " . $p -> Lisää ( 4 , 2 )); print ( "4 - 2 = " . $p -> Sub ( 4 , 2 )); print ( "4 * 2 = " . $p -> Mul ( 4 , 2 )); print ( "4/2 = " . $p -> Div ( 4 , 2 )); ?>

ActionScript

Toteutusesimerkki //tiedosto IMath.as paketti { julkinen käyttöliittymä IMath { function add ( a : Number , b : Number ) : Numero ; toiminto ala ( a : Numero , b : Numero ) : Numero ; funktio mul ( a : numero , b : numero ) : numero ; funktio div ( a : Numero , b : Numero ) : Numero ; } } //tiedosto MathSubject.as package { public class MathSubject toteuttaa IMath { public function add ( a : Number , b : Number ) : Number { return a + b ; } julkinen funktio ala ( a : Numero , b : Numero ) : Numero { return a - b ; } public function mul ( a : Numero , b : Numero ) : Numero { return a * b ; } julkinen funktio div ( a : Numero , b : Numero ) : Numero { return a / b ; } } } //tiedosto MathProxy.as paketti { public class MathProxy toteuttaa IMath { yksityinen var math : MathSubject ; public function MathProxy () { matematiikka = new MathSubject (); } julkinen funktio lisää ( a : Numero , b : Numero ) : Numero { return math . lisää ( a , b ); } julkinen funktio ala ( a : Numero , b : Numero ) : Numero { return math . ala ( a , b ); } julkinen funktio mul ( a : Numero , b : Numero ) : Numero { return math . mul ( a , b ); } julkinen funktio div ( a : Luku , b : Luku ) : Luku { if ( b != 0 ) return math . div ( a , b ); else { trace ( "Jako nollalla." ); palautusnumero . _ POSITIVE_INFINITY ; } } } } //tiedosto Main.as package { import flash.display.Sprite ; public class Main laajentaa Sprite { public function Main () { playWithMath ( uusi MathSubject ()); playWithMath ( uusi MathProxy ()); } public function playWithMath ( matematiikka : IMath ) : void { trace ( matematiikka . add ( 5 , 0 )); jäljittää ( matematiikka . osa ( 5 , 0 )); jäljittää ( matem . mul ( 5 , 0 )); jäljittää ( matemaattinen . div ( 5 , 0 )); } } }

Python

Toteutusesimerkki # -*- koodaus: utf-8 -*- class IMath : """Liitäntä välityspalvelimelle ja oikealle aiheelle""" def add ( self , x , y ): nosta NotImplementedError () def sub ( self , x , y ): nosta NotImplementedError () def mul ( self , x , y ): nosta NotImplementedError () def div ( self , x , y ): nosta NotImplementedError () luokka Math ( IMath ): """Oikea aihe""" def add ( itse , x , y ): paluu x + y def sub ( self , x , y ): palauttaa x - y def mul ( itse , x , y ): palauttaa x * y def div ( self , x , y ): palauttaa x / y luokan välityspalvelin ( IMath ): """Välityspalvelin""" def __init__ ( self ): itse . matematiikka = matematiikka () def add ( self , x , y ): return x + y def sub ( self , x , y ): palauttaa x - y def mul ( itse , x , y ): palauta itse . matematiikka . mul ( x , y ) def div ( self , x , y ): palauttaa float ( 'inf' ) , jos y == 0 else self . matematiikka . div ( x , y ) p = Välityspalvelin () x , y = 4 , 2 print '4 + 2 = ' + str ( p . add ( x , y )) tulosta '4 - 2 = ' + str ( p . sub ( x , y )) tulosta '4 * 2 = ' + str ( p . mul ( x , y )) tulosta '4 / 2 = ' + str ( p . div ( x , y ))

VB.NET

Toteutusesimerkki Tuo System.Threading Luokan MainApp jaettu alipää () ' Luo matemaattinen välityspalvelin Dim p As IMath = Uusi matemaattinen välityspalvelin () ' Tee matematiikan konsoli . WriteLine ( " 4 + 2 = " & p . Add ( 4 , 2 )) Konsoli . WriteLine ( " 4 - 2 = " & p . Subtr ( 4 , 2 )) Konsoli . WriteLine ( " 4 * 2 = " & p . Mul ( 4 , 2 )) Konsoli . WriteLine ( " 4 / 2 = " & p . Div ( 4 , 2 )) Odota käyttäjäkonsolia . Lue () Lopeta Sub End Class '''' <summary> '''' Aihe - ''':n aihe </summary> ''' <huomautukset> ''' <li> ''' <lu> määrittelee yhteisen <see cref="Math"/ > ja <katso cref="Välityspalvelin"/> käyttöliittymä, joten luokkaa ''' <see cref="Välityspalvelin"/> voidaan käyttää missä tahansa <katso cref="Math"/></lu> ''' </ li> '' ' ' </ remarks > Julkinen käyttöliittymä IMath Funktio Lisää ( ByVal x As Double , ByVal y As Double ) Kaksoisfunktiona Subtr ( ByVal x As Double , ByVal y As Double ) Kaksoisfunktiona Mul ( ByVal x As Double , ByVal y As Double ) As Double Function Div ( ByVal x As Double , ByVal y As Double ) As Double End Interface '''' <summary> ''' RealSubject - todellinen objekti ''' </summary> ''' <huomautukset> ''' <li> ''' <lu>tunnistaa välityspalvelimen edustaman todellisen objektin</lu > '' ' </li> ''' </remarks > Luokkamatematiikka toteuttaa IMath Julkinen Sub Uusi () Konsoli . WriteLine ( "Luo objekti Math. Odota..." ) Lanka . Sleep ( 1000 ) End Sub Julkinen funktio Lisää ( ByVal x As Double , ByVal y As Double ) Double Toteuttaa IMath . _ Lisää Return x + y End -funktio Public Function Subtr ( ByVal x As Double , ByVal y As Double ) Double Toteuttaa IMath . _ Subtr Return x - y End Function Julkinen toiminto Mul ( ByVal x As Double , ByVal y As Double ) Double Toteuttaa IMath . _ Mul Return x * y End Function Public Function Div ( ByVal x As Double , ByVal y As Double ) As Double toteuttaa IMath . Div Return x / y End Function loppuluokka _ '''' <summary> '''' Välityspalvelin ''' </summary> ''' <remarks> ''' <li> ' ' ' <lu> tallentaa viitteen, jonka avulla välityspalvelin voi viitata todelliseen 'aihe. Luokan <see cref="MathProxy"/> objekti voi viitata luokan ''' objektiin <katso cref="IMath"/>, jos luokan liitännät <katso cref="Math"/> ja <katso cref= "IMath"/ > ovat samat;</lu> '' <lu>tarjoaa käyttöliittymän, joka on samanlainen kuin <katso cref="IMath"/>, joten paikkamerkki ''' voidaan aina antaa todellinen aihe;</lu> ''' < lu>valvoo pääsyä todelliseen aiheeseen ja saattaa olla vastuussa sen luomisesta ''' ja poistamisesta;</lu> ''' <lu>muut tehtävät riippuvat välityspalvelimen tyypistä : ''' <li> ''' <lu><b >etävälityspalvelin</b> vastaa pyynnön ja sen argumenttien koodaamisesta ''' ja koodatun pyynnön lähettämisestä todelliselle subjektille eri osoiteavaruudessa '' ';</lu> '' <lu><b>virtuaalinen välityspalvelin</b> voi tallentaa välimuistiin lisätietoja ''' todellisesta kohteesta, mikä viivästyttää sen luomista.</lu> ''' <lu><b> suojaava välityspalvelin</b> tarkistaa, onko soittajalla '' tarvittavat oikeudet tehdä pyyntö; </lu> ''' </li> ''' </lu> ''' </li> ''' < /huomautukset> Class MathProxy toteuttaa IMathin yksityisen matematiikan matematiikkana = ei mitään '''' <summary> '''' Nopea toiminta - ei vaadi oikeaa aihetta ''' </summary> Julkinen funktio Lisää ( ByVal x As Double , ByVal y As Double ) As Double Implements IMath . Lisää Return x + y End -funktio Public Function Subtr ( ByVal x As Double , ByVal y As Double ) Double Toteuttaa IMath . _ Subtr Return x - y End Function '''' <summary> '''' Hidas toiminta - vaatii todellisen subjektin luomisen ''' </summary> Public Function Mul ( ByVal x As Double , ByVal y As Double ) As Double toteuttaa IMath . Mul Jos matematiikka ei ole mitään , matematiikka = Uusi matematiikka () End If Return math . Mul ( x , y ) Loppufunktio _ Public Function Div ( ByVal x As Double , ByVal y As Double ) As Double toteuttaa IMath . Div Jos matematiikka ei ole mitään , matematiikka = Uusi matematiikka () End If Return math . Div ( x , y ) Päätefunktion loppuluokka _ _

Swift

Toteutusesimerkki // aiheprotokollan ottelu { funktio add ( x : Int , y : Int ) -> Int funktio sub ( x : Int , y : Int ) -> Int funktio mul ( x : Int , y : Int ) -> Int funktio div ( x : Int , y ) : Int ) -> Int } // Oikea oppiaineluokka MatchImp : Match { func add ( x : Int , y : Int ) -> Int { return x + y } func sub ( x : Int , y : Int ) -> Int { return x - y } func mul ( x : Int , y : Int ) -> Int { return x * y } func div ( x : Int , y : Int ) -> Int { return x / y } } // Välityspalvelinluokka MatchProxy : Match { yksityinen let math = MatchImp () func add ( x : Int , y : Int ) -> Int { return math . lisää ( x : x , y : y ) } func sub ( x : Int , y : Int ) -> Int { return math . ali ( x : x , y : y ) } func mul ( x : Int , y : Int ) -> Int { return matematiikka . mul ( x : x , y : y ) } func div ( x : Int , y : Int ) -> Int { return math . div ( x : x , y : y ) } } // käytä välityspalvelinta anna välityspalvelin = MatchProxy () tulosta ( "7 * 8 = \( välityspalvelin . mul ( x : 8 , y : 7 )) " )

Katso myös

  • Objektin jälkeinen ohjelmointi

Muistiinpanot

  1. ↑ Kehittäjän päiväkirjat // Välityspalvelin (downlink) . Haettu 26. toukokuuta 2010. Arkistoitu alkuperäisestä 14. toukokuuta 2010. 

Kirjallisuus

  • CodeLIB.YOURS // Välityspalvelin arkistoitu 14. toukokuuta 2010 Wayback Machinessa
  • E. Gamma, R. Helm, R. Johnson, J. Vlissides . Olio-suunnittelun tekniikat. Design Patterns.=Suunnittelukuviot. Uudelleenkäytettävän olio-ohjelmiston elementit. - Pietari. : Peter, 2001. - 368 s. — ISBN 5-272-00355-1 .
  • Eric Freeman, Elizabeth Freeman, Kathy Siera, Bert Bates. Suunnittelumalleja. - Pietari. : Peter, 2012. - 656 s. - ISBN 978-5-459-00435-9 .

Linkit