[ Design Patterns ] - Observer pattern with Golang

Mayfest2023

Ha Noi, Wed 10/05/2023

At the moment, a little speech to give to the present...

Cơn mưa ngang qua mang em đi xa

Cơn mưa ngang qua khiến em nhạt nhòa...

Today, I listened to Son Tung's old song. I missed something in the past. At the same time as this song, I read a story on Voz that's name is "[Kể lại 1 câu chuyện] Đặt tên là "CƠN MƯA NGANG QUA". This story is very perfect, let's read it! 😊😊😊

I. Observer Pattern

Observer is a behavioral design pattern that lets you define a subscription mechanism to notify multiple objects about any events that happen to the object they’re observing.

Reference: Observer Pattern

II. Implement

1. The problem

Imagine that we have two objects: customers and the Apple Store.

The customer is a big fan of Apple, and he always wants to have the newest brand model whenever Apple introduces a new brand model. So, he must go to the Apple Store every day and ask the Apple Store's employees about the new brand model of Apple. Maybe it is still not available in the Apple Store, so he must spend lots of days going to the store.

Hmm, as in the image above, to resolve his problem, the store will notify and email all customers whenever the new brand model is available in the store. Nicely, the solution resolved his problem about spending time going to the store. But some customers like Android phones, so whenever they receive a notification about the new brand model from Apple, they are very angry and not happy.

2. The solution

So, to resolve this problem for him and some other customers who like Android phones, the store created a registration form to buy the new brand model. Whenever the product is available, the store will send a notification to all customers registered to buy iPhones.

So, to resolve the problem, we will use the Observer Pattern.

3. Implement Observer Pattern

3.1. Interface Publisher

ipublisher.go: This is the action interface of the publisher.

package publisher

import "design-pattern-golang-example/observer_pattern/subscriber"

type IPublisher interface {
	Subscribe(s subscriber.ISubscriber)
	UnSubscribe(s subscriber.ISubscriber)
	NotifySubscribes()
}

3.2. Concrete Publisher

apple_store.go: The publisher will handle and implement the logic for all actions that define by the interface publisher. Here, I define a publisher as Apple Store.

package concrete_publisher

import (
	"fmt"
	"time"

	"design-pattern-golang-example/observer_pattern/publisher"
	"design-pattern-golang-example/observer_pattern/subscriber"
)

type AppleStore struct {
	Subscribers []subscriber.ISubscriber
	Name        string
}

func NewAppleStore(subscribers []subscriber.ISubscriber, name string) publisher.IPublisher {
	return &AppleStore{
		Subscribers: subscribers,
		Name:        name,
	}
}

func (as *AppleStore) Subscribe(s subscriber.ISubscriber) {
	as.Subscribers = append(as.Subscribers, s)
	time.Sleep(1 * time.Second)
	fmt.Println(s.GetEmail() + " was subscribed...")
}

func (as *AppleStore) UnSubscribe(s subscriber.ISubscriber) {
	subscribersUpdate := make([]subscriber.ISubscriber, 0)
	for _, sub := range as.Subscribers {
		if sub.GetEmail() != s.GetEmail() {
			subscribersUpdate = append(subscribersUpdate, sub)
		}
	}

	time.Sleep(1 * time.Second)
	fmt.Println(s.GetEmail() + " was unsubscribed...")

	as.Subscribers = subscribersUpdate
}

func (as *AppleStore) NotifySubscribes() {
	for _, sub := range as.Subscribers {
		sub.SendEmail("We have had a new model of the iPhone")
		time.Sleep(1 * time.Second)
	}
}

3.3. Interface Subscriber

isubscriber.go: This is the action interface of the subscribers.

package subscriber

// ISubscriber this is the observer
type ISubscriber interface {
	SendEmail(notification string)
	GetEmail() string
}

3.4. Concrete Subscriber

customer_subscriber.go: The subscriber will handle and implement the logic for all actions that define by the interface subscriber. Here, I define a subscriber as a customer.

package concrete_subscriber

import (
	"fmt"

	"design-pattern-golang-example/observer_pattern/subscriber"
)

type Customer struct {
	Email string
}

func NewCustomer(email string) subscriber.ISubscriber {
	return &Customer{Email: email}
}

func (c *Customer) SendEmail(notification string) {
	content := fmt.Sprintf(`Sending the notification for %s with content "%s"`, c.GetEmail(), notification)
	fmt.Println(content)
}

func (c *Customer) GetEmail() string {
	return c.Email
}

3.5. Main Function

main.go: Hàm chạy chương trình

package main

import (
	"time"

	"design-pattern-golang-example/observer_pattern/publisher/concrete_publisher"
	"design-pattern-golang-example/observer_pattern/subscriber"
	"design-pattern-golang-example/observer_pattern/subscriber/concrete_subscriber"
)

func main() {
	// init publisher
	appleStore := concrete_publisher.NewAppleStore([]subscriber.ISubscriber{}, "apple store")

	// init observer
	subscriberOne := concrete_subscriber.NewCustomer("subscribe-one@gmail.com")
	subscriberTwo := concrete_subscriber.NewCustomer("subscribe-two@gmail.com")

	// the observer subscribes publisher
	appleStore.Subscribe(subscriberOne)
	appleStore.Subscribe(subscriberTwo)

	// send notification
	time.Sleep(3 * time.Second)
	appleStore.NotifySubscribes()

	// the observer unsubscribes publisher
	appleStore.UnSubscribe(subscriberTwo)

	// send notification
	time.Sleep(3 * time.Second)
	appleStore.NotifySubscribes()
}

Result

subscribe-one@gmail.com was subscribed...
subscribe-two@gmail.com was subscribed...
Sending the notification for subscribe-one@gmail.com with content "We have had a new model of the iPhone"
Sending the notification for subscribe-two@gmail.com with content "We have had a new model of the iPhone"
subscribe-two@gmail.com was unsubscribed...
Sending the notification for subscribe-one@gmail.com with content "We have had a new model of the iPhone"

Process finished with the exit code 0