• 设计模式：观察者模式（C#、JAVA、JavaScript、C++、Python、Go、PHP）

    上一篇《命令模式》                                                                    下一篇《策略模式》

    简介：

    观察者模式，它是一种行为型设计模式，它允许一个对象自动通知其依赖者（观察者）状态的变化。当被观察者的状态发生改变时，它会通知所有的观察者对象，使他们能够及时做出响应。在观察者模式中，被观察者和观察者对象之间不需要知道对方的具体实现，只需要知道对方的接口，从而避免了紧耦合的关系。

    在观察者模式中，有以下几个核心组成部分：
    1、被观察者（Subject）：它是一个抽象类或接口，维护一个观察者对象的列表，并定义了注册和删除观察者对象的方法。当被观察者的状态发生变化时，它负责通知所有已注册的观察者对象。
    2、具体被观察者（ConcreteSubject）：它是被观察者的具体实现，它维护一个状态，并定义了存储状态的方法。当它的状态发生变化时，它会通知所有已注册的观察者对象。
    3、观察者（Observer）：它是一个抽象类或接口，定义了更新方法以响应被观察者的状态变化。
    4、具体观察者（ConcreteObserver）：它是观察者的具体实现，实现了更新方法以响应被观察者的状态变化，并执行一些具体的业务逻辑处理。

    在观察者模式中，被观察者和观察者之间形成了一种“一对多”的关系，当被观察者的状态发生变化时，所有注册的观察者都会得到通知并做出相应的响应。这种设计模式使得观察者与被观察者之间的耦合度降低，符合开闭原则，可以动态地增加或者删除观察者对象。然而，也需要注意避免出现循环依赖的问题，并确保在适当的时候移除观察者对象，避免内存泄漏的问题。

    观察者模式的使用场景：
    1、关联行为场景：观察者模式适用于建立一套触发机制的场景，例如用户关注某个商品的价格，当商品降价时进行通知，这样用户和商品产生了关联，触发机制就是商品降价。
    2、事件处理系统：观察者模式可以用于实现事件处理系统，例如在购物网站中，多个用户关注某商品后，当商品降价时，就会自动通知关注该商品的用户。

    总的来说，观察者模式适用于需要实现一对多的依赖关系，并且需要在对象状态改变时自动通知所有依赖者的场景。

    观察者模式的创建步骤：
    1、创建被观察者（Watched）类，该类通常包含一个观察者列表，以及一个用于添加、删除和通知观察者的方法。
    2、创建观察者（Watcher）类，该类通常包含一个更新方法，用于在被观察者状态发生改变时更新自身状态。
    3、在被观察者类中添加注册和注销观察者的方法，以便于添加和删除观察者对象。
    4、在被观察者类中实现通知观察者的方法，以便于在状态发生改变时通知所有观察者对象。
    5、创建具体被观察者（ConcreteWatched）类，该类继承自被观察者类，并实现具体的业务逻辑。
    6、创建具体观察者（ConcreteWatcher）类，该类继承自观察者类，并实现具体的业务逻辑。
    7、将具体被观察者和具体观察者对象进行组合，以便于在被观察者状态发生改变时通知所有观察者对象。

    以上是观察者模式的基本创建步骤，需要注意的是，在实际应用中可能需要根据具体情况进行调整和优化。

    观察者模式的优点，主要包括：
    1、实现表示层和数据逻辑层的分离，并定义了稳定的消息更新传递机制，抽象了更新接口，使得可以有各种各样不同的表示层充当具体观察者角色。
    2、在观察目标和观察者之间建立一个抽象的耦合，观察目标只需要维持一个抽象观察者的集合，无须了解其具体观察者。由于观察目标和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。
    3、支持广播通信，观察目标会向所有已注册的观察者对象发送通知，简化了一对多系统设计的难度。
    4、符合“开闭原则”的要求，增加新的具体观察者无须修改原有系统代码，在具体观察者与观察目标之间不存在关联关系的情况下，增加新的观察目标也很方便。

    观察者模式的缺点，主要包括：
    1、如果一个观察目标对象有很多直接和间接观察者，将所有的观察者都通知到会花费很多时间。
    2、如果在观察者和观察目标之间存在循环依赖，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
    3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

    因此，在使用观察者模式时需要注意以上问题，避免出现不必要的缺陷。


    示例：


    一、C#观察者模式

    以下是一个示例，展示了如何在C#中实现观察者模式：

    1. //首先，定义一个被观察者接口：
    2. public interface ISubject  
    3. {  
    4.     void Register(IObserver observer);  
    5.     void Remove(IObserver observer);  
    6.     void Notify();  
    7. }
    8. //然后，定义一个具体被观察者类：
    9. public class ConcreteSubject : ISubject  
    10. {  
    11.     private List observers;  
    12.     private string state;  
    13.   
    14.     public ConcreteSubject()  
    15.     {  
    16.         observers = new List();  
    17.     }  
    18.   
    19.     public void Register(IObserver observer)  
    20.     {  
    21.         observers.Add(observer);  
    22.     }  
    23.   
    24.     public void Remove(IObserver observer)  
    25.     {  
    26.         observers.Remove(observer);  
    27.     }  
    28.   
    29.     public void Notify()  
    30.     {  
    31.         foreach (var observer in observers)  
    32.         {  
    33.             observer.Update(state);  
    34.         }  
    35.     }  
    36.   
    37.     public void SetState(string state)  
    38.     {  
    39.         this.state = state;  
    40.         Notify();  
    41.     }  
    42. }
    43. //接下来，定义一个观察者接口：
    44. public interface IObserver  
    45. {  
    46.     void Update(string state);  
    47. }
    48. //最后，定义一个具体观察者类：
    49. public class ConcreteObserver : IObserver  
    50. {  
    51.     private string name;  
    52.     public ConcreteObserver(string name)  
    53.     {  
    54.         this.name = name;  
    55.     }  
    56.     public void Update(string state)   
    57.     {   
    58.         Console.WriteLine("{0} received update and the new state is {1}", name, state);   
    59.     }   
    60. }   
    61. //接下来，可以创建一个具体的被观察者和多个具体观察者，并实现它们之间的交互：
    62. public static void Main(string[] args){
    63.     ISubject subject = new ConcreteSubject(); 
    64.     
    65.     IObserver observer1 = new ConcreteObserver("Observer 1");
    66.     IObserver observer2 = new ConcreteObserver("Observer 2"); 
    67.     IObserver observer3 = new ConcreteObserver("Observer 3"); 
    68.     
    69.     subject.Register(observer1); 
    70.     subject.Register(observer2); 
    71.     subject.Register(observer3); 
    72.     subject.SetState("New State"); 
    73. } 

    在这个示例中，我们创建了一个被观察者对象subject和一个观察者对象observer1、observer2和observer3。我们将这些观察者对象注册到被观察者对象subject中，然后调用subject的SetState方法来改变其状态。当状态发生变化时，所有注册的观察者都会自动收到通知并执行Update方法。
    在这个例子中，我们只是简单地打印出每个观察者的名称和新的状态。你可以根据自己的需求扩展这个示例。

    二、java观察者模式

    观察者模式通常通过以下方式实现：

    1. public interface Subject {  
    2.     void register(Observer observer);  
    3.     void remove(Observer observer);  
    4.     void notifyObservers(String message);  
    5. }
    6. public class ConcreteSubject implements Subject {  
    7.     private List observers;  
    8.     private String message;  
    9.   
    10.     public ConcreteSubject() {  
    11.         observers = new ArrayList<>();  
    12.     }  
    13.   
    14.     @Override  
    15.     public void register(Observer observer) {  
    16.         observers.add(observer);  
    17.     }  
    18.   
    19.     @Override  
    20.     public void remove(Observer observer) {  
    21.         observers.remove(observer);  
    22.     }  
    23.   
    24.     @Override  
    25.     public void notifyObservers(String message) {  
    26.         for (Observer observer : observers) {  
    27.             observer.update(message);  
    28.         }  
    29.     }  
    30.   
    31.     public void setMessage(String message) {  
    32.         this.message = message;  
    33.         notifyObservers(message);  
    34.     }  
    35. } 
    36.  
    37. public interface Observer {  
    38.     void update(String message);  
    39. }
    40. class ConcreteObserver implements Observer {  
    41.     private String name;  
    42.   
    43.     public ConcreteObserver(String name) {  
    44.         this.name = name;  
    45.     }  
    46.   
    47.     @Override  
    48.     public void update(String message) {  
    49.         System.out.println(name + " received update with message: " + message);  
    50.     }  
    51. }  
    52. public class Main {  
    53.     public static void main(String[] args) {  
    54.         Subject subject = new ConcreteSubject();  
    55.         Observer observer1 = new ConcreteObserver("Observer 1");  
    56.         Observer observer2 = new ConcreteObserver("Observer 2");  
    57.         Observer observer3 = new ConcreteObserver("Observer 3");  
    58.         subject.register(observer1);  
    59.         subject.register(observer2);  
    60.         subject.register(observer3);  
    61.         subject.setMessage("Hello World!");  
    62.     }  
    63. }

    三、javascript观察者模式

    在JavaScript中实现观察者模式，通常需要定义一个被观察者（Subject）和一个或多个观察者（Observer）。被观察者维护一个观察者列表，并在状态发生变化时遍历这个列表并调用每个观察者的更新方法。

    下面是一个简单的JavaScript观察者模式的代码示例：

    1. class Subject {  
    2.   constructor() {  
    3.     this.observers = [];  
    4.   }  
    5.   
    6.   subscribe(observer) {  
    7.     this.observers.push(observer);  
    8.   }  
    9.   
    10.   unsubscribe(observer) {  
    11.     this.observers = this.observers.filter(obs => obs !== observer);  
    12.   }  
    13.   
    14.   notify(message) {  
    15.     this.observers.forEach(observer => observer.update(message));  
    16.   }  
    17. }  
    18.   
    19. class Observer {  
    20.   constructor(name) {  
    21.     this.name = name;  
    22.   }  
    23.   
    24.   update(message) {  
    25.     console.log(`${this.name} received update with message: ${message}`);  
    26.   }  
    27. }  
    28.   
    29. // 使用示例  
    30. const subject = new Subject();  
    31. const observer1 = new Observer("Observer 1");  
    32. const observer2 = new Observer("Observer 2");  
    33. const observer3 = new Observer("Observer 3");  
    34. subject.subscribe(observer1);  
    35. subject.subscribe(observer2);  
    36. subject.subscribe(observer3);  
    37. subject.notify("Hello World!");

    四、C++观察者模式

    以下是在C++中实现观察者模式：

    1. //定义一个观察者接口
    2. class Observer {  
    3. public:  
    4.     virtual void update(Subject* subject) = 0;  
    5. };
    6. //定义一个被观察者接口
    7. class Subject {  
    8. public:  
    9.     virtual void registerObserver(Observer* observer) = 0;  
    10.     virtual void removeObserver(Observer* observer) = 0;  
    11.     virtual void notifyObservers() = 0;  
    12. };
    13. //创建一个具体被观察者类
    14. class ConcreteSubject : public Subject {  
    15. private:  
    16.     std::vector observers;  
    17.   
    18. public:  
    19.     void registerObserver(Observer* observer) override {  
    20.         observers.push_back(observer);  
    21.     }  
    22.   
    23.     void removeObserver(Observer* observer) override {  
    24.         for (auto it = observers.begin(); it != observers.end(); ++it) {  
    25.             if (*it == observer) {  
    26.                 observers.erase(it);  
    27.                 break;  
    28.             }  
    29.         }  
    30.     }  
    31.   
    32.     void notifyObservers() override {  
    33.         for (auto observer : observers) {  
    34.             observer->update(this);  
    35.         }  
    36.     }  
    37. };
    38. //创建一个具体观察者类
    39. class ConcreteObserver : public Observer {  
    40. private:  
    41.     std::string name;  
    42.   
    43. public:  
    44.     ConcreteObserver(std::string name) : name(name) {}  
    45.   
    46.     void update(Subject* subject) override {  
    47.         std::cout << name << " received update." << std::endl;  
    48.     }  
    49. };
    50. //使用示例：
    51. int main() {  
    52.     ConcreteSubject subject;  
    53.     ConcreteObserver observer1("Observer 1");  
    54.     ConcreteObserver observer2("Observer 2");  
    55.     ConcreteObserver observer3("Observer 3");  
    56.     subject.registerObserver(&observer1);  
    57.     subject.registerObserver(&observer2);  
    58.     subject.registerObserver(&observer3);  
    59.     subject.notifyObservers(); // 输出：Observer 1 received update. Observer 2 received update. Observer 3 received update.  
    60.     subject.removeObserver(&observer2); // 删除一个观察者  
    61.     subject.notifyObservers(); // 输出：Observer 1 received update. Observer 3 received update.  
    62.     return 0;  
    63. }

    五、python观察者模式

    在Python中实现观察者模式，通常需要定义一个被观察者类和一个或多个观察者类。被观察者类维护一个观察者列表，并在状态发生变化时遍历这个列表并调用每个观察者的更新方法。
    以下是在python中实现观察者模式：

    1. class Subject:  
    2.     def __init__(self):  
    3.         self._observers = []  
    4.           
    5.     def attach(self, observer):  
    6.         self._observers.append(observer)  
    7.           
    8.     def detach(self, observer):  
    9.         self._observers.remove(observer)  
    10.           
    11.     def notify(self, value=None):  
    12.         for observer in self._observers:  
    13.             observer.update(value)  
    14.               
    15. class Observer:  
    16.     def update(self, value):  
    17.         pass  
    18.           
    19. class ConcreteObserver(Observer):  
    20.     def update(self, value):  
    21.         print(f"Observer received update with value: {value}")  
    22.           
    23. # 使用示例  
    24. subject = Subject()  
    25. observer1 = ConcreteObserver()  
    26. observer2 = ConcreteObserver()  
    27. observer3 = ConcreteObserver()  
    28. subject.attach(observer1)  
    29. subject.attach(observer2)  
    30. subject.attach(observer3)  
    31. subject.notify(100) # 输出：Observer received update with value: 100 Observer received update with value: 100 Observer received update with value: 100   
    32. subject.detach(observer2) # 删除一个观察者  
    33. subject.notify(200) # 输出：Observer received update with value: 200 Observer received update with value: 200

    六、go观察者模式

    以下是一个示例，展示了如何在go中实现观察者模式：

    1. type Subject struct {  
    2.     observers []Observer  
    3. }  
    4.   
    5. func (s *Subject) Attach(observer Observer) {  
    6.     s.observers = append(s.observers, observer)  
    7. }  
    8.   
    9. func (s *Subject) Notify() {  
    10.     for _, observer := range s.observers {  
    11.         observer.Update()  
    12.     }  
    13. }  
    14.   
    15. typeObserver interface {  
    16.     Update()  
    17. }  
    18.   
    19. typeConcreteObserver struct {  
    20.     name string  
    21. }  
    22.   
    23. func (o *ConcreteObserver) Update() {  
    24.     fmt.Printf("Observer %s received update.\n", o.name)  
    25. }

    在这个示例中，我们定义了一个被观察者结构体Subject，它维护一个观察者列表observers。我们定义了一个Attach方法用于将一个观察者添加到观察者列表中，以及一个Notify方法用于遍历观察者列表并调用每个观察者的Update方法。我们定义了一个观察者接口Observer，它包含一个Update方法。最后，我们创建了一个具体观察者结构体ConcreteObserver，它实现了Observer接口的Update方法。在主函数中，我们创建了一个被观察者对象subject和一个具体观察者对象observer，并将它们分别添加到被观察者和观察者列表中。然后我们调用被观察者的Notify方法来通知所有注册的观察者状态变化。

    七、PHP观察者模式

    以下是一个示例，展示了如何在PHP中实现观察者模式：

    1. //定义一个主题接口（Subject）：
    2. interface Subject {  
    3.     public function attach(Observer $observer);  
    4.     public function detach(Observer $observer);  
    5.     public function notify(Observer $observer);  
    6. }
    7. //定义一个具体主题类（ConcreteSubject）：
    8. class ConcreteSubject implements Subject {  
    9.     private $observers = [];  
    10.     private $state;  
    11.   
    12.     public function attach(Observer $observer) {  
    13.         $this->observers[] = $observer;  
    14.     }  
    15.   
    16.     public function detach(Observer $observer) {  
    17.         $index = array_search($observer, $this->observers);  
    18.         if ($index !== false) {  
    19.             unset($this->observers[$index]);  
    20.         }  
    21.     }  
    22.   
    23.     public function notify(Observer $observer) {  
    24.         foreach ($this->observers as $observer) {  
    25.             $observer->update($this->state);  
    26.         }  
    27.     }  
    28.   
    29.     public function setState($state) {  
    30.         $this->state = $state;  
    31.         $this->notify($this->observers);  
    32.     }  
    33. }
    34. //定义一个观察者接口（Observer）：
    35. interface Observer {  
    36.     public function update($state);  
    37. }
    38. //定义一个具体观察者类（ConcreteObserver）：
    39. class ConcreteObserver implements Observer {  
    40.     private $name;  
    41.   
    42.     public function __construct($name) {  
    43.         $this->name = $name;  
    44.     }  
    45.   
    46.     public function update($state) {  
    47.         echo "Observer {$this->name} received update with state: {$state}\n";  
    48.     }  
    49. }
    50.  
    51. // 创建具体观察者对象  
    52. $observer1 = new ConcreteObserver("Observer 1");  
    53. $observer2 = new ConcreteObserver("Observer 2");  
    54. $observer3 = new ConcreteObserver("Observer 3");  
    55.   
    56. // 创建具体主题对象并附加观察者对象  
    57. $subject = new ConcreteSubject();  
    58. $subject->attach($observer1);  
    59. $subject->attach($observer2);  
    60. $subject->attach($observer3);  
    61.   
    62. // 设置主题状态并通知观察者对象更新状态信息  
    63. $subject->setState("new state");

      
    《完结》

    上一篇《命令模式》                                                                    下一篇《策略模式》

  • 相关阅读:
    直观全面解释Transformer模型；上海人工智能实验室推出首个图文混合创作大模型浦语灵笔
    Vue中的计算属性和侦听器有什么区别？
    Karpor - 让 AI 全面赋能 Kubernetes！
    How to install oracle19c in Centos8
    银行实时汇率查询易语言代码
    苹果电脑专业的条形码工具iBarcoder：助力高效条形码生成，提升工作效率
    政安晨：【Keras机器学习示例演绎】（十六）—— 用于图像分类的混合增强
    ACL与NAT相关知识
    android 创建桌面快捷方式 ShortCut
    校园网课刷题小程序源码系统 带完整搭建教程
  • 原文地址：https://blog.csdn.net/yetyrain/article/details/133975306