如何在Golang中实现观察者模式_Golang观察者模式实现方法汇总

type Observer interface {
    Update(message string)
}
type Subject interface {
Register(observer Observer)
Deregister(observer Observer)
Notify(message string)
}

type ConcreteSubject struct {
    observers []Observer
}
func (s *ConcreteSubject) Register(observer Observer) {
s.observers = append(s.observers, observer)
}
func (s *ConcreteSubject) Deregister(observer Observer) {
for i, obs := range s.observers {
if obs == observer {
s.observers = append(s.observers[:i], s.observers[i+1:]...)
break
}
}
}
func (s *ConcreteSubject) Notify(message string) {
for _, observer := range s.observers {
observer.Update(message)
}
}

type ConcreteObserver struct {
    name string
}
func (o *ConcreteObserver) Update(message string) {
fmt.Printf("[%s] 收到消息: %s\n", o.name, message)
}

subject := &ConcreteSubject{}
observerA := &ConcreteObserver{name: "A"}
observerB := &ConcreteObserver{name: "B"}
subject.Register(observerA)
subject.Register(observerB)
subject.Notify("系统更新了")
// 输出：
// [A] 收到消息: 系统更新了
// [B] 收到消息: 系统更新了

type AsyncSubject struct {
    register   chan Observer
    deregister chan Observer
    message    chan string
    observers  map[Observer]bool
}
func NewAsyncSubject() *AsyncSubject {
subject := &AsyncSubject{
register:   make(chan Observer),
deregister: make(chan Observer),
message:    make(chan string),
observers:  make(map[Observer]bool),
}
go subject.start()
return subject
}
func (s *AsyncSubject) start() {
for {
select {
case observer := <-s.register:
s.observers[observer] = true
case observer := <-s.deregister:
delete(s.observers, observer)
case msg := <-s.message:
for observer := range s.observers {
go observer.Update(msg) // 异步通知
}
}
}
}
func (s *AsyncSubject) Register(observer Observer) {
s.register <- observer
}
func (s *AsyncSubject) Deregister(observer Observer) {
s.deregister <- observer
}
func (s *AsyncSubject) Notify(message string) {
s.message <- message
}

type Callback func(message string)
type FuncObserver struct {
callback Callback
}
func (f *FuncObserver) Update(message string) {
f.callback(message)
}
// 使用示例
observer := &FuncObserver{
callback: func(msg string) {
fmt.Println("闭包收到:", msg)
},
}

type GenericObserver[T any] interface {
    OnEvent(data T)
}
type GenericSubject[T any] struct {
observers []GenericObserver[T]
}
func (s *GenericSubject[T]) Attach(obs GenericObserver[T]) {
s.observers = append(s.observers, obs)
}
func (s *GenericSubject[T]) Notify(data T) {
for _, obs := range s.observers {
obs.OnEvent(data)
}
}