Diving into the Observer Pattern

Welcome back! After exploring the Strategy Pattern, it's time to delve into another important behavioral design pattern: the Observer Pattern. This pattern focuses on establishing one-to-many relationships between objects, allowing an object (subject) to notify other objects (observers) about changes in its state.

In this lesson, you will discover how to implement the Observer Pattern in Go, covering the following key concepts:

1. Defining Observers: You will learn how to define an interface for observers so they can receive updates from the subject when something changes.
2. Creating a Subject: Next, you will see how to create a concrete subject that maintains a list of observers and provides methods to register, unregister, and notify them.
3. Putting It All Together: Finally, you will combine these elements to create a functional example where the subject notifies multiple observers of state changes.

Let's look at an example to illustrate these concepts:

We start by defining the Observer interface with an Update method that observers must implement:

type Observer interface {
    Update(string)
}

Next, we create a concrete observer that implements the Observer interface. When the Update method is called, the observer receives a message from the subject:

type ConcreteObserver struct {
    ID   int
    Name string
}

func (co *ConcreteObserver) Update(message string) {
    fmt.Printf("Subscriber %s (ID: %d) received weather update: %s\n", co.Name, co.ID, message)
}

Now, let's define the Subject interface and a concrete subject that implements it. The subject maintains a list of observers and provides methods to register, unregister, and notify them. When the NotifyObservers method is called, the subject sends a message to all observers by calling their Update methods, thereby notifying them of the state change:

type Subject interface {
    RegisterObserver(Observer)
    UnregisterObserver(Observer)
    NotifyObservers(string)
}

type ConcreteSubject struct {
    observers []Observer
}

func (cs *ConcreteSubject) RegisterObserver(o Observer) {
    cs.observers = append(cs.observers, o)
}

func (cs *ConcreteSubject) UnregisterObserver(o Observer) {
    var updatedObservers []Observer
    for _, observer := range cs.observers {
        if observer != o {
            updatedObservers = append(updatedObservers, observer)
        }
    }
    cs.observers = updatedObservers
}

func (cs *ConcreteSubject) NotifyObservers(message string) {
    for _, observer := range cs.observers {
        observer.Update(message)
    }
}

Finally, we can put it all together in the main function:

func main() {
    subscriber1 := &ConcreteObserver{ID: 1, Name: "WeatherApp"}
    subscriber2 := &ConcreteObserver{ID: 2, Name: "NewsWebsite"}

    weatherStation := &ConcreteSubject{}

    weatherStation.RegisterObserver(subscriber1)
    weatherStation.RegisterObserver(subscriber2)

    weatherStation.NotifyObservers("Sunny with a high of 25°C") // Both observers receive the message and print it to the console

    weatherStation.UnregisterObserver(subscriber1)

    weatherStation.NotifyObservers("Rainy with a chance of thunderstorms") // Only subscriber2 receives the message, as subscriber1 was unregistered
}

Let's break down this example:

• We define the Observer interface with an Update method that observers must implement.
• The ConcreteObserver struct implements the Observer interface and prints the received message when the Update method is called.
• The Subject interface defines methods to register, unregister, and notify observers.
• The ConcreteSubject struct maintains a list of observers and implements the Subject interface methods. In UnregisterObserver, we filter the list to remove all instances of the specified observer, ensuring the operation is safe even if the observer isn't found or the list is empty.
• In the main function, we create two observers (subscriber1 and subscriber2) and a subject (weatherStation).
• We register the observers with the subject, notify them of a state change, and then unregister one of the observers before sending another notification.
• When the subject notifies the observers, they receive the message and print it to the console with their respective names and IDs.

The output of the example will look like this:

Subscriber WeatherApp (ID: 1) received weather update: Sunny with a high of 25°C
Subscriber NewsWebsite (ID: 2) received weather update: Sunny with a high of 25°C
Subscriber NewsWebsite (ID: 2) received weather update: Rainy with a chance of thunderstorms

Notice how the observers receive the updates from the subject and react accordingly. This demonstrates the one-to-many relationship established by the Observer Pattern.

Let's understand what are the key components of the Observer Pattern:

• Subject: Represents the object being observed. It maintains a list of observers and provides methods to register, unregister, and notify them. In our example, Subject is the interface that subjects must implement, and ConcreteSubject is a concrete subject that implements this interface.
• Observer: Defines an interface for objects that should be notified of changes in the subject. In our example, Observer is the interface that observers must implement, and ConcreteObserver is a concrete observer that implements this interface.

By following this example, you will gain a solid understanding of how the Observer Pattern works and how it can be applied in real-world scenarios.