Patrón decorador en servicios de pagos

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

Cursos Empresas Blog Live Conf Eventos Precios

0:0012:57

Patrón decorador en servicios de pagos

Curso de Patrones de Diseño y SOLID en Python

Clase 20 de 27

Clase 20 / 27

Recursos

Aplicar el patrón decorador en Python con protocolos tipados aporta flexibilidad y control. Aquí verás cómo envolver un PaymentService con lógica de logging sin tocar el comportamiento original, usando typing.Protocol, composición con wrap y una implementación limpia con @dataclass.

¿Cómo aplicar el patrón decorador al PaymentService paso a paso?

Para extender un servicio de pagos sin modificarlo, se define una interfaz con Protocol, se implementa la clase principal conforme a esa interfaz y luego se crea un decorador que delega en el servicio real, añadiendo logging.

Crear el protocolo del servicio con typing.Protocol.
Hacer que la clase PaymentService implemente ese protocolo.
Definir un protocolo para los decoradores con el atributo wrap.
Implementar un decorador de logging que imprime inicio y fin, y delega la lógica.
Instanciar el decorador en main envolviendo el servicio real.

# service_protocol.py
from typing import Protocol

class PaymentServiceProtocol(Protocol):
    def process_transaction(self, customer_data, payment_data): ...
    def process_refund(self, transaction_id: str): ...
    def setup_recurring(self, customer_data, payment_data): ...

¿Qué protocolos y clases intervienen en el diseño?

Se definen dos abstracciones clave. Primero, el protocolo del servicio que actúa como contrato: especifica firmas, no comportamiento. Segundo, el protocolo del decorador que replica esas firmas y agrega el atributo wrap tipado como PaymentServiceProtocol para delegar la ejecución. Esto asegura sustitución transparente y facilita pruebas.

# decorator_protocol.py
from typing import Protocol
from service_protocol import PaymentServiceProtocol

class PaymentServiceDecoratorProtocol(Protocol):
    wrap: PaymentServiceProtocol

    def process_transaction(self, customer_data, payment_data): ...
    def process_refund(self, transaction_id: str): ...
    def setup_recurring(self, customer_data, payment_data): ...

Protocol: interfaz estructural que define métodos esperados.
wrap: composición para delegar en el servicio real.
Firmas replicadas: garantizan compatibilidad con el contrato original.
Importaciones mínimas: solo lo necesario para tipar y delegar.

¿Cómo mejora el logging sin alterar la lógica original?

El decorador PaymentServiceLogging implementa el protocolo del decorador, usa @dataclass para su construcción y añade prints de inicio y fin alrededor de cada método. La clave es llamar a self.wrap con los mismos parámetros y retornar la respuesta original, manteniendo el comportamiento intacto.

# logging_service.py
from dataclasses import dataclass
from decorator_protocol import PaymentServiceDecoratorProtocol
from service_protocol import PaymentServiceProtocol

@dataclass
class PaymentServiceLogging(PaymentServiceDecoratorProtocol):
    wrap: PaymentServiceProtocol

    def process_transaction(self, customer_data, payment_data):
        print("start process transaction")
        response = self.wrap.process_transaction(customer_data, payment_data)
        print("finish process transaction")
        return response

    def process_refund(self, transaction_id: str):
        print(f"start process refund: transaction_id={transaction_id}")
        response = self.wrap.process_refund(transaction_id)
        print("finish process refund")
        return response

    def setup_recurring(self, customer_data, payment_data):
        print("start setup recurring")
        response = self.wrap.setup_recurring(customer_data, payment_data)
        print("finish setup recurring")
        return response

¿Cómo se instancia el decorador en main?

# main.py (fragmento)
from payment_service import PaymentService  # implementación existente
from logging_service import PaymentServiceLogging

service = PaymentService(...)
service = PaymentServiceLogging(wrap=service)

service.process_transaction(customer_data, payment_data)
service.process_refund("1234")  # si el servicio real no implementa refund, fallará.

En la demostración, el intento de refund sirve para ilustrar el flujo decorado, aunque el servicio real no tenga ese procesador. La idea central se mantiene: extender funcionalidad (logging y depuración) sin modificar el código del servicio.

¿Qué habilidades y keywords refuerzas con este patrón?

Diseño con Protocol como interfaz estructural.
Abstracción y contrato de métodos.
Composición con wrap para delegación.
Extensibilidad sin modificar comportamiento original.
Logging y debugging de transacciones.
Uso de @dataclass para instanciación clara.

¿De qué otras formas aplicarías el patrón decorador en tu PaymentService o en otras capas? Comparte tus ideas y casos en los comentarios.

Mario Alexander Vargas Celis

Hace 2 años

Implementemos el **Patrón Decorator** para un sistema de pagos. Supongamos que tienes un servicio base que procesa pagos, y quieres añadir funcionalidades como registro de logs, validación antifraude y notificaciones sin modificar la clase original. ### Paso 1: Clase Base para el Servicio de Pagos Define una interfaz común para el servicio de pagos que será implementada por la clase base y los decoradores.

class PaymentService(ABC):    @abstractmethod    def process\_payment(self, amount: float, currency: str):        pass```
Implementa la funcionalidad básica en una clase concreta.
```pythonclass BasicPaymentService(PaymentService):    def process\_payment(self, amount: float, currency: str):        print(f"Procesando pago de {amount} {currency}.")```
\### Paso 2: Crear Decoradores para Extender Funcionalidades
Los decoradores implementan la misma interfaz y envuelven la instancia del servicio de pagos.
\#### Decorador de Registro de Logs
```pythonclass LoggingDecorator(PaymentService):    def \_\_init\_\_(self, payment\_service: PaymentService):        self.payment\_service = payment\_service
    def process\_payment(self, amount: float, currency: str):        print(f"\[Logger]: Procesando un pago de {amount} {currency}.")        self.payment\_service.process\_payment(amount, currency)```
\#### Decorador de Validación Antifraude
```pythonclass FraudCheckDecorator(PaymentService):    def \_\_init\_\_(self, payment\_service: PaymentService):        self.payment\_service = payment\_service
    def process\_payment(self, amount: float, currency: str):        if self.\_is\_fraudulent(amount):            print("\[FraudCheck]: Pago marcado como fraudulento. Transacción detenida.")        else:            print("\[FraudCheck]: Pago validado.")            self.payment\_service.process\_payment(amount, currency)
    def \_is\_fraudulent(self, amount: float) -> bool:        # Simulación de reglas antifraude: Ejemplo, montos mayores a 10,000 son sospechosos        return amount > 10000```
\#### Decorador de Notificación
```pythonclass NotificationDecorator(PaymentService):    def \_\_init\_\_(self, payment\_service: PaymentService):        self.payment\_service = payment\_service
    def process\_payment(self, amount: float, currency: str):        self.payment\_service.process\_payment(amount, currency)        self.\_send\_notification(amount, currency)
    def \_send\_notification(self, amount: float, currency: str):        print(f"\[Notification]: Enviando notificación por el pago de {amount} {currency}.")```
\### Paso 3: Componer el Servicio Decorado
Crea un servicio de pagos básico y añade las funcionalidades deseadas mediante decoradores.
```python# Servicio de pagos básicobasic\_service = BasicPaymentService()
\# Añadir funcionalidad de registro de logslogged\_service = LoggingDecorator(basic\_service)
\# Añadir validación antifraudefraud\_checked\_service = FraudCheckDecorator(logged\_service)
\# Añadir notificaciónfull\_service = NotificationDecorator(fraud\_checked\_service)
\# Usar el servicio decoradoprint("=== Pago 1 ===")full\_service.process\_payment(5000, "USD")
print("\n=== Pago 2 ===")full\_service.process\_payment(15000, "USD")```
\### Resultado Esperado
\*\*Pago 1 (válido):\*\*```\[Logger]: Procesando un pago de 5000 USD.\[FraudCheck]: Pago validado.Procesando pago de 5000 USD.\[Notification]: Enviando notificación por el pago de 5000 USD.```
\*\*Pago 2 (fraudulento):\*\*```\[Logger]: Procesando un pago de 15000 USD.\[FraudCheck]: Pago marcado como fraudulento. Transacción detenida.```
\### Ventajas del Patrón Decorator en este Contexto
1\. \*\*Modularidad\*\*: Cada funcionalidad (logs, antifraude, notificaciones) está separada en su propio decorador, lo que facilita su mantenimiento.2. \*\*Flexibilidad\*\*: Puedes añadir, quitar o combinar decoradores según sea necesario, sin modificar las clases originales.3. \*\*Cumple con SOLID\*\*:   - \*\*Responsabilidad Única (SRP)\*\*: Cada decorador tiene una responsabilidad clara.   - \*\*Abierto/Cerrado (OCP)\*\*: Puedes extender el comportamiento sin modificar las clases existentes.
\### Extensión del Ejemplo
\#### Añadir un Decorador para Conversión de Moneda
Si necesitas convertir el monto a una moneda específica antes de procesarlo:
```pythonclass CurrencyConverterDecorator(PaymentService):    def \_\_init\_\_(self, payment\_service: PaymentService, exchange\_rate: float):        self.payment\_service = payment\_service        self.exchange\_rate = exchange\_rate
    def process\_payment(self, amount: float, currency: str):        converted\_amount = amount \* self.exchange\_rate        print(f"\[CurrencyConverter]: Convertido {amount} {currency} a {converted\_amount} USD.")        self.payment\_service.process\_payment(converted\_amount, "USD")```
Usa este decorador antes de los demás si necesitas convertir monedas.
\### Conclusión
El \*\*Patrón Decorator\*\* permite agregar funcionalidades como logs, validaciones y notificaciones al servicio de pagos de manera limpia y extensible. Es especialmente útil para aplicaciones empresariales donde los requisitos cambian con frecuencia y los servicios deben ser altamente configurables.

Patrones de Diseño y Principios SOLID

Patrones de diseño y SOLID en Python

Principios SOLID

Qué es el principio de responsabilidad única

Procesador de pagos en Python con Stripe

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

Principio open-closed en Python

Clases abstractas y principio abierto-cerrado

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

Principio de sustitución de Liskov en Python

Principio de segregación de interfaces en SOLID

Segregación de interfaces en procesadores de pagos

Principio de inversión de dependencias en SOLID

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

Qué es el patrón Decorator

Patrón decorador en servicios de pagos

Builder Pattern: construcción paso a paso

Builder Pattern aplicado a un servicio 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

Código funcional vs código mantenible en Python

Patrón decorador en servicios de pagos

Progreso del curso

Patrones de Diseño y Principios SOLID

Principios SOLID

Reestructuración del proyecto

Patrones de Diseño

Recursos

Recursos