Golang设计模式-观察者模式

一.观察者模式介绍 

意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

如何解决：使用面向对象技术，可以将这种依赖关系弱化。

观察者模式：定义对象间的一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生改变时，会通知所有观察者对象，使它们能够自动更新自己。 

 

二.观察者模式优缺点

优点：

• 观察者和被观察者是抽象耦合的。
• 建立一套触发机制。

缺点：

• 如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
• 如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
• 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

三.代码实现

package Design
import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

type Event struct {
	level int
}

//抽象观察者
type Observer interface{
	Update(*Event)
}

//抽象被观察者
type Subject interface {
	Attach(Observer) //添加观察者
	Detach(Observer) //删除观察者
	Notify() //通知观察者
}

//具体被观察者
type ConcreteSubject struct {
	observers []Observer
	value  interface{}
}

var instance *ConcreteSubject
var once sync.Once
func GetSubjectInstannce() *ConcreteSubject{
	once.Do(func() {
		instance = &ConcreteSubject{}
		instance.observers = make([]Observer, 0)
		rand.Seed(time.Now().UnixNano())
	})
	return instance
}
func (subject *ConcreteSubject) Attach(observer ...Observer) {
	subject.observers = append(subject.observers, observer...)
}

func (subject *ConcreteSubject) Detach(observer Observer) bool {
	for index, value := range subject.observers {
		if value ==  observer {
			subject.observers = append(subject.observers[:index], subject.observers[index +1:]...)
			return true
		}
	}
	return false
}

func (subject *ConcreteSubject) Notify() {
	for _, value := range subject.observers {
		event := &Event{level:rand.Intn(10)}
		value.Update(event)
	}
}

//具体观察者1
type ConcreteObserver1 struct{}
func (Observer *ConcreteObserver1) Update(evrnt *Event) {
	fmt.Println(fmt.Sprintln("ConcreteObserver1 dill the Event[%v],resualt:[%d]", *evrnt, evrnt.level + 1))
}

//具体观察者2
type ConcreteObserver2 struct{}
func (Observer *ConcreteObserver2) Update(evrnt *Event) {
	fmt.Println(fmt.Sprintln("ConcreteObserver2 dill the Event[%v],resualt:[%d]", *evrnt, evrnt.level + 2))
}

3.1 测试

package main

import (
	"./Design"
)

func main() {
	subject := Design.GetSubjectInstannce()
	ConcreteObserver1 := new(Design.ConcreteObserver1)
	ConcreteObserver2 := new(Design.ConcreteObserver2)
	subject.Attach(ConcreteObserver1)
	subject.Attach(ConcreteObserver2)
	subject.Notify()
	return
}

3.2 测试结果

ConcreteObserver1 dill the Event[%v],resualt:[%d] {4} 5

ConcreteObserver2 dill the Event[%v],resualt:[%d] {7} 9

Process finished with exit code 0

四.使用场景

• 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。
• 一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。
• 一个对象必须通知其他对象，而并不知道这些对象是谁。
• 需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。