Principios SOLID y Patrones de Diseño en Procesadores de Pago

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

Resumen

¿Por qué son importantes los principios SOLID y los patrones de diseño?

Los principios SOLID y los patrones de diseño son fundamentales en el desarrollo de software, ya que permiten la creación de sistemas más mantenibles, escalables y flexibles. Al aplicarlos, garantizamos que nuestras aplicaciones no solo cumplan con su función principal, sino que también sean sostenibles a largo plazo. A lo largo de este curso, hemos integrado estos principios en el diseño de un procesador de pagos, demostrando su impacto positivo en la calidad del código.

¿Cómo se aplicaron los principios SOLID en el procesador de pagos?

Principio de responsabilidad única: Inicialmente, el procesador de pagos tenía un único método que realizaba múltiples tareas, desde validar la información hasta notificar a servicios externos. Al aplicar este principio, separamos estas responsabilidades en clases individuales, cada una encargada de una tarea específica.
Principio de abierto/cerrado: A medida que evoluciona un software, es crucial que este pueda admitir nuevas funcionalidades sin alterar su estructura existente. Dividimos el código en módulos, permitiendo extender sus capacidades sin comprometer su estabilidad inicial.
Principio de sustitución de Liskov: Nos aseguramos de que las clases derivadas pudieran sustituir a las clases base sin alterar la funcionalidad del programa, realizando pruebas y validaciones constantes.
Principio de segregación de interfaces: Implementamos interfaces más específicas para evitar que las clases estuvieran obligadas a depender de métodos que no necesitan, haciendo el código más limpio y comprensible.
Principio de inversión de dependencias: Invertimos las relaciones de dependencia para que las implementaciones dependieran de abstracciones, facilitando el intercambio de componentes sin impactar gravemente en el sistema completo.

¿Qué patrones de diseño se integraron en el sistema?

Patrón Builder: Este patrón facilitó la instancia de las clases de forma más sencilla y clara, mejorando la legibilidad del código y reduciendo la complejidad al crear objetos complejos.
Patrón Factory: Dependiendo de las circunstancias, el patrón Factory nos permitió seleccionar el procesador de pagos adecuado, garantizando que la elección del objeto fuera adecuada para cada contexto específico.
Cadena de responsabilidades: Esta se utilizó para validar la información antes de procesar un pago, asegurando que solo las transacciones correctas fueran enviadas para su procesamiento, reduciendo errores y mejorando la eficacia.

¿Qué beneficios aporta la refactorización del código original?

La refactorización del código inicial proporcionó un sistema más sólido y preparado para el futuro. Algunas de las mejoras logradas incluyen:

Mantenibilidad: El código es más fácil de entender, revisar y actualizar, lo que permite integrar cambios o mejoras sin grandes complicaciones.
Escalabilidad: Está preparado para manejar un mayor volumen de transacciones y permitir la inclusión de nuevas funcionalidades de forma sencilla.
Adaptabilidad: A pesar de que el software eventualmente será reemplazado, su diseño actual lo hace flexible ante distintas necesidades y futuros cambios.

El trabajo con principios SOLID y patrones de diseño no solo garantiza un software funcional, sino uno que está preparado para evolucionar. Recuerda siempre: la dedicación y el aprendizaje continuo son claves para la excelencia en el desarrollo de software. ¡Nunca pares de aprender!

juan esteban colcombet

student•

es posible subir el codigo final en algun lado?

Mario Alexander Vargas Celis

student•

es el GitHub del profesor: https://github.com/platzi/solid-principles-python/tree/main

Ulises Alejandro Mánica Caricio

student•

Es curioso porque a primera vista podría ser mucho más tedioso desarrollar con principios y con patrones que sin ellos pero es esta misma robustez lo que te facilitará las cosas a futuro... Te felicito Eduardo ... Gran trabajo en la elaboración del curso... a veces puede volverse difícil de seguir pero con lecturas complementarias y volviendo a ver el vídeo varias veces se tiene una comprensión más profunda de lo mencionado.... Saludos!

edgardo ponce

student•

dejo mi repo, les puede ahorrar un tiempo. Esta dividido por branchs. saludos

Mario Alexander Vargas Celis

student•

Diseñar un **Procesador de Pagos** utilizando **Patrones de Diseño** y aplicando los **Principios SOLID** permite crear un sistema flexible, extensible y fácil de mantener. Este ejemplo integrará los principios SOLID y varios patrones de diseño. ### Escenario Un sistema de procesador de pagos que soporta múltiples métodos de pago (tarjeta de crédito, PayPal, transferencia bancaria) y permite extensiones futuras para agregar nuevos métodos sin modificar el código existente. ## Principios SOLID Aplicados 1. **Principio de Responsabilidad Única (SRP)**: Cada clase tendrá una única responsabilidad, como manejar un método de pago específico.2. **Principio Abierto/Cerrado (OCP)**: Permitimos agregar nuevos métodos de pago sin modificar las clases existentes, gracias al uso de interfaces y el patrón *Factory*.3. **Principio de Sustitución de Liskov (LSP)**: Las clases derivadas de una interfaz o clase base pueden ser utilizadas indistintamente.4. **Principio de Segregación de Interfaces (ISP)**: Las interfaces estarán bien segmentadas, asegurando que cada clase implemente solo lo que necesita.5. **Principio de Inversión de Dependencias (DIP)**: El sistema dependerá de abstracciones y no de implementaciones concretas. ## Arquitectura y Patrones Usados 1. **Patrón Strategy**: Se utilizará para definir los métodos de pago como estrategias intercambiables.2. **Patrón Factory**: Ayuda a crear instancias de métodos de pago según sea necesario.3. **Patrón Decorator**: Para agregar funcionalidad adicional, como registro o validación.4. **Patrón Chain of Responsibility**: Para validar las solicitudes de pago en pasos secuenciales.

## Implementación en Python ### 1. Definición de Interfaces y Clases Base Definimos una interfaz para los métodos de pago.

class MetodoPago(ABC):    @abstractmethod    def procesar\_pago(self, monto):        """Procesa el pago."""        pass```
\### 2. Métodos de Pago Concretos
Creamos implementaciones específicas para cada método de pago.
```pythonclass TarjetaCredito(MetodoPago):    def procesar\_pago(self, monto):        print(f"Procesando pago de ${monto} con tarjeta de crédito.")
class PayPal(MetodoPago):    def procesar\_pago(self, monto):        print(f"Procesando pago de ${monto} con PayPal.")
class TransferenciaBancaria(MetodoPago):    def procesar\_pago(self, monto):        print(f"Procesando pago de ${monto} mediante transferencia bancaria.")```
\### 3. Patrón Factory
Creamos un *\*factory\** para generar instancias de métodos de pago.
```pythonclass MetodoPagoFactory:    @staticmethod    def crear\_metodo\_pago(tipo):        if tipo == "tarjeta":            return TarjetaCredito()        elif tipo == "paypal":            return PayPal()        elif tipo == "transferencia":            return TransferenciaBancaria()        else:            raise ValueError(f"Método de pago no soportado: {tipo}")```
\### 4. Validación con Chain of Responsibility
Definimos una cadena para validar las solicitudes de pago.
```pythonclass Validador(ABC):    def \_\_init\_\_(self):        self.siguiente = None
    def establecer\_siguiente(self, validador):        self.siguiente = validador        return validador
    @abstractmethod    def validar(self, datos):        pass
class ValidadorMonto(Validador):    def validar(self, datos):        if datos.get("monto", 0) <= 0:            return "Error: Monto inválido."        elif self.siguiente:            return self.siguiente.validar(datos)        return "Validación completada."
class ValidadorMetodoPago(Validador):    def validar(self, datos):        if not datos.get("metodo\_pago"):            return "Error: Método de pago no especificado."        elif self.siguiente:            return self.siguiente.validar(datos)        return "Validación completada."```
\### 5. Decorador para Funcionalidades Adicionales
Usamos el patrón *\*Decorator\** para agregar funcionalidades como registro.
```pythonclass LoggerDecorator(MetodoPago):    def \_\_init\_\_(self, metodo\_pago):        self.\_metodo\_pago = metodo\_pago
    def procesar\_pago(self, monto):        print(f"Registrando el pago de ${monto}.")        self.\_metodo\_pago.procesar\_pago(monto)```
\### 6. Flujo Principal
Integramos todo en un flujo de procesamiento.
```python# Configurar validacionesvalidador\_monto = ValidadorMonto()validador\_metodo\_pago = ValidadorMetodoPago()validador\_monto.establecer\_siguiente(validador\_metodo\_pago)
\# Datos de pagodatos\_pago = {"monto": 150, "metodo\_pago": "paypal"}
\# Validar datosresultado\_validacion = validador\_monto.validar(datos\_pago)if resultado\_validacion != "Validación completada.":    print(resultado\_validacion)else:    # Crear el método de pago    metodo\_pago = MetodoPagoFactory.crear\_metodo\_pago(datos\_pago\["metodo\_pago"])
    # Decorar con registro    metodo\_pago = LoggerDecorator(metodo\_pago)
    # Procesar el pago    metodo\_pago.procesar\_pago(datos\_pago\["monto"])```
\### Salida Esperada
```Validación completada.Registrando el pago de $150.Procesando pago de $150 con PayPal.```
\## Beneficios del Diseño
1\. \*\*Extensibilidad\*\*: Se pueden agregar nuevos métodos de pago sin modificar el código existente.2. \*\*Modularidad\*\*: Cada componente tiene una responsabilidad única y bien definida.3. \*\*Flexibilidad\*\*: Los validadores y decoradores se pueden reorganizar o ampliar fácilmente.4. \*\*Mantenibilidad\*\*: El código está organizado de forma lógica, facilitando los cambios futuros.
Este diseño combina lo mejor de los principios SOLID y patrones de diseño para crear un procesador de pagos robusto, escalable y fácil de mantener.