Patrón Factory para procesar pagos con match

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:0011:06

Patrón Factory para procesar pagos con match

Curso de Patrones de Diseño y SOLID en Python

Clase 18 de 27

Clase 18 / 27

Recursos

Aplicar patrón factory en Python permite encapsular la lógica de creación de objetos y tomar decisiones limpias y reutilizables. Aquí se muestra cómo elegir entre Stripe, offline y local según el PaymentData y su PaymentType, usando enum, match, static method y un protocol para el procesador. Además, se integra en un class method con tipado Self y manejo de errores con ValueError.

¿Qué problema resuelve el patrón factory en pagos?

El objetivo es centralizar la decisión de qué procesador instanciar según la información de pago. El PaymentData ahora incluye un tipo mediante un enum de Python con valores: offline u online. El tipo por defecto es online, lo que aporta contexto sobre cómo cobrar.

Si el tipo es offline, retorna el procesador OfflinePaymentProcessor.
Si el tipo es online y la moneda es USD, retorna StripePaymentProcessor.
Si el tipo es online y la moneda no es USD, retorna LocalPaymentProcessor.
Se define un caso por defecto que lanza ValueError para tipos no soportados.

Así, la lógica de decisión queda encapsulada y puede reutilizarse en todo el servicio.

¿Cómo implementar PaymentProcessorFactory con match en Python?

La clase PaymentProcessorFactory expone un static method createPaymentProcessor que recibe paymentData y devuelve un PaymentProcessorProtocol. La decisión se implementa con el operador de pattern matching match.

from commons import PaymentData, PaymentType
from processors import (
    PaymentProcessorProtocol,
    OfflinePaymentProcessor,
    StripePaymentProcessor,
    LocalPaymentProcessor,
)

class PaymentProcessorFactory:
    @staticmethod
    def createPaymentProcessor(paymentData: PaymentData) -> PaymentProcessorProtocol:
        match paymentData.type:
            case PaymentType.OFFLINE:
                return OfflinePaymentProcessor()
            case PaymentType.ONLINE:
                match paymentData.currency:
                    case "USD":
                        return StripePaymentProcessor()
                    case _:
                        return LocalPaymentProcessor()
            case _:
                # Caso ejemplo para tipos no soportados
                raise ValueError("Tipo de pago no soportado")

Puntos clave:

PaymentType es un enum con valores offline y online.
Se usa match con case y _ como caso por defecto.
El método retorna un PaymentProcessorProtocol, asegurando contrato de integración.
Se lanza ValueError para señalizar validaciones fallidas.

¿Cómo integrarlo en el servicio con createWithPaymentProcessor?

Se añade un class method que, a partir del paymentData, pide al factory el procesador adecuado y crea la instancia del servicio con los demás atributos que llegan como kwargs: notifier, customer validator, payment validator y logger.

from typing import Self
from factory import PaymentProcessorFactory

class PaymentService:
    @classmethod
    def createWithPaymentProcessor(cls, paymentData: PaymentData, **kwargs) -> Self:
        try:
            processor = PaymentProcessorFactory.createPaymentProcessor(paymentData)
            return cls(payment_processor=processor, **kwargs)
        except ValueError as e:
            print("Error creando la clase")
            raise e

Se utiliza Self para indicar que retorna una instancia de la misma clase.
kwargs actúa como diccionario con los atributos restantes del servicio.
El try/except captura ValueError lanzada por el factory.

¿Cómo usarlo desde main con PaymentData de ejemplo?

El PaymentData incluye monto, fuente y moneda. Si la moneda es USD y el tipo por defecto es online, se selecciona Stripe.

from commons import PaymentData

paymentData = PaymentData(
    amount=100,
    source="stock visa",
    currency="USD",  # type por defecto: online
)

service = PaymentService.createWithPaymentProcessor(
    paymentData,
    notifier=notifier,
    customer_validator=customer_validator,
    payment_validator=payment_validator,
    logger=logger,
)

¿Qué habilidades y conceptos aplicas aquí?

Patrón factory: encapsular creación y aislar reglas de negocio.
Enums: PaymentType con offline y online.
Match/case en Python para decisiones claras y anidadas.
Protocolos: PaymentProcessorProtocol como contrato de integración.
Métodos estáticos y de clase: static method para crear, class method para orquestar.
Tipado avanzado: uso de Self y tipos explícitos.
Manejo de errores: ValueError para entradas no soportadas.
Composición con kwargs: pasar notifier, customer validator, payment validator y logger al constructor.
Depuración: uso de breakpoint para verificar el flujo y la instancia seleccionada.

¿De qué otra forma aplicarías patrón factory en este proyecto? Comparte tus ideas en comentarios.

Mario Alexander Vargas Celis

Hace 2 años

El **Patrón Factory** es útil para centralizar la creación de objetos, especialmente cuando tienes varias clases que comparten una interfaz común o base y quieres que el cliente no se preocupe por los detalles de su creación. Implementaremos un ejemplo paso a paso para entenderlo.

---

### Ejemplo: Sistema de Vehículos

Queremos implementar un sistema para crear vehículos como autos, motocicletas y camiones. Cada uno tendrá características específicas, pero todos compartirán un comportamiento común: **mostrar su tipo de vehículo**.

---

### Paso 1: Crear la Interfaz Común

Definimos una clase base o interfaz que todas las clases de vehículos implementarán.


from abc import ABC, abstractmethod



class Vehicle(ABC):

&#x20;   @abstractmethod

&#x20;   def get\_type(self) -> str:

&#x20;       """Devuelve el tipo de vehículo."""

&#x20;       pass

---

### Paso 2: Implementar Clases Concretas

Creamos clases para cada tipo de vehículo.


class Car(Vehicle):

&#x20;   def get\_type(self) -> str:

&#x20;       return "Auto"



class Motorcycle(Vehicle):

&#x20;   def get\_type(self) -> str:

&#x20;       return "Motocicleta"



class Truck(Vehicle):

&#x20;   def get\_type(self) -> str:

&#x20;       return "Camión"

---

### Paso 3: Crear la Fábrica

La fábrica centraliza la lógica para instanciar diferentes tipos de vehículos según sea necesario.


class VehicleFactory:

&#x20;   @staticmethod

&#x20;   def create\_vehicle(vehicle\_type: str) -> Vehicle:

&#x20;       if vehicle\_type == "car":

&#x20;           return Car()

&#x20;       elif vehicle\_type == "motorcycle":

&#x20;           return Motorcycle()

&#x20;       elif vehicle\_type == "truck":

&#x20;           return Truck()

&#x20;       else:

&#x20;           raise ValueError(f"Tipo de vehículo desconocido: {vehicle\_type}")

---

### Paso 4: Usar el Patrón Factory

Utilizamos la fábrica para crear vehículos de forma sencilla.


\# Crear vehículos usando la fábrica

vehicle1 = VehicleFactory.create\_vehicle("car")

vehicle2 = VehicleFactory.create\_vehicle("motorcycle")

vehicle3 = VehicleFactory.create\_vehicle("truck")



\# Mostrar sus tipos

print(vehicle1.get\_type())  # Output: Auto

print(vehicle2.get\_type())  # Output: Motocicleta

print(vehicle3.get\_type())  # Output: Camión

---

### Ventajas del Patrón Factory

1. **Centralización**: Toda la lógica de creación de objetos está en un solo lugar.

2. **Extensibilidad**: Agregar un nuevo tipo de vehículo solo requiere crear una nueva clase y modificar la fábrica.

3. **Separación de Responsabilidades**: El cliente no necesita saber cómo se crean los objetos, solo qué tipo necesita.

---

### Mejorando con Diccionarios

Para evitar múltiples condicionales, podemos usar un diccionario para mapear tipos de vehículos a sus clases concretas.


class VehicleFactory:

&#x20;   \_vehicle\_classes = {

&#x20;       "car": Car,

&#x20;       "motorcycle": Motorcycle,

&#x20;       "truck": Truck,

&#x20;   }



&#x20;   @staticmethod

&#x20;   def create\_vehicle(vehicle\_type: str) -> Vehicle:

&#x20;       vehicle\_class = VehicleFactory.\_vehicle\_classes.get(vehicle\_type)

&#x20;       if not vehicle\_class:

&#x20;           raise ValueError(f"Tipo de vehículo desconocido: {vehicle\_type}")

&#x20;       return vehicle\_class()

---

### Extensión del Patrón Factory

#### Agregar un Nuevo Vehículo

Si deseas agregar, por ejemplo, una bicicleta al sistema:

1. Crea una nueva clase concreta:

```python

class Bicycle(Vehicle):

def get_type(self) -> str:

return "Bicicleta"

```

2. Agrega su mapeo en el diccionario de la fábrica:

```python

_vehicle_classes = {

"car": Car,

"motorcycle": Motorcycle,

"truck": Truck,

"bicycle": Bicycle, # Nueva clase agregada

}

```

### Conclusión

El **Patrón Factory** simplifica la creación de objetos al delegar esta tarea a una clase específica. Es un patrón especialmente útil cuando se espera que el sistema crezca, ya que permite añadir nuevos tipos de objetos sin modificar el código del cliente, promoviendo el **Principio Abierto/Cerrado (OCP)**.

Este ejemplo muestra cómo aplicar el patrón de forma sencilla en Python, con la flexibilidad para adaptarlo a proyectos más complejos.

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 Factory para procesar pagos con match

Progreso del curso

Patrones de Diseño y Principios SOLID

Principios SOLID

Reestructuración del proyecto

Patrones de Diseño

Recursos

Recursos