Thilan Dissanayaka Software Architecture 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
Remote Command Execution
Mar 23 Application Security

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....

Decorator Pattern explained simply
Apr 26 Software Architecture

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**....

Building a Web3 CLI Tool for the Ballerina Language: From Idea to Reality
Apr 26 WSO2

πŸš€ Excited to finally share my journey of building a web3 CLI tool for Ballerina! This tool bridges the gap between Ethereum smart contracts and the Ballerina programming language by automatically....

GDB reverse engineering tutorial
Mar 23 Low level Development

hiii, I selected an interesting topic to discuss. Here, we are going to disassemble a binary file and take a look at what it does. This process is called reverse engineering. Let's run the program....

ACID Properties in Databases: The Key to Reliable Transactions
Apr 25 Database Systems

When working with databases, one thing is absolutely critical: keeping your data safe, consistent, and reliable. That's where ACID properties come in β€” a set of principles that ensure every....

Ballerina connector for Hubspot Schema API
Mar 23 WSO2

Hi all, It's a new article on something cool. Here we are going to see how we can use the Hubspot schema connector with Ballerina. When it comes to building connectors for seamless integration....