Observer Pattern

Observer (or Pub/Sub) is a behavioral design pattern that lets an object (the subject or publisher) notify other objects (the observers or subscribers) about changes in its state without tightly coupling their classes.

Purpose and Use Case

Use the Observer pattern when a change to the state of one object requires changing other objects, and you don't know in advance how many objects need to change. It promotes adherence to the Single Responsibility Principle (SOLIDGlosarioSOLIDAcrónimo de cinco principios de diseño orientado a objetos y programación diseñados para hacer que el software sea más comprensible, flexible y mantenible: S - Single Responsibility Principle (Responsabilidad Única) O - Open/Closed Principle (Abierto/Cerrado) L - Liskov Substitution Principle (Sustitución de Liskov) I - Interface Segregation Principle (Segregación de Interfaz) D - Dependency Inversion Principle (Inversión de Dependencias) Ver término completo →) and keeps code decoupled (KISSGlosarioKISS (Keep It Simple, Stupid)Principio de diseño que establece que la mayoría de los sistemas funcionan mejor si se mantienen simples en lugar de hacerlos complejos. Se debe evitar la complejidad innecesaria en la arquitectura y el código.Ver término completo →).

Unlike creational patterns such as the Singleton Pattern or Factory Method Pattern, Observer manages dynamic runtime communication.

Pattern Structure

1. Subject (Publisher): Emits events of interest and maintains a list of subscribers to notify them.
2. Observer (Subscriber): Interface declaring the update method (update).
3. Concrete Observers: Implementations that react to notifications sent by the publisher.

Execution Flow

1. Subscription: Observer objects register with the subject via .subscribe(observer).
2. Event: A state change occurs in the subject (e.g., new order placed).
3. Notification: The subject iterates through its internal subscriber list and invokes the .update(data) method on each observer.

Real Implementation Examples

interface Observer<T> {
  update(data: T): void;
}
 
class OrderService {
  private observers: Observer<{ orderId: string; total: number }>[] = [];
 
  public subscribe(observer: Observer<{ orderId: string; total: number }>): void {
    this.observers.push(observer);
  }
 
  public unsubscribe(observer: Observer<{ orderId: string; total: number }>): void {
    this.observers = this.observers.filter(obs => obs !== observer);
  }
 
  public createOrder(orderId: string, total: number): void {
    console.log(`Order ${orderId} created for $${total}`);
    this.notify({ orderId, total });
  }
 
  private notify(data: { orderId: string; total: number }): void {
    this.observers.forEach(obs => obs.update(data));
  }
}
 
// Observer 1: Email notification
class EmailNotifier implements Observer<{ orderId: string; total: number }> {
  update(data: { orderId: string; total: number }): void {
    console.log(`[Email] Confirmation sent for order ${data.orderId}`);
  }
}
 
// Observer 2: Inventory manager
class InventoryManager implements Observer<{ orderId: string; total: number }> {
  update(data: { orderId: string; total: number }): void {
    console.log(`[Inventory] Stock updated for order ${data.orderId}`);
  }
}
 
// Usage:
const orderService = new OrderService();
orderService.subscribe(new EmailNotifier());
orderService.subscribe(new InventoryManager());
 
orderService.createOrder("ORD-2026-99", 149.99);