observer.go
最后更新于：2022-04-02 04:50:17
~~~
/*
Observer 观察者模式：
定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。
这个主题对象在状态发生改变时，会通知所有观察者对象，使它们能够自动更新自己。
个人想法：抽象通知者依赖抽象观察者，具体观察者依赖具体通知者
作者： HCLAC
日期： 20170310
*/
package observer
import (
"fmt"
)
type Subject interface {
Notify()
State() int
SetState(int)
AddCallFunc(*update)
RemoveCallFunc(*update)
}
type update func(int)
type SubjectA struct {
state int
call []*update
}
func (s *SubjectA) Notify() {
if s == nil {
return
}
for _, c := range s.call {
(*c)(s.state)
}
}
func (s *SubjectA) State() int {
if s == nil {
return 0
}
return s.state
}
func (s *SubjectA) SetState(i int) {
if s == nil {
return
}
s.state = i
}
func (s *SubjectA) AddCallFunc(f *update) {
if s == nil {
return
}
for _, c := range s.call {
if c == f {
return
}
}
s.call = append(s.call, f)
}
func (s *SubjectA) RemoveCallFunc(f *update) {
if s == nil {
return
}
for i, c := range s.call {
if c == f {
s.call = append(s.call[:i], s.call[i+1:]...)
}
}
}
func NewSubjectA(s int) *SubjectA {
return &SubjectA{s, []*update{}}
}
type Observer interface {
Update(int)
}
type ObserverA struct {
s Subject
state int
}
func (o *ObserverA) Update(s int) {
if o == nil {
return
}
fmt.Println("ObserverA")
fmt.Println(s)
fmt.Println(o)
}
func NewObserverA(sa Subject, s int) *ObserverA {
return &ObserverA{sa, s}
}
type ObserverB struct {
s Subject
state int
}
func (o *ObserverB) Update(s int) {
if o == nil {
return
}
fmt.Println("ObserverB")
fmt.Println(s)
fmt.Println(o)
}
func NewObserverB(sa Subject, s int) *ObserverB {
return &ObserverB{sa, s}
}
~~~
';