观察者模式
观察者模式定义了对象之间一对多依赖，当一个对象改变状态时，他的所有依赖者都会收到通知并自动更新。有新类型的观察者出现时，主题的代码不需要修改，主题不在乎别的，他只会发送通知到所有注册并实现了观察者接口的对象。为了交互对象之间的松耦合涉及而努力。
观察者模式的要点有如下几点：
- Subject 一定要包含一个Observer 接口的列表
- Subject 要实现Attach函数来新增Observer
- Subject 要实现Notify函数，遍历Observer的列表，并调用每一个observer的Update函数进行更新
- Subject 要实现ContextUpdate函数，来更新Context数据，并调用Notify函数进行广播通知
- Subject 要实现Remove函数来剔除一部分Observer
- Observer 接口的Struct 要实现Update函数，这个Update函数的参数一定是Subject对象
observer.go:
package observer
import "fmt"
type Subjectstruct {
Observers []Observer //所有实现了Observer接口的struct都可以使用这个subject
context string
}
func NewSubject(cstring)(s *Subject) {
return &Subject{Observers:make([]Observer,0)}
}
func (s *Subject)Attach(o Observer) {
s.Observers=append(s.Observers,o)
}
func (s*Subject)Remove(o Observer)bool{
for i,j:=range s.Observers{
if j==o{
s.Observers=append(s.Observers[:i],s.Observers[i+1:]...)
return true
}
}
return false
}
func (s *Subject)Notify(){
for _,i:=range s.Observers{
i.Update(s)
}
}
func (s *Subject)UpdateContext(c string){
s.context=c
s.Notify()
}
type Observerinterface {
Update(subject *Subject)
}
type Readerstruct {
name string
}
func (r *Reader)Update(s *Subject) {
fmt.Printf("%s Received Context %s \n",r.name,s.context)
}
func NewReader(n string) (r *Reader) {
return &Reader{name:n}
}
observer_test.go:
package observer
func ExampleObserver() {
subject:=NewSubject("init subject")
reader1:=NewReader("frank")
reader2:=NewReader("tom")
reader3:=NewReader("paul")
reader4:=NewReader("fred")
subject.Attach(reader1)
subject.Attach(reader2)
subject.Attach(reader3)
subject.UpdateContext("hi ,i am updated to jjj")
if subject.Remove(reader4){
subject.UpdateContext("hi ,i am updated to remove paul successful")
}else {
subject.UpdateContext("hi ,No result found while i am trying to remove paul")
}
// Output: The output of
// this example.
}
在目录下执行go test，可自动执行ExampleObserver函数
