观察者模式 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
### Go语言中的观察者模式Go语言实现观察者模式可以通过定义接口来解耦被观察对象和多个观察者之间的依赖关系。这种方式使得当一个对象的状态发生变化时,所有依赖于它的对象都会得到通知并自动更新。 #### 定义观察者的接口 为了使代码更加灵活且易于维护,在Go中通常会先定义一个`Observer`接口,这个接口包含了接收通知的方法签名: ```go type Observer interface { Update(message string) } ``` 此方法用于向所有的注册过的观察者发送状态改变的信息[^1]。 #### 创建具体的观察者类 接着可以基于上述接口创建一些具体的观察者实例,这些实例实现了`Update()`函数以便处理来自主题的通知: ```go // ConcreteObserverA 是一种类型的观察者 type ConcreteObserverA struct{} func (o *ConcreteObserverA) Update(message string) { fmt.Printf("ConcreteObserverA received message: %s\n", message) } // ConcreteObserverB 另外一种类型的观察者 type ConcreteObserverB struct{} func (o *ConcreteObserverB) Update(message string) { fmt.Printf("ConcreteObserverB received message: %s\n", message) } ``` 以上两个结构体分别代表两种不同类型的观察者,并各自有不同的响应逻辑[^2]。 #### 设计Subject(被观察者) 之后需要构建一个主体(`Subject`),它负责管理一组观察者列表以及提供附加或移除观察者的能力;同时也要有办法去通知它们有关自身的更改情况: ```go type Subject struct { observers []Observer } func NewSubject() *Subject { return &Subject{observers: make([]Observer, 0)} } func (s *Subject) Attach(observer Observer) { s.observers = append(s.observers, observer) } func (s *Subject) Detach(observer Observer) { for i := range s.observers { if s.observers[i] == observer { s.observers = append(s.observers[:i], s.observers[i+1:]...) break } } } func (s *Subject) Notify(message string) { for _, obs := range s.observers { go obs.Update(message) // 使用goroutine并发执行以提高效率 } } ``` 这里特别注意的是`Notify()`方法内部采用了协程的方式调用了各个观察者的`Update()`方法,从而允许异步地完成通知过程,提高了程序性能[^3]。 #### 测试观察者模式的功能 最后编写一段简单的测试代码验证整个机制的工作原理: ```go func main() { subject := NewSubject() var ( observerA = new(ConcreteObserverA) observerB = new(ConcreteObserverB) ) subject.Attach(observerA) subject.Attach(observerB) time.AfterFunc(time.Second*2, func() { // 模拟两秒后的事件触发 subject.Notify("State has changed!") }) select {} // 阻塞主线程防止过早退出 } ``` 这段代码展示了如何创建一个新的`Subject`实例并将几个不同的观察者添加进去。经过一段时间延迟后模拟了一次状态变更的发生,这时所有已登记的观察者都将接收到相应的消息提示。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值