观察者模式的实际应用

本文转载自微信公众号「crossoverJie」，作者crossoverJie。转载本文请联系crossoverJie公众号。

公司主营业务：成都网站建设、网站设计、移动网站开发等业务。帮助企业客户真正实现互联网宣传，提高企业的竞争能力。成都创新互联是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化，感谢他们对我们的高要求，感谢他们从不同领域给我们带来的挑战，让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。成都创新互联推出宁海免费做网站回馈大家。

前言

设计模式不管是在面试还是工作中都会遇到，但我经常碰到小伙伴抱怨实际工作中自己应用设计模式的机会非常小。

正好最近工作中遇到一个用观察者模式解决问题的场景，和大家一起分享。

背景如下：

在用户创建完订单的标准流程中需要做额外一些事情：

同时这些业务也是不固定的，随时会根据业务发展增加、修改逻辑。

如果直接将逻辑写在下单业务中，这一”坨“不是很核心的业务就会占据的越来越多，修改时还有可能影响到正常的下单流程。

当然也有其他方案，比如可以启动几个定时任务，定期扫描扫描订单然后实现自己的业务逻辑;但这样会浪费许多不必要的请求。

观察者模式

因此观察者模式就应运而生，它是由事件发布者在自身状态发生变化时发出通知，由观察者获取消息实现业务逻辑。

这样事件发布者和接收者就可以完全解耦，互不影响;本质上也是对开闭原则的一种实现。

示例代码

先大体看一下观察者模式所使用到的接口与关系：

  • 主体接口：定义了注册实现、循环通知接口。
  • 观察者接口：定义了接收主体通知的接口。
  • 主体、观察者接口都可以有多个实现。
  • 业务代码只需要使用 Subject.Nofity() 接口即可。

接下来看看创建订单过程中的实现案例。

代码采用 go 实现，其他语言也是类似。

首先按照上图定义了两个接口：

  
 
 
 
       
  
  
  
  1. type Subject interface { 
    2.    
  
  
  
  2.  Register(Observer) 
    3.    
  
  
  
  3.  Notify(data interface{}) 
    4.    
  
  
  
  4. } 
    5.    
  
  
  
  5.  
    6.    
  
  
  
  6. type Observer interface { 
    7.    
  
  
  
  7.  Update(data interface{}) 
    8.    
  
  
  
  8. } 
    9.

由于我们这是一个下单的事件，所以定义了 OrderCreateSubject 实现 Subject：

  
 
 
 
       
  
  
  
  1. type OrderCreateSubject struct { 
    2.    
  
  
  
  2.  observerList []Observer 
    3.    
  
  
  
  3. } 
    4.    
  
  
  
  4.  
    5.    
  
  
  
  5. func NewOrderCreate() Subject { 
    6.    
  
  
  
  6.  return &OrderCreateSubject{} 
    7.    
  
  
  
  7. } 
    8.    
  
  
  
  8.  
    9.    
  
  
  
  9. func (o *OrderCreateSubject) Register(observer Observer) { 
    10.    
  
  
  
  10.  o.observerList = append(o.observerList, observer) 
    11.    
  
  
  
  11. } 
    12.    
  
  
  
  12. func (o *OrderCreateSubject) Notify(data interface{}) { 
    13.    
  
  
  
  13.  for _, observer := range o.observerList { 
    14.    
  
  
  
  14.   observer.Update(data) 
    15.    
  
  
  
  15.  } 
    16.    
  
  
  
  16. } 
    17.

其中的 observerList 切片是用于存放所有订阅了下单事件的观察者。

接着便是编写观察者业务逻辑了，这里我实现了两个：

  
 
 
 
       
  
  
  
  1. type B1CreateOrder struct { 
    2.    
  
  
  
  2. } 
    3.    
  
  
  
  3. func (b *B1CreateOrder) Update(data interface{}) { 
    4.    
  
  
  
  4.  fmt.Printf("b1.....data %v \n", data) 
    5.    
  
  
  
  5. } 
    6.    
  
  
  
  6.  
    7.    
  
  
  
  7.  
    8.    
  
  
  
  8. type B2CreateOrder struct { 
    9.    
  
  
  
  9. } 
    10.    
  
  
  
  10. func (b *B2CreateOrder) Update(data interface{}) { 
    11.    
  
  
  
  11.  fmt.Printf("b2.....data %v \n", data) 
    12.    
  
  
  
  12. } 
    13.

使用起来也非常简单：

  
 
 
 
       
  
  
  
  1. func TestObserver(t *testing.T) { 
    2.    
  
  
  
  2.  create := NewOrderCreate() 
    3.    
  
  
  
  3.  create.Register(&B1CreateOrder{}) 
    4.    
  
  
  
  4.  create.Register(&B2CreateOrder{}) 
    5.    
  
  
  
  5.  
    6.    
  
  
  
  6.  create.Notify("abc123") 
    7.    
  
  
  
  7. } 
    8.

Output：

  
 
 
 
       
  
  
  
  1. b1.....data abc123 
    2.    
  
  
  
  2.  
    3.    
  
  
  
  3. b2.....data abc123 
    4.
  1. 创建一个创建订单的主体 subject。
  2. 注册所有的订阅事件。
  3. 在需要通知处调用 Notify 方法。

这样一旦我们需要修改各个事件的实现时就不会互相影响，即便是要加入其他实现也是非常容易的：

  1. 编写实现类。
  2. 注册进实体。

不会再修改核心流程。

配合容器

其实我们也可以省略掉注册事件的步骤，那就是使用容器;大致流程如下：

自定义的事件全部注入进容器。

再注册事件的地方从容器中取出所有的事件，挨个注册。

这里所使用的容器是 https://github.com/uber-go/dig

修改后的代码中，每当我们新增一个观察者(事件订阅)时，只需要使用容器所提供 Provide 函数注册进容器即可。

同时为了让容器能够支持同一个对象存在多个实例也需要新增部分代码：

  
 
 
 
       
  
  
  
  1. type Observer interface { 
    2.    
  
  
  
  2.  Update(data interface{}) 
    3.    
  
  
  
  3. } 
    4.    
  
  
  
  4. type ( 
    5.    
  
  
  
  5.  Instance struct { 
    6.    
  
  
  
  6.   dig.Out 
    7.    
  
  
  
  7.   Instance Observer `group:"observers"` 
    8.    
  
  
  
  8.  } 
    9.    
  
  
  
  9.  
    10.    
  
  
  
  10.  InstanceParams struct { 
    11.    
  
  
  
  11.   dig.In 
    12.    
  
  
  
  12.   Instances []Observer `group:"observers"` 
    13.    
  
  
  
  13.  } 
    14.    
  
  
  
  14. ) 
    15.

在 observer 接口中需要新增两个结构体用于存放同一个接口的多个实例。

group:"observers" 用于声明是同一个接口。

创建具体观察者对象时返回 Instance 对象。

  
 
 
 
       
  
  
  
  1. func NewB1() Instance { 
    2.    
  
  
  
  2.  return Instance{ 
    3.    
  
  
  
  3.   Instance: &B1CreateOrder{}, 
    4.    
  
  
  
  4.  } 
    5.    
  
  
  
  5. } 
    6.    
  
  
  
  6.  
    7.    
  
  
  
  7. func NewB2() Instance { 
    8.    
  
  
  
  8.  return Instance{ 
    9.    
  
  
  
  9.   Instance: &B2CreateOrder{}, 
    10.    
  
  
  
  10.  } 
    11.    
  
  
  
  11. } 
    12.

其实就是用 Instance 包装了一次。

这样在注册观察者时，便能从 InstanceParams.Instances 中取出所有的观察者对象了。

  
 
 
 
       
  
  
  
  1. err = c.Invoke(func(subject Subject, params InstanceParams) { 
    2.    
  
  
  
  2.  for _, instance := range params.Instances { 
    3.    
  
  
  
  3.   subject.Register(instance) 
    4.    
  
  
  
  4.  } 
    5.    
  
  
  
  5. }) 
    6.

这样在使用时直接从容器中获取主题对象，然后通知即可：

  
 
 
 
       
  
  
  
  1. err = c.Invoke(func(subject Subject) { 
    2.    
  
  
  
  2.  subject.Notify("abc123") 
    3.    
  
  
  
  3. }) 
    4.

更多关于 dig 的用法可以参考官方文档：

https://pkg.go.dev/go.uber.org/dig#hdr-Value_Groups

总结

有经验的开发者会发现和发布订阅模式非常类似，当然他们的思路是类似的;我们不用纠结与两者的差异(面试时除外);学会其中的思路更加重要。

网站题目：观察者模式的实际应用
URL标题：http://www.shufengxianlan.com/qtweb/news24/150974.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站维护知识

各行业网站

彭州做网站　　 　网站营销　　 　外贸网站建设　　 　成都谷歌推广　　 　防护网厂　　 　资阳网站建设　　 　服务器机柜租用　　 　成都网页设计　　 　成都网站建设　　 　成都机房机柜租用　　 　简阳网站建设　　 　衣柜书柜酒柜定制　　 　上海济桢教育　　 　成都网站建设　　 　添翼二手车鉴定　　 　成都定制网站开发　　 　成都免费自助建站　　 　中国电信成都枢纽中心　　 　禾巨建站　　 　雅安服务器托管