Decorator: añadir comportamiento envolviendo
- Lección 13 de 32
- 11 min
- Intermedio
- 12 pasos
Sumarle log y caché a un cliente HTTP con herencia pide una subclase por cada mezcla. Vas a envolverlo en capas con la misma interfaz y ver por qué el orden de esas capas cambia el resultado.
- Clases extra para combinar
- 2
- Líneas de log (ejemplo)
- —
- petición
- respuesta
- fallo de caché
- petición fallida
Paso 1 de 12
Problema
Una subclase por cada mezcla
Tienes una clase Http con un método get(url) que descarga una página. Un día te piden registrar cada llamada en el log; otro día, guardar en caché las respuestas repetidas.
Con herencia, cada mezcla es una subclase: LoggedHttp, CachedHttp y, para tener las dos cosas, CachedLoggedHttp. Dos comportamientos ya piden tres clases, y la tercera repite código de las otras dos.
Qué cambió
- LoggedHttp, CachedHttp y CachedLoggedHttp
Paso 2 de 12
Problema
Llega un tercer comportamiento
Ahora también quieres reintentar cuando la red falla: nace RetryHttp. Pero también quieres caché con reintentos, log con reintentos y los tres juntos.
Con 3 comportamientos combinables salen 7 subclases (2³ − 1), como suma el panel; con 4 serían 15. Cada comportamiento nuevo casi duplica las clases, y en cada una el orden en que se aplican queda fijo.
Qué cambió
- RetryHttp
- 3 combinaciones más con reintentos
Paso 3 de 12
Concepto
Envolver en vez de heredar
Otra idea: un objeto que envuelve a otro. withLog recibe un Fetcher, devuelve otro Fetcher y, en su get, escribe el log y luego le pasa la llamada al objeto de dentro.
Los dos cumplen el mismo contrato, la interfaz Fetcher. Por eso App no nota la diferencia: llama a get(url) como siempre. Eso es un Decorator: la misma interfaz, un comportamiento extra y la clase original sin tocar.
Qué cambió
- interface Fetcher
- withLog
- las subclases
Paso 4 de 12
Técnica
Un decorador en pocas líneas
El decorador guarda el objeto de dentro (f), hace su parte y delega con f.get(url). Aquí está escrito como una función que devuelve un objeto; una clase con un campo privado sirve igual.
Fíjate en lo que no pasó: Http no cambió y no hay subclases. Se puede envolver cualquier Fetcher: el real, uno falso para los tests u otro decorador.
Qué cambió
- console.log antes de delegar
- Http, sin cambios
Paso 5 de 12
Solución
Un decorador dentro de otro
Como un decorador también es un Fetcher, se puede envolver otra vez: withCache(withLog(http)). La primera llamada a /a entra por la caché, que aún no la tiene (un fallo de caché), pasa por el log y llega a Http.
La respuesta vuelve por las mismas capas y la caché la guarda de paso. Cada comportamiento es una sola clase: con caché, log y reintentos serían 3 decoradores, no 7 subclases.
Qué cambió
- withCache, por fuera de withLog
Paso 6 de 12
Solución
La segunda llamada no baja
Segunda llamada a /a: la caché ya tiene la respuesta y la devuelve sin llamar al objeto de dentro. withLog y Http ni se enteran: no hay segunda línea de log ni segunda petición a la API.
La línea que decide es el if: solo cuando la URL no está en el Map, withCache delega en f.get(url).
Qué cambió
- la caché responde sola
Paso 7 de 12
Problema
El orden de las capas sí importa
Cambia el orden: withLog(withCache(http)). Ahora el log está por fuera de la caché, así que ve las dos llamadas, también la que la caché responde sola. Mismas piezas, 2 líneas de log en vez de 1.
Ninguno de los dos órdenes está mal: depende de qué quieres registrar. Pero el resultado cambia, así que el orden es parte del diseño. Arma la cadena en un solo sitio para que no dependa de quién la escriba.
Qué cambió
- withLog por fuera, withCache por dentro
Paso 8 de 12
Concepto
Ya lo usas: la lectura de archivos en Java
La biblioteca de entrada y salida de Java está hecha así. BufferedReader es un Reader que envuelve a otro Reader y le añade un búfer, con el que puedes leer línea a línea con readLine(). La documentación de InputStreamReader recomienda justo esto: envolverlo en un BufferedReader.
InputStreamReader, a su vez, convierte los bytes de un InputStream en caracteres. Eso cambia la interfaz, así que hace de adapter (lo viste dos lecciones atrás). En una misma cadena pueden convivir los dos patrones.
Qué cambió
- withCache → BufferedReader
- withLog → InputStreamReader
Paso 9 de 12
Concepto
Ya lo usas: `@lru_cache` en Python
En Python, functools.lru_cache envuelve una función con otra que memoriza sus resultados: si ya calculó fib(30), lo devuelve sin volver a calcularlo. Es la idea de withCache, aplicada a una función.
El @ es azúcar del lenguaje: poner @lru_cache(maxsize=None) encima de def fib equivale a escribir fib = lru_cache(maxsize=None)(fib) debajo. Y functools.wraps copia el nombre y la documentación de la función original al envoltorio, para que siga pareciendo ella.
Qué cambió
- withCache → @lru_cache
- Http → fib
Paso 10 de 12
Concepto
Tres ideas equivocadas
«El orden da igual»: ya viste que no. Con el log por fuera de la caché, cada llamada deja una línea.
«Decorator es la sintaxis `@`»: el @ de Python o el de TypeScript (que desde la versión 5.0 sigue la propuesta estándar de JavaScript) es una función del lenguaje emparentada con el patrón, no el patrón. withLog es un Decorator y no lleva @.
«Un decorador puede cambiar la interfaz»: si la cambia, ya no puedes usarlo en lugar del original. Eso es un adapter.
Paso 11 de 12
Compromiso
Cuándo no envolver y qué cuesta
Si siempre usas la misma combinación y nunca cambia, escribe esa clase y listo: un decorador «por si acaso» es una capa más que leer. El patrón paga cuando combinas comportamientos de formas distintas o los activas según la configuración.
Costes: cada capa es un paso más en la traza de un error, y con muchas capas cuesta ver dónde falló. Además, el envoltorio es otro objeto: client === http da false, y client instanceof Http también. No compares identidades a través de un decorador.
Paso 12 de 12
Resumen
Envolver para sumar
Cuando quieres sumar comportamiento (log, caché, reintentos) a un objeto sin tocar su clase ni crear una subclase por mezcla, envuélvelo en otro con la misma interfaz que hace su parte y delega.
Los decoradores se apilan en el orden que elijas, y ese orden cambia el resultado. Si la combinación es siempre la misma, no lo necesitas.
← → paso · R repetir · Espacio pausa
Aprenderás
- Reconocer el problema: una subclase por cada combinación de comportamientos. (visto)
- Envolver un objeto en otro con la misma interfaz que hace su parte y delega. (visto)
- Apilar varios decoradores y saber que el orden cambia el resultado. (visto)
- Reconocer decoradores que ya usas: `BufferedReader` en Java y `@lru_cache` en Python. (visto)
- Saber cuándo un decorador sobra y qué cuesta. (visto)