Notes: Go Design Patterns - Observer Pattern

Observer Pattern as the name suggests is based on observation of something, maybe a state, maybe an event, or something else. It is a behavioral pattern.

In this pattern, we have two actors, publishers and subscribers. Publishers' job is to maintain the list of subscribers by adding or removing the subscribers and also notify them about the required changes that these subscribers expect. So, publishers' interface can look something like this:

type publisher interface {
    register(subscriber subscriber)
    deregister(subscriber subscriber)
    notifyAll()
}

Now, as soon as the publisher notifies subscribers, they need to act on it. So, subscribers can have a simple interface like this:

type subscriber interface {
    trigger(context context.Context)
}

Let's try to understand this with an example. Let's build a notifier for Out of Stock products for an e-commerce store. If there is any item that is out of stock, users will be able to subscribe to that item and as soon as it gets available, they'll be notified and users will be able to act on that.

First, we can have an event manager/ publisher who will contain information of product which is being subscribed and the list of its subscribers. It can be something like this:

type stockCheckEventManager struct {
    subscribers stockCheckSubscriberMap
    productID   string
    productName string
    inStock     bool
}

This will implement publisher interface we mentioned in the beginning.

Next is subscribers. Subscribers are users, so they can be represented like this:

type stockCheckSubscriberObject struct {
    userID   string
    userName string
}

This will implement subscriber interface mentioned in the beginning.

I'm skipping subscriber addition and removal part as it's not that important. Now, let's look into how things will move.

Now, to start the whole process, first, we call updateStockAvailability method as soon as stock is available again.

func (em *stockCheckEventManager) updateStockAvailability() {
    fmt.Printf("item %v is now in stock\n", em.productName)
    em.inStock = true
    em.notifyAll()
}

This then calls notifyAll method to notify all the subscribers:

func (em *stockCheckEventManager) notifyAll() {
    if em.inStock {
        ctx := context.WithValue(context.Background(), productIDKey, em.productID)
        for _, subscriber := range em.subscribers {
            subscriber.trigger(ctx)
        }
    }
}

Now, notifyAll method goes through all the subscribers and executes the trigger method:

func (s *stockCheckSubscriberObject) trigger(ctx context.Context) {
    productID := ctx.Value(productIDKey)
    fmt.Printf("Product: %v back in Stock. Trigger subsequent events like sending mail, browser notification etc for user: %v\n", productID, s.userID)
}

And this ends our execution flow.

Full working code:

package main

import (
    "context"
    "fmt"
)

type contextKey string

const productIDKey contextKey = "productID"

// central manager interface
type publisher interface {
    register(subscriber subscriber)
    deregister(subscriber subscriber)
    notifyAll()
}

// observer interface
type subscriber interface {
    trigger(context context.Context)
}

type stockCheckSubscriber interface {
    subscriber
    getKey() string
}

type stockCheckSubscriberMap map[string]stockCheckSubscriber

// for subscribers, make sure key is subscriber related
// to avoid subscriber duplication
type stockCheckEventManager struct {
    subscribers stockCheckSubscriberMap
    productID   string
    productName string
    inStock     bool
}

func newStockCheckEventManager(productID string, productName string) *stockCheckEventManager {
    subscribers := make(stockCheckSubscriberMap)

    return &stockCheckEventManager{
        subscribers: subscribers,
        productID:   productID,
        productName: productName,
        inStock:     false,
    }
}

func (em *stockCheckEventManager) register(subscriber subscriber) {
    stockCheckSubscriber := subscriber.(stockCheckSubscriber)
    em.subscribers[stockCheckSubscriber.getKey()] = stockCheckSubscriber

    fmt.Printf("registered %v as subscriber\n", stockCheckSubscriber.getKey())
}

func (em *stockCheckEventManager) deregister(subscriber subscriber) {
    stockCheckSubscriber := subscriber.(stockCheckSubscriber)
    delete(em.subscribers, stockCheckSubscriber.getKey())

    fmt.Printf("deregistered %v as subscriber\n", stockCheckSubscriber.getKey())
}

func (em *stockCheckEventManager) notify(subscribers map[string]subscriber) {
    if em.inStock {
        ctx := context.WithValue(context.Background(), productIDKey, em.productID)
        for _, subscriber := range subscribers {
            subscriber.trigger(ctx)
        }
    }
}

func (em *stockCheckEventManager) notifyAll() {
    if em.inStock {
        ctx := context.WithValue(context.Background(), productIDKey, em.productID)
        for _, subscriber := range em.subscribers {
            subscriber.trigger(ctx)
        }
    }
}

func (em *stockCheckEventManager) updateStockAvailability() {
    fmt.Printf("item %v is now in stock\n", em.productName)
    em.inStock = true
    em.notifyAll()
}

/************************************
**** Stock Check Subscriber Code ****
*************************************/
type stockCheckSubscriberObject struct {
    userID   string
    userName string
}

func newStockCheckSubscribers(userID string, userName string) *stockCheckSubscriberObject {
    return &stockCheckSubscriberObject{
        userID:   userID,
        userName: userName,
    }
}

func (s *stockCheckSubscriberObject) trigger(ctx context.Context) {
    productID := ctx.Value(productIDKey)
    fmt.Printf("Product: %v back in Stock. Trigger subsequent events like sending mail, browser notification etc for user: %v", productID, s.userID)
}

func (s *stockCheckSubscriberObject) getKey() string {
    return s.userID
}

func main() {
    stockCheckSubscriber1 := newStockCheckSubscribers("156", "kshitij")
    stockCheckSubscriber2 := newStockCheckSubscribers("528", "nidhi")
    stockCheckSubscriber3 := newStockCheckSubscribers("339", "coco")

    newStockCheckManager1 := newStockCheckEventManager("107", "shirt")
    newStockCheckManager2 := newStockCheckEventManager("108", "skirt")

    newStockCheckManager1.register(stockCheckSubscriber1)
    newStockCheckManager1.register(stockCheckSubscriber2)

    newStockCheckManager2.register(stockCheckSubscriber2)
    newStockCheckManager2.register(stockCheckSubscriber3)

    newStockCheckManager1.updateStockAvailability()

    newStockCheckManager2.deregister(stockCheckSubscriber2)

    newStockCheckManager2.updateStockAvailability()
}