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
SSRF - Server Side Request Forgery
May 27 Application Security

Server-Side Request Forgery (SSRF) is a web security vulnerability that allows an attacker to induce the server-side application to make HTTP requests to an arbitrary domain of the attacker's....

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

Build A Simple Web shell
Mar 23 Application Security

A web shell is a type of code that hackers use to gain control over a web server. It is particularly useful for post-exploitation attacks, and there are various types of web shells available. Some of....

How does SLL work?
May 17 Cryptography

Every time you see that small padlock icon in your browser's address bar, you're witnessing one of the internet's most important security technologies at work. This tiny symbol represents....

Proxy Pattern explained simply
Apr 26 Software Architecture

Sometimes you don't want or can't allow direct access to an object. Maybe it's expensive to create, needs special permissions, or you want to control access in some way. This is where the **Proxy....