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
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
}
}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.
quizPon a prueba lo que leíste
Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.
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).
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)LO IDIOMÁTICO EN C# / .NET: Cada decorador es una clase que implementa la misma interfaz y recibe al envuelto por su constructor primario. Es el mismo diseño de DelegatingHandler en HttpClient, donde librerías como Polly añaden reintentos o caché como capas. El filtro de excepciones when decide si se reintenta.
IFuenteTiposCambio fuente = new ConCache(new ConLog(new ConReintentos(new ApiTiposCambio())), TimeSpan.FromMinutes(5));
Console.WriteLine(await fuente.ObtenerAsync("USD")); // → consultando USD, reintento 1..., 3.75
Console.WriteLine(await fuente.ObtenerAsync("USD")); // 3.75 (desde la caché)
public interface IFuenteTiposCambio
{
Task<decimal> ObtenerAsync(string moneda);
}
public class ApiTiposCambio : IFuenteTiposCambio
{
private int _llamadas;
public Task<decimal> ObtenerAsync(string moneda)
{
if (++_llamadas == 1) throw new TimeoutException("Tiempo de espera agotado"); // el proveedor falla a veces
return Task.FromResult(moneda == "USD" ? 3.75m : 4.05m);
}
}
public class ConReintentos(IFuenteTiposCambio interno, int intentos = 3) : IFuenteTiposCambio
{
public async Task<decimal> ObtenerAsync(string moneda)
{
for (var intento = 1; ; intento++)
{
try
{
return await interno.ObtenerAsync(moneda);
}
catch (TimeoutException) when (intento < intentos)
{
Console.WriteLine($" reintento {intento}...");
}
}
}
}
public class ConCache(IFuenteTiposCambio interno, TimeSpan duracion) : IFuenteTiposCambio
{
private readonly Dictionary<string, (decimal Valor, DateTime Expira)> _cache = [];
public async Task<decimal> ObtenerAsync(string moneda)
{
if (_cache.TryGetValue(moneda, out var guardado) && guardado.Expira > DateTime.UtcNow)
return guardado.Valor;
var valor = await interno.ObtenerAsync(moneda);
_cache[moneda] = (valor, DateTime.UtcNow + duracion);
return valor;
}
}
public class ConLog(IFuenteTiposCambio interno) : IFuenteTiposCambio
{
public Task<decimal> ObtenerAsync(string moneda)
{
Console.WriteLine($"→ consultando {moneda}");
return interno.ObtenerAsync(moneda);
}
}LO IDIOMÁTICO EN JAVA: Es el patrón con el que está construido java.io: new BufferedReader(new InputStreamReader(...)). Cada decorador implementa la misma interfaz y recibe al envuelto en el constructor. Los fallos del proveedor son una excepción no comprobada (RuntimeException) propia.
void main() {
FuenteTiposCambio fuente = new ConCache(new ConLog(new ConReintentos(new ApiTiposCambio(), 3)), Duration.ofMinutes(5));
IO.println(fuente.obtener("USD")); // → consultando USD, reintento 1..., 3.75
IO.println(fuente.obtener("USD")); // 3.75 (desde la caché)
}
interface FuenteTiposCambio {
double obtener(String moneda);
}
class ProveedorNoDisponible extends RuntimeException {
@Serial private static final long serialVersionUID = 1L;
ProveedorNoDisponible(String mensaje) { super(mensaje); }
}
class ApiTiposCambio implements FuenteTiposCambio {
private int llamadas;
@Override
public double obtener(String moneda) {
if (++llamadas == 1) throw new ProveedorNoDisponible("Tiempo de espera agotado"); // el proveedor falla a veces
return moneda.equals("USD") ? 3.75 : 4.05;
}
}
class ConReintentos implements FuenteTiposCambio {
private final FuenteTiposCambio interno;
private final int intentos;
ConReintentos(FuenteTiposCambio interno, int intentos) {
this.interno = interno;
this.intentos = intentos;
}
@Override
public double obtener(String moneda) {
for (var intento = 1; ; intento++) {
try {
return interno.obtener(moneda);
} catch (ProveedorNoDisponible error) {
if (intento >= intentos) throw error;
IO.println(" reintento " + intento + "...");
}
}
}
}
class ConCache implements FuenteTiposCambio {
private record Entrada(double valor, Instant expira) {}
private final FuenteTiposCambio interno;
private final Duration duracion;
private final Map<String, Entrada> cache = new ConcurrentHashMap<>();
ConCache(FuenteTiposCambio interno, Duration duracion) {
this.interno = interno;
this.duracion = duracion;
}
@Override
public double obtener(String moneda) {
var guardado = cache.get(moneda);
if (guardado != null && guardado.expira().isAfter(Instant.now())) return guardado.valor();
var valor = interno.obtener(moneda);
cache.put(moneda, new Entrada(valor, Instant.now().plus(duracion)));
return valor;
}
}
class ConLog implements FuenteTiposCambio {
private final FuenteTiposCambio interno;
ConLog(FuenteTiposCambio interno) {
this.interno = interno;
}
@Override
public double obtener(String moneda) {
IO.println("→ consultando " + moneda);
return interno.obtener(moneda);
}
}LO IDIOMÁTICO EN JAVASCRIPT: En JavaScript las funciones son valores, así que un decorador suele ser una función de orden superior: recibe una función y devuelve otra con la misma firma y comportamiento añadido. Las capas se combinan anidando llamadas, sin clases.
let llamadas = 0;
async function obtenerDeApi(moneda) {
llamadas++;
if (llamadas === 1) throw new Error('Tiempo de espera agotado'); // el proveedor falla a veces
return moneda === 'USD' ? 3.75 : 4.05;
}
export const conReintentos = (fn, intentos = 3) => async (...args) => {
for (let intento = 1; ; intento++) {
try {
return await fn(...args);
} catch (error) {
if (intento >= intentos) throw error;
console.log(` reintento ${intento}...`);
}
}
};
export const conCache = (fn, ttlMs = 5 * 60_000) => {
const cache = new Map();
return async (clave) => {
const guardado = cache.get(clave);
if (guardado && guardado.expira > Date.now()) return guardado.valor;
const valor = await fn(clave);
cache.set(clave, { valor, expira: Date.now() + ttlMs });
return valor;
};
};
export const conLog = (fn) => async (...args) => {
console.log(`→ consultando ${args.join(', ')}`);
return fn(...args);
};
// ── Uso ──
// El orden importa: la caché va por fuera para no registrar ni reintentar lo que ya está guardado.
const obtenerTipoCambio = conCache(conLog(conReintentos(obtenerDeApi)));
console.log(await obtenerTipoCambio('USD')); // → consultando USD, reintento 1..., 3.75
console.log(await obtenerTipoCambio('USD')); // 3.75 (desde la caché)LO IDIOMÁTICO EN PYTHON: Los decoradores @ de Python son exactamente este patrón aplicado a funciones: cada uno envuelve a la función y devuelve otra con la misma firma. functools.wraps conserva el nombre y la documentación de la original. Se aplican de abajo hacia arriba, así que el orden se lee en el código.
import time
from collections.abc import Callable
from functools import wraps
Consulta = Callable[[str], float]
def con_reintentos(intentos: int = 3) -> Callable[[Consulta], Consulta]:
def decorar(funcion: Consulta) -> Consulta:
@wraps(funcion)
def envoltura(moneda: str) -> float:
for intento in range(1, intentos + 1):
try:
return funcion(moneda)
except TimeoutError:
if intento == intentos:
raise
print(f" reintento {intento}...")
raise AssertionError("inalcanzable")
return envoltura
return decorar
def con_cache(ttl_segundos: float) -> Callable[[Consulta], Consulta]:
def decorar(funcion: Consulta) -> Consulta:
cache: dict[str, tuple[float, float]] = {}
@wraps(funcion)
def envoltura(moneda: str) -> float:
if moneda in cache and cache[moneda][1] > time.monotonic():
return cache[moneda][0]
valor = funcion(moneda)
cache[moneda] = (valor, time.monotonic() + ttl_segundos)
return valor
return envoltura
return decorar
def con_log(funcion: Consulta) -> Consulta:
@wraps(funcion)
def envoltura(moneda: str) -> float:
print(f"→ consultando {moneda}")
return funcion(moneda)
return envoltura
_llamadas = 0
# El orden importa: la caché va por fuera para no registrar ni reintentar lo que ya está guardado
@con_cache(ttl_segundos=300)
@con_log
@con_reintentos(intentos=3)
def obtener_tipo_cambio(moneda: str) -> float:
"""Consulta la API del proveedor de tipos de cambio."""
global _llamadas
_llamadas += 1
if _llamadas == 1:
raise TimeoutError("Tiempo de espera agotado") # el proveedor falla a veces
return 3.75 if moneda == "USD" else 4.05
if __name__ == "__main__":
print(obtener_tipo_cambio("USD")) # → consultando USD, reintento 1..., 3.75
print(obtener_tipo_cambio("USD")) # 3.75 (desde la caché)
print(obtener_tipo_cambio.__name__, "-", obtener_tipo_cambio.__doc__) # wraps conserva los metadatosLO IDIOMÁTICO EN GO: Igual que los middlewares de net/http: un decorador es una función que recibe una función y devuelve otra con la misma firma. Las capas se combinan anidando llamadas y los errores viajan como valores, envueltos con %w para no perder la causa original.
package main
import (
"errors"
"fmt"
"time"
)
type Consulta func(moneda string) (float64, error)
func ConReintentos(intentos int) func(Consulta) Consulta {
return func(siguiente Consulta) Consulta {
return func(moneda string) (float64, error) {
var err error
for intento := 1; intento <= intentos; intento++ {
var valor float64
if valor, err = siguiente(moneda); err == nil {
return valor, nil
}
if intento < intentos {
fmt.Printf(" reintento %d...\n", intento)
}
}
return 0, fmt.Errorf("tras %d intentos: %w", intentos, err)
}
}
}
func ConCache(ttl time.Duration) func(Consulta) Consulta {
type entrada struct {
valor float64
expira time.Time
}
return func(siguiente Consulta) Consulta {
cache := map[string]entrada{} // con varias goroutines, habría que protegerlo con un sync.Mutex
return func(moneda string) (float64, error) {
if e, existe := cache[moneda]; existe && time.Now().Before(e.expira) {
return e.valor, nil
}
valor, err := siguiente(moneda)
if err != nil {
return 0, err
}
cache[moneda] = entrada{valor, time.Now().Add(ttl)}
return valor, nil
}
}
}
func ConLog(siguiente Consulta) Consulta {
return func(moneda string) (float64, error) {
fmt.Println("→ consultando", moneda)
return siguiente(moneda)
}
}
func main() {
llamadas := 0
api := func(moneda string) (float64, error) {
llamadas++
if llamadas == 1 {
return 0, errors.New("tiempo de espera agotado") // el proveedor falla a veces
}
if moneda == "USD" {
return 3.75, nil
}
return 4.05, nil
}
// El orden importa: la caché va por fuera para no registrar ni reintentar lo que ya está guardado
obtener := ConCache(5 * time.Minute)(ConLog(ConReintentos(3)(api)))
fmt.Println(obtener("USD")) // → consultando USD, reintento 1..., 3.75 <nil>
fmt.Println(obtener("USD")) // 3.75 <nil> (desde la caché)
}LO IDIOMÁTICO EN RUST: Cada decorador es un struct genérico sobre lo que envuelve (ConCache<F: FuenteTiposCambio>): el compilador conoce toda la pila de capas y no hay llamadas dinámicas, así que decorar no cuesta nada en tiempo de ejecución. Los fallos viajan en Result.
use std::collections::HashMap;
use std::time::{Duration, Instant};
trait FuenteTiposCambio {
fn obtener(&mut self, moneda: &str) -> Result<f64, String>;
}
struct ApiTiposCambio {
llamadas: u32,
}
impl FuenteTiposCambio for ApiTiposCambio {
fn obtener(&mut self, moneda: &str) -> Result<f64, String> {
self.llamadas += 1;
if self.llamadas == 1 {
return Err("tiempo de espera agotado".to_string()); // el proveedor falla a veces
}
Ok(if moneda == "USD" { 3.75 } else { 4.05 })
}
}
struct ConReintentos<F> {
interno: F,
intentos: u32,
}
impl<F: FuenteTiposCambio> FuenteTiposCambio for ConReintentos<F> {
fn obtener(&mut self, moneda: &str) -> Result<f64, String> {
let mut intento = 1;
loop {
match self.interno.obtener(moneda) {
Ok(valor) => return Ok(valor),
Err(error) if intento >= self.intentos => {
return Err(format!("tras {intento} intentos: {error}"));
}
Err(_) => {
println!(" reintento {intento}...");
intento += 1;
}
}
}
}
}
struct ConCache<F> {
interno: F,
duracion: Duration,
cache: HashMap<String, (f64, Instant)>,
}
impl<F: FuenteTiposCambio> FuenteTiposCambio for ConCache<F> {
fn obtener(&mut self, moneda: &str) -> Result<f64, String> {
if let Some(&(valor, expira)) = self.cache.get(moneda)
&& expira > Instant::now()
{
return Ok(valor);
}
let valor = self.interno.obtener(moneda)?;
self.cache
.insert(moneda.to_string(), (valor, Instant::now() + self.duracion));
Ok(valor)
}
}
struct ConLog<F>(F);
impl<F: FuenteTiposCambio> FuenteTiposCambio for ConLog<F> {
fn obtener(&mut self, moneda: &str) -> Result<f64, String> {
println!("→ consultando {moneda}");
self.0.obtener(moneda)
}
}
fn main() {
// El orden importa: la caché va por fuera para no registrar ni reintentar lo que ya está guardado
let mut fuente = ConCache {
interno: ConLog(ConReintentos {
interno: ApiTiposCambio { llamadas: 0 },
intentos: 3,
}),
duracion: Duration::from_secs(5 * 60),
cache: HashMap::new(),
};
println!("{:?}", fuente.obtener("USD")); // → consultando USD, reintento 1..., Ok(3.75)
println!("{:?}", fuente.obtener("USD")); // Ok(3.75) desde la caché
}LO IDIOMÁTICO EN PHP: Cada decorador implementa la misma interfaz y recibe al envuelto con promoción de propiedades (private FuenteTiposCambio $interno). Es el mismo diseño de los clientes HTTP compatibles con PSR-18, que se envuelven para añadir reintentos, caché o registro.
<?php
declare(strict_types=1);
interface FuenteTiposCambio
{
public function obtener(string $moneda): float;
}
final class ApiTiposCambio implements FuenteTiposCambio
{
private int $llamadas = 0;
public function obtener(string $moneda): float
{
if (++$this->llamadas === 1) throw new RuntimeException('Tiempo de espera agotado'); // el proveedor falla a veces
return $moneda === 'USD' ? 3.75 : 4.05;
}
}
final readonly class ConReintentos implements FuenteTiposCambio
{
public function __construct(private FuenteTiposCambio $interno, private int $intentos = 3) {}
public function obtener(string $moneda): float
{
for ($intento = 1; ; $intento++) {
try {
return $this->interno->obtener($moneda);
} catch (RuntimeException $error) {
if ($intento >= $this->intentos) throw $error;
echo " reintento {$intento}...\n";
}
}
}
}
final class ConCache implements FuenteTiposCambio
{
/** @var array<string, array{valor: float, expira: int}> */
private array $cache = [];
public function __construct(private readonly FuenteTiposCambio $interno, private readonly int $segundos = 300) {}
public function obtener(string $moneda): float
{
$guardado = $this->cache[$moneda] ?? null;
if ($guardado !== null && $guardado['expira'] > time()) return $guardado['valor'];
$valor = $this->interno->obtener($moneda);
$this->cache[$moneda] = ['valor' => $valor, 'expira' => time() + $this->segundos];
return $valor;
}
}
final readonly class ConLog implements FuenteTiposCambio
{
public function __construct(private FuenteTiposCambio $interno) {}
public function obtener(string $moneda): float
{
echo "→ consultando {$moneda}\n";
return $this->interno->obtener($moneda);
}
}
// El orden importa: la caché va por fuera para no registrar ni reintentar lo que ya está guardado
$fuente = new ConCache(new ConLog(new ConReintentos(new ApiTiposCambio())));
echo $fuente->obtener('USD'), "\n"; // → consultando USD, reintento 1..., 3.75
echo $fuente->obtener('USD'), "\n"; // 3.75 (desde la caché)