Arquetipo
Patrones estructuralesUso: AltaComplejidad: Media

Proxy

Sustituto · Intermediario

Proporciona un sustituto de otro objeto para controlar el acceso a él: carga perezosa, permisos, caché o acceso remoto.

“Necesito controlar el acceso a un objeto: carga perezosa, permisos o caché.”

workEl caso real

El sistema de una red de clínicas muestra la historia clínica de cada paciente: datos, diagnósticos y estudios de imagen que pesan cientos de megas en un almacenamiento externo. Hay dos reglas: solo el médico tratante puede ver la historia, y las imágenes no deben descargarse hasta que alguien las abra.

warningEl problema sin el patrón

El repositorio descarga todo al cargar al paciente, aunque el médico solo mire los datos generales. Y la verificación de permisos está copiada en cada controlador: basta que un endpoint nuevo la olvide para exponer datos sensibles.

check_circleCómo lo resuelve el patrón

Un ProxyHistoriaClinica implementa la misma interfaz que la historia real. Comprueba los permisos antes de cada acceso (proxy de protección) y no descarga las imágenes hasta que se piden (proxy virtual). El resto del sistema no distingue el proxy del objeto real.

schemaDiagrama de clases

Diagrama interactivo: puedes acercar, mover el lienzo y pasar el cursor sobre cada clase para ver su detalle.

codeEl código, antes y después

cancelSin el patrónANTES
// Repetido en cada controlador
if (!usuario.esMedicoTratante(pacienteId)) throw new AccesoDenegado();
const historia = await repo.cargarCompleta(pacienteId); // descarga también las imágenes
return historia.diagnosticos();
check_circleCon el patrónDESPUÉS
interface HistoriaClinica {
  diagnosticos(): Diagnostico[];
  imagenes(): Promise<Imagen[]>;
}

class ProxyHistoriaClinica implements HistoriaClinica {
  private cache?: Imagen[];
  constructor(private real: HistoriaClinicaReal, private usuario: Usuario) {}

  diagnosticos() {
    this.verificarAcceso();
    return this.real.diagnosticos();
  }

  async imagenes() {
    this.verificarAcceso();
    return (this.cache ??= await this.real.imagenes()); // carga perezosa
  }

  private verificarAcceso() {
    if (!this.usuario.esMedicoTratante(this.real.pacienteId)) throw new AccesoDenegado();
  }
}

Ejemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.

thumb_upCuándo usarlo

  • ✓Proxy virtual: el objeto es costoso de crear o cargar y no siempre se usa.
  • ✓Proxy de protección: el acceso depende de los permisos de quien lo pide.
  • ✓Proxy remoto, de caché o de registro: el objeto vive en otro servicio, sus respuestas se pueden reutilizar o quieres dejar constancia de cada llamada.
  • ✓Referencia inteligente: liberar un objeto costoso cuando ya nadie lo está usando.

do_not_disturb_onCuándo no usarlo

  • ✕El objeto es barato y no necesita ningún control: el proxy solo añade una capa.
  • ✕La latencia es crítica y cada indirección cuenta.

memoryPrincipios en juego

  • •Responsabilidad única: el control de acceso y la carga perezosa salen del objeto real.
  • •Abierto/Cerrado: añades controles sin modificar la clase real ni a sus clientes.

hubPatrones relacionados

  • •Decorator: misma forma, pero el decorador añade comportamiento que elige el cliente y el proxy controla el acceso.
  • •Adapter: ofrece una interfaz distinta; Proxy ofrece la misma.
  • •Facade: también se coloca delante de algo, pero para simplificar un subsistema completo.
compare_arrowsSe suele confundir conProxy vs Decorator / Adapter →

quizPon a prueba lo que leíste

Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.

Más ejercicios →

code_blocksProxy en tu lenguaje

El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.

LO IDIOMÁTICO EN TYPESCRIPT: El proxy es una clase que implementa la misma interfaz que el objeto real; ??= resuelve la carga perezosa en una línea. JavaScript también ofrece el objeto nativo Proxy, útil para interceptar cualquier propiedad de forma genérica, pero una clase explícita es más clara y tipada.

proxy.ts · 62 líneas
interface Usuario { id: string; pacientesAsignados: string[] }
interface Imagen { nombre: string; megas: number }

export interface HistoriaClinica {
  readonly pacienteId: string;
  diagnosticos(): string[];
  imagenes(): Promise<Imagen[]>;
}

class HistoriaClinicaReal implements HistoriaClinica {
  constructor(readonly pacienteId: string) {}

  diagnosticos(): string[] {
    return ['Hipertensión controlada'];
  }

  async imagenes(): Promise<Imagen[]> {
    console.log('  (descargando estudios del almacenamiento...)');
    return [{ nombre: 'resonancia-2026-10.dcm', megas: 340 }];
  }
}

export class ProxyHistoriaClinica implements HistoriaClinica {
  #imagenes?: Imagen[];

  constructor(private readonly real: HistoriaClinica, private readonly usuario: Usuario) {}

  get pacienteId(): string {
    return this.real.pacienteId;
  }

  diagnosticos(): string[] {
    this.#verificarAcceso();
    return this.real.diagnosticos();
  }

  async imagenes(): Promise<Imagen[]> {
    this.#verificarAcceso();
    return (this.#imagenes ??= await this.real.imagenes()); // solo se descarga la primera vez
  }

  #verificarAcceso(): void {
    if (!this.usuario.pacientesAsignados.includes(this.real.pacienteId)) {
      throw new Error(`Acceso denegado a la historia ${this.real.pacienteId}`);
    }
  }
}

// ── Uso ──
const medica: Usuario = { id: 'dra-rios', pacientesAsignados: ['P-77'] };
const historia: HistoriaClinica = new ProxyHistoriaClinica(new HistoriaClinicaReal('P-77'), medica);

console.log(historia.diagnosticos());             // no descarga imágenes
console.log((await historia.imagenes()).length);  // descarga
console.log((await historia.imagenes()).length);  // reutiliza lo ya cargado

const ajena = new ProxyHistoriaClinica(new HistoriaClinicaReal('P-90'), medica);
try {
  ajena.diagnosticos();
} catch (error) {
  console.log((error as Error).message); // Acceso denegado a la historia P-90
}
Ver los 23 patrones en TypeScript →