Patrón Observer: Gestión de Eventos y Notificaciones Automáticas

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

Resumen

¿Qué es el Observer Pattern?

Comenzar a profundizar en el Observer Pattern es descubrir un patrón de diseño que proporciona una solución eficiente para la gestión de notificaciones de eventos en un sistema. Este patrón de diseño es esencial en sistemas donde es necesario implementar un servicio de suscripción y notificación de eventos, y por su simplicidad y eficacia es muy utilizado en la industria del software.

¿Cómo se estructura el Observer Pattern?

Para desglosar un poco más el Observer Pattern, se compone de tres entidades principales: la clase Manager, la interfaz Listener y las clases que implementan esta interfaz. La clase Manager tiene un papel crucial, manejando la dinámica de agregar, remover y notificar a todos los listeners suscritos. Su gestión eficiente permite que los eventos se mantengan actualizados automáticamente.

Clase Manager:
- Métodos:
  - Agregar Listeners: Permite suscribir nuevos objetos interesados en los eventos.
  - Remover Listeners: Retira aquellos que ya no necesitan notificaciones.
  - Notificar a todos los Listeners: Avisa a todos los suscriptores de un evento que ha ocurrido.
Interfaz Listener:
- Define un método Update que recibe un evento de cualquier tipo como parámetro.
Clases que implementan Listener:
- Son los diferentes servicios o componentes que necesitan recibir notificaciones. En el ejemplo discutido, tenemos servicios de email y login que implementan el método Update.

¿Cuándo debemos aplicar el Observer Pattern?

El Observer Pattern es ideal en situaciones donde:

Un cambio en el estado de un objeto necesita ser notificado a múltiples objetos.
Se requiere implementar un sistema de eventos.
Se necesitan mecanismos de suscripción y notificación articulados.

Esta versatilidad lo hace poderoso para gestionar la comunicación entre componentes del sistema sin crear dependencias rígidas.

Implementación del Observer Pattern

Implementar el Observer Pattern es un proceso estructurado que se puede seguir en tres pasos claros:

Definir la interfaz Listener:
- Crear la interfaz que dispondrá del método de notificación, permitiendo comunicación flexible con los múltiples objetos suscriptores.
Crear la clase Manager:
- Encargada de gestionar los listeners. Aquí es donde se definen los métodos de suscripción, desuscripción y notificación.
Incorporar el Manager en la clase de alto nivel:
- Usarlo como atributo en la clase principal que orquestará las notificaciones. En nuestro ejemplo, es el servicio de pagos el encargado de invocar notifyAll del manager cuando es necesario comunicar un evento.

Conclusión: El poder del Observer Pattern

El uso del Observer Pattern no solo facilita la comunicación eficaz y la gestión de eventos dentro de un sistema, sino que ofrece una estructura modular flexible que puede adaptarse a las necesidades cambiantes de un proyecto. Este patrón de diseño subraya la importancia de separar las preocupaciones y mantener la flexibilidad en el desarrollo de software, permitiendo que los componentes interactúen de manera eficiente sin estar estrechamente acoplados. ¡No dudes en aplicar el patrón Observer en tu próximo proyecto para ver sus ventajas en acción!

Ray Trápala

student•

En mi proyecto de bot de trading, uso un WebsocketManager que gestiona las conexiones las suscripciones de los websockets así como creación y eliminación de los mismos y las suscripciones a los streams.

La estrategia usa estos para notificar por consolar y por mensaje de telegram.

Este escenario es factible para este patrón, me queda la duda? uso colas asíncronas que van guardando los mensajes en la cola y la estrategia las va analizando

Eduardo José Álvarez

Team Platzi•

sí es porque en este caso tienes diferentes sitios a los que tienes que notificar (consola y telegram), este patrón te permite definir un solo lugar donde gestionar las notificaciones que debes hacer

Rodrigo Martinez

student•

Tu escenario es factible para el Patrón Observer. El WebsocketManager actuaría como el "Manager" que notifica los eventos, y tu estrategia de trading con sus notificaciones (consola, Telegram) serían los "Listeners" que reaccionan a esos eventos. Las colas asíncronas encajan para gestionar esos mensajes.

José Salas Bolívar

student•

El patrón Observer se estructura en tres componentes principales:

Interfaz Listener: Define el método update(), el cual será implementado por los objetos que quieren recibir actualizaciones.
Clase Manager (Subject): Gestiona a los observadores. Tiene métodos para agregar, eliminar y notificar a los listeners cuando ocurre un evento.
Clases Observadoras: Implementan la interfaz Listener y definen la lógica que se ejecutará cuando sean notificadas.

Este patrón se usa para implementar sistemas de eventos donde múltiples objetos necesitan estar al tanto de los cambios en otro objeto.

José Salas Bolívar

student•

El patrón Observer es un patrón de diseño de comportamiento que permite a un objeto (el sujeto) notificar a otros objetos (los observadores) sobre cambios en su estado. Esto es útil en situaciones donde un cambio en un objeto requiere la actualización de otros objetos. En Python, se define una interfaz Listener con un método update, que los observadores implementan. Un Manager gestiona la suscripción y notificación de los observadores, permitiendo que el sujeto los notifique cuando suceden eventos relevantes. Este patrón es ideal para sistemas de eventos y notificaciones automáticas.

Mario Alexander Vargas Celis

student•

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.