Adjunto (patrón de diseño)
La versión actual de la página aún no ha sido revisada por colaboradores experimentados y puede diferir significativamente de la
versión revisada el 10 de julio de 2018; las comprobaciones requieren
9 ediciones .
| Diputado |
|---|
| apoderado |
| |
| Tipo de |
estructural |
| Objetivo |
Proporciona un objeto sustituto que controla el acceso a otro objeto. |
| ventajas |
- sustituto remoto;
- el proxy virtual puede realizar la optimización;
- sustituto protector;
- enlace "inteligente";
|
| menos |
- Aumento dramático en el tiempo de respuesta.
|
| Descrito en Patrones de diseño |
Sí |
Proxy ( Ing. Proxy ) es un patrón de diseño estructural que proporciona un objeto que controla el acceso a otro objeto, interceptando todas las llamadas (realiza la función de un contenedor ).
Propósito
Problema
El acceso al objeto debe controlarse sin cambiar el comportamiento del cliente.
Es necesario acceder al objeto de tal manera que no cree objetos reales directamente, sino a través de otro objeto que puede tener una funcionalidad adicional.
Solución
Crea un sustituto para un objeto real. El Proxy almacena una referencia que permite al Proxy referirse al sujeto real (un objeto de la clase Proxy puede referirse a un objeto de la clase Sujeto si las interfaces del Sujeto Real y el Sujeto son las mismas). Dado que la interfaz "Sujeto real" es idéntica a la interfaz "Sujeto", de modo que el "Sustituto" puede sustituir al "Sujeto real", controla el acceso al "Sujeto real", puede ser responsable de crear o eliminar el " verdadero sujeto". "Asunto" define una interfaz común entre "Asunto real" y "Apoderado" para que se pueda utilizar "Apoderado" dondequiera que se espere un "Asunto real". Si es necesario, las solicitudes pueden ser enviadas por el "Adjunto" al "Sujeto real".
Especies
- Proxy de registro: registra todas las llamadas al "Asunto" con sus parámetros.
- Proxy remoto ( eng. proxy remoto ): proporciona comunicación con el "Sujeto", que se encuentra en un espacio de direcciones diferente o en una máquina remota. También puede ser responsable de codificar la solicitud y sus argumentos y enviar la solicitud codificada al "Asunto" real
- Proxies virtuales ( ing. virtual proxies ): asegura la creación de un "Asunto" real solo cuando es realmente necesario. También puede almacenar en caché parte de la información sobre el "sujeto" real para retrasar su creación,
- Copy-on-write : proporciona una copia del "asunto" cuando el cliente realiza determinadas acciones (un caso especial del "proxy virtual").
- Proxies de protección : Puede verificar si la persona que llama tiene los permisos necesarios para completar la solicitud .
- Proxy de almacenamiento en caché : proporciona almacenamiento temporal de los resultados de los cálculos antes de enviarlos a varios clientes que pueden compartir estos resultados.
- Proxy de filtrado : protege al "Sujeto" de clientes peligrosos (o viceversa).
- Proxy de sincronización : realiza el control de acceso sincronizado al "sujeto" en un entorno asincrónico de subprocesos múltiples .
- Enlace "inteligente" ( eng. proxy de referencia inteligente ): realiza acciones adicionales cuando se crea un enlace al "Asunto", por ejemplo, calcula el número de enlaces activos al "Asunto".
Ventajas y desventajas de usar
Beneficios
Desventajas
- Aumento dramático en el tiempo de respuesta.
Alcance
El patrón Proxy se puede usar cuando se trabaja con una conexión de red, con un objeto enorme en la memoria (o en el disco), o con cualquier otro recurso que sea difícil o difícil de copiar. Un caso de uso bien conocido es un objeto que cuenta el número de referencias.
Proxy y patrones relacionados [1]
- Un adaptador proporciona una interfaz distinta a un objeto.
- El proxy proporciona la misma interfaz.
- El decorador proporciona una interfaz extendida.
Ejemplos de implementación
Ejemplo de implementación
clase pública Principal {
public static void main ( String [] args ) {
// Crear proxy matemático
IMath p = new MathProxy ();
// Haz el sistema matemático . fuera _ println ( "4 + 2 = " + p . sumar ( 4 , 2 ));
sistema _ fuera _ println ( "4 - 2 = " + p . sub ( 4 , 2 ));
sistema _ fuera _ println ( "4 * 2 = " + p . mul ( 4 , 2 ));
sistema _ fuera _ println ( "4/2 = " + p . div ( 4 , 2 ));
}
}
/**
* "Asunto"
*/
interfaz pública IMath {
public double add ( doble x , doble y );
public double sub ( doble x , doble y );
público doble mul ( doble x , doble y );
público doble div ( doble x , doble y );
}
/**
* "Sujeto Real"
*/
public class Math implementa IMath {
public double add ( double x , double y ) {
return x + y ;
}
public double sub ( doble x , doble y ) {
return x - y ;
}
public double mul ( doble x , doble y ) {
return x * y ;
}
public double div ( doble x , doble y ) {
return x / y ;
}
}
/**
* "Objeto Proxy"
*/ la
clase pública MathProxy implementa IMath {
matemáticas matemáticas privadas ;
public double add ( doble x , doble y ) {
lazyInitMath ();
matemáticas de retorno . sumar ( x , y ); }
public double sub ( doble x , doble y ) {
lazyInitMath ();
matemáticas de retorno . sub ( x , y ); }
public double mul ( doble x , doble y ) {
lazyInitMath ();
matemáticas de retorno . mu ( x , y ); }
public double div ( doble x , doble y ) {
lazyInitMath ();
matemáticas de retorno . div ( x , y ); }
private void lazyInitMath () {
if ( matemáticas == nulo ) {
matemáticas = new Math ();
}
}
}
Ejemplo de implementación
object Main extiende la aplicación {
val p : IMath = new MathProxy
System . fuera _ println ( "4 + 2 = " + p . sumar ( 4 , 2 ))
Sistema . fuera _ println ( "4 - 2 = " + p . sub ( 4 , 2 ))
Sistema . fuera _ println ( "4 * 2 = " + p . mul ( 4 , 2 ))
Sistema . fuera _ println ( "4/2 = " + p . div ( 4 , 2 ))
}
/**
* "Sujeto"
*/
rasgo IMath {
def add ( x : Doble , y : Doble ): Doble
def sub ( x : Doble , y : Doble ): Doble
def mul ( x : Doble , y : Doble ): Doble
def div ( x : Doble , y : Doble ): Doble
}
/**
* "Sujeto real"
*/
class Math extiende IMath {
def add ( x : Double , y : Double ) = x + y
def sub ( x : Doble , y : Doble ) = x - y
def mul ( x : Doble , y : Doble ) = x * y
def div ( x : Doble , y : Doble ) = x / y
}
/**
* "Objeto Proxy"
*/
class MathProxy extiende IMath {
private lazy val math = new Math
def sumar ( x : doble , y : doble ) = matemáticas . sumar ( x , y )
def sub ( x : Doble , y : Doble ) = matemática . sub ( x , y )
def mul ( x : Doble , y : Doble ) = matemáticas . mul ( x , y )
def div ( x : Doble , y : Doble ) = matemáticas . división ( x , y )
}
Ejemplo de implementación
/**
* "Asunto"
*/
clase IMath {
público :
suma doble virtual ( doble , doble ) = 0 ;
sub doble virtual ( doble , doble ) = 0 ;
doble virtual mul ( doble , doble ) = 0 ;
div doble virtual ( doble , doble ) = 0 ;
};
/**
* "Sujeto real"
*/
clase Matemáticas : public IMath {
público :
suma doble virtual ( doble x , doble y ) {
devuelve x + y _
}
sub doble virtual ( doble x , doble y ) {
devuelve x - y ;
}
doble virtual mul ( doble x , doble y ) {
volver x * y _
}
div doble virtual ( doble x , doble y ) {
volver x / y _
}
};
/**
* "Objeto proxy"
*/
clase MathProxy : public IMath {
público :
Proxy matemático ()
{
matemática = nueva matemática ();
}
virtual ~ MathProxy ()
{
eliminar matemáticas ;
}
suma doble virtual ( doble x , doble y ) {
devolver matemáticas -> agregar ( x , y );
}
sub doble virtual ( doble x , doble y ) {
devuelve matemática -> sub ( x , y );
}
doble virtual mul ( doble x , doble y ) {
devuelve matemáticas -> mul ( x , y );
}
div doble virtual ( doble x , doble y ) {
devuelve matemática -> div ( x , y );
}
privado :
IMath * matemáticas ;
};
#incluir <iostream>
usando std :: cout ;
usando std :: endl ;
int principal () {
// Crear proxy matemático
IMath * proxy = new MathProxy ();
// Haz el cálculo matemático
<< "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 ;
eliminar proxy ;
devolver 0 ;
}
Ejemplo de implementación
utilizando el sistema ;
utilizando System.Threading ;
class MainApp
{
static void Main ()
{
// Crear proxy matemático
IMath p = new MathProxy ();
// Haz la consola matemática . WriteLine ( "4 + 2 = " + p . Sumar ( 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 ));
// Esperar a la
Consola del usuario . leer ();
}
}
/// <summary>
/// Subject - subject
/// </summary>
/// <remarks>
/// <li>
/// <lu> define un común para <see cref="Math"/> y <ver cref="Proxy"/> interfaz para que la clase
/// <ver cref="Proxy"/> se pueda usar en cualquier lugar <ver cref="Math"/></lu>
/// </ li>
/ // </observaciones>
interfaz pública IMath { double Add ( double x , double y ); doble Sub ( doble x , doble y ); doble Mul ( doble x , doble y ); doble Div ( doble x , doble y ); }
/// <summary>
/// RealSubject - objeto real
/// </summary>
/// <remarks>
/// <li>
/// <lu>define el objeto real representado por el proxy</lu>
// / </li>
/// </remarks>
class Math : IMath
{
public Math ()
{
Console . WriteLine ( "Crear objeto Math. Espera..." );
hilo _ Dormir ( 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 ( doble x , doble y ){ return x / y ;}
}
/// <summary>
/// Proxy es un proxy
/// </summary>
/// <remarks>
/// <li>
/// <lu> almacena una referencia que permite que el proxy se refiera a lo real
/// asunto. El objeto de clase <ver cref="MathProxy"/> puede referirse al objeto de clase
/// <ver cref="IMath"/> si las interfaces de clase <ver cref="Math"/> y <ver cref="IMath"/ > son iguales;</lu>
/// <lu>proporciona una interfaz idéntica a la de <see cref="IMath"/>, de modo que
siempre se puede proporcionar un proxy /// en lugar del asunto real;</ lu>
/// < lu>controla el acceso al tema real y puede ser responsable de crear
/// y borrarlo;</lu>
/// <lu>otras funciones dependen del tipo de proxy:
/// < li>
/// <lu><b >proxy remoto</b> es responsable de codificar la solicitud y sus argumentos
/// y enviar la solicitud codificada al sujeto real
/// en un espacio de direcciones diferente;</lu >
/// <lu><b>el proxy virtual</b> puede almacenar en caché
/// información adicional sobre el tema real para retrasar su creación.</lu>
/// <lu><b>proxy de protección</b > comprueba si la persona que llama
/// tiene los permisos necesarios para realizar la solicitud; </lu>
/// </li>
/// </lu>
/// </li>
/// < /observaciones>
class MathProxy : IMath
{
Math math ;
MathProxy público ()
{
matemáticas = nulo ;
}
/// <summary>
/// Operación rápida: no requiere un sujeto real
/// </summary>
/// <param name="x"></param>
/// <param name="y" >< /param>
/// <devoluciones></devoluciones>
public double Add ( double x , double y )
{
return x + y ;
}
public double Sub ( doble x , doble y )
{
return x - y ;
}
/// <summary>
/// Operación lenta: requiere la creación de un sujeto real
/// </summary>
/// <param name="x"></param>
/// <param name="y" >< /param>
/// <devoluciones></devoluciones>
public double Mul ( double x , double y )
{
if ( math == null )
math = new Math ();
matemáticas de retorno . Mu ( x , y ); }
public double Div ( doble x , doble y )
{
if ( math == null )
math = new Math ();
matemáticas de retorno . División ( x , y ); } }
Ejemplo de implementación
/* Asunto */
class IMath {
add ( x , y ) {}
sub ( x , y ) {}
}
/* Sujeto real */
class RMath extends IMath {
add ( x , y ) {
return x + y ;
}
sub ( x , y ) {
devuelve x - y ;
}
}
/* Proxy */
clase MathProxy extiende IMath {
matemáticas = nuevo RMath ()
agregar ( x , y ) {
devuelve esto . matemáticas _ add ( x , y )
}
sub ( x , y ) {
devuelve esto . matemáticas _ sub ( x , y )
}
}
const prueba = new MathProxy ()
alerta ( prueba . agregar ( 3 , 2 )) // 5
alerta ( prueba . sub ( 3 , 2 )) // 1
Ejemplo de implementación
módulo ProxyPattern
# Proxy tiene la misma interfaz que un sujeto real
#
Cuenta de clase de sujeto real attr_reader : saldo
def inicializar ( saldo = 0 )
@saldo = fin del saldo
depósito def ( cantidad )
@saldo += cantidad
final
def retirar ( cantidad )
@saldo -= cantidad
final
final
protección del
módulo # Funcionalidad adicional para controlar el acceso al sujeto real
# Proxy
class AccountProxy
def initialize ( asunto , usuario_actual )
@asunto = asunto
@usuario_actual = usuario_actual
@saldo = 0
end
depósito def ( cantidad )
@subject . depósito ( cantidad ) si autorizar
fin
def retirar ( cantidad )
@subject . retirar ( cantidad ) si autorizar
fin
def equilibrar
@sujeto . final del saldo
privado
def Authorize
pone 'Acceso denegado' a menos que @current_user == ' admin' @current_user == 'admin' end end
def auto . ejecutar
pone '=> Proxy::Protection'
pone 'como usuario'
protected_account = AccountProxy . nueva ( Cuenta . nueva , 'usuario' )
cuenta_protegida . depósito ( 20 )
protected_account . retirar ( 10 )
pone la cuenta_protegida . balance
pone 'como administrador'
protected_account = AccountProxy . new ( Cuenta . new , 'admin' )
protected_account . depósito ( 20 )
protected_account . retirar ( 10 )
pone la cuenta_protegida . balance
pone ''
fin
fin
módulo Virtual
# Delay realSubject loading (lazy loading)
# Proxy
class AccountProxy
def initialize ( local_balance = 0 )
@local_balance = local_balance
end
depósito def ( cantidad )
@local_balance += cantidad
final
def retirar ( cantidad )
@local_balance -= cantidad
final
tema de equilibrio
def . final del saldo
def sujeto
@asunto ||= Cuenta . nuevo ( @local_balance )
_
_
def auto . ejecutar
pone '=> Proxy::Virtual'
cuenta_local = AccountProxy . nueva
cuenta_local . depósito ( 20 )
cuenta_local . retirar ( 10 )
cuenta_local . depósito ( 15 )
local_account . retirar ( 5 )
pone 'Todavía no hay una cuenta real:'
pone cuenta_local . inspeccionar
cuenta_local . saldo
pone 'Se creó la cuenta real:'
pone local_account . inspeccionar
pone ''
fin
fin
def auto . ejecutar
Protección . ejecutarVirtual ._
_ correr fin fin
Ejemplo de implementación
<?php
/// Asunto - asunto
/// define una interfaz común entre Math y "Proxy", de modo que
/// la clase "Proxy" se puede usar en cualquier lugar
interface IMath
{
function Add ( $x , $y );
función Sub ( $x , $y );
función Mul ( $x , $y );
función Div ( $x , $y );
}
/// RealSubject - el objeto real
/// define el objeto real representado por el proxy
class Math implementa IMath
{
función pública __construct () { print ( "Crear objeto Math. Espere..." ); dormir ( 5 ); }
función pública Agregar ( $x , $y ){ volver $x + $y ;}
función pública Sub ( $x , $y ){ volver $x - $y ;} función pública Mul ( $x , $y ){ volver $x * $y ;} función pública Div ( $x , $y ){ return $x / $y ;} }
/// Proxy - proxy
/// almacena un enlace que permite que el proxy se refiera al
/// asunto real. El objeto de clase "MathProxy" puede acceder al
objeto de clase /// "Math" si las interfaces de las clases "Math" e "IMath" son las mismas;
/// proporciona una interfaz idéntica a la interfaz "IMath", por lo
que siempre se puede proporcionar un proxy /// en lugar del sujeto real;
/// controla el acceso al tema real y puede ser responsable de crearlo
/// y borrarlo;
/// otras tareas dependen del tipo de proxy:
/// el proxy remoto es responsable de codificar la solicitud y sus argumentos
/// y enviar la solicitud codificada al sujeto real
/// en un espacio de direcciones diferente;
/// El proxy virtual puede almacenar en caché
/// información adicional sobre el sujeto real para retrasar su creación.
/// el proxy protector verifica si la persona que llama
/// tiene los permisos necesarios para ejecutar la solicitud;
class MathProxy implementa IMath
{
protected $math ;
public function __construct ()
{
$this -> math = null ;
}
/// Operación rápida: no requiere un sujeto real
función pública Add ( $x , $y ) { return $x + $y ; }
función pública Sub ( $x , $y )
{
return $x - $y ;
}
/// Operación lenta: requiere la creación de una función pública de sujeto real Mul ( $x , $y ) { if ( $this -> math == null ) $this -> math = new Math (); devuelve $esto -> matemática -> Mul ( $x , $y ); }
public function Div ( $x , $y )
{
if ( $this -> math == null )
$this -> math = new Math ();
devuelve $esto -> matemática -> Div ( $x , $y );
}
}
$p = nuevo MathProxy ;
// Haz la impresión matemática ( "4 + 2 = " . $p -> Suma ( 4 , 2 ));
imprimir ( "4 - 2 = " . $p -> Sub ( 4 , 2 ));
imprimir ( "4 * 2 = " . $p -> Mul ( 4 , 2 ));
imprimir ( "4/2 = " . $p -> Div ( 4 , 2 ));
?>
Ejemplo de implementación
//archivo IMath.as
paquete
{
interfaz pública IMath { function add ( a : Número , b : Número ) : Número ; función sub ( a : Número , b : Número ) : Número ; función mul ( a : Número , b : Número ) : Número ; función div ( a : Número , b : Número ) : Número ; } }
//file MathSubject.as
paquete
{
public class MathSubject implementa IMath
{
public function add ( a : Number , b : Number ) : Number
{
return a + b ;
}
public function sub ( a : Número , b : Número ) : Número
{
return a - b ;
}
public function mul ( a : Número , b : Número ) : Número
{
return a * b ;
}
public function div ( a : Número , b : Número ) : Número
{
return a / b ;
}
}
}
//file MathProxy.as
paquete
{
public class MathProxy implementa IMath
{
private var math : MathSubject ;
función pública MathProxy ()
{
matemáticas = new MathSubject ();
}
función pública sumar ( a : Número , b : Número ) : Número
{
return math . suma ( a , b );
}
función pública sub ( a : Número , b : Número ) : Número
{
return math . sub ( a , b );
}
public function mul ( a : Número , b : Número ) : Número
{
return math . mu ( a , b );
}
función pública div ( a : número , b : número ) : número
{
si ( b ! = 0 )
devuelve matemáticas . div ( a , b );
else
{
trace ( "División por cero." );
número de retorno ._ INFINITO_POSITIVO ; } } } }
//archivo Main.as
paquete
{
import flash.display.Sprite ;
clase pública Main extiende Sprite
{
public function Main ()
{
playWithMath ( new MathSubject ());
jugarConMath ( nuevo MathProxy ());
}
función pública playWithMath ( math : IMath ) : void
{
trace ( math . add ( 5 , 0 ));
rastrear ( matemáticas . sub ( 5 , 0 ));
rastrear ( matemáticas . mul ( 5 , 0 ));
rastrear ( matemáticas . div ( 5 , 0 ));
}
}
}
Ejemplo de implementación
# -*- codificación: utf-8 -*-
clase IMath :
"""Interfaz para proxy y sujeto real"""
def add ( self , x , y ):
aumentar NotImplementedError ()
def sub ( self , x , y ):
aumentar NotImplementedError ()
def mul ( self , x , y ):
aumentar NotImplementedError ()
def div ( self , x , y ):
aumentar NotImplementedError ()
class Math ( IMath ):
"""Sujeto real"""
def add ( self , x , y ):
devuelve x + y
def sub ( self , x , y ):
devuelve x - y
def mul ( self , x , y ):
devuelve x * y
def div ( self , x , y ):
devuelve x / y
class Proxy ( IMath ):
"""Proxy"""
def __init__ ( self ):
self . matemáticas = Matemáticas ()
def suma ( self , x , y ):
devuelve x + y
def sub ( self , x , y ):
devuelve x - y
def mul ( self , x , y ):
devuelve self . matemáticas _ mul ( x , y )
def div ( self , x , y ):
return float ( 'inf' ) if y == 0 else self . matemáticas _ división ( x , y )
p = Proxy ()
x , y = 4 , 2
print '4 + 2 = ' + str ( p . add ( x , y ))
print '4 - 2 = ' + str ( p . sub ( x , y ))
imprime '4 * 2 = ' + str ( p . mul ( x , y ))
imprime '4 / 2 = ' + str ( p . div ( x , y ))
Ejemplo de implementación
Importaciones Sistema.Roscado
Class MainApp
Shared Sub Main ()
' Crear proxy matemático
Dim p As IMath = New MathProxy ()
' Haz la consola de matemáticas . WriteLine ( "4 + 2 = " & p . Agregar ( 4 , 2 ))
Consola . WriteLine ( "4 - 2 = " & p . Subtr ( 4 , 2 ))
Consola . WriteLine ( "4 * 2 = " & p . Mul ( 4 , 2 ))
Consola . WriteLine ( "4/2 = " & p . Div ( 4 , 2 ))
'Esperar a la
Consola del usuario . Lectura ()
End Sub
End Class
''' <summary>
''' Asunto - el asunto de
''' </summary>
''' <comentarios>
''' <li>
''' <lu> define común a <see cref="Math"/ > y <see cref="Proxy"/> interfaz para que la clase
''' <see cref="Proxy"/> se pueda usar en cualquier lugar <see cref="Math"/></lu>
''' </ li>
''' </remarks>
Interfaz pública 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 As Double ) As Double Function Div ( ByVal x As Double , ByVal y As Double ) As Double End Interfaz
''' <summary>
''' RealSubject - el objeto real
''' </summary>
''' <remarks>
''' <li>
''' <lu>identifica el objeto real representado por el proxy</lu >
'' ' </li>
''' </remarks>
Class Math
implementa IMath
Public Sub New ()
Consola . WriteLine ( "Crear objeto Math. Espere..." )
Thread . Dormir ( 1000 )
Finalizar sub
Public Function Add ( ByVal x As Double , ByVal y As Double ) As Double Implementa IMath . Añadir
Retorno x + y
Función final
Función Pública Subtr ( ByVal x As Double , ByVal y As Double ) As Double Implementa IMath . Subtr
Retorno x - y
Función final
Función Pública Mul ( ByVal x As Double , ByVal y As Double ) As Double Implementa IMath . Mul
Return x * y
End Function
Public Function Div ( ByVal x As Double , ByVal y As Double ) As Double Implementa IMath . Div
Retorno x / y
Función final
clase final
''' <summary>
''' Proxy proxy
''' </summary>
''' <remarks>
''' <li>
''' <lu> almacena una referencia que permite que el proxy se refiera al real
'' ' sujeto . Un objeto de clase <ver cref="MathProxy"/> puede referirse a un objeto de clase
''' <ver cref="IMath"/> si la clase interactúa <ver cref="Math"/> y <ver cref= "IMath"/ > son iguales;</lu>
''' <lu>proporciona una interfaz idéntica a la de <see cref="IMath"/>, de modo que
siempre se puede proporcionar el marcador de posición ''' en lugar del sujeto real;</lu>
''' < lu>controla el acceso al sujeto real y puede ser responsable de su creación
''' y eliminación;</lu>
''' <lu>otras funciones dependen del tipo de proxy :
''' <li>
''' <lu><b >proxy remoto</b> es responsable de codificar la solicitud y sus argumentos
''' y enviar la solicitud codificada al sujeto real en un
espacio de direcciones diferente '' ';</lu>
''' <lu><b>el proxy virtual</b> puede almacenar en caché información adicional
''' sobre el sujeto real para retrasar su creación.</lu>
''' <lu><b> proxy de protección</b> comprueba si la persona que llama
''' tiene los permisos necesarios para realizar la solicitud; </lu>
''' </li>
''' </lu>
''' </li>
''' < /observaciones>
Class MathProxy
implementa IMath
Matemáticas privadas As Math = Nothing
''' <summary>
''' Operación rápida - no requiere un sujeto real
''' </summary>
Public Function Add ( ByVal x As Double , ByVal y As Double ) As Double Implementa IMath . Añadir
Retorno x + y
Función final
Función Pública Subtr ( ByVal x As Double , ByVal y As Double ) As Double Implementa IMath . Subtr
Retorno x - y
Función final
''' <summary>
''' Operación lenta - requiere la creación de un sujeto real
''' </summary>
Public Function Mul ( ByVal x As Double , ByVal y As Double ) As Double Implementa IMath . Mul
Si math no es nada Entonces
math = New Math ()
End If
Return math . Mul ( x , y )
Función final
Public Function Div ( ByVal x As Double , ByVal y As Double ) As Double Implementa IMath . Div
Si las matemáticas no son nada Entonces
matemáticas = New Math ()
End If
Return math . Div ( x , y )
Función final Clase final
Ejemplo de implementación
//
coincidencia de protocolo de asunto {
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
}
//
Clase de sujeto real MatchImp : Match {
func add ( x : Int , y : Int ) -> Int {
return x + y
}
func sub ( x : Int , y : Int ) -> Int {
retornar x - y
}
func mul ( x : Int , y : Int ) -> Int {
retornar x * y
}
func div ( x : Int , y : Int ) -> Int {
retornar x / y
}
}
//
Clase de proxy MatchProxy : Coincidencia {
privado dejar matemáticas = MatchImp ()
func add ( x : Int , y : Int ) -> Int {
return math . sumar ( 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 . mu ( x : x , y : y )
}
func div ( x : Int , y : Int ) -> Int {
return math . div ( x : x , y : y )
}
}
// usa proxy
let proxy = MatchProxy ()
print ( "7 * 8 = \( proxy . mul ( x : 8 , y : 7 )) " )
Véase también
- Programación posterior al objeto
Notas
- ↑ Diarios del desarrollador // Proxy (enlace descendente) . Consultado el 26 de mayo de 2010. Archivado desde el original el 14 de mayo de 2010. (indefinido)
Literatura
- CodeLIB.YOURS // Proxy Archivado el 14 de mayo de 2010 en Wayback Machine .
- E. Gamma, R. Helm, R. Johnson, J. Vlissides . Técnicas de diseño orientado a objetos. Design Patterns.=Design Patterns.Elementos de software orientado a objetos reutilizable. - San Petersburgo. : Pedro, 2001. - 368 p. — ISBN 5-272-00355-1 .
- Eric Freeman, Elizabeth Freeman, Kathy Siera, Bert Bates. Patrones de diseño. - San Petersburgo. : Pedro, 2012. - 656 p. - ISBN 978-5-459-00435-9 .
Enlaces