Thilan Dissanayaka Design Patterns Apr 26

Observer Pattern explained simply

When one object needs to notify many other objects about changes in its state automatically,
the Observer Pattern steps in.

What is the Observer Pattern?

  • Defines a one-to-many dependency between objects.
  • When the subject changes, all its observers are notified and updated automatically.
  • Helps achieve loose coupling between components.

In short:

One subject, many listeners!

Real-Life Analogy

Think about a YouTube Channel:

  • You subscribe (observer) to a channel (subject).
  • When the channel posts a new video, you get a notification.

Simple and automatic.

Structure

  • Subject (Observable): Holds a list of observers and notifies them of changes.
  • Observers: Register themselves to the subject and react to changes.

Example in Java

Subject Interface

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

Observer Interface

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

Concrete Subject

import java.util.ArrayList;
import java.util.List;

public class Channel implements Subject {
    private List<Observer> subscribers = new ArrayList<>();
    private String latestVideo;

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

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

    @Override
    public void notifyObservers() {
        for (Observer observer : subscribers) {
            observer.update(latestVideo);
        }
    }

    public void uploadNewVideo(String title) {
        this.latestVideo = title;
        System.out.println("New video uploaded: " + title);
        notifyObservers();
    }
}

Concrete Observer

public class Subscriber implements Observer {
    private String name;

    public Subscriber(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name + " received notification: " + message);
    }
}

Using the Observer Pattern

public class MainProgram {
    public static void main(String[] args) {
        Channel techChannel = new Channel();

        Subscriber alice = new Subscriber("Alice");
        Subscriber bob = new Subscriber("Bob");
        Subscriber charlie = new Subscriber("Charlie");

        techChannel.attach(alice);
        techChannel.attach(bob);

        techChannel.uploadNewVideo("Observer Pattern in Java!");

        techChannel.attach(charlie);

        techChannel.uploadNewVideo("Singleton Pattern Explained!");
    }
}

Output:

New video uploaded: Observer Pattern in Java!
Alice received notification: Observer Pattern in Java!
Bob received notification: Observer Pattern in Java!
New video uploaded: Singleton Pattern Explained!
Alice received notification: Singleton Pattern Explained!
Bob received notification: Singleton Pattern Explained!
Charlie received notification: Singleton Pattern Explained!

Why Use Observer Pattern?

  • Loose Coupling: Subjects and observers are independent.
  • Dynamic Relationships: Observers can be added/removed at runtime.
  • Scalability: Suitable when multiple objects depend on a single object.

Real-World Use Cases

  • Event handling systems (GUI frameworks, button click listeners).
  • Messaging systems (notifications, chat applications).
  • Distributed systems (monitoring services).
  • Model-View-Controller (MVC) architecture (model updates views).

Summary

The Observer Pattern lets you build dynamic, decoupled, and event-driven applications.
It’s perfect whenever you need automatic notifications between components without tightly coupling them.

ALSO READ
Decorator Pattern explained simply
Apr 26 Design Patterns

When you want to **add new functionalities** to an object **without modifying its structure**, the **Decorator Pattern** comes to the rescue. The Decorator Pattern lets you dynamically **wrap**....

Remote Command Execution
Mar 23 Web App Hacking

Remote Command Execution (RCE) is a critical security vulnerability that allows an attacker to execute arbitrary commands on a remote server. This vulnerability can lead to unauthorized access, data....

Singleton Pattern explained simply
Apr 26 Design Patterns

Ever needed just one instance of a class in your application? Maybe a logger, a database connection, or a configuration manager? This is where the Singleton Pattern comes in — one of the simplest....

Out of Band SQL Injection
Apr 26 Web App Hacking

Normally in SQL Injection, the attacker: Sees direct errors, or Infers information through page behavior or timing. But Out-of-Band SQL Injection is different: OOB SQLi relies on making....

Database Indexing: Speeding Up Your Queries Like a Pro
Apr 26 Database Systems

In the world of databases, speed matters. Whether you're powering an e-commerce store, a social media app, or a business dashboard — users expect data to load instantly. That’s where database....

Assembly programming for beginners
Mar 23 Linux exploits

Assembly is a low-level programming language. You already know that low-level programming languages are close to machines and very hard to understand by humans. We have already written some programs....