👀 Observer Design Pattern — Java LLD + UML + Real-World Use Cases

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

---

🧠 What Is the Observer Pattern?

The Observer Pattern is a behavioral design pattern where:

• A Subject (Observable) maintains a list of Observers.
• When the Subject’s state changes, all registered Observers are notified.
• Promotes loose coupling between the Subject and Observers.

---

📦 Real-World Use Cases

Use Case	Description
📰 News Feed Subscription	Readers get notified of new articles
💬 Chat App (Message Stream)	Chat UI observes incoming message stream
📲 Event Bus / Pub-Sub	Listeners get notified of published events
📊 Live Data Dashboard	Charts observe backend data updates
🌦 Weather Monitoring App	UI gets updates when weather data changes
🧪 JUnit / Test Listeners	Hooks triggered when test results change

---

🔧 When to Use

✅ Use when:

• You want to decouple state producer from state consumers
• Many objects need to react to changes in a shared object
• You want to implement event-driven behavior cleanly

---

📐 UML Diagram

+---------------------+          +--------------------+
|      Subject        |<>------->|     Observer       |
+---------------------+          +--------------------+
| +attach(obs)        |          | +update()          |
| +detach(obs)        |          +--------------------+
| +notifyObservers()  |
+---------------------+
         ▲
         |
+-------------------------+
|   ConcreteSubject       |
+-------------------------+
| - state                 |
| +getState(), setState() |
+-------------------------+
         ▲
         |
+-------------------------+
|   ConcreteObserver      |
+-------------------------+
| - name                  |
| - subject ref           |
| +update()               |
+-------------------------+

---

💻 Java Implementation — Weather Monitoring Example

✅ Observer.java

public interface Observer {
    void update(String temperature);
}

---

✅ Subject.java

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

---

✅ WeatherStation.java (Concrete Subject)

public class WeatherStation implements Subject {
    private String temperature;
    private final List<Observer> observers = new ArrayList<>();

    public void setTemperature(String temp) {
        this.temperature = temp;
        notifyObservers();
    }

    public String getTemperature() {
        return temperature;
    }

    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer o : observers) {
            o.update(temperature);
        }
    }
}

---

✅ WeatherDisplay.java (Concrete Observer)

public class WeatherDisplay implements Observer {
    private final String displayId;

    public WeatherDisplay(String displayId) {
        this.displayId = displayId;
    }

    @Override
    public void update(String temperature) {
        System.out.println("📺 Display [" + displayId + "] - Temp Updated: " + temperature);
    }
}

---

✅ Client.java

public class ObserverDemo {
    public static void main(String[] args) {
        WeatherStation station = new WeatherStation();

        WeatherDisplay display1 = new WeatherDisplay("Lobby");
        WeatherDisplay display2 = new WeatherDisplay("Office");

        station.attach(display1);
        station.attach(display2);

        station.setTemperature("25°C");
        station.setTemperature("28°C");

        station.detach(display1);

        station.setTemperature("30°C");
    }
}

---

🧪 Output

📺 Display [Lobby] - Temp Updated: 25°C
📺 Display [Office] - Temp Updated: 25°C
📺 Display [Lobby] - Temp Updated: 28°C
📺 Display [Office] - Temp Updated: 28°C
📺 Display [Office] - Temp Updated: 30°C

---

✨ Benefits

Feature	Description
✅ Loose coupling	Subject doesn’t need to know concrete observers
✅ Scalability	Can add/remove observers at runtime
✅ Reactive systems	Ideal for implementing event-driven behavior
✅ Open/Closed	Add new observers without modifying subject

---

⚠️ Limitations

• ❌ Notification order is not guaranteed
• 🧩 Potential performance hit if observer list is large
• ⚠️ Risk of memory leaks if observers are not detached properly

---

🧾 Summary

Key Point	Value
Pattern Type	Behavioral
Participants	Subject, Observer, ConcreteObserver
Key Use Case	Push-based event propagation
Real Java Example	java.util.Observable (deprecated), Spring ApplicationEventPublisher, RxJava, Akka

---

🧠 Interview Tip

When asked to design a notification system, event bus, or data feed, use the Observer Pattern.

You can also mention:

• ✅ Kafka (pub-sub variation)
• ✅ RxJava / Project Reactor (reactive observers)
• ✅ Spring Events (Observer abstraction)

---