Chain of Responsibility para validar pagos

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

Resumen

Aprende a aplicar el patrón de diseño Chain of Responsibility para crear una cadena de responsabilidades clara, escalable y fácil de mantener. Ideal para validación de pagos, autenticación y cualquier flujo que requiera pasos secuenciales con reglas específicas.

¿Qué es el patrón chain of responsibility y para qué sirve?

Este es un patrón de diseño de comportamiento que define un flujo de procesamiento de solicitudes a través de distintos manejadores. Cada manejador tiene una responsabilidad única y puede evaluar condiciones específicas antes de decidir si continúa o detiene el proceso.

¿Cómo funciona la cadena de responsabilidades?

Una clase base, como Validator, expone dos métodos: Set Next y Validate.
Set Next conecta el siguiente elemento en la cadena.
Validate decide si lo que llega es válido o no.
Si aprueba, pasa la solicitud al siguiente manejador. Si no, la rechaza.
Se pueden crear implementaciones como validador de monto, validador de tarjeta y validador de fraude para un servicio de pagos.

¿Cuándo aplicarlo en validación y autenticación?

Cuando se necesita procesar una solicitud en una serie de pasos.
En validación de pagos con verificaciones encadenadas: monto, tarjeta y fraude.
En autenticación y autorización: validar que el usuario esté autenticado, autorizado y cumpla requerimientos antes de una acción.
Cuando se busca una estructura flexible de validación de datos.

¿Cómo implementar la cadena de manejadores paso a paso?

La aplicación es directa y favorece abstracciones para mantener bajo acoplamiento y alta cohesión. El flujo se arma declarando la interfaz, creando los manejadores y conectándolos en orden lógico.

Definir una interfaz o clase abstracta para los manejadores.
Implementar cada manejador que herede de esa interfaz o clase abstracta.
Configurar la cadena de manejadores en el orden deseado.
Enviar la solicitud al primer manejador y dejar que el flujo avance o se detenga.

¿Qué decide cada manejador en el flujo?

Valida su condición puntual con Validate.
Si es válida, pasa al siguiente con Set Next ya configurado.
Si no cumple, rechaza la solicitud inmediatamente.

¿Qué conceptos y habilidades refuerzas al usar este patrón?

Usar Chain of Responsibility impulsa prácticas de diseño limpias, con responsabilidad clara por componente y reglas de negocio aisladas. Además, facilita pruebas y cambios sin romper el flujo completo.

Abstracción como base del diseño.
Interfaz o clase abstracta para un contrato común.
Responsabilidad única por manejador.
Flujo de procesamiento definido como cadena.
Validación flexible de datos con condiciones específicas.
Ejemplo en pagos: validador de monto, tarjeta y fraude.
Aplicación en autenticación y autorización.

¿Dónde integrarías este patrón en tu servicio de pagos o seguridad? Cuéntame en comentarios qué feature modificarías para aplicar la cadena de responsabilidad.

Franco Manca

student•

El patrón Chain of Responsibility es un patrón de diseño de comportamiento que permite pasar solicitudes a lo largo de una cadena de manejadores. Cada manejador puede procesar la solicitud o pasársela al siguiente en la cadena.

Características:

Cada manejador tiene una unica responsabilidad.
El flujo de procesamiento de solicitudes es transparente.
Cada manejador puede aplicar condiciones especificas.

Cuándo aplicarlo:

Cuando se requiere un procesamiento de solicitudes a través de múltiples pasos, como en validaciones de pagos o autenticación.

Cómo aplicarlo:

Define una interfaz o clase abstracta para los manejadores con un método para establecer el siguiente manejador
Implementar manejadores concretos
Configura la cadena de manejadores.
Envía la solicitud al primer manejador
Cada manejador que decidirá: si procesarla o pasarla al siguiente (delegarla)

Hector Emanuel Barboza

student•

!Estructura del patrón de diseño Chain Of Responsibility

Mario Alexander Vargas Celis

student•

El **Patrón Chain of Responsibility** es un patrón de diseño de comportamiento que permite procesar una solicitud a través de una cadena de objetos (o manejadores), donde cada objeto decide si procesa la solicitud o la pasa al siguiente en la cadena. ### Escenario de Ejemplo Imaginemos un sistema de soporte técnico donde diferentes niveles de soporte (básico, avanzado, experto) procesan las solicitudes de los clientes según su complejidad. ### Implementación Paso a Paso #### Paso 1: Crear la Clase Base para los Manejadores Definimos una interfaz común para todos los manejadores en la cadena.

class Manejador(ABC):    def \_\_init\_\_(self):        self.siguiente = None
    def establecer\_siguiente(self, manejador):        """Establece el siguiente manejador en la cadena."""        self.siguiente = manejador        return manejador
    @abstractmethod    def manejar(self, solicitud):        """Intenta procesar la solicitud o pasa al siguiente manejador."""        pass```
\#### Paso 2: Crear los Manejadores Concretos
Cada manejador procesa la solicitud si cumple sus criterios; de lo contrario, la pasa al siguiente.
```pythonclass SoporteBasico(Manejador):    def manejar(self, solicitud):        if solicitud == "problema básico":            return "Soporte Básico: Resolviendo el problema básico."        elif self.siguiente:            return self.siguiente.manejar(solicitud)        return "Soporte Básico: No se pudo resolver el problema."
class SoporteAvanzado(Manejador):    def manejar(self, solicitud):        if solicitud == "problema avanzado":            return "Soporte Avanzado: Resolviendo el problema avanzado."        elif self.siguiente:            return self.siguiente.manejar(solicitud)        return "Soporte Avanzado: No se pudo resolver el problema."
class SoporteExperto(Manejador):    def manejar(self, solicitud):        if solicitud == "problema crítico":            return "Soporte Experto: Resolviendo el problema crítico."        elif self.siguiente:            return self.siguiente.manejar(solicitud)        return "Soporte Experto: No se pudo resolver el problema."```
\#### Paso 3: Configurar la Cadena de Responsabilidad
Conectamos los manejadores en el orden deseado.
```python# Crear los manejadoressoporte\_basico = SoporteBasico()soporte\_avanzado = SoporteAvanzado()soporte\_experto = SoporteExperto()
\# Configurar la cadenasoporte\_basico.establecer\_siguiente(soporte\_avanzado).establecer\_siguiente(soporte\_experto)```
\#### Paso 4: Probar la Cadena
Creamos solicitudes y las pasamos al primer manejador de la cadena.
```python# Probar la cadena con diferentes solicitudessolicitudes = \["problema básico", "problema avanzado", "problema crítico", "problema desconocido"]
for solicitud in solicitudes:    print(f"Solicitud: {solicitud}")    respuesta = soporte\_basico.manejar(solicitud)    print(f"Respuesta: {respuesta}\n")```
\### Salida Esperada
```Solicitud: problema básicoRespuesta: Soporte Básico: Resolviendo el problema básico.
Solicitud: problema avanzadoRespuesta: Soporte Avanzado: Resolviendo el problema avanzado.
Solicitud: problema críticoRespuesta: Soporte Experto: Resolviendo el problema crítico.
Solicitud: problema desconocidoRespuesta: Soporte Experto: No se pudo resolver el problema.```
\### Ventajas del Patrón Chain of Responsibility
1\. \*\*Desacoplamiento\*\*: Cada manejador es independiente y no necesita conocer la implementación de otros manejadores.2. \*\*Flexibilidad\*\*: Puedes reorganizar o extender la cadena sin modificar los manejadores existentes.3. \*\*Reutilización\*\*: Los manejadores son reutilizables en diferentes cadenas o sistemas.
\### Aplicaciones Reales
1\. \*\*Sistemas de soporte técnico\*\*: Escalar problemas a niveles superiores.2. \*\*Validación de datos\*\*: Verificar diferentes aspectos de una solicitud de manera secuencial.3. \*\*Procesamiento de eventos\*\*: Manejar eventos en sistemas complejos donde cada paso puede delegar al siguiente.
\### Conclusión
El \*\*Patrón Chain of Responsibility\*\* es una solución elegante para manejar solicitudes dinámicas que pueden requerir diferentes niveles de procesamiento. Su implementación en Python es sencilla y proporciona un sistema flexible, modular y fácil de mantener.

Jhon Alexander Triana Arcila

student•

Chain of Responsibility para validar pagos

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