El Patrón Proxy en Java

// Sin proxy: todas las imágenes se cargan al crear el documento
public class Editor {
    private List<ImagenReal> imagenes = new ArrayList<>();

    public void abrirDocumento(String ruta) {
        // ⚠️ Carga TODAS las imágenes de disco inmediatamente
        for (String archivo : obtenerRutasImagenes(ruta)) {
            imagenes.add(new ImagenReal(archivo)); // Lectura costosa
        }
    }
}

        ┌─────────────────────┐
        │    <<interface>>     │
        │       Sujeto         │
        ├─────────────────────┤
        │ + operacion(): void  │
        └──────────┬──────────┘
                   │ implements
          ┌────────┴────────┐
          │                 │
┌─────────┴───────┐  ┌─────┴──────────────┐
│   SujetoReal    │  │      Proxy          │
├─────────────────┤  ├────────────────────┤
│ + operacion()   │  │ - sujetoReal: Sujeto│
│   // lógica real│  │ + operacion(): void │
└─────────────────┘  └────────────────────┘
                          │ usa ──▶ SujetoReal

public interface Imagen {
    void mostrar();
    int getAncho();
    int getAlto();
    String getNombre();
}

import java.io.File;

public class ImagenReal implements Imagen {
    private String rutaArchivo;
    private byte[] datosPixeles;
    private int ancho, alto;

    public ImagenReal(String rutaArchivo) {
        this.rutaArchivo = rutaArchivo;
        cargarDesdeArchivo();  // ⚠️ Operación costosa
    }

    private void cargarDesdeArchivo() {
        System.out.println("  [ImagenReal] Cargando: " + rutaArchivo);
        try { Thread.sleep(500); } catch (InterruptedException e) { }
        this.datosPixeles = new byte[1024 * 1024]; // 1 MB
        this.ancho = 1920;
        this.alto = 1080;
        System.out.println("  [ImagenReal] Cargada: " + ancho + "x" + alto);
    }

    @Override public void mostrar() {
        System.out.println("  [ImagenReal] Mostrando: " + rutaArchivo);
    }
    @Override public int getAncho()  { return ancho; }
    @Override public int getAlto()   { return alto; }
    @Override public String getNombre() {
        return new File(rutaArchivo).getName();
    }
}

public class ProxyImagen implements Imagen {
    private String rutaArchivo;
    private ImagenReal imagenReal;  // null hasta que se necesite

    public ProxyImagen(String rutaArchivo) {
        this.rutaArchivo = rutaArchivo;
        System.out.println("  [Proxy] Proxy creado para: " + rutaArchivo);
    }

    private void cargarSiNecesario() {
        if (imagenReal == null) {
            System.out.println("  [Proxy] Primera solicitud → cargando...");
            imagenReal = new ImagenReal(rutaArchivo);
        }
    }

    @Override public void mostrar() {
        cargarSiNecesario();
        imagenReal.mostrar();
    }
    @Override public int getAncho() {
        cargarSiNecesario();
        return imagenReal.getAncho();
    }
    @Override public int getAlto() {
        cargarSiNecesario();
        return imagenReal.getAlto();
    }
    @Override public String getNombre() {
        return new java.io.File(rutaArchivo).getName();
    }
}

public class DemoProxyVirtual {
    public static void main(String[] args) {
        System.out.println("=== Creando documento con 3 imágenes ===");
        Imagen img1 = new ProxyImagen("/fotos/paisaje_4k.jpg");
        Imagen img2 = new ProxyImagen("/fotos/retrato_hd.png");
        Imagen img3 = new ProxyImagen("/fotos/diagrama_uml.svg");

        System.out.println("\n=== Documento abierto (0 cargadas) ===");
        System.out.println("Nombre img1: " + img1.getNombre());

        System.out.println("\n=== Scroll hasta img2 ===");
        img2.mostrar();   // Carga por primera vez

        System.out.println("\n=== img2 de nuevo ===");
        img2.mostrar();   // Ya cargada — no recarga
    }
}

=== Creando documento con 3 imágenes ===
  [Proxy] Proxy creado para: /fotos/paisaje_4k.jpg
  [Proxy] Proxy creado para: /fotos/retrato_hd.png
  [Proxy] Proxy creado para: /fotos/diagrama_uml.svg

=== Documento abierto (0 cargadas) ===
Nombre img1: paisaje_4k.jpg

=== Scroll hasta img2 ===
  [Proxy] Primera solicitud → cargando...
  [ImagenReal] Cargando: /fotos/retrato_hd.png
  [ImagenReal] Cargada: 1920x1080
  [ImagenReal] Mostrando: /fotos/retrato_hd.png

=== img2 de nuevo ===
  [ImagenReal] Mostrando: /fotos/retrato_hd.png

public interface Documento {
    String leer();
    void escribir(String contenido);
    void eliminar();
}

public class DocumentoConfidencial implements Documento {
    private String contenido;
    private final String titulo;

    public DocumentoConfidencial(String titulo, String contenido) {
        this.titulo = titulo;
        this.contenido = contenido;
    }
    @Override public String leer() { return contenido; }
    @Override public void escribir(String nuevoContenido) {
        this.contenido = nuevoContenido;
        System.out.println("[Doc] Actualizado: " + titulo);
    }
    @Override public void eliminar() {
        this.contenido = null;
        System.out.println("[Doc] Eliminado: " + titulo);
    }
}

public class ProxyDocumentoProtegido implements Documento {
    private final DocumentoConfidencial docReal;
    private final String rolUsuario;

    public ProxyDocumentoProtegido(DocumentoConfidencial doc, String rol) {
        this.docReal = doc;
        this.rolUsuario = rol;
    }

    @Override public String leer() {
        if ("INVITADO".equals(rolUsuario)) {
            throw new SecurityException("Acceso denegado: invitados no pueden leer");
        }
        System.out.println("[Proxy] Lectura concedida a: " + rolUsuario);
        return docReal.leer();
    }

    @Override public void escribir(String contenido) {
        if (!"ADMIN".equals(rolUsuario) && !"EDITOR".equals(rolUsuario)) {
            throw new SecurityException("Rol " + rolUsuario + " no puede escribir");
        }
        System.out.println("[Proxy] Escritura concedida a: " + rolUsuario);
        docReal.escribir(contenido);
    }

    @Override public void eliminar() {
        if (!"ADMIN".equals(rolUsuario)) {
            throw new SecurityException("Solo ADMIN puede eliminar");
        }
        System.out.println("[Proxy] Eliminación concedida a: " + rolUsuario);
        docReal.eliminar();
    }
}

public interface ServicioClima {
    String obtenerTemperatura(String ciudad);
}

public class ServicioClimaReal implements ServicioClima {
    @Override
    public String obtenerTemperatura(String ciudad) {
        return "22°C en " + ciudad;
    }
}

public class ProxyServicioClima implements ServicioClima {
    private final String urlServidor;

    public ProxyServicioClima(String urlServidor) {
        this.urlServidor = urlServidor;
    }

    @Override
    public String obtenerTemperatura(String ciudad) {
        System.out.println("[ProxyRemoto] Petición a: " + urlServidor);
        // Aquí iría HttpClient, JSON, manejo de errores...
        try { Thread.sleep(200); } catch (InterruptedException e) { }
        return "22°C en " + ciudad + " (vía proxy remoto)";
    }
}

import java.util.HashMap;
import java.util.Map;

public interface RepositorioProductos {
    String buscarPorId(int id);
}

public class RepositorioProductosBD implements RepositorioProductos {
    @Override
    public String buscarPorId(int id) {
        System.out.println("  [BD] SELECT * FROM productos WHERE id=" + id);
        try { Thread.sleep(300); } catch (InterruptedException e) { }
        return "Producto #" + id + " (desde BD)";
    }
}

public class ProxyCacheProductos implements RepositorioProductos {
    private final RepositorioProductosBD repoReal;
    private final Map<Integer, String> cache = new HashMap<>();

    public ProxyCacheProductos(RepositorioProductosBD repo) {
        this.repoReal = repo;
    }

    @Override
    public String buscarPorId(int id) {
        if (cache.containsKey(id)) {
            System.out.println("  [Cache] HIT para id=" + id);
            return cache.get(id);
        }
        System.out.println("  [Cache] MISS → delegando a BD id=" + id);
        String resultado = repoReal.buscarPorId(id);
        cache.put(id, resultado);
        return resultado;
    }

    public void invalidar(int id) { cache.remove(id); }
    public void invalidarTodo()   { cache.clear(); }
}

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

// ── Interfaz común ──
public interface Recurso {
    String obtenerContenido();
    String getNombre();
    long getTamano();
}

// ── Sujeto Real ──
public class ArchivoGrande implements Recurso {
    private final String nombre;
    private final byte[] datos;

    public ArchivoGrande(String nombre) {
        this.nombre = nombre;
        System.out.println("    [Archivo] Cargando '" + nombre + "'...");
        try { Thread.sleep(800); } catch (InterruptedException e) { }
        this.datos = new byte[5 * 1024 * 1024]; // 5 MB
        System.out.println("    [Archivo] Cargado (" + getTamano()/1024 + " KB)");
    }
    @Override public String obtenerContenido() {
        return "Contenido de " + nombre + " (" + datos.length + " bytes)";
    }
    @Override public String getNombre() { return nombre; }
    @Override public long getTamano()   { return datos.length; }
}

// ── Proxy Virtual ──
public class ProxyVirtualRecurso implements Recurso {
    private final String nombre;
    private ArchivoGrande archivoReal;

    public ProxyVirtualRecurso(String nombre) { this.nombre = nombre; }

    private void cargarSiNecesario() {
        if (archivoReal == null) archivoReal = new ArchivoGrande(nombre);
    }
    @Override public String obtenerContenido() {
        cargarSiNecesario();
        return archivoReal.obtenerContenido();
    }
    @Override public String getNombre() { return nombre; }
    @Override public long getTamano()   {
        cargarSiNecesario();
        return archivoReal.getTamano();
    }
}

// ── Proxy de Registro ──
public class ProxyRegistroRecurso implements Recurso {
    private final Recurso recursoInterno;
    private final List<String> log = new ArrayList<>();
    private static final DateTimeFormatter FMT =
            DateTimeFormatter.ofPattern("HH:mm:ss.SSS");

    public ProxyRegistroRecurso(Recurso recurso) {
        this.recursoInterno = recurso;
    }
    @Override public String obtenerContenido() {
        String e = FMT.format(LocalDateTime.now()) + " → obtenerContenido()";
        log.add(e);
        System.out.println("    [Log] " + e);
        return recursoInterno.obtenerContenido();
    }
    @Override public String getNombre() { return recursoInterno.getNombre(); }
    @Override public long getTamano()   { return recursoInterno.getTamano(); }
    public List<String> getRegistro() { return List.copyOf(log); }
}

// ── Demo ──
public class DemoSistemaDocumental {
    public static void main(String[] args) {
        // Encadenamiento: Log → Virtual → ArchivoGrande
        var informe = new ProxyRegistroRecurso(
                new ProxyVirtualRecurso("informe_2025.pdf"));
        var presentacion = new ProxyRegistroRecurso(
                new ProxyVirtualRecurso("presentacion_q4.pptx"));

        System.out.println("1. Documentos registrados (no cargados)");
        System.out.println("   - " + informe.getNombre());
        System.out.println("   - " + presentacion.getNombre());

        System.out.println("\n2. Abriendo informe:");
        System.out.println("   " + informe.obtenerContenido());

        System.out.println("\n3. Informe de nuevo (ya cargado):");
        System.out.println("   " + informe.obtenerContenido());

        System.out.println("\n4. Presentación nunca se cargó ✅");

        System.out.println("\n5. Log de accesos:");
        informe.getRegistro().forEach(e -> System.out.println("   • " + e));
    }
}