Patrón Proxy

from abc import ABC, abstractmethod


class Imagen(ABC):
    @abstractmethod
    def nombre(self): ...

    @abstractmethod
    def mostrar(self): ...


class ImagenReal(Imagen):
    """El objeto real: crearlo es caro (lee el fichero entero en el constructor)."""
    def __init__(self, nombre):
        self._nombre = nombre
        print(f"  (cargando {nombre} desde el disco: 2 MB)")

    def nombre(self):
        return self._nombre

    def mostrar(self):
        print(f"  Mostrando {self._nombre}")


class ImagenProxy(Imagen):
    """El proxy: la misma interfaz, y no carga la imagen hasta que alguien la quiere ver."""
    def __init__(self, nombre):
        self._nombre = nombre
        self._real = None                          # None hasta que haga falta

    def nombre(self):
        return self._nombre                        # esto lo sabe sin cargar nada

    def mostrar(self):
        if self._real is None:
            self._real = ImagenReal(self._nombre)  # carga perezosa: solo la primera vez
        self._real.mostrar()


galeria = [ImagenProxy("playa.jpg"), ImagenProxy("montaña.jpg"), ImagenProxy("ciudad.jpg")]
print(f"Galería con {len(galeria)} fotos: {', '.join(i.nombre() for i in galeria)}")
print("Se abre la segunda foto:")
galeria[1].mostrar()
print("Se vuelve a abrir:")
galeria[1].mostrar()

/** El objeto real: crearlo es caro (lee el fichero entero en el constructor). */
class ImagenReal {
    constructor(nombre) {
        this._nombre = nombre;
        console.log(`  (cargando ${nombre} desde el disco: 2 MB)`);
    }
    nombre() { return this._nombre; }
    mostrar() { console.log(`  Mostrando ${this._nombre}`); }
}

/** El proxy: los mismos métodos, y no carga la imagen hasta que alguien la quiere ver. */
class ImagenProxy {
    #real = null;                                   // null hasta que haga falta
    constructor(nombre) { this._nombre = nombre; }

    nombre() { return this._nombre; }               // esto lo sabe sin cargar nada

    mostrar() {
        this.#real ??= new ImagenReal(this._nombre); // carga perezosa: solo la primera vez
        this.#real.mostrar();
    }
}

const galeria = [new ImagenProxy("playa.jpg"), new ImagenProxy("montaña.jpg"), new ImagenProxy("ciudad.jpg")];
console.log(`Galería con ${galeria.length} fotos: ${galeria.map((i) => i.nombre()).join(", ")}`);
console.log("Se abre la segunda foto:");
galeria[1].mostrar();
console.log("Se vuelve a abrir:");
galeria[1].mostrar();

using System;
using System.Collections.Generic;
using System.Linq;

interface IImagen {
    string Nombre { get; }
    void Mostrar();
}

// El objeto real: crearlo es caro (lee el fichero entero en el constructor).
class ImagenReal : IImagen {
    public string Nombre { get; }
    public ImagenReal(string nombre) {
        Nombre = nombre;
        Console.WriteLine(
quot;  (cargando {nombre} desde el disco: 2 MB)");
    }
    public void Mostrar() => Console.WriteLine(
quot;  Mostrando {Nombre}");
}

// El proxy: la misma interfaz, y no carga la imagen hasta que alguien la quiere ver.
class ImagenProxy : IImagen {
    private ImagenReal? real;                        // null hasta que haga falta
    public string Nombre { get; }                    // esto lo sabe sin cargar nada
    public ImagenProxy(string nombre) => Nombre = nombre;

    public void Mostrar() {
        real ??= new ImagenReal(Nombre);             // carga perezosa: solo la primera vez
        real.Mostrar();
    }
}

class Program {
    static void Main() {
        var galeria = new List<IImagen> { new ImagenProxy("playa.jpg"), new ImagenProxy("montaña.jpg"), new ImagenProxy("ciudad.jpg") };
        Console.WriteLine(
quot;Galería con {galeria.Count} fotos: {string.Join(", ", galeria.Select(i => i.Nombre))}");
        Console.WriteLine("Se abre la segunda foto:");
        galeria[1].Mostrar();
        Console.WriteLine("Se vuelve a abrir:");
        galeria[1].Mostrar();
    }
}

<?php
interface Imagen {
    public function nombre(): string;
    public function mostrar(): void;
}

/** El objeto real: crearlo es caro (lee el fichero entero en el constructor). */
class ImagenReal implements Imagen {
    public function __construct(private string $nombre) {
        echo "  (cargando $nombre desde el disco: 2 MB)\n";
    }
    public function nombre(): string { return $this->nombre; }
    public function mostrar(): void { echo "  Mostrando {$this->nombre}\n"; }
}

/** El proxy: la misma interfaz, y no carga la imagen hasta que alguien la quiere ver. */
class ImagenProxy implements Imagen {
    private ?ImagenReal $real = null;                 // null hasta que haga falta

    public function __construct(private string $nombre) {}

    public function nombre(): string { return $this->nombre; }   // esto lo sabe sin cargar nada

    public function mostrar(): void {
        $this->real ??= new ImagenReal($this->nombre);            // carga perezosa: solo la primera vez
        $this->real->mostrar();
    }
}

$galeria = [new ImagenProxy("playa.jpg"), new ImagenProxy("montaña.jpg"), new ImagenProxy("ciudad.jpg")];
echo "Galería con ", count($galeria), " fotos: ", implode(", ", array_map(fn (Imagen $i) => $i->nombre(), $galeria)), "\n";
echo "Se abre la segunda foto:\n";
$galeria[1]->mostrar();
echo "Se vuelve a abrir:\n";
$galeria[1]->mostrar();

class ProxyRegistro:
    """Un proxy genérico: delega cualquier atributo en el objeto real y registra cada llamada."""
    def __init__(self, real):
        self._real = real

    def __getattr__(self, nombre):              # solo se llama con lo que el proxy no tiene
        atributo = getattr(self._real, nombre)
        if callable(atributo):
            def envoltura(*args, **kwargs):
                print(f"Llamada a {nombre}{args}")
                return atributo(*args, **kwargs)
            return envoltura
        return atributo

# Django y SQLAlchemy usan objetos perezosos parecidos: la consulta no se lanza hasta que se usan los datos.

// JavaScript trae los proxies de serie: new Proxy(objeto, manejador) intercepta cada acceso
const alumno = { nombre: "Ana", nota: 8 };
const vigilado = new Proxy(alumno, {
    get(obj, prop) {
        console.log(`Lectura de ${String(prop)}`);
        return obj[prop];
    },
    set(obj, prop, valor) {
        if (prop === "nota" && (valor < 0 || valor > 10)) throw new RangeError("Nota fuera de rango");
        obj[prop] = valor;
        return true;
    },
});
vigilado.nota = 9;        // pasa por el proxy, que comprueba el valor
// Vue usa Proxy para saber qué datos cambian y volver a pintar solo lo necesario.

// Lazy<T> es un proxy virtual de la biblioteca: crea el objeto la primera vez que se pide Value
private readonly Lazy<Informe> informe = new(() => new Informe("ventas-2026.xlsx"));
public void Ver() => informe.Value.Mostrar();     // aquí se crea, y solo una vez

// Entity Framework crea proxies de tus entidades para cargar las relaciones al usarlas
// (UseLazyLoadingProxies), y DispatchProxy permite crear proxies de cualquier interfaz.

<?php
// __call recibe las llamadas a métodos que la clase no tiene: base de muchos proxies en PHP
class ProxyRegistro {
    public function __construct(private object $real) {}

    public function __call(string $metodo, array $args): mixed {
        echo "Llamada a $metodo\n";
        return $this->real->$metodo(...$args);
    }
}

// Doctrine (el ORM de Symfony) genera clases proxy de tus entidades para cargarlas al usarlas.