devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【设计模式】观察者模式

作者：小小林熬夜学编程 | 2024-06-15 06:14:21

赞

踩

【设计模式】观察者模式

一、介绍

观察者模式是一种行为设计模式，当一个对象的状态发生改变时，依赖（观察）它的对象会接收到通知，并进行自动的更新操作。

举例：某公司发布了一款新的手机，性能很强大，许多人都想买，但是该公司又没宣布售卖时间。想买的人为了第一时间就拥有这台手机，就必须每天到官网或线下实体店看有没有出售，这样对于用户来说体验很不好。如果不想频繁的去查看，这时想买手机的用户就可以在实体店或网站上留下联系方式，等到手机出售的当天公司通过邮件或者短信的形式通知到购买者。

二、优缺点

优点：

  • 符合开闭原则。 无需修改发布者代码就能引入新的观察者类 。

  • 可以在运行时建立对象之间的联系。

缺点：

  • 无法设置订阅者收到的顺序

  • 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率

三、核心结构

  • Subject（目标）：被观察者，它是指被观察的对象。 类中有一个用来存放观察者对象的容器，这个容器是被观察者类的核心。其中还有几个方法：attach方法是向这个容器中添加观察者对象。detach方法是从容器中移除观察者对象。notify方法是依次调用观察者对象的对应方法。

  • ConcreteSubject（具体目标）：目标类的具体子类，当它的状态发生改变时，向它的各个观察者发出通知。同时它还实现了在目标类中定义的抽象业务逻辑方法（如果有的话）。

  • Observer（观察者）：观察者将对观察目标的改变做出反应，观察者一般定义为接口，该接口声明了更新数据的方法 update()。

  • ConcreteObserver（具体观察者）：在具体观察者中维护一个指向具体目标对象的引用，它存储具体观察者的有关状态，这些状态需要和具体目标的状态保持一致，它实现了在观察者 Observer 中定义的 update()方法。

四、代码实现

1、在PHP中已经有相关的Subject（目标）和Observer（观察者）接口了，我们可以拿来直接实现。分别是SplSubject和SplObserver接口，以下代码就是以这两个接口为例进行编写。其中还用到一个SplObjectStorage类，它也是PHP中的一个类，用于存储和管理对象。它是一个关联数组，其中键是对象的哈希值，值是对象本身。

1.1、实现ConcreteSubject（具体目标）

  1. <?php
  2. /**
  3.  * Created by PhpStorm
  4.  * Author: fengzi
  5.  * Date: 2024/5/17
  6.  * Time: 10:43
  7.  */
  8.  
  9. namespace app\admin\service\mode\observers;
  10.  
  11. use SplObserver;
  12.  
  13. /**
  14.  * 观察者模式
  15.  * 使用PHP自带的观察者设计模式
  16.  */
  17. class ObserversService implements \SplSubject
  18. {
  19.     public int $status;
  20.  
  21.     private $observers;
  22.  
  23.     public function __construct()
  24.     {
  25.         $this->observers = new \SplObjectStorage();
  26.     }
  27.  
  28.     /**
  29.      * 添加观察者
  30.      * @param SplObserver $observer
  31.      * @return void
  32.      * @Author: fengzi
  33.      * @Date: 2024/5/20 17:50
  34.      */
  35.     public function attach(SplObserver $observer)
  36.     {
  37.         // TODO: Implement attach() method.
  38.         echo "添加一个观察者\n";
  39.         $this->observers->attach($observer);
  40.     }
  41.  
  42.     /**
  43.      * 删除观察者
  44.      * @param SplObserver $observer
  45.      * @return void
  46.      * @Author: fengzi
  47.      * @Date: 2024/5/20 17:50
  48.      */
  49.     public function detach(SplObserver $observer)
  50.     {
  51.         // TODO: Implement detach() method.
  52.         echo "\n分离一个观察者\n";
  53.         $this->observers->detach($observer);
  54.     }
  55.  
  56.     /**
  57.      * 通知观察者
  58.      * @return void
  59.      * @Author: fengzi
  60.      * @Date: 2024/5/20 17:51
  61.      */
  62.     public function notify()
  63.     {
  64.         // TODO: Implement notify() method.
  65.         echo "已通知观察者\n";
  66.         foreach ($this->observers as $observer) {
  67.             $observer->update($this);
  68.         }
  69.     }
  70.  
  71.     /**
  72.      * 实现被观察者业务，并通知观察者
  73.      * @return void
  74.      * @Author: fengzi
  75.      * @Date: 2024/5/20 17:51
  76.      */
  77.     public function doSomeLogic(): void
  78.     {
  79.         echo "\nSubject: 我做了一些业务...\n";
  80.         $this->status = rand(0, 10);
  81.  
  82.         echo "Subject: 业务状态小于5时观察者才做出反应，当前业务状态: {$this->status}\n";
  83.         $this->notify();
  84.     }
  85. }

1.2、实现ConcreteObserver（具体观察者），我这里实现了两个观察者，分别为 ConcreteObserverB 和 ConcreteObserverA 。

  1. <?php
  2. /**
  3.  * Created by PhpStorm
  4.  * Author: fengzi
  5.  * Date: 2024/5/17
  6.  * Time: 10:54
  7.  */
  8.  
  9. namespace app\admin\service\mode\observers;
  10.  
  11. use SplSubject;
  12.  
  13. class ConcreteObserverB implements \SplObserver
  14. {
  15.  
  16.     public function update(SplSubject $subject)
  17.     {
  18.         // TODO: Implement update() method.
  19.         if ($subject->status < 5) {
  20.             echo "ConcreteObserverB: 我接受到状态，并做出了相应的反应。\n";
  21.         }
  22.     }
  23. }

  1. <?php
  2. /**
  3.  * Created by PhpStorm
  4.  * Author: fengzi
  5.  * Date: 2024/5/17
  6.  * Time: 10:54
  7.  */
  8.  
  9. namespace app\admin\service\mode\observers;
  10.  
  11. use SplSubject;
  12.  
  13. class ConcreteObserverA implements \SplObserver
  14. {
  15.  
  16.     public function update(SplSubject $subject)
  17.     {
  18.         // TODO: Implement update() method.
  19.         if ($subject->status < 5) {
  20.             echo "ConcreteObserverA: 我接受到状态，并做出了相应的反应。\n";
  21.         }
  22.     }
  23. }

1.3、客户端调用

  1. <?php
  2. /**
  3.  * Created by PhpStorm
  4.  * Author: fengzi
  5.  * Date: 2024/5/17
  6.  * Time: 10:34
  7.  */
  9. namespace app\admin\controller\mode\observers;
  10.  
  11. use app\admin\service\mode\observers\ConcreteObserverA;
  12. use app\admin\service\mode\observers\ConcreteObserverB;
  13. use app\admin\service\mode\observers\ObserversService;
  14.  
  15. /**
  16.  * 观察者模式客户端调用
  17.  */
  18. class ObserversController
  19. {
  20.     public function index()
  21.     {
  22.         // 创建被观察者
  23.         $subject = new ObserversService();
  24.  
  25.         // 创建观察者
  26.         $obA = new ConcreteObserverA();
  27.         $obB = new ConcreteObserverB();
  28.  
  29.         // 注册观察者
  30.         $subject->attach($obA);
  31.         $subject->attach($obB);
  32.  
  33.         // 被观察者执行业务逻辑并通知给观察者
  34.         $subject->doSomeLogic();
  35.  
  36.         // 移除观察者
  37.         $subject->detach($obB);
  38.  
  39.         // 被观察者执行业务逻辑并通知给观察者
  40.         $subject->doSomeLogic();
  41.  
  42.         dd('结束');
  43.     }
  44. }

1.4、客户端调用结果展示

2、上面介绍了使用PHP本身观察者设计模式的接口，下面就自己手写一个观察者模式。

2.1、实现Subject（目标）接口

  1. <?php
  2. /**
  3.  * Created by PhpStorm
  4.  * Author: fengzi
  5.  * Date: 2024/5/21
  6.  * Time: 10:52
  7.  */
  9. namespace app\admin\service\mode\observers\my;
  10.  
  11. /**
  12.  * 被观察者接口
  13.  */
  14. interface Subject
  15. {
  16.     /**
  17.      * 添加观察者对象
  18.      * @param Observer $observer    观察者对象
  19.      * @return mixed
  20.      * @Author: fengzi
  21.      * @Date: 2024/5/21 10:56
  22.      */
  23.     public function attach(Observer $observer);
  24.  
  25.     /**
  26.      * 删除观察者对象
  27.      * @param Observer $observer    观察者对象
  28.      * @return mixed
  29.      * @Author: fengzi
  30.      * @Date: 2024/5/21 10:56
  31.      */
  32.     public function detach(Observer $observer);
  33.  
  34.     /**
  35.      * 通知观察者
  36.      * @return mixed
  37.      * @Author: fengzi
  38.      * @Date: 2024/5/21 10:54
  39.      */
  40.     public function notify();
  41.  
  42. }

2.2、实现ConcreteSubject（具体目标）

  1. <?php
  2. /**
  3.  * Created by PhpStorm
  4.  * Author: fengzi
  5.  * Date: 2024/5/21
  6.  * Time: 10:54
  7.  */
  8.  
  9. namespace app\admin\service\mode\observers\my;
  10.  
  11. class ConcreteSubject implements Subject
  12. {
  13.     public int $status;
  14.  
  15.     private array $observers = [];
  16.  
  17.     public function attach(Observer $observer)
  18.     {
  19.         // TODO: Implement attach() method.
  20.         echo "添加一个观察者\n";
  21.         if ( !in_array($observer, $this->observers, true) ) {
  22.             $this->observers[] = $observer;
  23.         }
  24.     }
  25.  
  26.     public function detach(Observer $observer)
  27.     {
  28.         // TODO: Implement detach() method.
  29.         echo "\n分离一个观察者：".get_class($observer)."\n";
  30.         if ( in_array($observer, $this->observers, true) ) {
  31.             unset($this->observers[array_search($observer, $this->observers, true)]);
  32.         }
  33.     }
  34.  
  35.     public function notify()
  36.     {
  37.         // TODO: Implement notify() method.
  38.         echo "已通知观察者\n";
  39.         foreach ($this->observers as $observer) {
  40.             $observer->update($this);
  41.         }
  42.     }
  43.  
  44.     public function doSomething()
  45.     {
  46.         echo "\nSubject: 我做了一些业务...\n";
  47.         $this->status = rand(0, 10);
  48.  
  49.         echo "Subject: 业务状态小于5时观察者才做出反应，当前业务状态: {$this->status}\n";
  50.         $this->notify();
  51.     }
  52. }

2.3、实现Observer（观察者）

  1. <?php
  2. /**
  3.  * Created by PhpStorm
  4.  * Author: fengzi
  5.  * Date: 2024/5/21
  6.  * Time: 10:57
  7.  */
  8.  
  9. namespace app\admin\service\mode\observers\my;
  10.  
  11. /**
  12.  * 观察者接口
  13.  */
  14. interface Observer
  15. {
  16.     public function update(Subject $subject);
  17. }

2.4、实现ConcreteObserver（具体观察者），分别为 ConcreteObserverB 和 ConcreteObserverA 。

  1. <?php
  2. /**
  3.  * Created by PhpStorm
  4.  * Author: fengzi
  5.  * Date: 2024/5/21
  6.  * Time: 10:58
  7.  */
  8.  
  9. namespace app\admin\service\mode\observers\my;
  10.  
  11. /**
  12.  * 具体观察者A
  13.  */
  14. class ConcreteObserverA implements Observer
  15. {
  16.     public function update(Subject $subject)
  17.     {
  18.         // TODO: Implement update() method.
  19.         if ($subject->status < 5) {
  20.             echo "ConcreteObserverA: 我接受到状态，并做出了相应的反应。\n";
  21.         }
  22.     }
  23. }

  1. <?php
  2. /**
  3.  * Created by PhpStorm
  4.  * Author: fengzi
  5.  * Date: 2024/5/21
  6.  * Time: 11:06
  7.  */
  8.  
  9. namespace app\admin\service\mode\observers\my;
  10.  
  11. class ConcreteObserverB implements Observer
  12. {
  13.  
  14.     public function update(Subject $subject)
  15.     {
  16.         // TODO: Implement update() method.
  17.         if ($subject->status < 5) {
  18.             echo "ConcreteObserverB: 我接受到状态，并做出了相应的反应。\n";
  19.         }
  20.     }
  21. }

2.5、客户端调用

  1. <?php
  2. /**
  3.  * Created by PhpStorm
  4.  * Author: fengzi
  5.  * Date: 2024/5/17
  6.  * Time: 10:34
  7.  */
  9. namespace app\admin\controller\mode\observers;
  10.  
  11. use app\admin\service\mode\observers\ConcreteObserverA;
  12. use app\admin\service\mode\observers\ConcreteObserverB;
  13. use app\admin\service\mode\observers\my\ConcreteSubject;
  14. use app\admin\service\mode\observers\ObserversService;
  15.  
  16. /**
  17.  * 观察者模式客户端调用
  18.  */
  19. class ObserversController
  20. {
  21.     /**
  22.      * 使用PHP自带的观察者模式
  23.      * @return void
  24.      * @Author: fengzi
  25.      * @Date: 2024/5/21 11:18
  26.      */
  27.     public function index()
  28.     {
  29.         // 创建被观察者
  30.         $subject = new ObserversService();
  31.  
  32.         // 创建观察者
  33.         $obA = new ConcreteObserverA();
  34.         $obB = new ConcreteObserverB();
  35.  
  36.         // 注册观察者
  37.         $subject->attach($obA);
  38.         $subject->attach($obB);
  39.  
  40.         // 被观察者执行业务逻辑并通知给观察者
  41.         $subject->doSomeLogic();
  42.  
  43.         // 移除观察者
  44.         $subject->detach($obB);
  45.  
  46.         // 被观察者执行业务逻辑并通知给观察者
  47.         $subject->doSomeLogic();
  48.  
  49.         dd('结束');
  50.     }
  51.  
  52.     /**
  53.      * 使用自定义的观察者模式
  54.      * @return void
  55.      * @Author: fengzi
  56.      * @Date: 2024/5/21 11:18
  57.      */
  58.     public function mySubject()
  59.     {
  60.         // 创建被观察者
  61.         $subject = new ConcreteSubject();
  62.  
  63.         // 创建观察者
  64.         $obA = new \app\admin\service\mode\observers\my\ConcreteObserverA();
  65.         $obB = new \app\admin\service\mode\observers\my\ConcreteObserverB();
  66.  
  67.         // 注册观察者
  68.         $subject->attach($obA);
  69.         $subject->attach($obB);
  70.  
  71.         // 被观察者执行业务逻辑并通知给观察者
  72.         $subject->doSomething();
  73.  
  74.         // 移除观察者
  75.         $subject->detach($obB);
  76.  
  77.         // 被观察者执行业务逻辑并通知给观察者
  78.         $subject->doSomething();
  79.  
  80.         dd('结束');
  81.     }
  82. }

2.6、运行结果展示

文章转载自：疯子丶pony

原文链接：https://www.cnblogs.com/mklblog/p/18201411

体验地址：引迈 - JNPF快速开发平台_低代码开发平台_零代码开发平台_流程设计器_表单引擎_工作流引擎_软件架构

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/721220
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号