Golang观察者模式实现：channel与闭包结合应用

观察者模式在Golang中常通过channel与闭包实现。该模式是一种行为型设计模式，用于实现一对多的依赖通知机制，当对象状态变化时，所有依赖对象会被自动通知。在Go中，被观察者维护观察者列表并通知其状态变化，观察者则监听事件并通过channel接收通知。常见实现方式包括：1. 使用channel作为观察者通信媒介，Subject维护channel列表并在Notify方法中异步发送事件；2. 用闭包简化逻辑，将观察者定义为函数类型，直接注册处理逻辑；3. channel与闭包混合使用，封装内部监听channel的闭包函数，对外暴露调用接口。实现时需注意关闭channel避免泄露、使用缓冲channel防止阻塞、管理并发访问及执行顺序等问题。

在Golang中实现观察者模式，常见的做法是利用channel与闭包的结合。这种方式不仅简洁、高效，而且天然契合Go语言并发模型的特点。相比传统的面向对象式实现，用channel和闭包可以更灵活地管理观察者之间的通信。

什么是观察者模式？

观察者模式是一种行为型设计模式，用于一对多的依赖通知机制。当一个对象的状态发生变化时，所有依赖它的对象都会被自动通知并更新。

在Go中，没有类的概念，但我们可以用函数、channel和结构体来模拟这种行为。其中：

• 被观察者（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和闭包灵活实现，既可以做到高内聚低耦合，也能很好地适应并发场景。关键在于根据实际需求选择合适的方式组合这两者。基本上就这些。