Proxy pattern

Da Wikipedia, l'enciclopedia libera.

In informatica, il proxy pattern è un design pattern.

Un proxy, nella sua forma più generale è 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 è l'oggetto reference 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 sorgente]

Proxy pattern diagram.svg

Esempi[modifica | modifica sorgente]

Virtual proxy (in Java)[modifica | modifica sorgente]

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_Photo2
Displaying HiRes_10MB_Photo2

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_Photo2");   
 
        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 (in C#)[modifica | modifica sorgente]

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();
        }
    }
}

Voci correlate[modifica | modifica sorgente]

Collegamenti esterni[modifica | modifica sorgente]