How do you implement an observer pattern in Golang?

In Go, observer mode can be implemented through interfaces and channels, the Observer interface can be defined, the Observer interface includes the Update method, the Subject structure maintains the observer list and message channel, add observers through Attach, Notify sends messages, listen goroutine asynchronous broadcast updates, specific observers such as EmailService and LogService implement the Update method to handle notifications, the main program registers the observer and triggers events, and realizes a loosely coupled event notification mechanism, which is suitable for event-driven systems, logging and message notifications, etc.

In Go, you can implement the observer pattern using interfaces and channels to enable loose coupling between a subject (also called publisher) and its observers (subscribers). The idea is that when the subject's state changes, all registered observers are notified automatically.

Here's how you can implement it cleanly in Go:

Define the Observer Interface

Start by defining an interface that all observers must satisfy:

 type Observer interface {
    Update(message string)
}

Each observer will implement the Update method to react to changes.

Define the Subject (Publisher)

The subject maintains a list of observers and provides methods to add, remove, and notify them:

 type Subject struct {
    observers []Observer
    messages chan string
}

We use a channel ( messages ) to push updates asynchronously.

Initialize the subject:

 func NewSubject() *Subject {
    subject := &Subject{
        observers: make([]Observer, 0),
        messages: make(chan string, 10), // buffered channel
    }
    go subject.listen()
    Return subject
}

The listen method runs in a goroutine and broadcasts messages to all observers:

 func (s *Subject) listen() {
    for msg := range s.messages {
        for _, obs := range s.observers {
            obs.Update(msg)
        }
    }
}

Add methods to manage observers and trigger updates:

 func (s *Subject) Attach(obs Observer) {
    s.observers = append(s.observers, obs)
}

func (s *Subject) Notify(msg string) {
    s.messages <- msg
}

Note: We don't expose a Detach method here for simplicity, but you can add it by filtering the slice.

Implement Concrete Observers

Here's a simple observer that prints the message:

 type EmailService struct{}

func (e *EmailService) Update(message string) {
    fmt.Printf("Email sent with message: %s\n", message)
}

type LogService struct{}

func (l *LogService) Update(message string) {
    fmt.Printf("Log recorded: %s\n", message)
}

Usage Example

 func main() {
    subject := NewSubject()

    emailService := &EmailService{}
    logService := &LogService{}

    subject.Attach(emailService)
    subject.Attach(logService)

    subject.Notify("User registered!")
    subject.Notify("Payment processed.")

    // Give time for messages to be processed
    time.Sleep(time.Millisecond * 100)
}

Output:

 Email sent with message: User registered!
Log recorded: User registered!
Email sent with message: Payment processed.
Log recorded: Payment processed.

Key Points

• Channels make the notification asynchronous and safe for concurrent use.
• Interfaces allows flexibility — any type that implements Update can be an observer.
• You can extend this with typed messages, error handling, or unsubscription logic.
• For production use, consider using sync.RWMutex if observers are added/removed at runtime.

This pattern works well for event-driven systems, logging, notifications, or any scenario where components need to react to state changes without tight coupling. It's simple, idiomatic Go, and avoids complex dependencies.

The above is the detailed content of How do you implement an observer pattern in Golang?. For more information, please follow other related articles on the PHP Chinese website!