In complex software systems, we often encounter a scenario:When the state of an object changes, other objects need to be notified so that they can react accordingly.If dependencies are established directly between these objects, the coupling of the system will increase significantly and the code will become difficult to maintain.Observer PatternThe publish-subscribe approach helps us solve this problem elegantly. This article will introduce the concept of the observer pattern, the difference from other similar patterns, the problems it solves, its implementation in Golang, and its application and precautions in actual development.

What is the Observer Pattern?

Observer Patternis aBehavioral design patterns, defines aOne-to-manyWhen the state of an object changes, it notifies all objects that depend on it (observers), allowing them to update automatically. This pattern is widely used in event-driven systems, such as GUI event processing, message broadcasting, data change notification, etc.

Components of the Observer Pattern

1. Subject: The observed object is responsible for maintaining and notifying all observers.
2. Observer: An object that monitors changes in the subject status and will be notified when the subject is updated.
3. Concrete Subject: A concrete class that implements the Subject interface, manages its observers and notifies them when the state changes.
4. Concrete Observer: A concrete class that implements the observer interface and responds to the state changes of the subject.

How the Observer Pattern Differs from Other Similar Patterns

1. Mediator Pattern

• Target: The mediator pattern manages communication between multiple objects through mediator objects, reducing direct dependencies between objects.
• the difference: The mediator pattern is suitable for complex multi-object communication, while the observer pattern focuses onEvent subscription and notification.
  The mediator mode can be specifically referred to:In-depth analysis of the implementation and application of the Mediator Pattern in Golang

2. Publish-Subscribe Pattern

• Target: The publish-subscribe model is an evolved version of the observer model, which decouples publishers and subscribers through message delegation.
• the difference: In the publish-subscribe pattern, there is no direct relationship between the publisher and the subscriber, whereas the observer in the observer pattern directly depends on the subject.

3. Event Listener Pattern

• Target: The event listener pattern is usually used in GUI applications to capture user events (such as mouse clicks and key presses).
• the difference: The event listener is a special observer mode that focuses on the processing of UI events.

What problem does the observer pattern solve?

1. Reduce coupling between objects: The observer pattern loosens the dependencies between objects. The subject only needs to maintain a list of observers without knowing the specific observer implementation.
2. Realize the linkage update of multiple objects: When the subject state changes, all observers will automatically receive notifications and update their states, realizing linkage between objects.
3. Improve system scalability: New observers can be registered to the subject at any time without affecting existing code.

Application scenarios of the observer pattern

1. Event-driven systems: Such as button click events and form submission events in GUI applications.
2. Message push system: When the stock price changes, notify the subscribed users.
3. Data Binding: In front-end development, the UI will be automatically updated when the data changes.
4. Logging System: Multiple log modules can monitor system status changes and record logs.

Observer pattern implementation in Golang

Below we use a specific Golang example to show how to use the observer pattern to implement a simple stock price monitoring system.

Example: Stock price monitoring system

1. Define the observer interface

package main 

// Observer interface: the interface that all observers need to implement 
type Observer interface {
    Update(stockPrice float64)
}

2. Implementing specific observers

import "fmt" 

// Investor structure: specific observer 
type Investor struct {
    name string
}

func (i *Investor) Update(stockPrice float64) {
    fmt.Printf("Investor %s notified. New stock price: %.2f\n", i.name, stockPrice)
}

3. Define the theme interface

// Subject interface: defines methods for adding, removing, and notifying observers
type Subject interface {
    Register(observer Observer)
    Deregister(observer Observer)
    NotifyAll()
}

4. Implement specific themes

// Stock structure: specific subject 
type Stock struct {
    observers  []Observer
    stockPrice float64
}

// Register adds observers 
func (s *Stock) Register(observer Observer) {
    s.observers = append(s.observers, observer)
}

// Deregister removes observers 
func (s *Stock) Deregister(observer Observer) {
    for i, obs := range s.observers {
        if obs == observer {
            s.observers = append(s.observers[:i], s.observers[i+1:]...)
            break
        }
    }
}


// NotifyAll Notify all observers 
func (s *Stock) NotifyAll() {
    for _, observer := range s.observers {
        observer.Update(s.stockPrice)
    }
}

 // UpdatePrice updates the stock price and notifies the observer
func (s *Stock) UpdatePrice(price float64) {
    fmt.Printf("Stock price updated to: %.2f\n", price)
    s.stockPrice = price
    s.NotifyAll()
}

5. Sample code using the observer pattern

func main() { 
     // Create a specific topic
     stock := &Stock{} 
   
    // Create observer 
    investor1 := &Investor{name: "Alice"}  
    investor2 := &Investor{name: "Bob"}  
    
    // Register observer 
   stock.Register(investor1) 
   stock.Register(investor2) 

  // Update the stock price and notify the observer 
  stock.UpdatePrice(100.50) 
  stock.UpdatePrice(102.75) 

 // Remove the observer 
 stock.Deregister(investor1) 

// Update the price again and notify the remaining observers 
stock.UpdatePrice(98.00) 
}

Output

Stock price updated to: 100.50
Investor Alice notified. New stock price: 100.50
Investor Bob notified. New stock price: 100.50
Stock price updated to: 102.75
Investor Alice notified. New stock price: 102.75
Investor Bob notified. New stock price: 102.75
Stock price updated to: 98.00
Investor Bob notified. New stock price: 98.00

Code Analysis

1. Observer Interface: Defines the common interface for all observersUpdate.
2. Investor Structure: AchievedObserverInterface, representing a specific investor.
3. Subject Interface: Defines methods for registering, removing, and notifying observers.
4. Stock Structure: AchievedSubjectInterface, representing a specific stock price monitoring system.
5. main function: Demonstrates how to use the observer pattern to notify all investors when a stock price is updated.

Application in actual development

1. Event-driven UI framework: Events such as button clicks and input box changes will notify all registered listeners to respond.
2. Real-time data push system: Systems such as stock markets and weather forecasts will push data to all subscribers in real time.
3. Logging System: Different modules in the logging system can monitor system events and record logs.
4. Notification system: After a user subscribes to certain events, he will receive real-time notifications when the events are triggered.

Things to note when using the observer pattern

1. Number of observers: When the number of observers is large, notifying all observers may cause performance problems.
2. Notification frequency: Frequent status updates may result in too many notifications and affect system performance. You can useBatch UpdateorEvent FilteringTo optimize.
3. Avoid circular dependencies: Care should be taken to avoid circular calls between observers and subjects to prevent the program from falling into an infinite loop.

Comparison between the Observer pattern and the Mediator pattern

Summarize

The observer pattern is a very practical design pattern, especially suitable for event-driven systems. By decoupling state changes and event notifications, the observer pattern improves

The scalability and maintainability of the system are improved. In Golang, the implementation of the observer pattern is very simple and can be completed through the combination of interfaces and structures. In actual development, the observer pattern is widely used in scenarios such as UI frameworks, data push systems, and log systems.

Reference Links

• Design Patterns - Observer Pattern
• Golang Design Patterns

I hope that through this article, you can deeply understand the implementation and application of the observer pattern in Golang. If you need to implement event notification and state synchronization in your project, you might as well try to use the observer pattern to simplify the design.