观察者模式之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+1:]...)
        }
    }
}

// 通知所有已注册的观察者，变更自身的状态
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(2)
    oa := NewObserveA(3)
    ob := NewObserveB(4)

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

    fmt.Println("modify state")
    sa.SetState(5)
    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