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
Building and Extending a PHP Web Shell
Apr 27 Application Security

A **web shell** is a script that enables an attacker to gain remote control over a web server. It is especially useful for **post-exploitation tasks**, allowing an attacker to execute arbitrary....

Understanding Assembly Language: Purpose and Structure
Mar 23 Low level Development

Assembly language is a low-level programming language that provides a human-readable representation of a computer's binary instructions. Unlike high-level languages like C, C++, or Python, which are....

XSS - The Ultimate guide for Cross Site Scripting
May 27 Application Security

Cross-Site Scripting (XSS) is one of the most prevalent and dangerous web application security vulnerabilities. According to OWASP, XSS consistently ranks among the top 10 web application security....

Netcat The Hacker's Swiss Army Knife
May 02 Penetration Testing

Netcat, often abbreviated as `nc`, is a versatile command-line networking tool that can be used for almost anything related to TCP, UDP, or UNIX-domain sockets. It's beloved by network engineers,....

Adapter Pattern explained simply
Apr 26 Software Architecture

Ever needed to connect two incompatible interfaces without changing their source code? That’s exactly where the **Adapter Pattern** shines! The Adapter Pattern is a structural design pattern....

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