Observer

Intent

Defines a subscription mechanism that notifies multiple objects about events in the object they observe.

Problem

Customers keep polling the store for a new product, or the store spams everyone.

Solution

The publisher keeps a list of subscribers and notifies them when something happens. Events, signals and pub/sub are all Observer.

Real-world analogy

Structure

Hover or tap a numbered role to highlight it in the diagram.

1. 1Publisher — Publisher issues events and keeps the subscription list.
2. 2Publisher — When an event happens, it loops over subscribers and calls update().
3. 3Subscriber — Subscriber declares the notification interface, usually a single update method.
4. 4ConcreteSubscribers — Concrete Subscribers react to notifications.
5. 5Client — Client creates publishers and subscribers and registers subscriptions.

Try it

Code example

type Handler func(event string)

type Subject struct {
	mu       sync.Mutex
	handlers []Handler
}

func (s *Subject) Subscribe(h Handler) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.handlers = append(s.handlers, h)
}

func (s *Subject) Notify(event string) {
	s.mu.Lock()
	hs := append([]Handler(nil), s.handlers...)   // copy, then call outside the lock
	s.mu.Unlock()
	for _, h := range hs {
		h(event)
	}
}

Applicability

How to implement

1. Split business logic into a publisher and subscribers
2. Declare the subscriber interface (often a callback type)
3. Add subscribe / unsubscribe to the publisher
4. Notify subscribers when the event happens
5. Subscribers register with publishers

Pros and cons

Relations with other patterns

Check yourself