:::tips 观察者模式又叫 发布订阅模式

:::

定义

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. 在对象之间定义一个一对多的依赖，当一个对象状态改变的时候，所有依赖的对象都会自动收到通知。

示例

同步阻塞方式

golang

  1. package xtcp
  3. import (
  4.     "container/list"
  5.     "log"
  6.     "testing"
  7. )
  9. func Test_Server(t *testing.T) {
  10.     subject := ConcreteSubject{}
  11.     one := ConcreteObserveOne{}
  12.     two := ConcreteObserveTwo{}
  13.     subject.RegisterObserver(&one)
  14.     subject.RegisterObserver(&two)
  16.     subject.NotifyObserver("test")
  17.     subject.RemoveObserver(&one)
  18.     subject.NotifyObserver("test - 2")
  19. }
  21. type Subject interface {
  22.     RegisterObserver(observer Observer)
  23.     RemoveObserver(observer Observer)
  24.     NotifyObserver(message string)
  25. }
  27. type Observer interface {
  28.     Update(message string)
  29. }
  31. type ConcreteSubject struct {
  32.     observers list.List
  33. }
  35. func (c *ConcreteSubject) RegisterObserver(observer Observer)  {
  36.     c.observers.PushBack(observer)
  37. }
  39. func (c *ConcreteSubject) RemoveObserver(observer Observer) {
  40.     for e:= c.observers.Front(); e!= nil; e = e.Next(){
  41.         if e.Value == observer{
  42.             c.observers.Remove(e)
  43.             return
  44.         }
  45.     }
  46. }
  48. func (c *ConcreteSubject) NotifyObserver(message string)  {
  49.     for e:= c.observers.Front(); e!= nil; e = e.Next(){
  50.         observer := e.Value.(Observer)
  51.         observer.Update(message)
  52.     }
  53. }
  55. type ConcreteObserveOne struct {
  57. }
  59. type ConcreteObserveTwo struct {
  61. }
  63. func (o *ConcreteObserveOne) Update(message string)  {
  64.     log.Println("one" + message)
  65. }
  67. func (o *ConcreteObserveTwo) Update(message string)  {
  68.     log.Println("two" + message)
  69. }

异步队列方式

:::tips 没错, 消息队列就是一种, 并且耦合更小, 因为 被观察者感知不到观察者的存在

缺点是需要引入 消息队列 中间件

:::