Observer Pattern en sistemas de eventos

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:001:48

Observer Pattern en sistemas de eventos

Curso de Patrones de Diseño y SOLID en Python

Clase 23 de 27

Clase 23 / 27

Recursos

Aprende a aplicar el Observer Pattern para lograr gestión flexible de suscripciones y actualización automática ante eventos. Ideal cuando necesitas un servicio de notificación en sistemas con múltiples receptores, con una estructura clara: manager, listeners y un método update que centraliza la reacción a cambios.

¿Qué es el patrón observer y para qué sirve?

El Observer Pattern es un patrón de diseño de comportamiento que resuelve la notificación de eventos a múltiples interesados sin acoplarlos entre sí. Se utiliza para implementar un servicio de eventos simple y efectivo, ampliamente adoptado por su practicidad y facilidad.

¿Cómo se organiza la arquitectura con listeners y manager?

Clase manager: agrega, remueve y notifica a todos los listeners.
Interfaz listener: define el método update(evento: cualquier tipo).
Implementaciones de listener: servicios como email y login que reaccionan en su método update.
Clase principal: incluye al manager como atributo; por ejemplo, un servicio de pagos que llama a notifyAll cuando hay que notificar.

¿Cuándo aplicarlo en sistemas de eventos?

Se recomienda cuando:

Un cambio debe notificar a múltiples objetos de forma automática.
Se implementa un sistema de eventos con receptores independientes.
Se necesitan mecanismos de suscripción y notificación simples y claros.

¿Qué beneficios inmediatos aporta?

Gestión flexible de suscripciones y receptores.
Actualización automática ante nuevos eventos.
Simplicidad en la integración de nuevos listeners.

¿Cómo implementarlo paso a paso?

Aplica esta secuencia mínima:

Define una interfaz Listener con un método de notificación: update(evento).
Crea una clase manager que gestione listeners: agregar, remover y notifyAll.
Agrega el manager como atributo de la clase de alto nivel (por ejemplo, el servicio de pagos) y úsalo para notificar.

// 1) Interfaz Listener
interface Listener {
  update(event: any): void;
}

// 2) Clase manager (gestiona suscriptores y notificaciones)
class EventManager {
  private listeners: Listener[] = [];

  add(listener: Listener): void {
    this.listeners.push(listener);
  }

  remove(listener: Listener): void {
    this.listeners = this.listeners.filter(l => l !== listener);
  }

  notifyAll(event: any): void {
    this.listeners.forEach(l => l.update(event));
  }
}

// Implementaciones de Listener (servicios que reaccionan al evento)
class EmailListener implements Listener {
  update(event: any): void {
    // Lógica de notificación por email.
  }
}

class LoginListener implements Listener {
  update(event: any): void {
    // Lógica relacionada con login.
  }
}

// 3) Clase de alto nivel con el manager como atributo (servicio de pagos)
class PaymentsService {
  private manager = new EventManager();

  constructor() {
    this.manager.add(new EmailListener());
    this.manager.add(new LoginListener());
  }

  procesarPago(): void {
    // ... lógica de pago.
    this.manager.notifyAll(/* evento */ undefined);
  }
}

¿Qué habilidades y conceptos refuerza?

Uso de interfaces y clases para contratos claros.
Diseño de sistemas de eventos con suscripción y notificación.
Implementación de listeners como servicios: email y login.
Estructuración de una clase de alto nivel con atributo manager y método notifyAll.

¿Has aplicado el patrón Observer en tus proyectos? Compártelo en comentarios y cuéntanos tu caso de uso.

Mario Alexander Vargas Celis

Hace 2 años

El **Patrón Observer** es un patrón de diseño de comportamiento que define una relación de dependencia entre objetos, de manera que cuando un objeto cambia de estado (el *subject*), todos los objetos que dependen de él (los *observers*) son notificados automáticamente. Este patrón es útil para escenarios donde múltiples objetos deben reaccionar a los cambios en otro objeto sin acoplarse estrechamente. ### Ejemplo Clásico: Sistema de Notificaciones Vamos a implementar un sistema donde varios *observers* (como usuarios o servicios) sean notificados cuando un sistema de pagos cambie de estado, por ejemplo, cuando se procese un pago. ### Paso 1: Definir el Subject El **Subject** es el objeto principal al que los observadores se suscriben.

    def attach(self, observer):        """Agrega un observer a la lista."""        self.\_observers.append(observer)
    def detach(self, observer):        """Elimina un observer de la lista."""        self.\_observers.remove(observer)
    def notify(self, message):        """Notifica a todos los observers."""        for observer in self.\_observers:            observer.update(message)```
\### Paso 2: Definir la Interfaz del Observer
Cada \*\*Observer\*\* debe implementar un método `update` que será llamado por el Subject.
```pythonfrom abc import ABC, abstractmethod
class Observer(ABC):    @abstractmethod    def update(self, message):        pass```
\### Paso 3: Implementar Observers Concretos
Crea clases concretas que implementen la interfaz del Observer.
```pythonclass EmailNotifier(Observer):    def update(self, message):        print(f"EmailNotifier: Enviando email con el mensaje: '{message}'")
class SMSNotifier(Observer):    def update(self, message):        print(f"SMSNotifier: Enviando SMS con el mensaje: '{message}'")
class LogNotifier(Observer):    def update(self, message):        print(f"LogNotifier: Registrando en el log: '{message}'")```
\### Paso 4: Usar el Patrón Observer
Ahora conectemos todo. Supongamos que tenemos un sistema de pagos que notifica a los observadores cuando un pago se procesa.
```pythonclass PaymentSystem(Subject):    def process\_payment(self, amount, method):        print(f"Procesando pago de {amount} usando {method}.")        self.notify(f"Pago de {amount} procesado con {method}.")```
\#### Código Principal
```python# Crear un sistema de pagospayment\_system = PaymentSystem()
\# Crear observersemail\_notifier = EmailNotifier()sms\_notifier = SMSNotifier()log\_notifier = LogNotifier()
\# Suscribir observers al sistema de pagospayment\_system.attach(email\_notifier)payment\_system.attach(sms\_notifier)payment\_system.attach(log\_notifier)
\# Procesar un pagopayment\_system.process\_payment(100, "Tarjeta de Crédito")
\# Desuscribir un observerpayment\_system.detach(sms\_notifier)
\# Procesar otro pagopayment\_system.process\_payment(200, "PayPal")```
\### Salida Esperada
\*\*Primer pago (todos los observers suscritos):\*\*```Procesando pago de 100 usando Tarjeta de Crédito.EmailNotifier: Enviando email con el mensaje: 'Pago de 100 procesado con Tarjeta de Crédito.'SMSNotifier: Enviando SMS con el mensaje: 'Pago de 100 procesado con Tarjeta de Crédito.'LogNotifier: Registrando en el log: 'Pago de 100 procesado con Tarjeta de Crédito.'```
\*\*Segundo pago (SMSNotifier desuscrito):\*\*```Procesando pago de 200 usando PayPal.EmailNotifier: Enviando email con el mensaje: 'Pago de 200 procesado con PayPal.'LogNotifier: Registrando en el log: 'Pago de 200 procesado con PayPal.'```
\### Ventajas del Patrón Observer
1\. \*\*Desacoplamiento\*\*: Los *\*subjects\** no necesitan conocer los detalles de implementación de los *\*observers\**.2. \*\*Flexibilidad\*\*: Puedes añadir o eliminar *\*observers\** en tiempo de ejecución.3. \*\*Reutilización\*\*: Los *\*observers\** pueden ser reutilizados en diferentes *\*subjects\**.
\### Aplicaciones Reales
1\. \*\*Interfaces de usuario\*\*: Notificación de cambios en un modelo a vistas o controladores.2. \*\*Sistemas de eventos\*\*: Como el patrón *\*pub-sub\** en sistemas de mensajería.3. \*\*Notificaciones en tiempo real\*\*: Servicios como websockets o push notifications.
\### Conclusión
El \*\*Patrón Observer\*\* es una solución robusta para implementar sistemas donde un objeto central (como un sistema de pagos) necesita informar a otros objetos sobre sus cambios de estado. Su implementación en Python es simple y aprovecha características como listas dinámicas para gestionar observadores de manera eficiente.

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

Observer Pattern en sistemas de eventos

Progreso del curso

Patrones de Diseño y Principios SOLID

Principios SOLID

Reestructuración del proyecto

Patrones de Diseño

Recursos

Recursos