Go 观察者模式

缺乏、安全感 2024-04-28 08:00 5阅读 0赞

## Go 观察者模式 ##

Go 语言中的观察者模式（Observer Pattern）通常是通过使用通道（Channels）和 goroutines 来实现的，而不是像一些其他编程语言中那样使用类和对象。观察者模式用于定义对象之间的一对多依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都会得到通知并自动更新。

package main
    
    import "fmt"
    
    // 观察者接口
    type Observer interface {
        
    	Update(string)
    }
    
    // 主题接口
    type Subject interface {
        
    	RegisterObserver(Observer)
    	RemoveObserver(Observer)
    	NotifyObservers()
    }
    
    // 具体主题
    type ConcreteSubject struct {
        
    	observers []Observer
    	state     string
    }
    
    func (s *ConcreteSubject) RegisterObserver(observer Observer) {
        
    	s.observers = append(s.observers, observer)
    }
    
    func (s *ConcreteSubject) RemoveObserver(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) NotifyObservers() {
        
    	for _, observer := range s.observers {
        
    		observer.Update(s.state)
    	}
    }
    
    func (s *ConcreteSubject) SetState(state string) {
        
    	s.state = state
    	s.NotifyObservers()
    }
    
    // 具体观察者
    type ConcreteObserver struct {
        
    	name string
    }
    
    func (o *ConcreteObserver) Update(state string) {
        
    	fmt.Printf("观察者 %s 收到更新: %s\n", o.name, state)
    }
    
    func main() {
        
    	subject := &ConcreteSubject{
        }
    
    	observer1 := &ConcreteObserver{
        name: "观察者1"}
    	observer2 := &ConcreteObserver{
        name: "观察者2"}
    
    	subject.RegisterObserver(observer1)
    	subject.RegisterObserver(observer2)
    
    	subject.SetState("New state 1")
    	subject.SetState("New state 2")
    
    	subject.RemoveObserver(observer2)
    
    	subject.SetState("New state 3")
    }

观察者 观察者1 收到更新: New state 1
    观察者 观察者2 收到更新: New state 1
    观察者 观察者1 收到更新: New state 2
    观察者 观察者2 收到更新: New state 2
    观察者 观察者1 收到更新: New state 3

这段代码是使用Go语言实现的观察者设计模式。观察者模式是一种行为设计模式，它定义了对象之间一对多的依赖关系，当一个对象（主题）的状态发生变化时，所有依赖它的对象（观察者）会自动得到通知并更新。

在你的代码中：

1.  你定义了`Observer`（观察者）和`Subject`（主题）接口。`Observer`接口包含一个`Update`方法，而`Subject`接口包含用于注册、移除和通知观察者的方法。
2.  你实现了一个具体的主题，名为`ConcreteSubject`，它维护了一个观察者列表和自身的状态。它实现了`RegisterObserver`（注册观察者）、`RemoveObserver`（移除观察者）和`NotifyObservers`（通知观察者）的方法。
3.  你还定义了一个具体的观察者，名为`ConcreteObserver`，它包含一个名称属性和实现了`Update`方法，用于处理主题状态变化时的通知。
4.  在`main`函数中，你创建了一个`ConcreteSubject`对象，并注册了两个观察者（`observer1`和`observer2`）。然后，你通过调用`SetState`方法改变主题的状态，并观察到观察者收到了相应的更新通知。你还演示了如何移除一个观察者。

这个设计模式允许主题和观察者之间的松散耦合，使主题状态的改变可以通知所有相关观察者，而无需主题了解观察者的具体细节。这对于实现事件处理、消息传递和状态更新通知非常有用。