Adjunct (model de proiectare)
Versiunea actuală a paginii nu a fost încă revizuită de colaboratori experimentați și poate diferi semnificativ de
versiunea revizuită la 10 iulie 2018; verificările necesită
9 modificări .
| Adjunct |
|---|
| proxy |
| |
| Tip de |
structural |
| Scop |
Oferă un obiect surogat care controlează accesul la un alt obiect. |
| pro |
- înlocuitor la distanță;
- proxy-ul virtual poate efectua optimizarea;
- înlocuitor de protecție;
- link „inteligent”;
|
| Minusuri |
- creșterea dramatică a timpului de răspuns.
|
| Descris în Design Patterns |
da |
Proxy ( Eng. Proxy ) este un model de proiectare structurală care oferă un obiect care controlează accesul la un alt obiect, interceptând toate apelurile (îndeplinește funcția de container ).
Scop
Problemă
Accesul la obiect trebuie controlat fără a modifica comportamentul clientului.
Este necesar să accesați obiectul în așa fel încât să nu creați obiecte reale direct, ci printr-un alt obiect care poate avea funcționalitate suplimentară.
Soluție
Creați un surogat pentru un obiect real. Proxy-ul stochează o referință care îi permite Proxy-ului să se refere la subiectul real (un obiect al clasei Proxy se poate referi la un obiect al clasei Subiect dacă interfețele Subiectului Real și Subiectului sunt aceleași). Deoarece interfața „Subiect real” este identică cu interfața „Subiect”, astfel încât „Subiectul” poate fi înlocuit cu „Subiect real”, controlează accesul la „Subiect real”, poate fi responsabil pentru crearea sau ștergerea „Subiectului real”. Subiect real”. „Subiect” definește o interfață comună între „Subiect real” și „Proxy”, astfel încât „Subiect” să poată fi utilizat oriunde este de așteptat „Subiect real”. Dacă este necesar, cererile pot fi înaintate de către „Deputat” către „Subiectul real”.
Specie
- Proxy de înregistrare: înregistrează toate apelurile către „Subiect” cu parametrii acestora.
- Proxy la distanță ( de exemplu, proxy la distanță ): asigură comunicarea cu „Subiectul”, care se află într-un spațiu de adrese diferit sau pe o mașină la distanță. Poate fi, de asemenea, responsabil pentru codificarea cererii și argumentele acesteia și trimiterea cererii codificate către „Subiect” real
- Virtual Proxies ( ing. virtual proxies ): asigură crearea unui „Subiect” real doar atunci când este cu adevărat necesar. De asemenea, poate stoca în cache unele informații despre „Subiectul” real pentru a întârzia crearea acestuia,
- Copy-on-write : furnizează o copie a „subiectului” atunci când clientul efectuează anumite acțiuni (un caz special al „proxy-ului virtual”).
- Proxy de protecție : poate verifica dacă apelantul are permisiunile necesare pentru a finaliza solicitarea .
- Proxy de stocare în cache : oferă stocare temporară a rezultatelor calculelor înainte de a le furniza mai multor clienți care pot partaja aceste rezultate.
- Proxy de screening : protejează „Subiectul” de clienții periculoși (sau invers).
- Proxy de sincronizare : Efectuează controlul accesului sincronizat la „Subiect” într-un mediu asincron cu mai multe fire .
- Legătură „inteligentă” ( ing. proxy de referință inteligentă ): efectuează acțiuni suplimentare atunci când este creată o legătură către „Subiect”, de exemplu, calculează numărul de linkuri active către „Subiect”.
Avantajele și dezavantajele utilizării
Beneficii
Dezavantaje
- creșterea dramatică a timpului de răspuns.
Domeniul de aplicare
Modelul Proxy poate fi folosit atunci când lucrați cu o conexiune de rețea, cu un obiect uriaș în memorie (sau pe disc) sau cu orice altă resursă care este dificil sau dificil de copiat. Un caz de utilizare binecunoscut este un obiect care numără numărul de referințe.
Proxy și modele aferente [1]
- Un adaptor oferă o interfață distinctă unui obiect.
- Proxy-ul oferă aceeași interfață.
- Decoratorul oferă o interfață extinsă.
Exemple de implementare
Exemplu de implementare
clasă publică principală {
public static void main ( String [] args ) {
// Creați proxy matematic
IMath p = new MathProxy ();
// Faceți sistemul de matematică . afară . println ( "4 + 2 = " + p . adaugă ( 4 , 2 ));
Sistem . afară . println ( "4 - 2 = " + p . sub ( 4 , 2 ));
Sistem . afară . println ( "4 * 2 = " + p . mul ( 4 , 2 ));
Sistem . afară . println ( "4 / 2 = " + p . div ( 4 , 2 ));
}
}
/**
* „Subiect”
*/
interfață publică IMath {
public double add ( dublu x , dublu y );
public double sub ( dublu x , dublu y );
public double mul ( dublu x , dublu y );
public double div ( dublu x , dublu y );
}
/**
* „Subiect real”
*/
Clasa publică Math implementează IMath {
public double add ( double x , double y ) {
return x + y ;
}
public double sub ( dublu x , dublu y ) {
return x - y ;
}
public double mul ( double x , double y ) {
return x * y ;
}
public double div ( double x , double y ) {
return x / y ;
}
}
/**
* „Obiect proxy”
*/
clasa publică MathProxy implementează IMath {
matematică particulară ; _
public double add ( dublu x , dublu y ) {
lazyInitMath ();
întoarce matematica . adaugă ( x , y );
}
public double sub ( dublu x , dublu y ) {
lazyInitMath ();
întoarce matematica . sub ( x , y );
}
public double mul ( double x , double y ) {
lazyInitMath ();
întoarce matematica . mul ( x , y );
}
public double div ( dublu x , dublu y ) {
lazyInitMath ();
întoarce matematica . div ( x , y );
}
private void lazyInitMath () {
if ( math == null ) {
math = new Math ();
}
}
}
Exemplu de implementare
obiect Main extinde App {
val p : IMath = sistem MathProxy nou . afară . println ( "4 + 2 = " + p . adaugă ( 4 , 2 )) Sistem . afară . println ( "4 - 2 = " + p . sub ( 4 , 2 )) Sistem . afară . println ( "4 * 2 = " + p . mul ( 4 , 2 )) Sistem . afară . println ( "4 / 2 = " + p . div ( 4 , 2 )) }
/**
* „Subiect”
*/
trăsătură IMath {
def add ( x : Double , y : Double ): Double
def sub ( x : dublu , y : dublu ): dublu
def mul ( x : dublu , y : dublu ): dublu
def div ( x : dublu , y : dublu ): dublu
}
/**
* „Subiect real”
*/
class Math extinde IMath {
def add ( x : Double , y : Double ) = x + y
def sub ( x : dublu , y : dublu ) = x - y
def mul ( x : Double , y : Double ) = x * y
def div ( x : dublu , y : dublu ) = x / y
}
/**
* „Obiect proxy”
*/
clasa MathProxy extinde IMath {
private lazy val math = new Math
def add ( x : Double , y : Double ) = matematică . adaugă ( x , y )
def sub ( x : dublu , y : dublu ) = matematică . sub ( x , y )
def mul ( x : dublu , y : dublu ) = matematică . mul ( x , y )
def div ( x : dublu , y : dublu ) = matematică . div ( x , y )
}
Exemplu de implementare
/**
* „Subiect”
*/
clasa IMath {
public :
virtual double add ( dublu , dublu ) = 0 ;
virtual double sub ( dublu , dublu ) = 0 ;
virtual dublu mul ( dublu , dublu ) = 0 ;
virtual double div ( dublu , dublu ) = 0 ;
};
/**
* „Subiect real”
*/
class Math : public IMath {
public :
virtual double add ( dublu x , dublu y ) {
returnează x + y _
}
virtual dublu sub ( dublu x , dublu y ) {
întoarce x - y ;
}
virtual dublu mul ( dublu x , dublu y ) {
returnează x * y _
}
virtual double div ( dublu x , dublu y ) {
returnează x / y _
}
};
/**
* „Obiect proxy”
*/
clasa MathProxy : public IMath {
public :
MathProxy ()
{
math = new Math ();
}
virtual ~ MathProxy ()
{
sterge matematica ;
}
virtual double add ( dublu x , dublu y ) {
returnare matematică -> adăugare ( x , y );
}
virtual dublu sub ( dublu x , dublu y ) {
return math -> sub ( x , y );
}
virtual dublu mul ( dublu x , dublu y ) {
return math -> mul ( x , y );
}
virtual double div ( dublu x , dublu y ) {
return math -> div ( x , y );
}
privat :
IMath * matematică ;
};
#include <iostream>
folosind std :: cout ;
folosind std :: endl ;
int main () {
// Creați proxy matematic
IMath * proxy = nou MathProxy ();
// Faceți calculul matematic
<< " 4 + 2 = " << proxy -> add ( 4 , 2 ) << endl ;
cout << "4 - 2 = " << proxy -> sub ( 4 , 2 ) << endl ;
cout << "4 * 2 = " << proxy -> mul ( 4 , 2 ) << endl ;
cout << "4 / 2 = " << proxy -> div ( 4 , 2 ) << endl ;
șterge proxy ;
returnează 0 ;
}
Exemplu de implementare
folosind System ;
folosind System.Threading ;
class MainApp
{
static void Main ()
{
// Creați proxy matematic
IMath p = new MathProxy ();
// Faceți Consola de matematică . WriteLine ( "4 + 2 = " + p . Adăugați ( 4 , 2 ));
Consola . WriteLine ( "4 - 2 = " + p . Sub ( 4 , 2 ));
Consola . WriteLine ( "4 * 2 = " + p . Mul ( 4 , 2 ));
Consola . WriteLine ( "4 / 2 = " + p . Div ( 4 , 2 ));
// Așteptați
Consola utilizatorului . citește ();
}
}
/// <summary>
/// Subiect - subiect
/// </summary>
/// <remarks>
/// <li>
/// <lu> definește un comun pentru <see cref="Math"/> și <see cref="Proxy"/> interfață astfel încât clasa
/// <see cref="Proxy"/> să poată fi folosită oriunde <see cref="Math"/></lu>
/// </ li>
/ // </remarks>
interfață publică IMath { double Add ( double x , double y ); dublu Sub ( dublu x , dublu y ); dublu Mul ( dublu x , dublu y ); double Div ( dublu x , dublu y ); }
/// <summary>
/// RealSubject - obiect real
/// </summary>
/// <remarks>
/// <li>
/// <lu>definește obiectul real reprezentat de proxy</lu>
// / </li>
/// </remarks>
class Math : IMath
{
public Math ()
{
Console . WriteLine ( "Creează obiect Math. Așteaptă..." );
fir . Somn ( 1000 );
}
public double Adaugă ( 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 ( dublu x , dublu y ){ return x / y ;}
}
/// <summary>
/// Proxy este un proxy
/// </summary>
/// <remarks>
/// <li>
/// <lu> stochează o referință care permite proxy-ului să se refere la real
/// subiect . Obiectul de clasă <see cref="MathProxy"/> se poate referi la obiectul de clasă
/// <see cref="IMath"/> dacă interfețele de clasă <see cref="Math"/> și <see cref="IMath"/> sunt aceleași;</lu>
/// <lu>oferă o interfață identică cu cea a <see cref="IMath"/>, astfel încât un proxy
/// poate fi întotdeauna furnizat în locul subiectului real;</ lu>
/// < lu>controlează accesul la subiectul real și poate fi responsabil pentru crearea
/// și ștergerea acestuia;</lu>
/// <lu>alte sarcini depind de tipul de proxy:
/// < li>
/// <lu><b >proxy la distanță</b> este responsabil pentru codificarea cererii și argumentele acesteia
/// și trimiterea cererii codificate către subiectul real
/// într-un spațiu de adrese diferit;</lu >
/// <lu><b>proxy virtual</b> poate stoca în cache
informații /// suplimentare despre subiectul real pentru a întârzia crearea acestuia.</lu>
/// <lu><b>protecția proxy</b> > verifică dacă apelantul
/// are permisiunile necesare pentru a face cererea; </lu>
/// </li>
/// </lu>
/// </li>
/// < /remarks>
class MathProxy : IMath
{
Math math ;
public MathProxy ()
{
math = null ;
}
/// <summary>
/// Operare rapidă - nu necesită un subiect real
/// </summary>
/// <param name="x"></param>
/// <param name="y" ></param>
/// <returns></returns>
public double Add ( double x , double y )
{
return x + y ;
}
public double Sub ( dublu x , dublu y )
{
return x - y ;
}
/// <summary>
/// Operare lentă - necesită crearea unui subiect real
/// </summary>
/// <param name="x"></param>
/// <param name="y" ></param>
/// <returns></returns>
public double Mul ( double x , double y )
{
if ( math == null )
math = new Math ();
întoarce matematica . Mul ( x , y );
}
public double Div ( double x , double y )
{
if ( math == null )
math = new Math ();
întoarce matematica . Div ( x , y );
}
}
Exemplu de implementare
/* Subiect */
clasa IMath {
add ( x , y ) {}
sub ( x , y ) {}
}
/* Subiect real */
class RMath extinde IMath {
add ( x , y ) {
return x + y ;
}
sub ( x , y ) {
return x - y ;
}
}
/* Proxy */
clasa MathProxy extinde IMath {
math = nou RMath ()
add ( x , y ) {
return this . matematica . adaugă ( x , y )
}
sub ( x , y ) {
return this . matematica . sub ( x , y )
}
}
test const = alertă MathProxy () nouă ( test . adăugare ( 3 , 2 )) // 5 alertă ( test . sub ( 3 , 2 )) // 1
Exemplu de implementare
modulul ProxyPattern
# Proxy are aceeași interfață ca un subiect real
# Real Subject
class Account
attr_reader :balance
def initialize ( sold = 0 )
@balance = sold
final
def depozit ( suma )
@balance += suma
finală
def retrage ( suma )
@balance -= suma
finală
sfârșit
Modul Protecție
# Funcționalitate suplimentară pentru controlul accesului la subiectul real
# Clasa proxy AccountProxy
def initialize ( subiect , utilizator_actual ) @subject = subiect @utilizator_actual = utilizator_actual @balance = 0 final
depozit def ( sumă )
@subiect . depozit ( suma ) dacă se autorizează
încheierea
def retrage ( suma )
@subiect . retrage ( suma ) dacă se încheie autorizarea
def echilibru
@subject . sfârșitul echilibrului
privat
def authorize
pune „Acces refuzat”, cu excepția cazului în care @current_user == „ admin” @current_user == „admin” end end
def sine . run
pune „=> Proxy::Protection”
pune „ca utilizator”
protected_account = AccountProxy . new ( Cont . nou , 'utilizator' )
protected_account . depozit ( 20 )
protected_account . retrage ( 10 )
pune protected_account . echilibru
pune „ca admin”
protected_account = AccountProxy . nou ( Cont . nou , 'admin' )
protected_account . depozit ( 20 )
protected_account . retrage ( 10 )
pune protected_account . echilibru
pune ''
end
end
modul Virtual
# Întârziere încărcarea subiectului real (încărcare leneră)
# Clasa proxy AccountProxy
def initialize ( local_balance = 0 )
@local_balance = local_balance
end
def depozit ( suma )
@local_balance += suma
finală
def retrage ( suma )
@local_balance -= suma
finală
def echilibru
subiect . sfârșitul echilibrului
def subiect
@subject ||= Cont . nou ( @local_balance )
_
_
def sine . run
pune „=> Proxy::Virtual”
local_account = AccountProxy . cont_local nou
. depozit ( 20 ) cont_local . retrage ( 10 ) cont_local . depozit ( 15 ) cont_local . withdraw ( 5 ) pune „Nu există încă un cont real:” pune local_account . inspecta
cont_local . sold
puts „Contul real a fost creat:”
pune local_account . inspecta
pune ''
end
end
def sine . rulați
Protecția . runVirtual
_ _ run
end
end
Exemplu de implementare
<?php
/// Subiect - subiect
/// definește o interfață comună între Math și "Proxy", astfel încât
/// clasa "Proxy" poate fi folosită oriunde
interfață IMath
{
function Add ( $x , $y );
funcția Sub ( $x , $y );
funcția Mul ( $x , $y );
funcția Div ( $x , $y );
}
/// RealSubject - obiectul real
/// definește obiectul real reprezentat de proxy
class Math implementează IMath
{
public function __construct ()
{
print ( "Creează obiect Math. Wait..." );
somn ( 5 );
}
function public Add ( $x , $y ){ return $x + $y ;}
public function Sub ( $x , $y ){ return $x - $y ;}
public function Mul ( $x , $y ){ return $x * $y ;}
funcție publică Div ( $x , $y ){ return $x / $y ;} }
/// Proxy - proxy
/// stochează un link care permite proxy-ului să se refere la
subiectul /// real. Obiectul clasei „MathProxy” poate accesa obiectul clasei
„Math” /// dacă interfețele claselor „Math” și „IMath” sunt aceleași;
/// oferă o interfață identică cu interfața „IMath”, deci un proxy
/// poate fi întotdeauna furnizat în locul subiectului real;
/// controlează accesul la subiectul real și poate fi responsabil pentru crearea
/// și ștergerea acestuia;
/// alte sarcini depind de tipul de proxy:
/// proxy-ul la distanță este responsabil pentru codificarea cererii și argumentele acesteia
/// și trimiterea cererii codificate subiectului real
/// într-un spațiu de adrese diferit;
/// Proxy-ul virtual poate stoca
/// informații suplimentare despre subiectul real pentru a întârzia crearea acestuia.
/// proxy-ul de protecție verifică dacă apelantul
/// are permisiunile necesare pentru a executa cererea;
clasa MathProxy implementeaza IMath
{
protected $math ;
function public __construct ()
{
$this -> math = null ;
}
/// Operare rapidă - nu necesită o funcție publică subiect real
Adaugă ( $ x , $ y ) { return $x + $y ; }
function public Sub ( $x , $y )
{
return $x - $y ;
}
/// Operare lentă - necesită crearea unei funcții publice subiect real Mul ( $x , $y ) { if ( $this -> math == null ) $this -> math = new Math (); return $this -> math -> Mul ( $x , $y ); }
function public Div ( $x , $y )
{
if ( $this -> math == null )
$this -> math = new Math ();
return $this -> math -> Div ( $x , $y );
}
}
$p = nou MathProxy ;
// Faceți imprimarea matematică ( "4 + 2 = " . $p -> Adaugă ( 4 , 2 ));
print ( "4 - 2 = " . $p -> Sub ( 4 , 2 ));
print ( "4 * 2 = " . $p -> Mul ( 4 , 2 ));
print ( "4 / 2 = " . $p -> Div ( 4 , 2 ));
?>
Exemplu de implementare
//fișier IMath.as
pachet
{
interfață publică IMath { function add ( a : Număr , b : Număr ) : Număr ; function sub ( a : Număr , b : Număr ) : Număr ; function mul ( a : Număr , b : Număr ) : Număr ; function div ( a : Număr , b : Număr ) : Număr ; } }
//fișier MathSubject.as
pachet
{
public class MathSubject implementează IMath
{
public function add ( a : Number , b : Number ) : Number
{
return a + b ;
}
funcţia publică sub ( a : Număr , b : Număr ) : Număr
{
returnează a - b ;
}
public function mul ( a : Număr , b : Număr ) : Număr
{
return a * b ;
}
public function div ( a : Număr , b : Număr ) : Număr
{
return a / b ;
}
}
}
//fișier
pachet MathProxy.as
{
public class MathProxy implementează IMath
{
private var math : MathSubject ;
public function MathProxy ()
{
math = new MathSubject ();
}
public function add ( a : Number , b : Number ) : Number
{
return math . adaugă ( a , b );
}
funcția publică sub ( a : Număr , b : Număr ) : Număr
{
return math . sub ( a , b );
}
public function mul ( a : Număr , b : Număr ) : Număr
{
return math . mul ( a , b );
}
public function div ( a : Număr , b : Număr ) : Număr
{
dacă ( b != 0 )
returnează matematică . div ( a , b );
else
{
trace ( "Diviziunea la zero." );
returnNumber _ _ POSITIVE_INFINITY ;
}
}
}
}
//file Main.as
package
{
import flash.display.Sprite ;
public class Main extinde Sprite
{
public function Main ()
{
playWithMath ( new MathSubject ());
playWithMath ( nou MathProxy ());
}
funcția publică playWithMath ( math : IMath ) : void
{
trace ( math . add ( 5 , 0 ));
urmă ( math . sub ( 5 , 0 ));
urmă ( math . mul ( 5 , 0 ));
urmă ( math . div ( 5 , 0 ));
}
}
}
Exemplu de implementare
# -*- codificare: utf-8 -*-
class IMath :
"""Interfață pentru proxy și subiect real"""
def add ( self , x , y ):
raise NotImplementedError ()
def sub ( self , x , y ):
raise NotImplementedError ()
def mul ( self , x , y ):
raise NotImplementedError ()
def div ( self , x , y ):
raise NotImplementedError ()
clasa Matematică ( IMath ):
""" Subiect real """
def add ( self , x , y ):
return x + y
def sub ( self , x , y ):
returnează x - y
def mul ( self , x , y ):
return x * y
def div ( self , x , y ):
returnează x / y
clasa Proxy ( IMath ):
"""Proxy"""
def __init__ ( self ):
self . matematică = matematică ()
def add ( self , x , y ):
returnează x + y
def sub ( self , x , y ):
returnează x - y
def mul ( self , x , y ):
return self . matematica . mul ( x , y )
def div ( self , x , y ):
return float ( 'inf' ) if y == 0 else self . matematica . div ( x , y )
p = Proxy ()
x , y = 4 , 2
print '4 + 2 = ' + str ( p . adaugă ( x , y ))
print '4 - 2 = ' + str ( p . sub ( x , y ))
print '4 * 2 = ' + str ( p . mul ( x , y ))
print '4 / 2 = ' + str ( p . div ( x , y ))
Exemplu de implementare
Importuri System.Threading
Class MainApp
Shared Sub Main ()
' Creare proxy matematic
Dim p As IMath = New MathProxy ()
' Fă Consola de matematică . WriteLine ( "4 + 2 = " & p . Adăugați ( 4 , 2 ))
Consolă . WriteLine ( "4 - 2 = " & p . Subtr ( 4 , 2 ))
Consolă . WriteLine ( "4 * 2 = " & p . Mul ( 4 , 2 ))
Consolă . WriteLine ( "4 / 2 = " & p . Div ( 4 , 2 ))
' Așteptați
Consola utilizator . Citiți ()
End Sub
End Class
''' <summary>
''' Subiect - subiectul lui
''' </summary>
''' <remarks>
''' <li>
''' <lu> definește comun la <see cref="Math"/ > și interfața <see cref="Proxy"/>, astfel încât clasa
''' <see cref="Proxy"/> poate fi folosită oriunde <see cref="Math"/></lu>
''' </ li>
''' </remarks>
Public Interface IMath
Function Add ( ByVal x As Double , ByVal y As Double ) As Double
Function Subtr ( ByVal x As Double , ByVal y As Double ) As Double
Function Mul ( ByVal x As Double , ByVal y Ca dublu ) Ca dublu
Funcție Div ( ByVal x Ca dublu , ByVal și Ca dublu ) Ca interfață de capăt dublu
''' <summary>
''' RealSubject - obiectul real
''' </summary>
''' <remarks>
''' <li>
''' <lu>identifică obiectul real reprezentat de proxy</lu> >
'' ' </li>
''' </remarks>
Class Math
Implementează IMath
Public Sub New ()
Console . WriteLine ( "Creați obiectul Math. Așteptați..." )
Thread . Sleep ( 1000 )
End Sub
Funcția publică Adaugă ( ByVal x As Double , ByVal y As Double ) As Double Implementează IMath . Adăugați
funcția Return x + y
End
Funcția publică Subtr ( ByVal x As Double , ByVal y As Double ) As Double Implementează IMath . Subtr
Return x - y
End Function
Funcția publică Mul ( ByVal x As Double , ByVal y As Double ) As Double Implementă IMath . Mul
Return x * y
End Function
Public Function Div ( ByVal x As Double , ByVal y As Double ) As Double Implementă IMath . Div
Return x / y
End Function
termina clasa
''' <summary>
''' Proxy proxy
''' </summary>
''' <remarks>
''' <li>
''' <lu> stochează o referință care permite proxy-ului să se refere la adevăratul
'' ' subiect . Un obiect din clasa <see cref="MathProxy"/> se poate referi la un obiect din clasa
''' <see cref="IMath"/> dacă interfețele de clasă <see cref="Math"/> și <see cref= „IMath”/ > sunt aceleași;</lu>
''' <lu>oferă o interfață identică cu cea a lui <see cref="IMath"/>, astfel încât substituentul
„'' poate fi întotdeauna furnizat în locul subiect real;</lu>
''' < lu>controlează accesul la subiectul real și poate fi responsabil pentru crearea
''' și ștergerea acestuia;</lu>
''' <lu>alte sarcini depind de tipul de proxy :
''' <li>
''' <lu><b >proxy-ul la distanță</b> este responsabil pentru codificarea cererii și a argumentelor sale
''' și trimiterea cererii codificate la subiectul real într-un
spațiu de adrese diferit '' ';</lu>
''' <lu><b>proxy virtual</b> poate stoca în cache informații suplimentare
''' despre subiectul real pentru a întârzia crearea acestuia.</lu>
''' <lu><b> protecting proxy</b> verifică dacă apelantul
''' are permisiunile necesare pentru a face cererea; </lu>
''' </li>
''' </lu>
''' </li>
''' < /remarks>
Clasa MathProxy
implementează IMath
Matematică privată As Math = Nimic
''' <summary>
''' Operare rapidă - nu necesită un subiect real
''' </summary>
Funcție publică Adaugă ( ByVal x As Double , ByVal y As Double ) As Double Implementă IMath . Adăugați funcția Return x + y End
Funcția publică Subtr ( ByVal x As Double , ByVal y As Double ) As Double Implementează IMath . Subtr
Return x - y
End Function
''' <summary>
''' Operațiune lentă - necesită crearea unui subiect real
''' </summary>
Funcția publică Mul ( ByVal x As Double , ByVal y As Double ) As Double Implementă IMath . Mul Dacă matematica este nimic , atunci matematică = Matematică nouă () Sfârșit dacă Întoarce matematică . Mul ( x , y ) Funcție de sfârșit
Public Function Div ( ByVal x As Double , ByVal y As Double ) As Double Implementă IMath . Div
If math is Nothing Then
math = New Math ()
End If
Return math . Div ( x , y )
End Function
End Class
Exemplu de implementare
//
se potrivește protocolul subiectului {
func add ( x : Int , y : Int ) -> Int
func sub ( x : Int , y : Int ) -> Int
func mul ( x : Int , y : Int ) -> Int
func div ( x : Int , y : Int ) -> Int
}
//
Clasa de subiect real 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
}
}
//
Clasa proxy MatchProxy : Potrivire {
private let math = MatchImp ()
func add ( x : Int , y : Int ) -> Int {
return math . adaugă ( x : x , y : y )
}
func sub ( x : Int , y : Int ) -> Int {
return math . sub ( x : x , y : y )
}
func mul ( x : Int , y : Int ) -> Int {
return math . mul ( x : x , y : y )
}
func div ( x : Int , y : Int ) -> Int {
return math . div ( x : x , y : y )
}
}
// utilizarea proxy
let proxy = MatchProxy ()
print ( "7 * 8 = \( proxy . mul ( x : 8 , y : 7 )) " )
Vezi și
Note
- ↑ Jurnalele dezvoltatorilor // Proxy (link descendent) . Consultat la 26 mai 2010. Arhivat din original pe 14 mai 2010. (nedefinit)
Literatură
- CodeLIB.YOURS // Proxy Arhivat 14 mai 2010 la Wayback Machine
- E. Gamma, R. Helm, R. Johnson, J. Vlissides . Tehnici de proiectare orientată pe obiecte. Design Patterns.=Design Patterns.Elemente ale software-ului reutilizabil orientat pe obiecte. - Sankt Petersburg. : Peter, 2001. - 368 p. — ISBN 5-272-00355-1 .
- Eric Freeman, Elizabeth Freeman, Kathy Siera, Bert Bates. Modele de design. - Sankt Petersburg. : Peter, 2012. - 656 p. - ISBN 978-5-459-00435-9 .
Link -uri