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
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
}
}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.
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.
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.
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 facturaLO IDIOMÁTICO EN C# / .NET: C# tiene el patrón dentro del lenguaje: event con EventHandler<T>. Suscribirse es += y darse de baja -=. Para que el fallo de un suscriptor no impida avisar a los demás, se recorre GetInvocationList() y se llama a cada uno dentro de un try/catch.
var pagos = new ServicioPagos();
EventHandler<Pedido> emitirFactura = (_, pedido) => Console.WriteLine($" factura emitida por {pedido.Total}");
pagos.PedidoPagado += (_, pedido) => Console.WriteLine($" correo de confirmación para {pedido.Id}");
pagos.PedidoPagado += (_, _) => throw new InvalidOperationException("inventario no disponible");
pagos.PedidoPagado += emitirFactura;
pagos.Pagar(new Pedido("P-1", 250m));
pagos.PedidoPagado -= emitirFactura; // se da de baja
pagos.Pagar(new Pedido("P-2", 90m)); // ya no se emite factura
public record Pedido(string Id, decimal Total);
public class ServicioPagos
{
public event EventHandler<Pedido>? PedidoPagado;
public void Pagar(Pedido pedido)
{
Console.WriteLine($"Pedido {pedido.Id} cobrado");
var suscriptores = PedidoPagado?.GetInvocationList().Cast<EventHandler<Pedido>>() ?? [];
foreach (var suscriptor in suscriptores)
{
try
{
suscriptor(this, pedido);
}
catch (Exception error)
{
Console.WriteLine($" ⚠ un suscriptor falló: {error.Message}");
}
}
}
}LO IDIOMÁTICO EN JAVA: Los suscriptores son Consumer<Pedido> (lambdas) guardados en una CopyOnWriteArrayList, segura si se suscriben o dan de baja durante un aviso. suscribir devuelve un Runnable para darse de baja. (La antigua clase java.util.Observable está obsoleta; para flujos reactivos existe Flow.)
void main() {
var pagos = new ServicioPagos();
pagos.suscribir(p -> IO.println(" correo de confirmación para " + p.id()));
pagos.suscribir(p -> { throw new IllegalStateException("inventario no disponible"); });
Runnable cancelarFactura = pagos.suscribir(p -> IO.println(" factura emitida por " + p.total()));
pagos.pagar(new Pedido("P-1", 250));
cancelarFactura.run(); // se da de baja
pagos.pagar(new Pedido("P-2", 90)); // ya no se emite factura
}
record Pedido(String id, int total) {}
final class ServicioPagos {
private final List<Consumer<Pedido>> suscriptores = new CopyOnWriteArrayList<>();
Runnable suscribir(Consumer<Pedido> suscriptor) {
suscriptores.add(suscriptor);
return () -> suscriptores.remove(suscriptor);
}
void pagar(Pedido pedido) {
IO.println("Pedido " + pedido.id() + " cobrado");
for (var suscriptor : suscriptores) {
try {
suscriptor.accept(pedido);
} catch (RuntimeException error) {
IO.println(" ⚠ un suscriptor falló: " + error.getMessage());
}
}
}
}LO IDIOMÁTICO EN JAVASCRIPT: JavaScript ya trae el patrón: EventTarget con addEventListener y dispatchEvent, y los datos viajan en un CustomEvent. Para darse de baja se usa un AbortController, la forma moderna de cancelar suscripciones. Cada suscriptor se envuelve en un try/catch para aislar sus fallos.
export class ServicioPagos extends EventTarget {
/**
* @param {(pedido: { id: string, total: number }) => void} alPagar
* @param {AddEventListenerOptions} [opciones] por ejemplo, { signal } para darse de baja
*/
suscribir(alPagar, opciones = {}) {
this.addEventListener('pedido-pagado', (evento) => {
try {
alPagar(/** @type {CustomEvent} */ (evento).detail);
} catch (error) {
console.log(` ⚠ un suscriptor falló: ${error.message}`);
}
}, opciones);
}
pagar(pedido) {
console.log(`Pedido ${pedido.id} cobrado`);
this.dispatchEvent(new CustomEvent('pedido-pagado', { detail: pedido }));
}
}
// ── Uso ──
const pagos = new ServicioPagos();
const facturacion = new AbortController();
pagos.suscribir((p) => console.log(` correo de confirmación para ${p.id}`));
pagos.suscribir(() => { throw new Error('inventario no disponible'); });
pagos.suscribir((p) => console.log(` factura emitida por ${p.total}`), { signal: facturacion.signal });
pagos.pagar({ id: 'P-1', total: 250 });
facturacion.abort(); // da de baja al suscriptor de facturación
pagos.pagar({ id: 'P-2', total: 90 }); // ya no se emite facturaLO IDIOMÁTICO EN PYTHON: Los suscriptores son simples funciones. suscribir devuelve la misma función que recibe, así que se puede usar como decorador: @pagos.suscribir. Cada suscriptor se ejecuta dentro de un try/except para que el fallo de uno no impida que los demás reciban el aviso.
from collections.abc import Callable
from dataclasses import dataclass
@dataclass(frozen=True)
class Pedido:
id: str
total: float
Suscriptor = Callable[[Pedido], None]
class ServicioPagos:
def __init__(self) -> None:
self._suscriptores: list[Suscriptor] = []
def suscribir(self, funcion: Suscriptor) -> Suscriptor:
self._suscriptores.append(funcion)
return funcion
def desuscribir(self, funcion: Suscriptor) -> None:
self._suscriptores.remove(funcion)
def pagar(self, pedido: Pedido) -> None:
print(f"Pedido {pedido.id} cobrado")
for suscriptor in self._suscriptores:
try:
suscriptor(pedido)
except Exception as error:
print(f" ⚠ un suscriptor falló: {error}")
pagos = ServicioPagos()
@pagos.suscribir
def enviar_confirmacion(pedido: Pedido) -> None:
print(f" correo de confirmación para {pedido.id}")
@pagos.suscribir
def reservar_stock(pedido: Pedido) -> None:
raise RuntimeError("inventario no disponible")
@pagos.suscribir
def emitir_factura(pedido: Pedido) -> None:
print(f" factura emitida por {pedido.total:g}")
if __name__ == "__main__":
pagos.pagar(Pedido("P-1", 250))
pagos.desuscribir(emitir_factura)
pagos.pagar(Pedido("P-2", 90)) # ya no se emite facturaLO IDIOMÁTICO EN GO: Los suscriptores son funciones que devuelven error. Suscribir devuelve la función para darse de baja y Pagar avisa a todos aunque alguno falle, reuniendo los fallos con errors.Join. Para avisos asíncronos, lo idiomático sería enviar el evento por un canal a cada suscriptor.
package main
import (
"errors"
"fmt"
"slices"
)
type Pedido struct {
ID string
Total float64
}
type Suscriptor func(Pedido) error
type suscripcion struct {
id int
fn Suscriptor
}
// ServicioPagos no es seguro para varias goroutines; en ese caso, protegerlo con un sync.Mutex
type ServicioPagos struct {
suscripciones []suscripcion
ultimoID int
}
func (s *ServicioPagos) Suscribir(fn Suscriptor) (cancelar func()) {
s.ultimoID++
id := s.ultimoID
s.suscripciones = append(s.suscripciones, suscripcion{id, fn})
return func() {
s.suscripciones = slices.DeleteFunc(s.suscripciones, func(x suscripcion) bool { return x.id == id })
}
}
func (s *ServicioPagos) Pagar(p Pedido) error {
fmt.Printf("Pedido %s cobrado\n", p.ID)
var fallos []error
for _, sub := range s.suscripciones {
if err := sub.fn(p); err != nil {
fallos = append(fallos, err)
}
}
return errors.Join(fallos...)
}
func main() {
pagos := &ServicioPagos{}
pagos.Suscribir(func(p Pedido) error {
fmt.Println(" correo de confirmación para", p.ID)
return nil
})
pagos.Suscribir(func(Pedido) error {
return errors.New("inventario no disponible")
})
cancelarFactura := pagos.Suscribir(func(p Pedido) error {
fmt.Println(" factura emitida por", p.Total)
return nil
})
if err := pagos.Pagar(Pedido{"P-1", 250}); err != nil {
fmt.Println(" ⚠ fallos:", err)
}
cancelarFactura() // se da de baja
if err := pagos.Pagar(Pedido{"P-2", 90}); err != nil {
fmt.Println(" ⚠ fallos:", err) // ya no se emite factura
}
}LO IDIOMÁTICO EN RUST: Los suscriptores son cierres guardados como Box<dyn Fn(&Pedido) -> Result<(), String>>, junto a un identificador para poder darse de baja. pagar avisa a todos y reúne los fallos sin interrumpir a nadie. (Para avisos entre hilos, lo idiomático son los canales de std::sync::mpsc.)
struct Pedido {
id: &'static str,
total: u32,
}
type Suscriptor = Box<dyn Fn(&Pedido) -> Result<(), String>>;
#[derive(Default)]
struct ServicioPagos {
suscriptores: Vec<(u32, Suscriptor)>,
ultimo_id: u32,
}
impl ServicioPagos {
fn suscribir(&mut self, suscriptor: impl Fn(&Pedido) -> Result<(), String> + 'static) -> u32 {
self.ultimo_id += 1;
self.suscriptores
.push((self.ultimo_id, Box::new(suscriptor)));
self.ultimo_id
}
fn desuscribir(&mut self, id: u32) {
self.suscriptores.retain(|(otro, _)| *otro != id);
}
fn pagar(&self, pedido: &Pedido) -> Result<(), Vec<String>> {
println!("Pedido {} cobrado", pedido.id);
let fallos: Vec<String> = self
.suscriptores
.iter()
.filter_map(|(_, s)| s(pedido).err())
.collect();
if fallos.is_empty() {
Ok(())
} else {
Err(fallos)
}
}
}
fn main() {
let mut pagos = ServicioPagos::default();
pagos.suscribir(|p| {
println!(" correo de confirmación para {}", p.id);
Ok(())
});
pagos.suscribir(|_| Err("inventario no disponible".to_string()));
let factura = pagos.suscribir(|p| {
println!(" factura emitida por {}", p.total);
Ok(())
});
if let Err(fallos) = pagos.pagar(&Pedido {
id: "P-1",
total: 250,
}) {
println!(" ⚠ fallos: {fallos:?}");
}
pagos.desuscribir(factura); // se da de baja
if let Err(fallos) = pagos.pagar(&Pedido {
id: "P-2",
total: 90,
}) {
println!(" ⚠ fallos: {fallos:?}"); // ya no se emite factura
}
}LO IDIOMÁTICO EN PHP: PHP trae el patrón en su biblioteca estándar: las interfaces SplSubject y SplObserver, y SplObjectStorage para guardar los suscriptores sin duplicados. Cada aviso va dentro de un try/catch para que el fallo de un suscriptor no afecte a los demás.
<?php
declare(strict_types=1);
final class ServicioPagos implements SplSubject
{
/** @var SplObjectStorage<SplObserver, null> */
private SplObjectStorage $suscriptores;
public ?array $ultimoPedido = null;
public function __construct() { $this->suscriptores = new SplObjectStorage(); }
public function attach(SplObserver $observer): void { $this->suscriptores->offsetSet($observer); }
public function detach(SplObserver $observer): void { $this->suscriptores->offsetUnset($observer); }
public function notify(): void
{
foreach ($this->suscriptores as $suscriptor) {
try {
$suscriptor->update($this);
} catch (Throwable $error) {
echo " ⚠ un suscriptor falló: {$error->getMessage()}\n";
}
}
}
public function pagar(string $id, int $total): void
{
echo "Pedido {$id} cobrado\n";
$this->ultimoPedido = ['id' => $id, 'total' => $total];
$this->notify();
}
}
final class EnviarConfirmacion implements SplObserver
{
public function update(SplSubject $subject): void
{
assert($subject instanceof ServicioPagos);
echo " correo de confirmación para {$subject->ultimoPedido['id']}\n";
}
}
final class ReservarStock implements SplObserver
{
public function update(SplSubject $subject): void
{
throw new RuntimeException('inventario no disponible');
}
}
final class EmitirFactura implements SplObserver
{
public function update(SplSubject $subject): void
{
assert($subject instanceof ServicioPagos);
echo " factura emitida por {$subject->ultimoPedido['total']}\n";
}
}
$pagos = new ServicioPagos();
$factura = new EmitirFactura();
$pagos->attach(new EnviarConfirmacion());
$pagos->attach(new ReservarStock());
$pagos->attach($factura);
$pagos->pagar('P-1', 250);
$pagos->detach($factura); // se da de baja
$pagos->pagar('P-2', 90); // ya no se emite factura