您如何在Golang中实现观察者模式？

在Go中可以通过接口和通道实现观察者模式，定义Observer接口包含Update方法，Subject结构体维护观察者列表和消息通道，通过Attach添加观察者，Notify发送消息，listen goroutine异步广播更新，具体观察者如EmailService和LogService实现Update方法处理通知，主程序注册观察者并触发事件，实现松耦合的事件通知机制，适用于事件驱动系统、日志记录和消息通知等场景。

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 allow 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.

以上是您如何在Golang中实现观察者模式？的详细内容。更多信息请关注PHP中文网其他相关文章！