Observer Pattern · Design Patterns

What is the Observer pattern?

Observer means: one object (the subject) announces “something changed,” and every object that depends on it (the observers) gets notified automatically — without the subject knowing who they are.

Observers subscribe once. From then on, the subject just broadcasts to whoever is currently listening. It never keeps a hardcoded list of specific classes to call.

Three pieces work together:

A subject — keeps a list of observers; can register, remove, and notify them.
An observer interface — every subscriber implements it, usually one update method.
Concrete observers — react however they want; the subject does not need to know how.

The problem it solves

Without Observer, a subject that needs to inform several unrelated parts of a program tends to call each one directly.

def publish_breaking_news(headline: str) -> None:
    cnn_channel.display(headline)
    bbc_channel.display(headline)
    email_alert_service.send(headline)
    # add a fourth consumer? edit this function again.

public void publishBreakingNews(String headline) {
    cnnChannel.display(headline);
    bbcChannel.display(headline);
    emailAlertService.send(headline);
    // add a fourth consumer? edit this method again.
}

func PublishBreakingNews(headline string) {
	cnnChannel.Display(headline)
	bbcChannel.Display(headline)
	emailAlertService.Send(headline)
	// add a fourth consumer? edit this function again.
}

function publishBreakingNews(headline: string): void {
  cnnChannel.display(headline);
  bbcChannel.display(headline);
  emailAlertService.send(headline);
  // add a fourth consumer? edit this function again.
}

This works while the list of interested parties is small and stable. It breaks down the moment that list changes often, because every addition or removal means editing code that has nothing to do with the actual news — it is just wiring.

The observer and subject interfaces

from abc import ABC, abstractmethod


class Observer(ABC):
    @abstractmethod
    def update(self, message: str) -> None: ...


class Subject(ABC):
    @abstractmethod
    def register_observer(self, observer: Observer) -> None: ...

    @abstractmethod
    def remove_observer(self, observer: Observer) -> None: ...

    @abstractmethod
    def notify_observers(self) -> None: ...

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

public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// Go favors small interfaces — only Observer needs one here.
type Observer interface {
	Update(message string)
}

interface Observer {
  update(message: string): void;
}

interface Subject {
  registerObserver(observer: Observer): void;
  removeObserver(observer: Observer): void;
  notifyObservers(): void;
}

A concrete subject and its observers

class NewsAgency(Subject):
    def __init__(self) -> None:
        self._observers: list[Observer] = []
        self._news = ""

    def register_observer(self, observer: Observer) -> None:
        self._observers.append(observer)

    def remove_observer(self, observer: Observer) -> None:
        self._observers.remove(observer)

    def notify_observers(self) -> None:
        for observer in self._observers:
            observer.update(self._news)

    def publish(self, news: str) -> None:
        self._news = news
        self.notify_observers()


class NewsChannel(Observer):
    def __init__(self, name: str) -> None:
        self.name = name

    def update(self, news: str) -> None:
        print(f"{self.name} received: {news}")


# use
agency = NewsAgency()
agency.register_observer(NewsChannel("CNN"))
agency.register_observer(NewsChannel("BBC"))

agency.publish("Breaking news!")  # both channels notified automatically

public class NewsAgency implements Subject {
    private final List<Observer> observers = new ArrayList<>();
    private String news;

    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(news);
        }
    }

    public void publish(String news) {
        this.news = news;
        notifyObservers();
    }
}

public class NewsChannel implements Observer {
    private final String name;

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

    public void update(String news) {
        System.out.println(name + " received: " + news);
    }
}

// use
NewsAgency agency = new NewsAgency();
agency.registerObserver(new NewsChannel("CNN"));
agency.registerObserver(new NewsChannel("BBC"));

agency.publish("Breaking news!"); // both channels notified automatically

type NewsAgency struct {
	observers []Observer
	news      string
}

func (a *NewsAgency) RegisterObserver(o Observer) {
	a.observers = append(a.observers, o)
}

func (a *NewsAgency) RemoveObserver(o Observer) {
	for i, observer := range a.observers {
		if observer == o {
			a.observers = append(a.observers[:i], a.observers[i+1:]...)
			break
		}
	}
}

func (a *NewsAgency) Publish(news string) {
	a.news = news
	for _, observer := range a.observers {
		observer.Update(a.news)
	}
}

type NewsChannel struct {
	Name string
}

func (c NewsChannel) Update(news string) {
	fmt.Printf("%s received: %s\n", c.Name, news)
}

// use
agency := &NewsAgency{}
agency.RegisterObserver(NewsChannel{Name: "CNN"})
agency.RegisterObserver(NewsChannel{Name: "BBC"})

agency.Publish("Breaking news!") // both channels notified automatically

class NewsAgency implements Subject {
  private observers: Observer[] = [];
  private news = '';

  registerObserver(observer: Observer) {
    this.observers.push(observer);
  }

  removeObserver(observer: Observer) {
    this.observers = this.observers.filter((o) => o !== observer);
  }

  notifyObservers() {
    for (const observer of this.observers) {
      observer.update(this.news);
    }
  }

  publish(news: string) {
    this.news = news;
    this.notifyObservers();
  }
}

class NewsChannel implements Observer {
  constructor(private name: string) {}

  update(news: string) {
    console.log(`${this.name} received: ${news}`);
  }
}

// use
const agency = new NewsAgency();
agency.registerObserver(new NewsChannel('CNN'));
agency.registerObserver(new NewsChannel('BBC'));

agency.publish('Breaking news!'); // both channels notified automatically

NewsAgency never mentions NewsChannel by name. A third, fourth, or fifth observer can register at any time, and publish does not change at all.

Push versus pull

There are two ways to hand data to observers. In push, shown above, the subject sends the data directly in the update call — simple, but every observer gets the same payload. In pull, the subject just signals that something changed, and each observer calls back to fetch exactly what it needs.

class Observer(ABC):
    @abstractmethod
    def update(self, subject: "Subject") -> None: ...


# inside a concrete observer
def update(self, subject: "StockMarket") -> None:
    price = subject.get_price("AAPL")
    # fetch only what this observer needs

public interface Observer {
    void update(Subject subject);
}

// inside a concrete observer
public void update(Subject subject) {
    double price = ((StockMarket) subject).getPrice("AAPL");
    // fetch only what this observer needs
}

type Observer interface {
	Update(subject *StockMarket)
}

// inside a concrete observer
func (t *Trader) Update(subject *StockMarket) {
	price := subject.GetPrice("AAPL")
	// fetch only what this observer needs
	_ = price
}

interface Observer {
  update(subject: Subject): void;
}

// inside a concrete observer
update(subject: StockMarket) {
  const price = subject.getPrice('AAPL');
  // fetch only what this observer needs
}

Pull suits subjects with a lot of state where different observers care about different slices of it. Push suits simple notifications where the data is small and every observer needs the same thing.

Worked example: stock price notifications

Several independent traders react to price changes in a shared market.

class StockObserver(ABC):
    @abstractmethod
    def on_price_change(self, symbol: str, price: float) -> None: ...


class StockMarket:
    def __init__(self) -> None:
        self._observers: list[StockObserver] = []

    def register_observer(self, observer: StockObserver) -> None:
        self._observers.append(observer)

    def set_price(self, symbol: str, price: float) -> None:
        for observer in self._observers:
            observer.on_price_change(symbol, price)


class StockTrader(StockObserver):
    def __init__(self, name: str) -> None:
        self.name = name

    def on_price_change(self, symbol: str, price: float) -> None:
        print(f"{self.name} sees {symbol} at ${price}")


# use
market = StockMarket()
market.register_observer(StockTrader("Trader A"))
market.register_observer(StockTrader("Trader B"))

market.set_price("AAPL", 150.0)
market.set_price("GOOGL", 2500.0)

public interface StockObserver {
    void onPriceChange(String symbol, double price);
}

public class StockMarket {
    private final List<StockObserver> observers = new ArrayList<>();

    public void registerObserver(StockObserver observer) {
        observers.add(observer);
    }

    public void setPrice(String symbol, double price) {
        for (StockObserver observer : observers) {
            observer.onPriceChange(symbol, price);
        }
    }
}

public class StockTrader implements StockObserver {
    private final String name;

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

    public void onPriceChange(String symbol, double price) {
        System.out.println(name + " sees " + symbol + " at $" + price);
    }
}

// use
StockMarket market = new StockMarket();
market.registerObserver(new StockTrader("Trader A"));
market.registerObserver(new StockTrader("Trader B"));

market.setPrice("AAPL", 150.0);
market.setPrice("GOOGL", 2500.0);

type StockObserver interface {
	OnPriceChange(symbol string, price float64)
}

type StockMarket struct {
	observers []StockObserver
}

func (m *StockMarket) RegisterObserver(o StockObserver) {
	m.observers = append(m.observers, o)
}

func (m *StockMarket) SetPrice(symbol string, price float64) {
	for _, observer := range m.observers {
		observer.OnPriceChange(symbol, price)
	}
}

type StockTrader struct {
	Name string
}

func (t StockTrader) OnPriceChange(symbol string, price float64) {
	fmt.Printf("%s sees %s at $%.2f\n", t.Name, symbol, price)
}

// use
market := &StockMarket{}
market.RegisterObserver(StockTrader{Name: "Trader A"})
market.RegisterObserver(StockTrader{Name: "Trader B"})

market.SetPrice("AAPL", 150.0)
market.SetPrice("GOOGL", 2500.0)

interface StockObserver {
  onPriceChange(symbol: string, price: number): void;
}

class StockMarket {
  private observers: StockObserver[] = [];

  registerObserver(observer: StockObserver) {
    this.observers.push(observer);
  }

  setPrice(symbol: string, price: number) {
    for (const observer of this.observers) {
      observer.onPriceChange(symbol, price);
    }
  }
}

class StockTrader implements StockObserver {
  constructor(private name: string) {}

  onPriceChange(symbol: string, price: number) {
    console.log(`${this.name} sees ${symbol} at $${price}`);
  }
}

// use
const market = new StockMarket();
market.registerObserver(new StockTrader('Trader A'));
market.registerObserver(new StockTrader('Trader B'));

market.setPrice('AAPL', 150.0);
market.setPrice('GOOGL', 2500.0);

StockMarket has no idea how many traders exist or what they do with a price update — it just broadcasts. That is the whole point.

A note for Java readers: java.util.Observable exists but has been deprecated since Java 9, because it is a class (not an interface, so it uses up your one shot at inheritance) and is not thread-safe. Write your own small Subject/Observer interfaces as above, or reach for a reactive library for anything more elaborate than a handful of listeners.

When it helps

Observer fits wherever one change needs to ripple out to a variable, possibly-changing set of listeners: UI components reacting to model updates, logging or metrics hooks kept out of core business logic, cache invalidation, any publish/subscribe workflow.

When it hurts

Notification is indirect, so tracing “what happens when this value changes” means following every registered observer. If an observer’s update triggers a change back on the subject, you can get notification loops that are hard to debug.

There are two common traps. An observer that is never removed keeps a live reference to the subject (and vice versa), which leaks memory in long-running apps. And if one observer throws during notification, a naive loop can stop the rest from being notified — always isolate failures per observer.

For a handful of tightly related objects, a plain method call is simpler than wiring up a subject/observer relationship.

Practical tips

Keep the observer interface small — usually one method.
Choose push or pull deliberately, based on how much state observers actually need.
Wrap each observer’s update call so one broken listener cannot block the others.
Always provide a way to unregister, and call it.
Never notify observers from inside a constructor — the object is not fully built yet.

Check your understanding

Observer in one line?
One object notifies many dependent objects automatically when it changes.

Push vs pull?
Push sends the data in the notification. Pull just signals a change and lets observers fetch what they need.

Why is Java’s Observable class discouraged?
It is a class (not an interface), is not thread-safe, and has been deprecated since Java 9.

What are the two most common Observer bugs?
Forgetting to unregister an observer (a leak), and letting one observer’s exception stop the rest.

When should you avoid it?
When the relationship is a simple, fixed one-to-one call — a direct method call is easier to follow.

What to learn next

Next: State Pattern — let an object change its behavior when its internal state changes.