Proxy pattern
In informatica, il proxy pattern è un design pattern.
Nella sua forma più generale, un proxy è una classe che funziona come interfaccia per qualcos'altro. L'altro potrebbe essere qualunque cosa: una connessione di rete, un grosso oggetto in memoria, un file e altre risorse che sono costose o impossibili da duplicare.
Un esempio ben conosciuto di proxy pattern è la tecnica reference counting dei puntatori.
Nelle situazioni in cui molte copie di un oggetto complesso devono esistere, il proxy pattern può essere adottato per incorporare il Flyweight pattern per ridurre l'occupazione di memoria dell'oggetto. Tipicamente viene creata un'istanza di oggetto complesso, e molteplici oggetti proxy, ognuno dei quali contiene un riferimento al singolo oggetto complesso. Ogni operazione svolta sui proxy viene trasmessa all'oggetto originale. Una volta che tutte le istanze del proxy sono distrutte, l'oggetto in memoria può essere deallocato.
Diagramma[modifica | modifica wikitesto]
Esempi[modifica | modifica wikitesto]
Virtual proxy (in Java)[modifica | modifica wikitesto]
Il seguente esempio Java illustra il pattern "virtual proxy". L'output del programma è:
Loading HiRes_10MB_Photo1 Displaying HiRes_10MB_Photo1 Loading HiRes_10MB_Photo2 Displaying HiRes_10MB_Photo2 Displaying HiRes_10MB_Photo1 Displaying HiRes_10MB_Photo2 Loading HiRes_10MB_Photo3 Displaying HiRes_10MB_Photo3
La classe ProxyImage è utilizzata per ritardare l'operazione (onerosa) di caricamento di un file dal disco finché il risultato di questa operazione non è effettivamente necessario. Se il file non è mai necessario, il caricamento risulta essere completamente eliminato.
import java.util.*;
interface Image {
public void displayImage();
}
class RealImage implements Image {
private String filename;
public RealImage(String filename) {
this.filename = filename;
loadImageFromDisk();
}
private void loadImageFromDisk() {
// Potentially expensive operation
// ...
System.out.println("Loading "+filename);
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void displayImage() { System.out.println("Displaying "+filename); }
}
class ProxyImage implements Image {
private String filename;
private RealImage image;
public ProxyImage(String filename) { this.filename = filename; }
public void displayImage() {
if (image == null) {
image = new RealImage(filename); // load only on demand
}
image.displayImage();
}
}
class ProxyExample {
public static void main(String[] args) {
Image image1 = new ProxyImage("HiRes_10MB_Photo1");
Image image2 = new ProxyImage("HiRes_10MB_Photo2");
Image image3 = new ProxyImage("HiRes_10MB_Photo3");
image1.displayImage(); // loading necessary
image2.displayImage(); // loading necessary
image1.displayImage(); // no loading necessary; already done
image2.displayImage(); // no loading necessary; already done
image3.displayImage(); // loading necessary
}
}
Protection proxy[modifica | modifica wikitesto]
In questo esempio scritto in C#, nella classe RealClient è memorizzato un numero di conto. Soltanto gli utenti che conoscono una password valida possono accedere a questo conto. Il RealClient è protetto dal ProtectionProxy che conosce la password. Prima di far leggere il numero di conto all'utente, il proxy richiede che questi si autentichi; Solo se la password introdotta è corretta il proxy invoca il RealClient per restituire il numero di conto all'utente.
In questo esempio thePassword è la password corretta
using System;
namespace ConsoleApplicationTest.FundamentalPatterns.ProtectionProxyPattern
{
public interface IClient {
string GetAccountNo();
}
public class RealClient : IClient {
private string accountNo = "12345";
public RealClient() {
Console.WriteLine("RealClient: Initialized");
}
public string GetAccountNo() {
Console.WriteLine("RealClient's AccountNo: " + accountNo);
return accountNo;
}
}
public class ProtectionProxy : IClient
{
private string password; //password to get secret
RealClient client;
public ProtectionProxy(string pwd) {
Console.WriteLine("ProtectionProxy: Initialized");
password = pwd;
client = new RealClient();
}
// Authenticate the user and return the Account Number
public String GetAccountNo() {
Console.Write("Password: ");
string tmpPwd = Console.ReadLine();
if (tmpPwd == password) {
return client.GetAccountNo();
} else {
Console.WriteLine("ProtectionProxy: Illegal password!");
return "";
}
}
}
class ProtectionProxyExample
{
[STAThread]
public static void Main(string[] args) {
IClient client = new ProtectionProxy("thePassword");
Console.WriteLine();
Console.WriteLine("main received: " + client.GetAccountNo());
Console.WriteLine("\nPress any key to continue . . .");
Console.Read();
}
}
}
Segue lo stesso esempio implementato in Java, in questo caso le implementazioni dell'interfaccia Client sono RealClientImpl e ProtectionProxyClientImpl .
package fundamentalPatterns.protectionProxyPattern;
import java.util.Scanner;
public interface Client {
String getAccountNo();
}
public class RealClientImpl implements Client {
private String accountNo = "12345";
public RealClientImpl() {
System.out.println("RealClient: Initialized");
}
@Override
public String getAccountNo() {
System.out.println("RealClient's AccountNo: " + accountNo);
return accountNo;
}
}
public class ProtectionProxyClientImpl implements Client {
private String password; //password to get secret
private Client client;
private Scanner scanner = new Scanner(System.in);
public ProtectionProxyClientImpl(String pwd) {
System.out.println("ProtectionProxy: Initialized");
password = pwd;
client = new RealClientImpl();
}
/**
* Authenticate the user and return the Account Number
*/
@Override
public String getAccountNo() {
System.out.print("Password: ");
String tmpPwd = scanner.nextLine();
if (password == null || password.equals(tmpPwd)) {
return client.getAccountNo();
} else {
System.out.println("ProtectionProxy: Illegal password!");
return "";
}
}
}
public class ProtectionProxyExample {
public static void main(String[] args) {
Client client = new ProtectionProxyClientImpl("thePassword");
System.out.println();
System.out.println("main received: " + client.getAccountNo());
}
}
Voci correlate[modifica | modifica wikitesto]
Altri progetti[modifica | modifica wikitesto]
Wikimedia Commons contiene immagini o altri file su proxy pattern
Collegamenti esterni[modifica | modifica wikitesto]
- (EN) Proxy pattern in Java, su wiki.java.net. URL consultato l'11 giugno 2008 (archiviato dall'url originale il 28 aprile 2010).
- (EN) Proxy pattern in UML e in LePUS3 (un linguaggio di modellazione formale) (XML), su lepus.org.uk. URL consultato l'11 giugno 2008 (archiviato dall'url originale il 3 ottobre 2011).