观察者模式之Golang实现

观察者模式的具体概念原理，参见https://baike.baidu.com/item/%E8%A7%82%E5%AF%9F%E8%80%85%E6%A8%A1%E5%BC%8F/5881786?fr=aladdin，讲的很详细。

下面是Golang实现的观察者模式，有五个文件(都在src/designer/observe/目录下)，分别是：

1. defs.go : 定义被观察者和观察者接口

 package observe

 // 被观察者接口
 type Subject interface {
     Notify()                   // 当被观察者状态变更时，通知所有已注册的观察者，调用其自身的变更方法
     State() int                // 查看被观察者此时的状态
     SetState(int)              // 变更被观察者的状态
     AddObserve(ob Observer)    // 注册观察者
     RemoveObserve(ob Observer) // 删除观察者
 }

 // 观察者接口
 type Observer interface {
     Update(int) // 每个观察者要实现的变更自身的方法
 }

2. subject_a.go : 一个被观察者实例，实现被观察者接口

 package observe

 // 一个被观察者对象
 type SubjectA struct {
     state     int        // 观察者监听的状态数据
     observers []Observer // 存储已注册的观察者对象的容器
 }

 // 实现查看当前被观察者对象的状态
 func (sa *SubjectA) State() int {
     return sa.state
 }

 // 实现更改被观察者对象的状态
 func (sa *SubjectA) SetState(state int) {
     sa.state = state
 }

 // 注册观察者
 func (sa *SubjectA) AddObserve(ob Observer) {
     sa.observers = append(sa.observers, ob)
 }

 // 删除观察者
 func (sa *SubjectA) RemoveObserve(ob Observer) {
     for i, sao := range sa.observers {
         if sao == ob {
             sa.observers = append(sa.observers[:i], sa.observers[i+:]...)
         }
     }
 }

 // 通知所有已注册的观察者，变更自身的状态
 func (sa *SubjectA) Notify() {
     for _, sao := range sa.observers {
         sao.Update(sa.state)
     }
 }

 // 创建被观察者对象
 func NewSubjectA(state int) *SubjectA {
     return &SubjectA{state: state, observers: []Observer{}}
 }

3. observe_a.go: 一个观察者实例，实现观察者接口

 package observe

 // 一个观察者对象
 type ObserveA struct {
     selfStatus int
 }

 // 更新自身状态
 func (oa *ObserveA) Update(state int) {
     oa.selfStatus = state
 }

 // 创建观察者对象实例
 func NewObserveA(state int) *ObserveA {
     return &ObserveA{selfStatus: state}
 }

4. observe_b.go: 另一个观察者实例，实现观察者接口

 package observe

 // 一个观察者对象
 type ObserveB struct {
     selfStatus int
 }

 // 更新自身状态
 func (oa *ObserveB) Update(state int) {
     oa.selfStatus = state
 }

 // 创建观察者对象实例
 func NewObserveB(state int) *ObserveB {
     return &ObserveB{selfStatus: state}
 }

5. observe_test.go: 测试文件

 package observe

 import (
     "fmt"
     "testing"
 )

 func TestObserve(t *testing.T) {
     sa := NewSubjectA()
     oa := NewObserveA()
     ob := NewObserveB()

     fmt.Println(sa.State())
     fmt.Println(oa.selfStatus)
     fmt.Println(ob.selfStatus)

     fmt.Println("modify state")
     sa.SetState()
     fmt.Println(sa.State())

     fmt.Println("Add ob")
     sa.AddObserve(oa)
     sa.AddObserve(ob)

     sa.Notify()
     fmt.Println("notify")
     fmt.Println(sa.State())
     fmt.Println(oa.selfStatus)
     fmt.Println(ob.selfStatus)
 }

测试结果：

jerry@jerry-TravelMate-P243:~/golearn/src/designer/observe$ go test -v
=== RUN   TestObserve
2
3
4
modify state
5
Add ob
notify
5
5
5
--- PASS: TestObserve (0.00s)
PASS
ok      designer/observe        0.002s