Java.Reactive.What is the Observer pattern and how does it underlie reactive programming?

The Observer Pattern is a behavioral design pattern where:

• One object (the Subject) maintains a list of Observers.
• When the Subject’s state changes, it notifies all its Observers.

Think of it like a subscription model:

• You (Observer) subscribe to a newsletter (Subject).
• When there’s a new issue, the newsletter sends it to all subscribers.

---

🧱 Key Components

Role	Description
Subject	Maintains a list of observers, notifies them of changes
Observer	Gets notified when the subject changes

🧪 Simple Java Example (Observer Pattern)

interface Observer {
    void update(String data);
}

class Subject {
    private List<Observer> observers = new ArrayList<>();

    void addObserver(Observer o) {
        observers.add(o);
    }

    void notifyObservers(String data) {
        for (Observer o : observers) {
            o.update(data);
        }
    }
}

Usage:

Subject news = new Subject();
news.addObserver(data -> System.out.println("Received: " + data));
news.notifyObservers("Breaking news!");

⚡️ Reactive Programming = Observer Pattern on Steroids

Reactive programming elevates this pattern to work with:

• Asynchronous data sources
• Continuous streams (not one-time updates)
• Operators to transform/combine streams
• Schedulers for threading
• Error handling & completion events

Instead of Subject and Observer, RxJava (and others) use:

Traditional	RxJava Equivalent
Subject	Observable, Flowable, Publisher
Observer	Observer, Subscriber

🔄 In RxJava:

Observable<String> stream = Observable.just("data1", "data2");

stream.subscribe(
    data -> System.out.println("Got: " + data),
    error -> System.err.println("Error: " + error),
    () -> System.out.println("Done!")
);

You subscribe to a data source.

It emits items to all subscribers.

You get notified of data, errors, and completion.

📌 So, Reactive Programming:

✅ Uses the Observer pattern
✅ Adds time, streaming, threading, and declarative operations
✅ Is asynchronous and non-blocking

🧠 Analogy:

• Observer pattern is like subscribing to a newspaper.
• Reactive programming is like subscribing to a news API:
  • Pushes updates in real-time
  • Can merge sources, filter stories, switch feeds
  • Handles delays and network failures