Observer (Behavioral)

Intent / problem it solves

Define a one-to-many dependency so when one object changes state, all dependents are notified and updated automatically (publish/subscribe at the object level).

When to use / when NOT

Use for eventing, model-view updates, domain events, or UI data binding.

Avoid when updates must be strictly ordered in a pipeline (maybe Chain of Responsibility) or when message buses are a better scale-out fit.

Structure

Subject maintains observer list; concrete subjects call notify() after state changes; observers implement update.

Loading diagram…

Go example

package main

import "fmt"

type PriceListener interface {
	OnPrice(currency string, value float64)
}

type Market struct {
	listeners []PriceListener
}

func (market *Market) Subscribe(listener PriceListener) {
	market.listeners = append(market.listeners, listener)
}

func (market *Market) Publish(currency string, value float64) {
	for _, listener := range market.listeners {
		listener.OnPrice(currency, value)
	}
}

type ConsoleListener struct{}

func (ConsoleListener) OnPrice(currency string, value float64) {
	fmt.Println(currency, value)
}

func main() {
	market := &Market{}
	market.Subscribe(ConsoleListener{})
	market.Publish("USD", 1.1)
}

JavaScript example

class ObservableStore {
  constructor() {
    this.listeners = new Set();
  }

  subscribe(listener) {
    this.listeners.add(listener);
    return () => this.listeners.delete(listener);
  }

  emit(event) {
    for (const listener of this.listeners) {
      listener(event);
    }
  }
}

const store = new ObservableStore();
store.subscribe((event) => console.log('heard', event.kind));
store.emit({ kind: 'cartUpdated', total: 42 });

Interview phrase

“Observer decouples publishers from subscribers—domains emit facts; views or integrations react without the core knowing every listener.”

Connect to LLD for event subscribers, notification fan-out, or live dashboards in LLD case studies. Also see Pub/sub building block.

On this page