Observer Pattern in Java Explained with Story & Real Example (2025 Guide)

Tweet

 Observer Pattern Explained: From School Bell to Order Events

🎯 Why This Pattern Matters

In interviews, design patterns often pop up, and the Observer Pattern is one of the most asked. Instead of memorizing theory, let’s connect it to a story you’ll never forget — and then translate it into practical Java code you can actually show in an interview

📖 Story Analogy — The School Bell

Think back to school days:

At 12:30 PM, the bell rings.

Students run to lunch.

Teachers close books.

The peon opens gates.

👉 The bell (Subject) doesn’t know or care who reacts. Each Observer does its own thing when notified.

That’s the Observer Pattern: one subject, many independent observers reacting differently.

🧑‍💻 Practical Java Example — Order Placed Event

Let’s switch from school to a real project example: e-commerce order placement.

When an order is placed:

Send confirmation email

Write an audit log

Update metrics

Instead of hard-coding all in the service, we publish an event. Observers (listeners) handle their part.

Minimal Code

// Event class

class OrderPlacedEvent {

    String orderId;

    OrderPlacedEvent(String orderId) { this.orderId = orderId; }

}

// Subject (Publisher)

class OrderService {

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

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

    void placeOrder(String orderId) {

        System.out.println("Order placed: " + orderId);

        notifyObservers(new OrderPlacedEvent(orderId));

    }

    private void notifyObservers(OrderPlacedEvent event) {

        for (Observer o : observers) o.update(event);

    }

}

// Observer interface

interface Observer {

    void update(OrderPlacedEvent event);

}

// Observers

class EmailService implements Observer {

    public void update(OrderPlacedEvent e) {

        System.out.println("📧 Email sent for order " + e.orderId);

    }

}

class AuditLog implements Observer {

    public void update(OrderPlacedEvent e) {

        System.out.println("🧾 Audit log created for order " + e.orderId);

    }

}

// Demo

public class ObserverDemo {

    public static void main(String[] args) {

        OrderService service = new OrderService();

        service.addObserver(new EmailService());

        service.addObserver(new AuditLog());

        service.placeOrder("ORD-101");

    }

}

Output:

Order placed: ORD-101

📧 Email sent for order ORD-101

🧾 Audit log created for order ORD-101

🧠 How to Explain in an Interview

“Observer Pattern allows one subject to notify multiple observers independently.”

“In real systems, we use it for event-driven flows — e.g., when an order is placed, many services react without tight coupling.”

“In Spring Boot, this is implemented with @EventListener and ApplicationEventPublisher.”

✅ Conclusion

Story: Remember the school bell → one event, many reactions.

Practice: Show a minimal “order placed” code sample.

Interview-ready: Map it to Spring events or message queues in real projects.