观察者模式在golang中常通过channel与闭包实现。该模式是一种行为型设计模式，用于实现一对多的依赖通知机制，当对象状态变化时，所有依赖对象会被自动通知。在go中，被观察者维护观察者列表并通知其状态变化，观察者则监听事件并通过channel接收通知。常见实现方式包括：1. 使用channel作为观察者通信媒介，subject维护channel列表并在notify方法中异步发送事件；2. 用闭包简化逻辑，将观察者定义为函数类型，直接注册处理逻辑；3. channel与闭包混合使用，封装内部监听channel的闭包函数，对外暴露调用接口。实现时需注意关闭channel避免泄露、使用缓冲channel防止阻塞、管理并发访问及执行顺序等问题。
在Golang中实现观察者模式，常见的做法是利用channel与闭包的结合。这种方式不仅简洁、高效，而且天然契合Go语言并发模型的特点。相比传统的面向对象式实现，用channel和闭包可以更灵活地管理观察者之间的通信。
什么是观察者模式？
观察者模式是一种行为型设计模式，用于一对多的依赖通知机制。当一个对象的状态发生变化时，所有依赖它的对象都会被自动通知并更新。
在Go中，没有类的概念，但我们可以用函数、channel和结构体来模拟这种行为。其中：
立即学习“go语言免费学习笔记（深入）”；
- 被观察者（Subject） 负责维护观察者列表，并在状态变化时通知它们。
- 观察者（Observer） 可以是一个函数或goroutine，监听事件并通过channel接收通知。
使用Channel实现观察者模式
使用channel是最常见也最自然的方式。你可以将每个观察者注册为一个goroutine，通过监听同一个channel来接收事件。
type Event string
type Subject struct {
observers []chan Event
}
func (s *Subject) Register(observer chan Event) {
s.observers = append(s.observers, observer)
}
func (s *Subject) Notify(event Event) {
for _, observer := range s.observers {
go func(ch chan Event) {
ch <- event
}(observer)
}
}上面这个Subject结构体维护了一个channel列表。当调用Notify()方法时，它会异步向每一个观察者发送事件。
观察者可以这样写：
observer := make(chan Event)
go func() {
for {
select {
case event := <-observer:
fmt.Println("Received event:", event)
}
}
}()结合闭包简化观察者注册
如果希望观察者的逻辑更轻量级，可以用闭包代替channel监听的goroutine。
例如，我们可以在Subject中定义一个观察者类型为func(Event)，然后在注册的时候直接传入处理逻辑：
type ObserverFunc func(Event)
type Subject struct {
observers []ObserverFunc
}
func (s *Subject) Register(fn ObserverFunc) {
s.observers = append(s.observers, fn)
}
func (s *Subject) Notify(event Event) {
for _, observer := range s.observers {
go observer(event)
}
}使用方式如下：
subject.Register(func(e Event) {
fmt.Println("Observer 1 received:", e)
})
subject.Register(func(e Event) {
fmt.Println("Observer 2 received:", e)
})这种方法的好处是不需要额外维护channel和goroutine，逻辑更清晰，适合业务不复杂的场景。
Channel + 闭包混合使用：兼顾灵活性与解耦
有时候你既想保留channel带来的异步能力，又想让观察者逻辑保持简洁，可以考虑将两者结合起来。
例如，可以封装一个函数，它返回一个闭包，而该闭包内部监听某个私有channel：
func NewObserver(handler func(Event)) func() {
ch := make(chan Event)
go func() {
for {
select {
case event := <-ch:
handler(event)
}
}
}()
return func() {
ch <- "some event"
}
}然后你可以像这样使用：
notifyFunc := NewObserver(func(e Event) {
fmt.Println("Handling event:", e)
})
notifyFunc()这种方式隐藏了channel的具体细节，只暴露一个可调用函数给外部，观察者只需要关心怎么触发即可。
小贴士：一些容易忽略的细节
- channel要记得关闭，尤其是在取消观察者时，避免goroutine泄露。
- 如果观察者数量很多，建议使用缓冲channel，防止阻塞。
- 观察者执行顺序不一定可控，如果有顺序要求，需要自己加锁或队列管理。
- 注册/注销观察者操作最好加上互斥锁保护，避免并发问题。
总的来说，Golang中的观察者模式可以通过channel和闭包灵活实现，既可以做到高内聚低耦合，也能很好地适应并发场景。关键在于根据实际需求选择合适的方式组合这两者。基本上就这些。
