Observer Pattern

The Observer pattern defines a one-to-many dependency so that when one object changes state, all dependents are notified.

Core Structure

┌──────────────────────────┐
│      Subject (Publisher) │
├──────────────────────────┤
│ - observers: List        │
│ - state: State           │
├──────────────────────────┤
│ + attach(observer)       │
│ + detach(observer)       │
│ + notify()               │
└──────────┬───────────────┘
           │ notifies
     ┌─────┴──────┐
     │            │
┌────┴─────┐ ┌───┴──────┐
│ObserverA │ │ObserverB │
└──────────┘ └──────────┘

Observer Interface

// Observer interface
public interface Observer {
    void update(Event event);
}

// Subject interface
public interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers();
}

Subject Implementation

public class OrderService implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private OrderStatus status;
    
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }
    
    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(new OrderEvent(this.status));
        }
    }
    
    public void completeOrder(Order order) {
        // Process order...
        this.status = OrderStatus.COMPLETED;
        notifyObservers();
    }
}

Observer Implementations

public class EmailObserver implements Observer {
    @Override
    public void update(Event event) {
        if (event.getType() == OrderEvent.Type.COMPLETED) {
            emailService.send(event.getUser(), "Order complete!");
        }
    }
}

public class InventoryObserver implements Observer {
    @Override
    public void update(Event event) {
        if (event.getType() == OrderEvent.Type.COMPLETED) {
            inventoryService.reserve(event.getItems());
        }
    }
}

public class AnalyticsObserver implements Observer {
    @Override
    public void update(Event event) {
        analytics.track("order_completed", event.getData());
    }
}

Usage

OrderService orderService = new OrderService();

// Register observers
orderService.attach(new EmailObserver());
orderService.attach(new InventoryObserver());
orderService.attach(new AnalyticsObserver());

// When order completes, all observers are notified
orderService.completeOrder(order);

Different implementation approaches for the Observer pattern.

Push Model vs Pull Model

// Push Model: Subject sends data to observers
public interface Observer {
    void update(Order order, OrderStatus status, Map<String, Object> data);
}

// Pull Model: Observers pull what they need
public interface Observer {
    void update(Subject subject);
}

public class OrderObserver implements Observer {
    @Override
    public void update(Subject subject) {
        OrderService orderService = (OrderService) subject;
        OrderStatus status = orderService.getStatus(); // Pull what needed
    }
}

Thread-Safe Observer

public class ThreadSafeSubject implements Subject {
    private final List<Observer> observers = 
        Collections.synchronizedList(new ArrayList<>());
    
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }
    
    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    
    @Override
    public void notifyObservers() {
        synchronized (observers) {
            for (Observer observer : observers) {
                observer.update(getState());
            }
        }
    }
}

Event-Based Observer

// Generic event system
public class EventBus {
    private Map<Class<?>, List<Consumer<?>>> listeners = new HashMap<>();
    
    public <T> void subscribe(Class<T> eventType, Consumer<T> listener) {
        listeners.computeIfAbsent(eventType, k -> new ArrayList<>())
                 .add(listener);
    }
    
    public <T> void publish(T event) {
        List<Consumer<?>> eventListeners = listeners.get(event.getClass());
        if (eventListeners != null) {
            for (Consumer<?> listener : eventListeners) {
                ((Consumer<T>) listener).accept(event);
            }
        }
    }
}

// Usage
EventBus bus = new EventBus();

bus.subscribe(OrderCompletedEvent.class, event -> {
    emailService.send(event.getUser(), "Order complete!");
});

bus.subscribe(OrderCompletedEvent.class, event -> {
    inventoryService.reserve(event.getItems());
});

bus.publish(new OrderCompletedEvent(order));

Weak Reference Observer

// Prevent memory leaks with weak references
public class WeakSubject {
    private List<WeakReference<Observer>> observers = new ArrayList<>();
    
    public void attach(Observer observer) {
        observers.add(new WeakReference<>(observer));
    }
    
    public void notifyObservers() {
        observers.removeIf(ref -> ref.get() == null); // Clean dead refs
        for (WeakReference<Observer> ref : observers) {
            Observer observer = ref.get();
            if (observer != null) {
                observer.update(getState());
            }
        }
    }
}

Real-world event systems built on the Observer pattern.

E-Commerce Event System

// Event hierarchy
public interface DomainEvent {
    String getAggregateId();
    Instant getTimestamp();
}

public class OrderEvent implements DomainEvent {
    public enum Type { CREATED, PAID, SHIPPED, DELIVERED, CANCELLED }
    private final Type type;
    private final String orderId;
    private final Map<String, Object> data;
    // ...
}

// Event handlers
public class OrderEventHandler {
    @EventHandler
    public void onOrderCreated(OrderEvent event) {
        inventoryService.reserve(event.getItems());
    }
    
    @EventHandler
    public void onOrderPaid(OrderEvent event) {
        paymentService.confirm(event.getPaymentId());
    }
    
    @EventHandler
    public void onOrderShipped(OrderEvent event) {
        notificationService.sendTracking(event.getUser(), event.getTrackingId());
    }
}

Message Queue Observer

// Distributed observer using message queue
public class MessageQueueObserver implements Observer {
    private final MessageProducer producer;
    
    @Override
    public void update(Event event) {
        // Publish to message queue for distributed observers
        producer.send("order-events", event.toJson());
    }
}

// Observers in different services consume events
public class InventoryEventHandler {
    @KafkaListener(topics = "order-events")
    public void handle(OrderEvent event) {
        if (event.getType() == Type.COMPLETED) {
            inventoryService.reserve(event.getItems());
        }
    }
}

Observer Pattern in Frameworks

Framework	Implementation
Java	PropertyChangeListener, EventListener
Spring	ApplicationEvent, @EventListener
React	State management (Redux-like)
Node.js	EventEmitter
Android	LiveData, Observer interface

Event System Best Practices

1. Keep events immutable: Don't modify events after creation
2. Include context: Aggregate ID, timestamp, user info
3. Handle failures: What if observer throws exception?
4. Order matters: If order of notification matters, document it
5. Memory management: Detach observers when done
6. Async option: Consider async notification for performance