观察者模式 Go语言实现

            模式组成：

观察者模式包含如下角色：
目标（Subject）: 目标知道它的观察者。可以有任意多个观察者观察同一个目标。 提供注册和删除观察者对象的接口。
具体目标（ConcreteSubject）:  将有关状态存入各ConcreteObserver对象。
观察者(Observer):  为那些在目标发生改变时需获得通知的对象定义一个更新接口。当它的状态发生改变时, 向它的各个观察者发出通知。
具体观察者(ConcreteObserver):   维护一个指向ConcreteSubject对象的引用。存储有关状态，这些状态应与目标的状态保持一致。实现O b s e r v e r的更新接口以使自身状态与目标的状态保持一致。

效果：

Observer模式允许你独立的改变目标和观察者。你可以单独复用目标对象而无需同时复用其观察者, 反之亦然。它也使你可以在不改动目标和其他的观察者的前提下增加观察者。
下面是观察者模式其它一些优点:
1 )观察者模式可以实现表示层和数据逻辑层的分离,并定义了稳定的消息更新传递机制，抽象了更新接口，使得可以有各种各样不同的表示层作为具体观察者角色。
2 )在观察目标和观察者之间建立一个抽象的耦合 ：一个目标所知道的仅仅是它有一系列观察者 , 每个都符合抽象的Observer类的简单接口。目标不知道任何一个观察者属于哪一个具体的类。这样目标和观察者之间的耦合是抽象的和最小的。因为目标和观察者不是紧密耦合的, 它们可以属于一个系统中的不同抽象层次。一个处于较低层次的目标对象可与一个处于较高层次的观察者通信并通知它 , 这样就保持了系统层次的完整。如果目标和观察者混在一块 , 那么得到的对象要么横贯两个层次 (违反了层次性), 要么必须放在这两层的某一层中(这可能会损害层次抽象)。
3) 支持广播通信 :不像通常的请求, 目标发送的通知不需指定它的接收者。通知被自动广播给所有已向该目标对象登记的有关对象。目标对象并不关心到底有多少对象对自己感兴趣 ;它唯一的责任就是通知它的各观察者。这给了你在任何时刻增加和删除观察者的自由。处理还是忽略一个通知取决于观察者。
4) 观察者模式符合“开闭原则”的要求。

UML图：

源代码：

package main
           
import (
    "container/list"
)
           
type Subject interface {
    Attach(Observer) //注册观察者 
    Detach(Observer) //释放观察者 
    Notify()         //通知所有注册的观察者 
}
type Observer interface {
    Update(Subject) //观察者进行更新状态 
}
           
//implements Subject
type ConcreteSubject struct {
    observers *list.List
    value     int
}
           
func NewConcreteSubject() *ConcreteSubject {
    s := new(ConcreteSubject)
    s.observers = list.New()
    return s
}
           
func (s *ConcreteSubject) Attach(observe Observer) { //注册观察者 
    s.observers.PushBack(observe)
}
           
func (s *ConcreteSubject) Detach(observer Observer) { //释放观察者 
    for ob := s.observers.Front(); ob != nil; ob = ob.Next() {
        if ob.Value.(*Observer) == &observer {
            s.observers.Remove(ob)
            break
        }
    }
}
           
func (s *ConcreteSubject) Notify() { //通知所有观察者 
    for ob := s.observers.Front(); ob != nil; ob = ob.Next() {
        ob.Value.(Observer).Update(s)
    }
}
           
func (s *ConcreteSubject) setValue(value int) {
    s.value = value
    s.Notify()
}
           
func (s *ConcreteSubject) getValue() int {
    return s.value
}
           
/**
 * 具体观察者 implements Observer
 *
 */
type ConcreteObserver1 struct {
}
           
func (c *ConcreteObserver1) Update(subject Subject) {
    println("ConcreteObserver1  value is ", subject.(*ConcreteSubject).getValue())
}
           
/**
 * 具体观察者 implements Observer
 *
 */
type ConcreteObserver2 struct {
}
           
func (c *ConcreteObserver2) Update(subject Subject) {
    println("ConcreteObserver2 value is ", subject.(*ConcreteSubject).getValue())
}
           
func main() {
           
    subject := NewConcreteSubject()
    observer1 := new(ConcreteObserver1)
    observer2 := new(ConcreteObserver2)
    subject.Attach(observer1)
    subject.Attach(observer2)
    subject.setValue(5)
           
}

运行结果：

1 2	ConcreteObserver1  value is  5 ConcreteObserver2 vaue is  5