Arquetipo
Patrones estructuralesUso: Muy altaComplejidad: Media

Decorator

Decorador · Envoltorio

Añade responsabilidades a un objeto de forma dinámica, envolviéndolo en otros objetos que tienen la misma interfaz.

“Quiero sumar comportamiento (logs, reintentos, caché) sin tocar la clase.”

workEl caso real

Tu servicio consulta la API de un proveedor de tipos de cambio. Con el tiempo te piden registrar cada llamada en los logs, reintentar cuando el proveedor falla y guardar las respuestas en caché. No todos los usos necesitan todo: los reportes nocturnos no quieren caché y las pruebas no quieren reintentos.

warningEl problema sin el patrón

Los logs, los reintentos y la caché terminan dentro de ClienteTiposCambio, controlados con flags (usarCache, reintentar, log). La clase crece, cada combinación se prueba a mano y, para otra API, hay que copiar todo.

check_circleCómo lo resuelve el patrón

Cada capacidad es un decorador que implementa la misma interfaz que el cliente y envuelve a otro objeto: ConCache(ConReintentos(ApiTiposCambio)). Cada decorador hace su parte y delega en el que envuelve. Las combinaciones se arman al configurar la aplicación.

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
class ClienteTiposCambio {
  constructor(private usarCache: boolean, private reintentar: boolean, private log: boolean) {}

  async obtener(moneda: string) {
    if (this.usarCache && cache.has(moneda)) return cache.get(moneda);
    if (this.log) console.log('GET', moneda);
    // bucle de reintentos + llamada HTTP + guardar en caché... todo mezclado
  }
}
check_circleCon el patrónDESPUÉS
interface FuenteTiposCambio {
  obtener(moneda: string): Promise<number>;
}

class ConReintentos implements FuenteTiposCambio {
  constructor(private interno: FuenteTiposCambio, private intentos = 3) {}
  async obtener(moneda: string) {
    for (let i = 1; ; i++) {
      try { return await this.interno.obtener(moneda); }
      catch (error) { if (i >= this.intentos) throw error; }
    }
  }
}

class ConCache implements FuenteTiposCambio {
  private cache = new Map<string, number>();
  constructor(private interno: FuenteTiposCambio) {}
  async obtener(moneda: string) {
    if (!this.cache.has(moneda)) this.cache.set(moneda, await this.interno.obtener(moneda));
    return this.cache.get(moneda)!;
  }
}

// Cada contexto arma la combinación que necesita
const fuente = new ConCache(new ConReintentos(new ApiTiposCambio()));

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

thumb_upCuándo usarlo

  • ✓Quieres añadir responsabilidades transversales (logs, caché, reintentos, métricas, permisos) sin cambiar el objeto.
  • ✓Necesitas combinar esas capacidades de formas distintas según el contexto.

do_not_disturb_onCuándo no usarlo

  • ✕El orden de los decoradores importa y es difícil de controlar: ConCache(ConReintentos(x)) no se comporta igual que ConReintentos(ConCache(x)).
  • ✕Necesitas quitar o consultar un decorador concreto de en medio de la pila: el patrón no lo facilita.
  • ✕Solo hay una combinación posible: una clase simple es más clara.

memoryPrincipios en juego

  • •Responsabilidad única: cada decorador hace una sola cosa.
  • •Abierto/Cerrado: sumas comportamiento sin modificar la clase original.
  • •Composición sobre herencia: las combinaciones se arman en tiempo de ejecución, no con subclases.

hubPatrones relacionados

  • •Adapter: cambia la interfaz; Decorator la mantiene y añade comportamiento.
  • •Proxy: misma estructura, pero controla el acceso al objeto; los decoradores los elige y combina el cliente.
  • •Chain of Responsibility: parecido, pero en la cadena cualquier eslabón puede cortar el flujo; un decorador normalmente siempre delega.
  • •Composite: también envuelve objetos, pero agrupa varios hijos en lugar de uno.
compare_arrowsSe suele confundir conDecorator vs Proxy / 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_blocksDecorator en tu lenguaje

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

LO IDIOMÁTICO EN TYPESCRIPT: Cada decorador es una clase pequeña que implementa la misma interfaz y recibe al envuelto por constructor. Ojo: no confundir con los decoradores @ de TypeScript, que son otra cosa (anotaciones sobre clases y métodos).

decorator.ts · 56 líneas
export interface FuenteTiposCambio {
  obtener(moneda: string): Promise<number>;
}

class ApiTiposCambio implements FuenteTiposCambio {
  #llamadas = 0;
  async obtener(moneda: string): Promise<number> {
    this.#llamadas++;
    if (this.#llamadas === 1) throw new Error('Tiempo de espera agotado'); // el proveedor falla a veces
    return moneda === 'USD' ? 3.75 : 4.05;
  }
}

class ConReintentos implements FuenteTiposCambio {
  constructor(private readonly interno: FuenteTiposCambio, private readonly intentos = 3) {}

  async obtener(moneda: string): Promise<number> {
    for (let intento = 1; ; intento++) {
      try {
        return await this.interno.obtener(moneda);
      } catch (error) {
        if (intento >= this.intentos) throw error;
        console.log(`  reintento ${intento}...`);
      }
    }
  }
}

class ConCache implements FuenteTiposCambio {
  readonly #cache = new Map<string, { valor: number; expira: number }>();
  constructor(private readonly interno: FuenteTiposCambio, private readonly ttlMs = 5 * 60_000) {}

  async obtener(moneda: string): Promise<number> {
    const guardado = this.#cache.get(moneda);
    if (guardado && guardado.expira > Date.now()) return guardado.valor;
    const valor = await this.interno.obtener(moneda);
    this.#cache.set(moneda, { valor, expira: Date.now() + this.ttlMs });
    return valor;
  }
}

class ConLog implements FuenteTiposCambio {
  constructor(private readonly interno: FuenteTiposCambio) {}

  async obtener(moneda: string): Promise<number> {
    console.log(`→ consultando ${moneda}`);
    return this.interno.obtener(moneda);
  }
}

// ── Uso ──
// El orden importa: la caché va por fuera para no registrar ni reintentar lo que ya está guardado.
const fuente = new ConCache(new ConLog(new ConReintentos(new ApiTiposCambio())));

console.log(await fuente.obtener('USD')); // → consultando USD, reintento 1..., 3.75
console.log(await fuente.obtener('USD')); // 3.75 (desde la caché, sin llamar a la API)
Ver los 23 patrones en TypeScript →