Arquetipo
Patrones de comportamientoUso: Muy altaComplejidad: Baja

Observer

Observador · Publicador-suscriptor

Define una relación de uno a muchos: cuando un objeto cambia o emite un evento, todos sus suscriptores reciben el aviso.

“Cuando algo pasa, varias partes del sistema deben enterarse.”

workEl caso real

Cuando se paga un pedido en tu e-commerce deben pasar varias cosas: enviar el correo de confirmación, reservar el stock, generar la factura y avisar al almacén para preparar el envío. Cada trimestre, marketing o logística piden reaccionar a ese mismo evento de alguna forma nueva.

warningEl problema sin el patrón

El servicio de pagos llama directamente a correo, inventario, facturación y almacén. Cada requisito nuevo obliga a modificarlo, y termina conociendo a medio sistema.

check_circleCómo lo resuelve el patrón

El servicio de pagos (el sujeto) mantiene una lista de suscriptores y, cuando un pedido se paga, les notifica el evento. Cada servicio se suscribe por su cuenta. Para añadir una reacción nueva se crea un suscriptor nuevo; el servicio de pagos no cambia.

schemaDiagrama de clases

Diagrama interactivo: puedes acercar, mover el lienzo y pasar el cursor sobre cada clase para ver su detalle.

codeEl código, antes y después

cancelSin el patrónANTES
class ServicioPagos {
  pagar(pedido: Pedido) {
    // ...lógica del pago
    correo.enviarConfirmacion(pedido);
    inventario.reservar(pedido);
    facturacion.emitir(pedido);
    almacen.prepararEnvio(pedido); // cada requisito nuevo modifica esta clase
  }
}
check_circleCon el patrónDESPUÉS
interface SuscriptorPagos {
  pedidoPagado(pedido: Pedido): void;
}

class ServicioPagos {
  private suscriptores: SuscriptorPagos[] = [];

  suscribir(s: SuscriptorPagos) { this.suscriptores.push(s); }
  desuscribir(s: SuscriptorPagos) {
    this.suscriptores = this.suscriptores.filter((x) => x !== s);
  }

  pagar(pedido: Pedido) {
    // ...lógica del pago
    for (const s of this.suscriptores) s.pedidoPagado(pedido);
  }
}

class EnviarConfirmacion implements SuscriptorPagos {
  pedidoPagado(pedido: Pedido) { correo.enviarConfirmacion(pedido); }
}

pagos.suscribir(new EnviarConfirmacion());
pagos.suscribir(new ReservarStock());

Ejemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.

lightbulb

Matiz importante

En su forma básica la notificación es síncrona: si un suscriptor lanza una excepción, puede interrumpir a los demás e incluso al pago. Para aislar los fallos, se captura el error de cada suscriptor o se publica el evento en una cola (RabbitMQ, Kafka, SQS) para que cada servicio lo procese por separado.

thumb_upCuándo usarlo

  • ✓Un cambio en un objeto debe provocar reacciones en otros, y no sabes de antemano cuántos ni cuáles.
  • ✓Quieres separar el núcleo del negocio de sus efectos secundarios (correos, métricas, integraciones).

do_not_disturb_onCuándo no usarlo

  • ✕Las reacciones deben ejecutarse en un orden garantizado: con Observer el orden no debería importar.
  • ✕El flujo se vuelve difícil de seguir: al leer pagar() ya no ves todo lo que ocurre.
  • ✕Los suscriptores no se dan de baja: se acumulan referencias y aparecen fugas de memoria.

memoryPrincipios en juego

  • •Abierto/Cerrado: añades reacciones nuevas sin modificar al sujeto.
  • •Bajo acoplamiento: el sujeto solo conoce una interfaz de suscriptor.

hubPatrones relacionados

  • •Mediator: suele usar Observer para recibir avisos; Observer difunde, Mediator coordina.
  • •Chain of Responsibility: la petición la atiende uno; en Observer la reciben todos.
  • •Command: los eventos pueden encolarse como comandos para procesarlos más tarde.

quizPon a prueba lo que leíste

Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.

Más ejercicios →

code_blocksObserver en tu lenguaje

El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.

LO IDIOMÁTICO EN TYPESCRIPT: suscribir devuelve la función para darse de baja (el estilo habitual en JavaScript), los suscriptores se guardan en un Set y cada uno se ejecuta en un try/catch para que un fallo no impida que los demás reciban el aviso.

observer.ts · 40 líneas
export interface Pedido {
  id: string;
  total: number;
}

export interface SuscriptorPagos {
  pedidoPagado(pedido: Pedido): void | Promise<void>;
}

export class ServicioPagos {
  readonly #suscriptores = new Set<SuscriptorPagos>();

  suscribir(suscriptor: SuscriptorPagos): () => void {
    this.#suscriptores.add(suscriptor);
    return () => this.#suscriptores.delete(suscriptor);
  }

  async pagar(pedido: Pedido): Promise<void> {
    console.log(`Pedido ${pedido.id} cobrado`);
    for (const suscriptor of this.#suscriptores) {
      try {
        await suscriptor.pedidoPagado(pedido);
      } catch (error) {
        console.log(`  ⚠ un suscriptor falló: ${(error as Error).message}`);
      }
    }
  }
}

// ── Uso ──
const pagos = new ServicioPagos();

pagos.suscribir({ pedidoPagado: (p) => console.log(`  correo de confirmación para ${p.id}`) });
pagos.suscribir({ pedidoPagado: () => { throw new Error('inventario no disponible'); } });
const darDeBajaFactura = pagos.suscribir({ pedidoPagado: (p) => console.log(`  factura emitida por ${p.total}`) });

await pagos.pagar({ id: 'P-1', total: 250 });

darDeBajaFactura();
await pagos.pagar({ id: 'P-2', total: 90 }); // ya no se emite factura
Ver los 23 patrones en TypeScript →