All 15 Design Patterns in Java questions
More in Design Patterns in Java
What is the Adapter pattern, and when would you use it to make an existing class compatible with an interface it wasn't originally designed to implement? What is the Template Method pattern, and how is it used to define the skeleton of an algorithm while letting subclasses customize specific steps? What is the difference between composition and inheritance as ways to reuse code, and why does the design principle "favor composition over inheritance" generally guide modern Java design (including many design patterns themselves)? How would you implement the Composite pattern to treat individual objects and groups of objects uniformly, such as a file system with files and directories? How would you implement the Decorator pattern in Java, and how does java.io's InputStream/OutputStream class hierarchy exemplify this pattern in the JDK itself? How would you implement the Dependency Injection pattern manually (without a framework like Spring) using constructor injection, and what testability benefits does this provide? How would you implement the Visitor pattern in Java to add new operations to an existing class hierarchy without modifying those classes, and how do Java's sealed classes and pattern matching (switch expressions) provide a modern alternative? How would you use the Chain of Responsibility pattern to implement a request-processing pipeline (such as middleware-style validation/authentication/logging), and how does this relate conceptually to servlet filters or web framework middleware? How would you implement the Proxy pattern to add lazy initialization to an expensive-to-create object, and how does this differ structurally from the Decorator pattern despite both wrapping an object behind a shared interface?
Advertisement
Back to results for “Design Patterns in Java”
Java › Design Patterns in Java

How would you implement the Observer pattern in Java, and how does it compare to using the built-in PropertyChangeSupport or a reactive streams library?

Advanced

Answer

The Observer pattern defines a one-to-many dependency where a subject notifies registered observers of state changes -- implementable manually with a List<Observer> and a notify loop, via the JDK's built-in (though somewhat dated) java.beans.PropertyChangeSupport for JavaBean-style property change notification, or more robustly via a reactive streams library (like RxJava or Project Reactor) providing composable operators (filtering, mapping, backpressure handling) far beyond a simple manual observer list, making the choice largely dependent on whether you need simple notification or a full reactive pipeline with transformation and backpressure semantics.
public interface Observer { void update(String event); }

public class EventPublisher {
    private final List<Observer> observers = new ArrayList<>();
    public void subscribe(Observer o) { observers.add(o); }
    public void publish(String event) {
        for (Observer o : observers) { o.update(event); }
    }
}

EventPublisher publisher = new EventPublisher();
publisher.subscribe(event -> System.out.println("Received: " + event));
publisher.publish("orderPlaced");
Real-world example A simple in-process event bus used to decouple order processing from notification/logging concerns implements a lightweight manual Observer pattern (since the use case doesn't need reactive streams' backpressure or complex operator chains), while a data pipeline handling high-volume, filtered, transformed event streams instead adopts Project Reactor for its much richer composability.

Common follow-ups: What are the memory leak risks of the Observer pattern if subscribers forget to unsubscribe (a 'lapsed listener' problem)?;How does the Observer pattern relate conceptually to the publish-subscribe messaging pattern used in distributed systems?

SignalR & Real-Time Communication;Concurrency & Threads
All 15 Design Patterns in Java questions