Patrón Decorator en 5 pasos para funcionalidad dinámica

Clase 19 de 27 • Curso de Patrones de Diseño y SOLID en Python

Contenido del curso

Patrones de Diseño y Principios SOLID

1
Patrones de diseño y SOLID en Python
02:07 min

Principios SOLID

Reestructuración del proyecto

13
Reestructuración con módulos de Python y SOLID
13:32 min

Patrones de Diseño

Tomar examen

Resumen

Aprende a aplicar el patrón decorador (Decorator Pattern), un patrón de diseño estructural que permite añadir responsabilidades de forma dinámica y extender la funcionalidad sin alterar la estructura original. Aquí verás cómo lograr composición flexible de comportamientos y los cinco pasos concretos para implementarlo con claridad.

¿Qué es el patrón decorador y por qué es útil?

El patrón decorador agrega lógica adicional sobre un componente existente, sin modificar su código base. Es ideal cuando se necesita sumar funcionalidades a demanda y mantener un diseño limpio y extensible.

Añadir responsabilidades de forma dinámica sin tocar la clase original.
Extender funcionalidad conservando la estructura y el comportamiento base.
Composición flexible: varios decoradores pueden trabajar juntos.
Modularidad y mantenibilidad al separar comportamientos adicionales.

¿Qué problema resuelve y qué beneficios ofrece?

Evitar cambios en la clase base cuando aparece una nueva lógica.
Reutilizar comportamientos adicionales en distintos contextos.
Activar o desactivar funcionalidades de forma controlada.

¿Cómo funciona y cuándo aplicarlo?

La idea central es envolver un objeto básico con uno o más decoradores. Cada decorador implementa la misma interfaz que el componente original y agrega su propia lógica antes o después de delegar el comportamiento base. En un diagrama de clases, se muestra como capas que se apilan sobre el componente principal.

¿Cómo se compone con múltiples decoradores?

Se pueden crear múltiples instancias de decoradores.
Cada decorador aporta una lógica distinta sobre el mismo comportamiento base.
La composición permite una lógica aumentada mediante capas.

¿Cuándo aplicarlo de forma flexible y modular?

Cuando se deben combinar múltiples comportamientos de manera flexible y modular.
Cuando se necesita añadir funcionalidades en tiempo de ejecución según una condición del código o del contexto.
Cuando conviene agregar responsabilidades adicionales sin tocar la implementación original.

¿Cómo implementarlo paso a paso?

El proceso se entiende mejor como una secuencia de cinco puntos que separa responsabilidades y facilita la extensión.

¿Cuáles son los cinco pasos para aplicarlo?

Definir una interfaz o clase abstracta que describa el comportamiento del objeto. Representa el contrato del componente base.
Implementar esa interfaz en clases concretas que contengan el comportamiento principal.
Crear una clase decoradora abstracta que implemente la misma interfaz del componente principal.
Implementar decoradores concretos que extiendan la clase decoradora y agreguen comportamientos específicos.
Envolver los objetos básicos con los decoradores creados, componiendo según se necesite.

¿Has aplicado el patrón decorador en algún proyecto? Comparte tu experiencia y qué composición de decoradores te funcionó mejor.

Comentarios

Jovanny Delgado

student•

El patrón Decorador (Decorator Pattern) en Python es una herramienta útil para añadir funcionalidades a objetos de manera dinámica sin alterar la estructura de las clases existentes. Este patrón es especialmente útil en situaciones donde la herencia resulta demasiado rígida o cuando deseas modificar el comportamiento de objetos específicos en tiempo de ejecución, sin afectar a otros objetos de la misma clase.

Concepto Básico

El patrón Decorador se basa en el principio de que puedes "envolver" un objeto con múltiples capas de "decoradores" que pueden añadir o cambiar su comportamiento. Esto se logra al tener los decoradores y el objeto original compartiendo la misma interfaz o clase base.

Implementación en Python

Aquí tienes un ejemplo sencillo de cómo podrías implementar el patrón Decorador en Python:

class Component: def operation(self): pass

class ConcreteComponent(Component): def operation(self): return "Componente Concreto"

class Decorator(Component): def __init__(self, component): self._component = component

def operation(self): return self._component.operation()

class ConcreteDecoratorA(Decorator): def operation(self): return f"DecoradorConcretoA({self._component.operation()})"

class ConcreteDecoratorB(Decorator): def operation(self): return f"DecoradorConcretoB({self._component.operation()})"

Uso del Código

Y aquí te muestro cómo utilizarías estos objetos en tu código:

# Crear el objeto original simple = ConcreteComponent() print(simple.operation()) # Salida: Componente Concreto

# Añadir funcionalidades con los decoradores decorated = ConcreteDecoratorA(simple) more_decorated = ConcreteDecoratorB(decorated) print(decorated.operation()) # Salida: DecoradorConcretoA(Componente Concreto) print(more_decorated.operation()) # Salida: DecoradorConcretoB(DecoradorConcretoA(Componente Concreto))

Ventajas del Patrón Decorador

Flexibilidad: Permite añadir responsabilidades adicionales a objetos específicos de forma dinámica sin afectar a otros objetos de la misma clase.
Reutilización: Promueve la reutilización de código y evita clases cargadas con funcionalidades que no siempre se utilizan.

Consideraciones

El uso excesivo puede resultar en un diseño complicado y difícil de entender, especialmente cuando hay muchos decoradores involucrados.
Los objetos pueden terminar con muchas pequeñas clases y objetos envolventes que solo añaden una pequeña funcionalidad específica.

Este patrón es muy utilizado en Python, especialmente en frameworks y bibliotecas donde la modificación de comportamiento sin cambiar el código original es crucial.

Rodrigo Martinez

student•

Los retails online usan el patrón Decorador para añadir características a productos (como envoltorio para regalo o grabado) sin modificar el producto base. Esto permite combinar funcionalidades de forma flexible.

Jovanny Delgado

student•

Patrón Decorador en Python

Analogía del Café

Una analogía común para entender el Decorador es la de preparar un café. Imagina que tienes un café simple (el componente base). Puedes añadirle leche, azúcar, caramelo, etc. (los decoradores). Cada adición modifica el café sin cambiar su esencia.

Otro Ejemplo Práctico: Logueo

Pythonimport functools

def logger(func): @functools.wraps(func) def wrapper(*args, **kwargs): print(f"Calling {func.__name__} with args: {args}, kwargs: {kwargs}") result = func(*args, **kwargs) print(f"Result: {result}") return result return wrapper

@logger def add(x, y): return x + y

add(3, 4)

En este ejemplo, el decorador logger añade la funcionalidad de imprimir un mensaje antes y después de ejecutar la función add.

Decoradores en Python y el Patrón Decorador

Los decoradores en Python son una sintaxis azúcar que implementa el patrón Decorador. Sin embargo, es importante notar que no todos los usos de decoradores son ejemplos del patrón Decorador en su forma más estricta.

Casos de Uso Comunes

Logging: Agregar información de registro a funciones.
Validación de argumentos: Verificar que los argumentos pasados a una función sean válidos.
Caching: Almacenar resultados de funciones para evitar recalcularlos.
Transformación de datos: Modificar los datos antes o después de que una función los procese.

Consideraciones Adicionales

Orden de los Decoradores: El orden en que se aplican los decoradores puede afectar el resultado final.
Decoradores de Clase: Los decoradores también se pueden aplicar a clases para modificar su comportamiento.
Decoradores con Argumentos: Los decoradores pueden tomar argumentos para personalizar su comportamiento.

Ventajas Adicionales

Modularidad: Permite separar las funcionalidades en diferentes decoradores.
Extensibilidad: Facilita la adición de nuevas funcionalidades sin modificar el código original.

En resumen, el patrón Decorador es una herramienta versátil que puede ser utilizada para mejorar la flexibilidad y la modularidad de tu código. Al entender cómo funciona y cuándo usarlo, puedes escribir código más limpio y mantenible.

Mario Alexander Vargas Celis

student•

El **Patrón Decorator** es un patrón de diseño estructural que permite agregar funcionalidad a objetos de manera flexible y dinámica sin modificar su estructura original. Este patrón es ideal cuando necesitas extender el comportamiento de clases de manera controlada y no quieres modificar el código existente. ### Conceptos Clave del Patrón Decorator 1. **Objetos Envolventes (Wrappers)**: Los decoradores envuelven un objeto base, añadiendo funcionalidades antes o después de ejecutar los métodos del objeto original.2. **Composición sobre Herencia**: Este patrón favorece la composición en lugar de herencia, permitiendo extender funcionalidades sin modificar clases existentes.3. **Encadenamiento**: Es posible combinar múltiples decoradores para añadir capas de comportamiento. ### Implementación en Python Supongamos que tienes una clase que representa notificaciones y deseas añadir funcionalidades como registro de acciones y cifrado sin modificar la clase base. #### Paso 1: Crear una Interfaz Común Define una interfaz base que todos los decoradores y la clase original implementarán.

class Notifier(ABC):    @abstractmethod    def send(self, message: str):        pass```
\#### Paso 2: Implementar la Clase Base
Esta es la implementación básica de la funcionalidad principal.
```pythonclass EmailNotifier(Notifier):    def send(self, message: str):        print(f"Enviando correo: {message}")```
\#### Paso 3: Crear Decoradores
Los decoradores deben implementar la misma interfaz que la clase base, y recibirán una instancia del objeto base para extender su funcionalidad.
```pythonclass LoggerDecorator(Notifier):    def \_\_init\_\_(self, notifier: Notifier):        self.notifier = notifier
    def send(self, message: str):        print("\[Logger]: Registrando acción de notificación.")        self.notifier.send(message)

class EncryptionDecorator(Notifier):    def \_\_init\_\_(self, notifier: Notifier):        self.notifier = notifier
    def send(self, message: str):        encrypted\_message = self.\_encrypt(message)        print("\[Encryption]: Mensaje cifrado.")        self.notifier.send(encrypted\_message)
    def \_encrypt(self, message: str) -> str:        return "".join(chr(ord(char) + 1) for char in message)  # Cifrado básico```
\#### Paso 4: Usar el Patrón Decorator
Puedes combinar decoradores dinámicamente para añadir funcionalidades.
```python# Crear un notificador baseemail\_notifier = EmailNotifier()
\# Envolver con un decorador de registrologger\_notifier = LoggerDecorator(email\_notifier)
\# Envolver con un decorador de cifradosecure\_logger\_notifier = EncryptionDecorator(logger\_notifier)
\# Usar el decorador finalsecure\_logger\_notifier.send("Hola, este es un mensaje importante.")```
\*\*Salida esperada:\*\*
```\[Encryption]: Mensaje cifrado.\[Logger]: Registrando acción de notificación.Enviando correo: Ipmb-!ftuf!ft!vo!nfttbohf!jnqpsubouf/```
\### Ventajas del Patrón Decorator
1\. \*\*Flexibilidad\*\*: Puedes añadir funcionalidades de manera dinámica sin modificar el código existente.2. \*\*Reutilización\*\*: Los decoradores son reutilizables y pueden combinarse en diferentes configuraciones.3. \*\*Cumple con el Principio Abierto/Cerrado\*\*: Las clases están abiertas a la extensión, pero cerradas a la modificación.
\### Aplicación en la Vida Real
El patrón Decorator se utiliza comúnmente en:
1\. \*\*Bibliotecas de GUI\*\*: Para añadir comportamientos como bordes, desplazamiento, sombreado.2. \*\*Frameworks web\*\*: Para añadir middleware como autenticación, registro o manipulación de solicitudes.3. \*\*Manipulación de datos\*\*: Para transformar, validar o registrar datos antes de procesarlos.
\### Decoradores de Python (`@decorator`)
En Python, puedes usar la sintaxis de decoradores con funciones para casos simples.
\#### Ejemplo con Funciones
```pythondef logger(func):    def wrapper(\*args, \*\*kwargs):        print(f"Llamando a la función {func.\_\_name\_\_}")        return func(\*args, \*\*kwargs)    return wrapper
@loggerdef greet(name):    print(f"Hola, {name}!")
greet("Alice")```
\*\*Salida:\*\*```Llamando a la función greetHola, Alice!```
\### Conclusión
El \*\*Patrón Decorator\*\* en Python es una herramienta poderosa tanto en su implementación orientada a objetos como en su forma funcional (sintaxis `@decorator`). Es ampliamente usado en sistemas donde se necesita añadir comportamientos de manera flexible y reutilizable, manteniendo el código base limpio y extensible.

class Notifier(ABC):    @abstractmethod    def send(self, message: str):        pass```
\#### Paso 2: Implementar la Clase Base
Esta es la implementación básica de la funcionalidad principal.
```pythonclass EmailNotifier(Notifier):    def send(self, message: str):        print(f"Enviando correo: {message}")```
\#### Paso 3: Crear Decoradores
Los decoradores deben implementar la misma interfaz que la clase base, y recibirán una instancia del objeto base para extender su funcionalidad.
```pythonclass LoggerDecorator(Notifier):    def \_\_init\_\_(self, notifier: Notifier):        self.notifier = notifier
    def send(self, message: str):        print("\[Logger]: Registrando acción de notificación.")        self.notifier.send(message)

class EncryptionDecorator(Notifier):    def \_\_init\_\_(self, notifier: Notifier):        self.notifier = notifier
    def send(self, message: str):        encrypted\_message = self.\_encrypt(message)        print("\[Encryption]: Mensaje cifrado.")        self.notifier.send(encrypted\_message)
    def \_encrypt(self, message: str) -> str:        return "".join(chr(ord(char) + 1) for char in message)  # Cifrado básico```
\#### Paso 4: Usar el Patrón Decorator
Puedes combinar decoradores dinámicamente para añadir funcionalidades.
```python# Crear un notificador baseemail\_notifier = EmailNotifier()
\# Envolver con un decorador de registrologger\_notifier = LoggerDecorator(email\_notifier)
\# Envolver con un decorador de cifradosecure\_logger\_notifier = EncryptionDecorator(logger\_notifier)
\# Usar el decorador finalsecure\_logger\_notifier.send("Hola, este es un mensaje importante.")```
\*\*Salida esperada:\*\*
```\[Encryption]: Mensaje cifrado.\[Logger]: Registrando acción de notificación.Enviando correo: Ipmb-!ftuf!ft!vo!nfttbohf!jnqpsubouf/```
\### Ventajas del Patrón Decorator
1\. \*\*Flexibilidad\*\*: Puedes añadir funcionalidades de manera dinámica sin modificar el código existente.2. \*\*Reutilización\*\*: Los decoradores son reutilizables y pueden combinarse en diferentes configuraciones.3. \*\*Cumple con el Principio Abierto/Cerrado\*\*: Las clases están abiertas a la extensión, pero cerradas a la modificación.
\### Aplicación en la Vida Real
El patrón Decorator se utiliza comúnmente en:
1\. \*\*Bibliotecas de GUI\*\*: Para añadir comportamientos como bordes, desplazamiento, sombreado.2. \*\*Frameworks web\*\*: Para añadir middleware como autenticación, registro o manipulación de solicitudes.3. \*\*Manipulación de datos\*\*: Para transformar, validar o registrar datos antes de procesarlos.
\### Decoradores de Python (`@decorator`)
En Python, puedes usar la sintaxis de decoradores con funciones para casos simples.
\#### Ejemplo con Funciones
```pythondef logger(func):    def wrapper(\*args, \*\*kwargs):        print(f"Llamando a la función {func.\_\_name\_\_}")        return func(\*args, \*\*kwargs)    return wrapper
@loggerdef greet(name):    print(f"Hola, {name}!")
greet("Alice")```
\*\*Salida:\*\*```Llamando a la función greetHola, Alice!```
\### Conclusión
El \*\*Patrón Decorator\*\* en Python es una herramienta poderosa tanto en su implementación orientada a objetos como en su forma funcional (sintaxis `@decorator`). Es ampliamente usado en sistemas donde se necesita añadir comportamientos de manera flexible y reutilizable, manteniendo el código base limpio y extensible.

Patrón Decorator en 5 pasos para funcionalidad dinámica

Patrones de Diseño y Principios SOLID

Patrones de diseño y SOLID en Python

Principios SOLID

Principio de responsabilidad única en SOLID

Refactorizando código Python con principios SOLID

Cómo aplicar SRP en un procesador de pagos con Stripe

Open Closed Principle: extensión sin modificación

Cómo usar clases abstractas en Python

Principio de Liskov en S.O.L.I.D.

Principio de sustitución de Liskov en Python

Interface Segregation: cuándo separar contratos

Segregación de interfaces en procesadores de pagos

Principio de inversión de dependencias explicado

Principio de inversión de dependencias: servicio de pagos flexible

Reestructuración del proyecto

Reestructuración con módulos de Python y SOLID

Patrones de Diseño

Qué son los patrones de diseño: definición y categorías

Strategy Pattern con Python y setprocessor

Strategy Pattern para pagos en Python

Factory Pattern: centralizar creación de objetos

Patrón Factory para procesar pagos con match

Patrón Decorator en 5 pasos para funcionalidad dinámica

Patrón decorador en servicios de pagos

Builder Pattern: construcción paso a paso

Builder pattern para servicios de pagos

Observer Pattern en sistemas de eventos

Observer en sistemas de pagos con Python

Chain of Responsibility para validar pagos

Chain of Responsibility en servicios de pagos

Arquitectura robusta para procesadores de pago