设计模式-观察者模式

注意

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。

• 主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作
• 何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知

observer.go

package observer

import (
	"fmt"
	"sync"
)

type Observer interface {
	NotifyCallback(event Event)
}

type Event struct {
	Data int
	Source Subject
}

type Subject interface {
	AddListener(observer Observer)
	RemoveListener(observer Observer)
	Notify(event Event)
	PrintInfo()
}

type SubjectA struct {
	Name string
	Observers sync.Map
}

type ObserverA struct {

}

func (a *SubjectA)AddListener(observer Observer)  {
	a.Observers.Store(observer, struct {}{})
}

func (a *SubjectA) RemoveListener(observer Observer) {
	a.Observers.Delete(observer)
}

func (a *SubjectA)Notify(event Event) {
	a.Observers.Range(func(key, value interface{}) bool {
		observer, _ := key.(Observer)
		observer.NotifyCallback(event)
		return true
	})
}

func (a *SubjectA)PrintInfo()  {
	fmt.Println("subject a")
}

func (ob *ObserverA)NotifyCallback(event Event)  {
	fmt.Printf("event data %d\n", event.Data)
	source := event.Source
	source.PrintInfo()
}

observer_test.go

package observer

import (
	"sync"
	"testing"
)

func TestSubjectA_Notify(t *testing.T) {
	subject := SubjectA{
		Name:      "SubjectA",
		Observers: sync.Map{},
	}
	event := Event{
		Data:   0,
		Source: &subject,
	}

	observer := ObserverA{}
	subject.AddListener(&observer)
	subject.Notify(event)
}