java observer pattern

Java Observer Pattern Explained: A Practical Guide with Examples

By Michael Young
AD

The Java Observer Pattern is one of the most practical behavioral design patterns for building applications where objects need to react to changes without becoming tightly coupled to one another. Instead of having one component call dozens of others directly, a subject publishes an event, and any number of observers listen for that event and respond in their own way.

You will find this pattern throughout the Java ecosystem, from Swing event listeners to Spring application events and reactive streams. Understanding how the observer design pattern works, when to use it, and how to implement it safely in modern Java gives you a reliable foundation for event-driven code.

Understanding the Java Observer Pattern

The pattern defines a one-to-many dependency between a subject and its observers. When the subject changes state, it automatically notifies all registered observers, usually by calling a common update method. The subject does not need to know concrete observer classes; it only depends on an observer abstraction.

AD
Java Observer Pattern With Spring AOP
Java Observer Pattern With Spring AOP
Observer Design Pattern in Java
Observer Design Pattern in Java
Understanding software design patterns
Understanding software design patterns

In classic Java, this abstraction was represented by java.util.Observer and java.util.Observable. Those types were deprecated in Java 9 because they were limited and not flexible enough for modern development. Today, most teams create their own observer interfaces or use event frameworks, but the underlying principle remains the same: loose coupling between event producers and event consumers.

Core Components and Responsibilities

A typical implementation has four moving pieces. The subject or publisher maintains a collection of observers and exposes methods such as addObserver, removeObserver, and notifyObservers. The observer interface declares the update method that every listener must implement. Concrete subjects store the state that triggers notifications, and concrete observers perform actions when they receive an update.

Observer (Design Pattern)
Observer (Design Pattern)
Java Observer Design Pattern | Java Interview Series #19
Java Observer Design Pattern | Java Interview Series #19
Java Interview Series #14: Observer Design Pattern in Java | Java Interview Questions
Java Interview Series #14: Observer Design Pattern in Java | Java Interview Questions

In modern Java, you can also define the observer as a generic functional interface, such as Observer with a single update method, or even use Consumer from java.util.function. That choice keeps the pattern lightweight and lets you register lambdas without creating a class for every listener. The key is to keep the observer contract narrow and predictable.

How the Notification Flow Works

The notification flow begins when an observer registers with a subject. Later, a state change occurs, and the subject iterates through its observer list. For each observer, the subject calls the update method, passing either the changed data or a reference to the subject itself. Observers then react by logging, updating a UI, recalculating data, or publishing another event.

AD

There are two common communication styles: push and pull. In the push model, the subject sends detailed event data to observers. In the pull model, the subject only signals that something changed, and observers call getters to retrieve the details they need. Push can be simpler and more efficient, while pull can reduce the amount of data sent when observers only need a small subset. A stock price ticker is a classic example: the market data feed pushes price updates, and investor dashboards observe the changes.

Java HashMap Explained 🗺️ | DSA Pattern Cheat Sheet for Coding Interviews
Java HashMap Explained 🗺️ | DSA Pattern Cheat Sheet for Coding Interviews
Java Interview Series #24: Abstract Factory Design Pattern in Java
Java Interview Series #24: Abstract Factory Design Pattern in Java
Java Prototype Design Pattern Explained | Java Interview Questions #16
Java Prototype Design Pattern Explained | Java Interview Questions #16
Java Adapter Design Pattern Explained | Java Interview Questions #17
Java Adapter Design Pattern Explained | Java Interview Questions #17
Java Pattern Programs for Beginners | Star, Number, Pyramid & Diamond Patterns | Day 14
Java Pattern Programs for Beginners | Star, Number, Pyramid & Diamond Patterns | Day 14
Design Patterns Cheatsheet - Java Code Geeks
Design Patterns Cheatsheet - Java Code Geeks

Implementing the Observer Pattern in Modern Java

Java's built-in observer support is deprecated, so a modern implementation should rely on clean interfaces, generics, and concurrent collections. This approach avoids the limitations of the legacy classes and gives you control over threading, error handling, and event payloads. You can build a small event system in a few classes and expand it as requirements grow.

For simple in-process notifications, a custom subject class is often enough. For high-throughput or asynchronous event streams, Java's Flow API or a reactive library such as RxJava or Project Reactor may be a better fit. The pattern is the same at a conceptual level, but those tools add backpressure, cancellation, scheduling, and operators that are difficult to build from scratch.

AD

A Practical Custom Implementation

Start by defining an observer interface with a generic update method, for example, void update(T event). Then create a subject class that stores observers in a thread-safe collection such as CopyOnWriteArrayList. The subject exposes subscribe and unsubscribe methods and a notifyObservers method that loops through the current observers and calls update.

Java Interview Series #10: Design Patterns in Java | Important Interview Questions
Java Interview Series #10: Design Patterns in Java | Important Interview Questions
Java Singleton Design Pattern Explained | Java Interview Questions #27
Java Singleton Design Pattern Explained | Java Interview Questions #27
the design patterns in jwa poster is shown with information for each individual type and location
the design patterns in jwa poster is shown with information for each individual type and location
Intro to the Observable design pattern
Intro to the Observable design pattern

A weather station example makes this concrete. The WeatherStation class acts as the subject and holds the latest temperature and humidity. DisplayDevice and AlertService implement the observer interface. When new measurements arrive, the station updates its state and notifies every registered observer. You can also register a lambda: station.subscribe(data -> System.out.println(data)). That flexibility keeps the code readable and avoids unnecessary boilerplate. Remember to remove observers when they are no longer needed, especially in long-running applications.

Using Java's Flow API and Reactive Libraries

Java 9 introduced the Flow API with Publisher, Subscriber, Subscription, and Processor interfaces. It supports reactive streams with backpressure, meaning a slow subscriber can signal how many items it can handle. SubmissionPublisher is a ready-to-use publisher. This API is heavier than a simple observer list, but it is valuable when producers generate data faster than consumers can process it.

AD

Reactive libraries such as RxJava, Reactor, and Vert.x event bus offer even more power. They provide operators for filtering, mapping, batching, retrying, and combining streams. Spring's ApplicationEventPublisher also provides an observer-like mechanism for decoupled application events. Choose the simple observer pattern for local callbacks and UI updates; choose reactive streams when you need asynchronous pipelines, cancellation, or guaranteed flow control.

Best Practices, Pitfalls, and Real-World Use Cases

Use the Java Observer Pattern when a change in one object should trigger updates in an unknown number of other objects, or when you want to add new reactions without modifying the publisher. It is a strong fit for user interface events, domain events, cache invalidation, and monitoring hooks. It is a poor fit when you need strict transactional guarantees, ordered delivery, or durable messaging across services.

Common problems include memory leaks from observers that are never unregistered, concurrent modification exceptions during notification, and cascading updates that are difficult to trace. A synchronous notification loop can also block the subject if one observer performs slow work. Good design addresses these issues early with lifecycle management, snapshots, and clearly defined threading rules.

Thread Safety and Performance Considerations

Thread safety starts with how you store and iterate observers. CopyOnWriteArrayList works well when observers are added or removed infrequently and notifications are frequent. If you use a standard ArrayList, synchronize access or take a snapshot before notifying. Never hold a lock while calling observer code, because that code might call back into the subject and create a deadlock.

For asynchronous notifications, submit work to an ExecutorService or a reactive scheduler. This prevents one slow observer from blocking others, but it introduces questions about ordering, error handling, and backpressure. Performance is generally linear in the number of observers, so high-frequency events may require filtering by topic, batching updates, or moving to a message broker. In desktop applications, always deliver UI updates on the correct thread, such as the Swing event dispatch thread or the JavaFX application thread.

Real-World Java Examples and Use Cases

Java's standard library and popular frameworks are full of observer-like designs. Swing uses ActionListener and ChangeListener. JavaFX uses observable properties and listeners. JavaBeans support PropertyChangeListener. Spring publishes ApplicationEvent instances to interested beans. Android developers often use LiveData, RxJava, or Flow to observe data changes. In microservices, Kafka consumers and other message brokers extend the publish-subscribe idea across process boundaries.

Consider an order processing system. OrderService publishes an OrderPlaced event. InventoryService, EmailService, and AnalyticsService observe that event. Adding a new fraud-check observer does not require changing OrderService. However, if the business requires guaranteed delivery, retries, or replay, an in-memory observer list is not enough. At that point, use a message queue or event streaming platform. The observer pattern is still the mental model, but the infrastructure changes.

If you are building Java software where components need to react to changes without becoming tightly coupled, the observer pattern remains a dependable tool. Start with a small custom implementation, test how it behaves under concurrent access, and move to the Flow API or a reactive library when your event volume and delivery requirements grow. A well-designed notification model can keep your code adaptable for years.

AD