Artículo

Patrón Observer en Java: qué es y cómo implementarlo

Cómo funciona el patrón Observer en Java: sujeto, observadores, suscripción y notificación, con un ejemplo ejecutable y su equivalente con eventos de Spring.

En resumen: el patrón Observer permite que un objeto (el sujeto) avise a otros (los observadores) cuando ocurre algo, sin conocerlos. Los observadores implementan una interfaz común y se suscriben; el sujeto recorre la lista y los notifica. Así puedes añadir reacciones nuevas (enviar un email, facturar, auditar) sin tocar el código que produce el evento. Probado con Java 25, compatible desde Java 17.

Vídeo explicativo

El problema

void crearPedido(Pedido p) {
    repositorio.guardar(p);
    emailService.enviarConfirmacion(p);
    facturacion.generarFactura(p);
    antifraude.revisar(p);
    // ...y cada nueva necesidad obliga a tocar este método
}

El servicio de pedidos acaba dependiendo de media aplicación. Con Observer, solo sabe que hay «alguien interesado».

Implementación

import java.util.ArrayList;
import java.util.List;

interface PedidoListener {
    void pedidoCreado(String pedidoId, double importe);
}

class ServicioPedidos {
    private final List<PedidoListener> listeners = new ArrayList<>();

    void suscribir(PedidoListener listener) {
        listeners.add(listener);
    }

    void desuscribir(PedidoListener listener) {
        listeners.remove(listener);
    }

    void crearPedido(String id, double importe) {
        System.out.println("Pedido " + id + " guardado");
        for (PedidoListener l : List.copyOf(listeners)) {
            l.pedidoCreado(id, importe);
        }
    }
}

class EmailListener implements PedidoListener {
    @Override
    public void pedidoCreado(String pedidoId, double importe) {
        System.out.println("  Email: confirmación del pedido " + pedidoId);
    }
}

class FacturacionListener implements PedidoListener {
    @Override
    public void pedidoCreado(String pedidoId, double importe) {
        System.out.println("  Facturación: factura de " + importe + " €");
    }
}

public class Main {
    public static void main(String[] args) {
        ServicioPedidos servicio = new ServicioPedidos();
        EmailListener email = new EmailListener();
        servicio.suscribir(email);
        servicio.suscribir(new FacturacionListener());
        servicio.suscribir((id, importe) -> {
            if (importe > 100) {
                System.out.println("  Antifraude: revisar pedido " + id);
            }
        });

        servicio.crearPedido("A-1", 150);
        servicio.desuscribir(email);
        servicio.crearPedido("A-2", 40);
    }
}

Salida:

Pedido A-1 guardado
  Email: confirmación del pedido A-1
  Facturación: factura de 150.0 €
  Antifraude: revisar pedido A-1
Pedido A-2 guardado
  Facturación: factura de 40.0 €

Detalles que importan

  • La interfaz tiene un solo método, así que un observador puede ser una lambda, como el de antifraude. Es una interfaz funcional.
  • List.copyOf(listeners) al notificar: si un observador se desuscribe mientras se recorre la lista, no salta ConcurrentModificationException.
  • Orden y errores: los observadores se ejecutan en orden y en el mismo hilo. Si uno lanza una excepción, los siguientes no se ejecutan. Decide si quieres capturarla por observador.
  • Fugas de memoria: un observador que nunca se desuscribe sigue referenciado por el sujeto y no se libera.

Observer en Spring: eventos de aplicación

En Spring no necesitas montar la lista a mano: publicas un evento y cualquier bean puede escucharlo.

record PedidoCreado(String id, double importe) {}

@Service
class PedidoService {
    private final ApplicationEventPublisher eventos;

    PedidoService(ApplicationEventPublisher eventos) {
        this.eventos = eventos;
    }

    void crear(String id, double importe) {
        // guardar...
        eventos.publishEvent(new PedidoCreado(id, importe));
    }
}

@Component
class EmailAlCrearPedido {
    @EventListener
    void on(PedidoCreado evento) {
        System.out.println("Email del pedido " + evento.id());
    }
}

Con @TransactionalEventListener el observador se ejecuta solo si la transacción se confirma, y con @Async en otro hilo. Cuando el evento debe llegar a otra aplicación, se pasa a un broker como Kafka: es el mismo patrón a escala de microservicios.

Preguntas frecuentes

¿Observer y publicar/suscribir son lo mismo?

Se parecen. En Observer el sujeto conoce la lista de observadores; en publicar/suscribir hay un intermediario (un bus o un broker) y ninguno conoce al otro.

¿Qué pasó con java.util.Observable?

Está obsoleta desde Java 9: obliga a heredar de una clase y no es segura entre hilos. Usa tu propia interfaz, PropertyChangeListener o los eventos de Spring.

¿Cuándo no usarlo?

Cuando el orden y el resultado de cada paso importan para el flujo principal (por ejemplo, cobrar antes de confirmar). Ahí es mejor una llamada explícita.

Sigue aprendiendo

Más patrones: Composite, MVC, Builder y Factory. Los eventos de dominio y su papel en arquitecturas desacopladas se trabajan en el máster de arquitecto Java y Spring Boot con IA.

patrón observer patrones de diseño java eventos listener

Newsletter Semanal de Java

Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.

Sin spam. Cancela cuando quieras.

Compartir artículo