【再谈计划模式】观察者模式~对象间依赖关系的信使

一、弁言

        在软件工程、软件开辟的天下里，计划模式如同建筑蓝图中的经典结构，资助开辟者构建更加灵活、可维护和可扩展的软件系统。观察者模式就是其中一种极为重要的举动型计划模式，它在处置处罚对象间的一对多关系时展现出独特的魅力。

二、界说与描述

        观察者模式界说了对象之间的一种一对多依赖关系。其中有一个被观察的对象（称为主题Subject）和多个观察该对象的观察者（Observer）。主题对象负责维护一组观察者对象，并在自身状态发生改变时关照全部观察者。这种模式使得对象之间的耦合度低沉，主题和观察者可以独立地进行扩展和修改。

三、抽象背景

        在很多实际的软件场景中，存在着对象状态变化必要关照其他对象的需求。例如，在一个消息发布系统中，当有新的消息发布（消息对象状态改变）时，订阅了该消息频道的用户（观察者）必要实时得到关照；或者在一个游戏开辟中，当游戏脚色的某些属性（如生命值、位置等）发生变化时，与之相干的UI界面元素（观察者）必要更新表现。

四、适用场景与实际题目办理

• 事件驱动系统
  
  
  
  • 在图形用户界面（GUI）开辟中，用户的操作（如点击按钮、输入文本等）会触发事件。这些事件可以看作是主题的状态变化，而处置处罚这些事件的各个组件（如菜单更新、数据表现等）就是观察者。通过观察者模式，可以很方便地实现事件的分发和处置处罚，使差别的组件能够独立地相应事件。
    
  
  

• 股票市场监测
  
  
  
  • 当股票代价发生变化（主题状态改变）时，多个投资者（观察者）必要得到关照以便做出相应的决策。利用观察者模式可以高效地实现这种关照机制，而不必要在股票代价变化的代码中硬编码每个投资者的关照逻辑。
    
  
  

五、观察者模式的实际生活的例子

• 社交媒体平台
  
  
  
  • 当一个用户（主题）发布了一条新的动态时，他的好友（观察者）会收到关照。这里，用户是被观察的对象，好友们是观察者。社交平台负责维护好友关系（即主题中的观察者列表），并在用户发布新动态时关照全部好友。
    
  
  

• 景象站与订阅者
  
  
  
  • 景象站（主题）负责网络景象数据并检测天气状态的变化。当天气状态发生变化（如温度、湿度、气压等数据变化）时，景象站会关照全部订阅了景象信息的用户（观察者），如农民、飞行员、户外运动爱好者等。
    
  
  

六、初衷与题目办理

• 初衷
  
  
  
  • 观察者模式的初衷是为了实现对象之间的松耦合关系。在没有这种模式的情况下，如果一个对象的状态变化必要关照其他对象，大概会导致高度耦合的代码，即变化的对象必要直接调用其他对象的方法来关照它们。这使得代码难以维护和扩展，由于任何一个相干对象的改变都大概影响到其他对象。
    
  
  
• 题目办理
  
  
  
  • 通过观察者模式，主题和观察者之间通过抽象的接口进行交互。主题只必要维护一个观察者列表，并在状态变化时调用观察者的抽象关照方法。如许，主题不必要知道具体的观察者范例，观察者也不必要知道主题的具体实现细节。当有新的观察者或主题必要参加系统时，只必要实现相应的接口即可，不会影响到其他部门的代码。
    
  
  

七、代码示例

Java示例

1. import java.util.ArrayList;
2. import java.util.List;
4. // 观察者接口
5. interface Observer {
6.     void update(String message);
7. }
9. // 主题类
10. class Subject {
11.     private List<Observer> observers = new ArrayList<>();
12.     private String state;
14.     public void attach(Observer observer) {
15.         observers.add(observer);
16.     }
18.     public void detach(Observer observer) {
19.         observers.remove(observer);
20.     }
22.     public void setState(String state) {
23.         this.state = state;
24.         notifyAllObservers();
25.     }
27.     private void notifyAllObservers() {
28.         for (Observer observer : observers) {
29.             observer.update(state);
30.         }
31.     }
32. }
34. // 具体观察者类
35. class ConcreteObserver implements Observer {
36.     private String name;
38.     public ConcreteObserver(String name) {
39.         this.name = name;
40.     }
42.     @Override
43.     public void update(String message) {
44.         System.out.println(name + " received message: " + message);
45.     }
46. }
48. public class Main {
49.     public static void main(String[] args) {
50.         Subject subject = new Subject();
52.         Observer observer1 = new ConcreteObserver("Observer 1");
53.         Observer observer2 = new ConcreteObserver("Observer 2");
55.         subject.attach(observer1);
56.         subject.attach(observer2);
58.         subject.setState("New state!");
59.     }
60. }

复制代码

类图：

  Subject类与Observer接口之间是一对多的关系（Subject可以有多个Observer）ConcreteObserver类实现了Observer接口。 

C++示例

1. #include <iostream>
2. #include <vector>
4. // 观察者抽象类
5. class Observer {
6. public:
7.     virtual void update(std::string message) = 0;
8. };
10. // 主题类
11. class Subject {
12. private:
13.     std::vector<Observer*> observers;
14.     std::string state;
15. public:
16.     void attach(Observer* observer) {
17.         observers.push_back(observer);
18.     }
20.     void detach(Observer* observer) {
21.         for (auto it = observers.begin(); it!= observers.end(); ++it) {
22.             if (*it == observer) {
23.                 observers.erase(it);
24.                 break;
25.             }
26.         }
27.     }
29.     void setState(std::string state) {
30.         this.state = state;
31.         notifyAllObservers();
32.     }
34.     void notifyAllObservers() {
35.         for (auto observer : observers) {
36.             observer->update(state);
37.         }
38.     }
39. };
41. // 具体观察者类
42. class ConcreteObserver : public Observer {
43. private:
44.     std::string name;
45. public:
46.     ConcreteObserver(std::string name) : name(name) {}
48.     void update(std::string message) override {
49.         std::cout << name << " received message: " << message << std::endl;
50.     }
51. };
53. int main() {
54.     Subject subject;
56.     Observer* observer1 = new ConcreteObserver("Observer 1");
57.     Observer* observer2 = new ConcreteObserver("Observer 2");
59.     subject.attach(observer1);
60.     subject.attach(observer2);
62.     subject.setState("New state!");
64.     return 0;
65. }

复制代码

Python示例

1. # 观察者抽象类
2. class Observer:
3.     def update(self, message):
4.         pass
6. # 主题类
7. class Subject:
8.     def __init__(self):
9.         self.observers = []
10.         self.state = None
12.     def attach(self, observer):
13.         self.observers.append(observer)
15.     def detach(self, observer):
16.         self.observers.remove(observer)
18.     def setState(self, state):
19.         self.state = state
20.         self.notifyAllObservers()
22.     def notifyAllObservers(self):
23.         for observer in self.observers:
24.             observer.update(self.state)
27. # 具体观察者类
28. class ConcreteObserver(Observer):
29.     def __init__(self, name):
30.         self.name = name
32.     def update(self, message):
33.         print(f"{self.name} received message: {message}")
36. if __name__ == "__main__":
37.     subject = Subject()
39.     observer1 = ConcreteObserver("Observer 1")
40.     observer2 = ConcreteObserver("Observer 2")
42.     subject.attach(observer1)
43.     subject.attach(observer2)
45.     subject.setState("New state!")

复制代码

Go示例

1. package main
3. import (
4.     "fmt"
5. )
7. // 观察者接口
8. type Observer interface {
9.     update(message string)
10. }
12. // 主题结构体
13. type Subject struct {
14.     observers []Observer
15.     state     string
16. }
18. // 附加观察者
19. func (s *Subject) attach(observer Observer) {
20.     s.observers = append(s.observers, observer)
21. }
23. // 分离观察者
24. func (s *Subject) detach(observer Observer) {
25.     for i, obs := range s.observers {
26.         if obs == observer {
27.             s.observers = append(s.observers[:i], s.observers[i+1:]...)
28.             break
29.         }
30.     }
31. }
33. // 设置状态并通知观察者
34. func (s *Subject) setState(state string) {
35.     s.state = state
36.     s.notifyAllObservers()
37. }
39. // 通知所有观察者
40. func (s *Subject) notifyAllObservers() {
41.     for _, observer := range s.observers {
42.         observer.update(s.state)
43.     }
44. }
46. // 具体观察者结构体
47. type ConcreteObserver struct {
48.     name string
49. }
51. // 具体观察者实现更新方法
52. func (co *ConcreteObserver) update(message string) {
53.     fmt.Printf("%s received message: %s\n", co.name, message)
54. }
56. func main() {
57.     subject := Subject{}
59.     observer1 := ConcreteObserver{name: "Observer 1"}
60.     observer2 := ConcreteObserver{name: "Observer 2"}
62.     subject.attach(&observer1)
63.     subject.attach(&observer2)
65.     subject.setState("New state!")
66. }

复制代码

八、观察者模式的优缺点

• 长处
  
  
  
  • 松耦合：主题和观察者之间是松耦合的关系。主题不必要知道观察者的具体实现，只必要调用观察者的抽象接口。这使得在系统中添加或删除观察者非常容易，不会影响到主题的代码。
    
  • 可扩展性：可以很容易地增长新的观察者，只必要实现观察者接口即可。同样，主题也可以在不影响观察者的情况下进行扩展。
    
  • 支持广播通讯：一个主题可以关照多个观察者，实现了一对多的消息传递，适合于必要将信息广播给多个对象的场景。
    
  
  
• 缺点
  
  
  
  • 大概存在关照次序题目：如果有多个观察者，当主题关照观察者时，大概会存在关照次序不确定的题目。这在某些对次序有严格要求的场景下大概会导致题目。
    
  • 性能开销：如果观察者数量较多，当主题状态发生变化时，关照全部观察者大概会带来一定的性能开销。特别是在观察者的更新操作比力复杂时，这种开销会更加显着。
    
  
  

九、观察者模式的升级版

• 事件委托模型
  
  
  
  • 在传统的观察者模式中，主题直接关照全部的观察者。而在事件委托模型中，引入了事件源、事件和事件处置处罚步伐的概念。事件源（雷同于主题）产生事件，事件包含了关于状态变化的信息，事件处置处罚步伐（雷同于观察者）负责处置处罚事件。事件委托模型更加灵活，可以根据事件的范例、优先级等因向来决定怎样处置处罚事件，而不是简朴地关照全部观察者。
    
  
  
• 反应式编程中的观察者模式扩展
  
  
  
  • 在反应式编程（如RxJava、ReactiveX等）中，观察者模式得到了进一步的扩展。反应式编程关注的是数据的活动和异步处置处罚。在这种模式下，观察者可以对数据的变化做出反应，并且可以组合、转换和过滤数据。例如，在RxJava中，可以利用操作符来对数据流进行操作，然后再将处置处罚后的结果关照给观察者。这使得观察者模式在处置处罚异步和复杂的数据处置处罚场景时更加高效和灵活。
    
  
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。