Python: il Proxy Pattern

Il Proxy Pattern è un design pattern strutturale che consente di controllare l'accesso a un oggetto, fungendo da intermediario tra il client e l'oggetto reale. Questo può essere utile per scopi come il controllo dell'accesso, la gestione della memorizzazione nella cache, il monitoraggio dell'accesso e altro ancora. In questo articolo, esploreremo come implementare il Proxy Pattern in Python.

Concetto di Proxy Pattern

Il Proxy Pattern coinvolge due principali attori: il Proxy e il RealSubject (oggetto reale). Il Proxy implementa la stessa interfaccia dell'oggetto reale e funge da intermediario tra il client e l'oggetto reale. Può controllare l'accesso all'oggetto reale, eseguire operazioni aggiuntive prima o dopo l'accesso all'oggetto reale e persino gestire la creazione dell'oggetto reale.

Implementazione del Proxy Pattern in Python

Consideriamo un esempio in cui vogliamo controllare l'accesso a un oggetto Image che rappresenta un'immagine. Il nostro obiettivo è creare un proxy che verifichi se l'utente ha i diritti sufficienti per accedere all'immagine e, in caso affermativo, delega l'accesso all'oggetto RealImage, che rappresenta l'immagine effettiva.

# Interfaccia Image
class Image:
    def display(self):
        pass

# RealSubject
class RealImage(Image):
    def __init__(self, filename):
        self.filename = filename
        self.load_image()

    def load_image(self):
        print(f"Loading image from file: {self.filename}")

    def display(self):
        print(f"Displaying image: {self.filename}")

# Proxy
class ProxyImage(Image):
    def __init__(self, filename, user):
        self.filename = filename
        self.user = user
        self.real_image = None

    def display(self):
        if self.user_has_access():
            if self.real_image is None:
                self.real_image = RealImage(self.filename)
            self.real_image.display()
        else:
            print("Access denied.")

    def user_has_access(self):
        # Logica per verificare i diritti dell'utente
        return self.user == "admin"

In questo esempio, abbiamo l'interfaccia Image che definisce il metodo display. La classe RealImage implementa questa interfaccia e rappresenta l'oggetto reale che vogliamo proteggere. La classe ProxyImage funge da proxy e controlla l'accesso all'oggetto RealImage.

Il proxy verifica se l'utente ha i diritti di accesso prima di consentire l'accesso all'oggetto reale. Se l'utente ha i diritti, il proxy crea l'oggetto reale e inoltra la chiamata al metodo display. In caso contrario, il proxy restituisce un messaggio di "Accesso negato".

Utilizzo del Proxy Pattern

# Utilizzo del Proxy Pattern
user = "admin"
image_proxy = ProxyImage("example.jpg", user)
image_proxy.display()

Nell'esempio sopra, stiamo creando un proxy per l'immagine "example.jpg" e verifichiamo se l'utente ha i diritti di accesso come amministratore. Se l'utente è un amministratore, il proxy caricherà l'oggetto reale e visualizzerà l'immagine. In caso contrario, verrà visualizzato un messaggio di "Accesso negato".

Conclusioni

Il Proxy Pattern è un modo potente per controllare l'accesso agli oggetti e aggiungere funzionalità aggiuntive senza modificare l'oggetto reale. Può essere utilizzato per implementare meccanismi di sicurezza, caching, monitoraggio e altro ancora. Nell'esempio sopra, abbiamo visto come implementare il Proxy Pattern in Python per controllare l'accesso a un'immagine, ma le applicazioni del pattern sono estremamente versatili e possono essere adattate a una vasta gamma di scenari.