Suppleant (designmönster)
Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från
versionen som granskades den 10 juli 2018; kontroller kräver
9 redigeringar .
Vice |
---|
ombud |
|
Sorts |
strukturell |
Ändamål |
Tillhandahåller ett surrogatobjekt som styr åtkomst till ett annat objekt. |
fördelar |
- fjärrersättning;
- den virtuella proxyn kan utföra optimeringen;
- skyddande substitut;
- "smart" länk;
|
Minus |
- dramatisk ökning av svarstid.
|
Beskrivs i Design Patterns |
Ja |
Proxy ( Eng. Proxy ) är ett strukturellt designmönster som tillhandahåller ett objekt som kontrollerar åtkomst till ett annat objekt, som avlyssnar alla anrop (utför funktionen av en container ).
Syfte
Problem
Tillgången till objektet måste kontrolleras utan att klientens beteende ändras.
Det är nödvändigt att komma åt objektet på ett sådant sätt att du inte skapar riktiga objekt direkt, utan genom ett annat objekt som kan ha ytterligare funktionalitet.
Lösning
Skapa ett surrogat för ett riktigt objekt. Proxyn lagrar en referens som låter proxyn hänvisa till det verkliga subjektet (ett objekt i klassen Proxy kan hänvisa till ett objekt i klassen Subject om gränssnitten för det verkliga subjektet och subjektet är samma). Eftersom "Real Subject" -gränssnittet är identiskt med "Subject"-gränssnittet, så att "Ersättaren" kan ersätta "Real Subject", kontrollerar tillgången till "Real Subject", kan ansvara för att skapa eller ta bort " Verkligt ämne". "Ämne" definierar ett gemensamt gränssnitt mellan "Real Subject" och "Proxy" så att "Proxy" kan användas varhelst "Real Subject" förväntas. Vid behov kan förfrågningar vidarebefordras av "ställföreträdaren" till "verkliga subjektet".
Art
- Loggningsproxy : loggar alla anrop till "Ämnet" med deras parametrar.
- Fjärrproxy ( eng. remote proxies ): ger kommunikation med "Ämnet", som finns i ett annat adressutrymme eller på en fjärrdator. Kan också vara ansvarig för att koda begäran och dess argument och skicka den kodade begäran till det riktiga "Ämnet"
- Virtual Proxies ( eng. virtuella proxyer ): säkerställer skapandet av ett riktigt "Ämne" endast när det verkligen behövs. Den kan också cache en del av informationen om det verkliga "Ämnet" för att fördröja skapandet,
- Copy-on-write : ger en kopia av "ämnet" när klienten utför vissa åtgärder (ett specialfall av "virtuell proxy").
- Skyddsproxy : Kan kontrollera om den som ringer har nödvändiga behörigheter för att slutföra förfrågan .
- Cachingproxy : tillhandahåller tillfällig lagring av beräkningsresultat innan de skickas till flera klienter som kan dela dessa resultat.
- Screening proxy : skyddar "Ämnet" från farliga klienter (eller vice versa).
- Synkroniseringsproxy : Utför synkroniserad åtkomstkontroll till "Ämnet" i en asynkron flertrådig miljö.
- "Smart" länk ( eng. smart referens proxy ): utför ytterligare åtgärder när en länk till "Ämnet" skapas, till exempel beräknar antalet aktiva länkar till "Ämnet".
Fördelar och nackdelar med att använda
Fördelar
- fjärrersättning;
- den virtuella proxyn kan utföra optimeringen;
- skyddande substitut;
- "smart" länk (pekare) ;
Nackdelar
- dramatisk ökning av svarstid.
Omfattning
Proxymönstret kan användas när man arbetar med en nätverksanslutning, med ett stort objekt i minnet (eller på disken), eller med någon annan resurs som är svår eller svår att kopiera. Ett välkänt användningsfall är ett objekt som räknar antalet referenser.
Proxy och relaterade mönster [1]
- En adapter ger ett distinkt gränssnitt till ett objekt.
- Proxyn tillhandahåller samma gränssnitt.
- Dekoratören ger ett utökat gränssnitt.
Implementeringsexempel
Implementeringsexempel
offentlig klass Main {
public static void main ( String [] args ) {
// Create math proxy
IMath p = new MathProxy ();
// Gör
mattesystemet . ut . println ( "4 + 2 = " + s . add ( 4 , 2 ));
System . ut . println ( "4 - 2 = " + p . sub ( 4 , 2 ));
System . ut . println ( "4 * 2 = " + p . mul ( 4 , 2 ));
System . ut . println ( "4 / 2 = " + p . div ( 4 , 2 ));
}
}
/**
* "Ämne"
*/
offentligt gränssnitt IMath {
public double add ( dubbel x , dubbel y );
offentlig dubbelsub ( dubbel x , dubbel y ) ;
offentlig dubbel mul ( dubbel x , dubbel y );
offentlig dubbel div ( dubbel x , dubbel y );
}
/**
* "Real Subject"
*/
offentlig klass Math implementerar IMath {
public double add ( double x , double y ) {
return x + y ;
}
public double sub ( double x , double y ) {
return x - y ;
}
offentlig dubbel mul ( dubbel x , dubbel y ) {
return x * y ;
}
public double div ( double x , double y ) {
return x / y ;
}
}
/**
* "Proxy Object"
*/
public class MathProxy implementerar IMath {
privat matematik matematik ;
public double add ( double x , double y ) {
lazyInitMath ();
returnera matematik . add ( x , y );
}
public double sub ( double x , double y ) {
lazyInitMath ();
returnera matematik . sub ( x , y );
}
public double mul ( double x , double y ) {
lazyInitMath ();
returnera matematik . mul ( x , y );
}
public double div ( double x , double y ) {
lazyInitMath ();
returnera matematik . div ( x , y );
}
private void lazyInitMath () {
if ( matte == null ) {
matte = ny matematik ();
}
}
}
Implementeringsexempel
object Main utökar App {
val p : IMath = nytt MathProxy
System . ut . println ( "4 + 2 = " + s . add ( 4 , 2 ))
System . ut . println ( "4 - 2 = " + p . sub ( 4 , 2 ))
System . ut . println ( "4 * 2 = " + p . mul ( 4 , 2 ))
System . ut . println ( "4 / 2 = " + p . div ( 4 , 2 ))
}
/**
* "Ämne"
*/
egenskap IMath {
def add ( x : Double , y : Double ): Double
def sub ( x : Dubbel , y : Dubbel ): Dubbel
def mul ( x : Dubbel , y : Dubbel ): Dubbel
def div ( x : Dubbel , y : Dubbel ): Dubbel
}
/**
* "Real Subject"
*/
klass Math utökar IMath {
def add ( x : Double , y : Double ) = x + y
def sub ( x : Dubbel , y : Dubbel ) = x - y
def mul ( x : Dubbel , y : Dubbel ) = x * y
def div ( x : Dubbel , y : Dubbel ) = x / y
}
/**
* "Proxyobjekt"
*/
klass MathProxy utökar IMath {
privat lazy val math = new Math
def add ( x : Double , y : Double ) = matte . lägg till ( x , y )
def sub ( x : Dubbel , y : Dubbel ) = matematik . sub ( x , y )
def mul ( x : Dubbel , y : Dubbel ) = matematik . mul ( x , y )
def div ( x : Dubbel , y : Dubbel ) = matematik . div ( x , y )
}
Implementeringsexempel
/**
* "Ämne"
*/
klass IMath {
offentliga :
virtuell dubbel addera ( dubbel , dubbel ) = 0 ;
virtuell dubbelsub ( dubbel , dubbel ) = 0 ; _
virtuell dubbel mul ( dubbel , dubbel ) = 0 ;
virtuell dubbel div ( dubbel , dubbel ) = 0 ;
};
/**
* "Riktigt ämne"
*/
klass matematik : public IMath {
offentliga :
virtual double add ( double x , double y ) {
returnera x + y _
}
virtuell dubbelsub ( dubbel x , dubbel y ) { _
returnera x - y ;
}
virtuell dubbel mul ( dubbel x , dubbel y ) {
returnera x * y _
}
virtuell dubbel div ( dubbel x , dubbel y ) {
returnera x / y _
}
};
/**
* "Proxyobjekt"
*/
klass MathProxy : public IMath {
offentliga :
MathProxy ()
{
matte = ny matematik ();
}
virtuell ~ MathProxy ()
{
ta bort matematik ;
}
virtual double add ( double x , double y ) {
returnera matematik -> lägg till ( x , y );
}
virtuell dubbelsub ( dubbel x , dubbel y ) { _
return math -> sub ( x , y );
}
virtuell dubbel mul ( dubbel x , dubbel y ) {
returnera matematik -> mul ( x , y );
}
virtuell dubbel div ( dubbel x , dubbel y ) {
returnera matematik -> div ( x , y );
}
privat :
IMath * matematik ;
};
#include <iostream>
använder std :: cout ;
använder std :: endl ;
int main () {
// Skapa matematisk proxy
IMath * proxy = ny MathProxy ();
// Gör
matteräkningen << "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 ;
ta bort proxy ;
returnera 0 ;
}
Implementeringsexempel
använder System ;
använder System.Threading ;
class MainApp
{
static void Main ()
{
// Create math proxy
IMath p = new MathProxy ();
// Gör
mattekonsolen . WriteLine ( "4 + 2 = " + p . Lägg till ( 4 , 2 ));
Konsol . WriteLine ( "4 - 2 = " + p . Sub ( 4 , 2 ));
Konsol . WriteLine ( "4 * 2 = " + p . Mul ( 4 , 2 ));
Konsol . WriteLine ( "4 / 2 = " + p . Div ( 4 , 2 ));
// Vänta på
användarkonsolen . läs ();
}
}
/// <summary>
/// Ämne - ämne
/// </summary>
/// <remarks>
/// <li>
/// <lu> definierar en gemensam för <see cref="Math"/> och <see cref="Proxy"/> gränssnitt så att klass
/// <see cref="Proxy"/> kan användas var som helst <see cref="Math"/></lu>
/// </ li>
/ // </remarks>
offentligt gränssnitt IMath
{
double Add ( double x , double y );
dubbel Sub ( dubbel x , dubbel y );
dubbel Mul ( dubbel x , dubbel y );
dubbel Div ( dubbel x , dubbel y );
}
/// <summary>
/// RealSubject - real object
/// </summary>
/// <remarks>
/// <li>
/// <lu>definierar det verkliga objektet som representeras av proxyn</lu>
// / </li>
/// </remarks>
klass Math : IMath
{
public Math ()
{
Console . WriteLine ( "Skapa objekt Math. Vänta..." );
tråd . Sömn ( 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 ;}
}
/// <sammanfattning>
/// Proxy är en proxy
/// </summary>
/// <remarks>
/// <li>
/// <lu> lagrar en referens som låter proxyn referera till den verkliga
/// ämne . Klassobjekt <see cref="MathProxy"/> kan referera till
klassobjekt /// <see cref="IMath"/> om klassgränssnitt <see cref="Math"/> och <see cref="IMath"/ > är desamma;</lu>
/// <lu>tillhandahåller ett gränssnitt som är identiskt med det för <see cref="IMath"/>, så att en proxy
/// alltid kan tillhandahållas istället för det verkliga ämnet;</ lu>
/// < lu>kontrollerar åtkomsten till det verkliga ämnet och kan vara ansvarigt för att skapa
/// och ta bort det;</lu>
/// <lu>andra uppgifter beror på typen av proxy:
/// < li>
/// <lu><b >fjärrproxy</b> är ansvarig för att koda begäran och dess argument
/// och skicka den kodade begäran till det verkliga ämnet
/// i ett annat adressutrymme;</lu >
/// <lu><b>virtuell proxy</b> kan cachelagra ytterligare
/// information om det verkliga föremålet för att fördröja dess skapande.</lu>
/// <lu><b>skyddande proxy</b > kontrollerar om den som ringer
/// har nödvändiga behörigheter för att göra begäran; </lu>
/// </li>
/// </lu>
/// </li>
/// < /remarks>
class MathProxy : IMath
{
Math math ;
public MathProxy ()
{
math = null ;
}
/// <summary>
/// Snabb operation - kräver inte ett riktigt ämne
/// </summary>
/// <param name="x"></param>
/// <param name="y" >< /param>
/// <returns></returns>
public double Add ( double x , double y )
{
return x + y ;
}
public double Sub ( dubbel x , dubbel y )
{
retur x - y ;
}
/// <summary>
/// Långsam operation - kräver att ett verkligt ämne
skapas /// </summary>
/// <param name="x"></param>
/// <param name="y" >< /param>
/// <returns></returns>
public double Mul ( double x , double y )
{
if ( math == null )
math = new Math ();
returnera matematik . Mul ( x , y );
}
public double Div ( double x , double y )
{
if ( matte == null )
matte = ny matematik ();
returnera matematik . Div ( x , y );
}
}
Implementeringsexempel
/* Ämne */
klass IMath {
add ( x , y ) {}
sub ( x , y ) {}
}
/* Real Subject */
class RMath utökar IMath {
add ( x , y ) {
return x + y ;
}
sub ( x , y ) {
returnera x - y ;
}
}
/* Proxy */
class MathProxy utökar IMath {
math = new RMath ()
add ( x , y ) {
returnera detta . matte . add ( x , y )
}
sub ( x , y ) {
returnera detta . matte . sub ( x , y )
}
}
const test = new MathProxy ()
alert ( test . add ( 3 , 2 )) // 5
alert ( test . sub ( 3 , 2 )) // 1
Implementeringsexempel
modul ProxyPattern
# Proxy har samma gränssnitt som ett Real Subject
# Real Subject
class Account
attr_reader :saldo
def initiera ( balans = 0 )
@balans = balans
slut
def insättning ( belopp )
@saldo += belopp
slut
def draw ( belopp )
@saldo -= belopp
slut
slut
modul Skydd
# Ytterligare funktionalitet för att kontrollera åtkomsten till realSubject
#
Proxyklass KontoProxy
def initialisera ( ämne , aktuell_användare )
@ ämne = ämne
@aktuell_användare = aktuell_användare
@saldo = 0
slut
def insättning ( belopp )
@subject . insättning ( belopp ) om auktorisation
slut
def dra ut ( belopp )
@subject . dra tillbaka ( belopp ) om auktorisation
avslutas
def balans
@ämne . balans
slut
privat
def auktorisera
sätter 'Åtkomst nekad' om inte @current_user == ' admin' @current_user == ' admin ' slutslut
def själv . kör
sätter '=> Proxy::Protection'
sätter 'som användare'
protected_account = AccountProxy . nytt ( Konto . nytt , 'användare' )
protected_account . insättning ( 20 )
protected_account . dra ut ( 10 )
sätter protected_account . balans
sätter 'som admin'
protected_account = AccountProxy . nytt ( Konto . nytt , 'admin' )
protected_account . insättning ( 20 )
protected_account . dra ut ( 10 )
sätter protected_account . balans
sätter ' '
slutslut
modul Virtuell
# Fördröjning av verklig Ämnesladdning (lat laddning)
#
Proxyklass AccountProxy
def initialize ( local_balance = 0 )
@local_balance = local_balance
end
def insättning ( belopp )
@local_balance += belopp
slut
def uttag ( belopp )
@local_balance -= belopp
slut
def balans
ämne . balans
slut
def subject
@subject ||= Konto . ny ( @local_balance )
_
_
def själv . kör
sätter '=> Proxy::Virtual'
local_account = AccountProxy . nytt
lokalt_konto . insättning ( 20 )
local_account . dra ut ( 10 )
local_account . insättning ( 15 )
local_account . draw ( 5 )
sätter 'Inget riktigt konto ännu:'
sätter local_account . inspektera
lokalt_konto . saldo
sätter 'Riktigt konto skapades:'
sätter local_account . inspektera
sätter ' '
slutslut
def själv . kör
skydd . runVirtual
. _ köra slutet slutet
Implementeringsexempel
<?php
/// Ämne - ämne
/// definierar ett gränssnitt gemensamt mellan Math och "Proxy", så att
/// "Proxy"-klassen kan användas var som helst
gränssnitt IMath
{
function Add ( $x , $y );
funktion Sub ( $x , $y );
funktion Mul ( $x , $y );
funktion Div ( $x , $y );
}
/// RealSubject - det verkliga objektet
/// definierar det verkliga objektet som representeras av proxyn
class Math implementerar IMath
{
public function __construct ()
{
print ( "Skapa objekt Math. Vänta..." );
sömn ( 5 );
}
public function Add ( $x , $y ){ return $x + $y ;}
public function Sub ( $x , $y ){ return $x - $y ;}
public function Mul ( $x , $y ){ return $x * $y ;}
offentlig funktion Div ( $x , $y ){ return $x / $y ;}
}
/// Proxy - proxy
/// lagrar en länk som låter proxyn referera till det verkliga
/// ämnet. Klassobjektet "MathProxy" kan komma åt klassobjektet
"Math" /// om gränssnitten för klasserna "Math" och "IMath" är desamma;
/// tillhandahåller ett gränssnitt som är identiskt med "IMath"-gränssnittet, så en proxy
/// kan alltid tillhandahållas i stället för det verkliga ämnet;
/// kontrollerar åtkomst till det verkliga ämnet och kan vara ansvarigt för att skapa
/// och ta bort det;
/// andra uppgifter beror på typen av proxy:
/// fjärrproxyn är ansvarig för att koda begäran och dess argument
/// och skicka den kodade begäran till det verkliga subjektet
/// i ett annat adressutrymme;
/// Den virtuella proxyn kan cachelagra ytterligare
/// information om det verkliga ämnet för att fördröja dess skapande.
/// den skyddande proxyn kontrollerar om den som ringer
/// har nödvändiga behörigheter för att utföra begäran;
class MathProxy implementerar IMath
{
protected $math ;
offentlig funktion __construct ()
{
$this -> math = null ;
}
/// Snabb operation - kräver inte en
offentlig funktion för verkligt ämne Add ( $x , $y )
{
return $x + $y ;
}
public function Sub ( $x , $y )
{
return $x - $y ;
}
/// Långsam operation - kräver skapandet av en verkligt ämne
offentlig funktion Mul ( $x , $y )
{
if ( $this -> math == null )
$this -> math = new Math ();
returnera $this -> matte -> Mul ( $x , $y );
}
public function Div ( $x , $y )
{
if ( $this -> math == null )
$this -> matte = new Math ();
return $this -> math -> Div ( $x , $y );
}
}
$p = ny MathProxy ;
// Gör matteutskriften
( " 4 + 2 = " . $p -> Lägg till ( 4 , 2 ));
print ( "4 - 2 = " . $p -> Sub ( 4 , 2 ));
print ( "4 * 2 = " . $p -> Mul ( 4 , 2 ));
print ( "4 / 2 = " . $p -> Div ( 4 , 2 ));
?>
Implementeringsexempel
//file IMath.as
paket
{
public interface IMath
{
function add ( a : Number , b : Number ) : Number ;
function sub ( a : Number , b : Number ) : Number ;
funktion mul ( a : Tal , b : Tal ) : Tal ;
funktion div ( a : Tal , b : Tal ) : Tal ;
}
}
//file MathSubject.as
package
{
public class MathSubject implementerar IMath
{
public function add ( a : Number , b : Number ) : Number
{
retur a + b ;
}
public function sub ( a : Number , b : Number ) : Number
{
retur a - b ;
}
offentlig funktion mul ( a : Tal , b : Tal ) : Tal
{
retur a * b ;
}
public function div ( a : Number , b : Number ) : Number
{
retur a / b ;
}
}
}
//file MathProxy.as
paket
{
public class MathProxy implementerar IMath
{
private var math : MathSubject ;
offentlig funktion MathProxy ()
{
matte = nytt MathSubject ();
}
public function add ( a : Number , b : Number ) : Number
{
return math . addera ( a , b );
}
public function sub ( a : Number , b : Number ) : Number
{
return math . sub ( a , b );
}
offentlig funktion mul ( a : Tal , b : Tal ) : Tal
{
return math . mul ( a , b );
}
offentlig funktion div ( a : Tal , b : Tal ) : Tal
{
if ( b != 0 )
returnerar matematik . div ( a , b );
else
{
trace ( "Division med noll." );
returnummer . _ POSITIVE_INFINITY ; } } } }
//file Main.as-
paket
{
import flash.display.Sprite ;
public class Main utökar Sprite
{
public function Main ()
{
playWithMath ( nytt MathSubject ());
playWithMath ( ny MathProxy ());
}
public function playWithMath ( matte : IMath ) : void
{
trace ( math . add ( 5 , 0 ));
spåra ( matte . sub ( 5 , 0 ));
spåra ( matte . mul ( 5 , 0 ));
spåra ( matte . div ( 5 , 0 ));
}
}
}
Implementeringsexempel
# -*- kodning: utf-8 -*-
class IMath :
"""Gränssnitt för proxy och verkligt ämne"""
def add ( self , x , y ):
raise NotImplementedError ()
def sub ( self , x , y ):
höj NotImplementedError ()
def mul ( själv , x , y ):
höj NotImplementedError ()
def div ( själv , x , y ):
höj NotImplementedError ()
klass Math ( IMath ):
"""Riktigt ämne"""
def add ( själv , x , y ):
returnera x + y
def sub ( själv , x , y ):
returnera x - y
def mul ( själv , x , y ):
returnera x * y
def div ( själv , x , y ):
returnera x / y
class Proxy ( IMath ):
"""Proxy"""
def __init__ ( self ):
self . matte = matte ()
def add ( själv , x , y ):
returnera x + y
def sub ( själv , x , y ):
returnera x - y
def mul ( själv , x , y ):
returnera själv . matte . mul ( x , y )
def div ( själv , x , y ):
returnera flytande ( 'inf' ) om y == 0 annat själv . matte . div ( x , y )
p = Proxy ()
x , y = 4 , 2
print '4 + 2 = ' + str ( p . add ( 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 ))
Implementeringsexempel
Importerar System.Threading
Klass MainApp
Shared Sub Main ()
' Skapa matteproxy
Dim p As IMath = New MathProxy ()
" Gör
mattekonsolen . WriteLine ( "4 + 2 = " & s . Lägg till ( 4 , 2 ))
Konsol . WriteLine ( "4-2 = " & p . Subtr ( 4 , 2 ))
Konsol . WriteLine ( "4 * 2 = " & p . Mul ( 4 , 2 ))
Konsol . WriteLine ( "4 / 2 = " & p . Div ( 4 , 2 ))
" Vänta på
användarkonsolen . Läs ()
End Sub
End Class
''' <summary>
''' Ämne - ämnet för
''' </summary>
''' <remarks>
''' <li>
''' <lu> definierar gemensamt för <see cref="Math"/ > och <see cref="Proxy"/> gränssnitt så att klassen
''' <see cref="Proxy"/> kan användas var som helst <see cref="Math"/></lu>
''' </ li>
''' </remarks>
Public Interface IMath
Funktion Lägg till ( 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 As Double ) Som dubbelfunktions
Div ( ByVal x As Double , ByVal y As Double ) Som Double End Interface _
''' <summary>
''' RealSubject - det verkliga objektet
''' </summary>
''' <remarks>
''' <li>
''' <lu>identifierar det verkliga objektet som representeras av proxyn</lu >
'' ' </li>
''' </remarks>
Class Math
implementerar IMath
Public Sub New ()
Console . WriteLine ( "Skapa objekt Math. Vänta..." )
Tråd . Sleep ( 1000 )
End Sub
Public Function Add ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Lägg
till retur x + y
slutfunktion
Public Function Subtr ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Subtr
Return x - y
Slutfunktion _
Public Function Mul ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Mul
Return x * y
Slutfunktion _
Public Function Div ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Div
Return x / y
Slutfunktion _
slutklass _
''' <summary>
''' Proxy proxy
''' </summary>
''' <remarks>
''' <li>
''' <lu> lagrar en referens som gör att proxyn kan referera till den riktiga
'' ' ämne. Ett objekt av klassen <see cref="MathProxy"/> kan referera till ett objekt av klassen
''' <see cref="IMath"/> om klassen gränssnitt <see cref="Math"/> och <see cref= "IMath"/ > är desamma;</lu>
''' <lu>tillhandahåller ett gränssnitt som är identiskt med det för <see cref="IMath"/>, så att platshållaren
''' alltid kan tillhandahållas istället för verkligt ämne;</lu>
''' < lu>kontrollerar åtkomsten till det verkliga ämnet och kan vara ansvarigt för att det skapas
''' och raderas;</lu>
''' <lu>andra uppgifter beror på typen av proxy :
''' <li>
''' <lu><b >fjärrproxy</b> är ansvarig för att koda begäran och dess argument
''' och skicka den kodade begäran till det verkliga ämnet i ett
annat adressutrymme '' ';</lu>
''' <lu><b>virtuell proxy</b> kan cachelagra ytterligare information
''' om det verkliga föremålet för att fördröja skapandet.</lu>
''' <lu><b> protecting proxy</b> kontrollerar om den som ringer
''' har nödvändiga behörigheter för att göra begäran; </lu>
''' </li>
''' </lu>
''' </li>
''' < /anmärkningar>
Klass MathProxy
implementerar IMath
Privat matematik Som Math = Ingenting
''' <summary>
''' Snabb operation - kräver inte ett riktigt ämne
''' </summary>
Offentlig funktion Lägg till ( ByVal x As Double , ByVal y As Double ) As Double Implementerar IMath . Lägg
till retur x + y
slutfunktion
Public Function Subtr ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Subtr
Return x - y
Slutfunktion _
''' <summary>
''' Långsam operation - kräver att ett verkligt ämne skapas
''' </summary>
Public Function Mul ( ByVal x As Double , ByVal y As Double ) As Double Implementerar IMath . Mul
Om matte är ingenting Då
matte = Ny matte ()
End If
Return matte . Mul ( x , y )
Slutfunktion _
Public Function Div ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Div
Om matte är ingenting Då
matte = Ny matte ()
End If
Return matte . Div ( x , y )
Slutfunktion Slutklass
_ _
Implementeringsexempel
//
ämnesprotokoll match {
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
}
// Real Subject
class 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
}
}
//
Proxyklass MatchProxy : Matcha {
private let math = MatchImp ()
func add ( x : Int , y : Int ) -> Int {
return math . lägg till ( 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 )
}
}
// Använd proxy
låt proxy = MatchProxy ()
skriva ut ( "7 * 8 = \( proxy . mul ( x : 8 , y : 7 )) " )
Se även
- Post-objekt programmering
Anteckningar
- ↑ Utvecklarens dagböcker // Proxy (nedlänk) . Hämtad 26 maj 2010. Arkiverad från originalet 14 maj 2010. (obestämd)
Litteratur
- CodeLIB.YOURS // Proxy arkiverad 14 maj 2010 på Wayback Machine
- E. Gamma, R. Helm, R. Johnson, J. Vlissides . Tekniker för objektorienterad design. Design Patterns.=Design Patterns.Element av återanvändbar objektorienterad programvara. - St Petersburg. : Peter, 2001. - 368 sid. — ISBN 5-272-00355-1 .
- Eric Freeman, Elizabeth Freeman, Kathy Siera, Bert Bates. Design mönster. - St Petersburg. : Peter, 2012. - 656 sid. - ISBN 978-5-459-00435-9 .
Länkar