The Observer Pattern is a fundamental behavioral design pattern used to implement event-driven systems. It allows objects (observers) to subscribe to and be notified of changes in another object (subject). With Java 8 and the introduction of lambdas and functional interfaces, this pattern becomes more elegant, concise, and expressive.
In this tutorial, you’ll learn how to implement the Observer Pattern using functional interfaces, building reactive and loosely-coupled systems with modern Java.
🎯 What Is the Observer Pattern?
The Observer Pattern defines a one-to-many relationship between objects so that when one object changes state, all its dependents are notified and updated automatically.
Use Cases:
- Event systems (UI, user input)
- Messaging systems
- Live data updates (chat, prices, feeds)
- Logging and monitoring
🧱 Traditional Observer Pattern in Java
interface Observer {
void update(String event);
}
class EventPublisher {
private List<Observer> observers = new ArrayList<>();
void addObserver(Observer o) {
observers.add(o);
}
void notifyObservers(String event) {
for (Observer o : observers) {
o.update(event);
}
}
}
Usage
EventPublisher publisher = new EventPublisher();
publisher.addObserver(event -> System.out.println("Listener 1: " + event));
publisher.notifyObservers("DATA_READY");
✅ Functional Observer Pattern with Lambdas
Since Observer is a single-method interface, we can define it as a functional interface and replace observers with lambda expressions.
@FunctionalInterface
interface EventListener {
void onEvent(String event);
}
class FunctionalEventPublisher {
private final List<EventListener> listeners = new ArrayList<>();
void subscribe(EventListener listener) {
listeners.add(listener);
}
void publish(String event) {
listeners.forEach(listener -> listener.onEvent(event));
}
}
Usage
FunctionalEventPublisher publisher = new FunctionalEventPublisher();
publisher.subscribe(e -> System.out.println("Logger: " + e));
publisher.subscribe(e -> System.out.println("Auditor: " + e));
publisher.publish("USER_REGISTERED");
🔁 Using Built-In Functional Interfaces
We can use Consumer<T> instead of a custom interface:
class FunctionalEventBus {
private final List<Consumer<String>> consumers = new ArrayList<>();
void subscribe(Consumer<String> consumer) {
consumers.add(consumer);
}
void publish(String message) {
consumers.forEach(c -> c.accept(message));
}
}
🧠 Real-World Analogy: News Subscription
Imagine a newspaper (publisher) and readers (observers). When news is published, all subscribers are notified.
FunctionalEventBus newsBus = new FunctionalEventBus();
newsBus.subscribe(news -> System.out.println("Reader A: " + news));
newsBus.subscribe(news -> System.out.println("Reader B: " + news));
newsBus.publish("Breaking: Java 21 Released!");
🔧 Functional Observer Pattern with Filtering and Mapping
You can chain operations like filtering and transformation:
newsBus.subscribe(news -> {
if (news.contains("Java"))
System.out.println("Java Fan: " + news.toUpperCase());
});
📚 Real-World Use Case: Stock Price Listener
class StockMarket {
private final List<Consumer<Double>> priceListeners = new ArrayList<>();
void onPriceChange(Consumer<Double> listener) {
priceListeners.add(listener);
}
void updatePrice(double price) {
priceListeners.forEach(l -> l.accept(price));
}
}
Usage
StockMarket market = new StockMarket();
market.onPriceChange(p -> System.out.println("App1: " + p));
market.onPriceChange(p -> {
if (p > 1000) System.out.println("Alert: Price crossed 1k!");
});
market.updatePrice(995.50);
market.updatePrice(1020.00);
🔄 Unsubscribing Listeners
class ReactiveBus {
private final List<Consumer<String>> consumers = new ArrayList<>();
void subscribe(Consumer<String> consumer) {
consumers.add(consumer);
}
void unsubscribe(Consumer<String> consumer) {
consumers.remove(consumer);
}
void emit(String data) {
consumers.forEach(c -> c.accept(data));
}
}
📌 What's New in Java?
Java 8
- Lambdas,
Consumer<T>, Streams, functional interfaces
Java 9
- Flow API for reactive streams (Observer pattern at scale)
Java 11
varin lambda parameters
Java 17
- Pattern matching in
instanceofuseful in event processors
Java 21
- Structured concurrency, virtual threads, and scoped values support event-driven processing
✅ Conclusion and Key Takeaways
- The Observer Pattern is ideal for event-driven applications.
- Functional interfaces and lambdas make observer registration and notification clean and expressive.
- Built-in interfaces like
Consumer<T>reduce the need for custom boilerplate. - Ideal for building loggers, notification systems, analytics hooks, and real-time dashboards.
❓ Expert FAQ
Q1: Can I use method references as observers?
Yes. If the method matches the listener signature, e.g., System.out::println.
Q2: Are lambdas garbage collected like normal objects?
Yes. If nothing references the lambda or its captured variables, they’re GC-eligible.
Q3: Is this thread-safe?
Only if you synchronize access to the observer list.
Q4: How is this different from the Observer API in Java 1.0?
The built-in Observable/Observer was deprecated. Lambdas offer a cleaner alternative.
Q5: Can I use this pattern in GUIs?
Absolutely—perfect for JavaFX, Swing, or even WebSocket event handlers.
Q6: How do I prevent memory leaks?
Always unsubscribe listeners that are no longer needed, especially in long-lived systems.
Q7: Can I implement priority or delayed observers?
Yes—sort or schedule consumers before calling them.
Q8: Is this compatible with RxJava or Reactor?
Yes—RxJava is a reactive extension of this pattern, with operators and backpressure.
Q9: Can I broadcast different event types?
Use generics or tag-based routing for multiple event types.
Q10: Should I create a custom interface or use Consumer<T>?
Use Consumer<T> unless your domain logic demands a specific contract.