设计模式之观察者模式

最新推荐文章于 2022-11-17 16:38:58 发布

五山小新新

最新推荐文章于 2022-11-17 16:38:58 发布

阅读量489

点赞数

分类专栏：设计模式

本文链接：https://blog.csdn.net/Al_xin/article/details/38531665

版权

设计模式专栏收录该内容

24 篇文章 1 订阅

订阅专栏

1、观察者模式又叫做发布-订阅(Publish/Subscribe)模式。

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一主题对象，这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

UML图如下：

2、观察者模式的特点：

将一个系统分割成一系列相互协作的类有一个很不好的副作用，那就是需要维护相关对象间的一致性。我们不希望为了维护一致性而使各类紧密耦合，这样会给维护、扩展、和重用都带来不便。

而观察者模式的关键对象是主题Subject和观察者Observer，一个Subject可以有任意数目的依赖它的Observer，一旦Subject的状态改变，所有的Observer都可以得到通知。Subject发出通知时并不需要知道谁是它的观察者，也就是说，具体观察者是谁，它根本不需要知道。而任何一个具体的观察者不知道，也不需要知道其他观察者的存在。

3、什么时候需要考虑使用观察者模式呢？

答：当一个对象的改变需要同时改变其他对象的时候。而且它不知道具体有多少个对象有待改变时，应该考虑使用观察者模式，当一个抽象模型有两个方面，其中一方面依赖于另一方面，这时用观察者模式可以将这两都封装在独立的对象中使它们各自独立地改变和复用。

总的来说，观察者模式所做的工作其实就是在解除耦合。让耦合的双发都依赖于抽象，而不是依赖于具体。从而使得各自的变化都不会影响另一边的变化。

4、观察者模式的不足：

尽管已经用了依赖倒转原则，但是“抽象通知者”还是依赖“抽象观察者”，也就是说，万一没有了抽象观察者这样的接口，通知的功能就完不成了。另外就是每个具体观察者，它不都要调用“更新”方法。

5、C++代码实现

[cpp] view plaincopy

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
/* Observer类，抽象观察者，为所有的具体观察者定义
了一个接口，在得到主题的通知时更新自己。这个接口
叫做更新接口。抽象观察者一般用一个抽象类或者一个
接口实现。更新接口通常包含一个Update()方法，这个
方法叫做更新方法。 */
class Observer
{
public:
virtual void Update() = 0;
};
/* Subject类，可翻译为主题或抽象通知者一般用抽象类或
抽象接口实现。它把所有对观察者对象的引用保存在一个
聚集里，每个主题都可以有任何数量的观察者。抽象主题
提供一个接口，可以增加和删除观察者对象。 */
class Subject
{
private:
//观察者对象的引用的聚集容器
vector<Observer *> observers;
public:
//添加主题的观察者
void Attach(Observer * p_observer) {
observers.push_back(p_observer);
}
//删除主题的观察者
void Detach(Observer * p_observer) {
vector<Observer *>::iterator it;
it = find(observers.begin(), observers.end(), p_observer);
observers.erase(it);
}
//通知所有和主题关联的观察者，主题对象的状态改变了
void Notify() {
int length = observers.size();
for (int i = 0; i < length; ++i) {
observers[i]->Update();
}
}
};
/* ConcreteSubject类，具体主题或具体通知者，将有关
状态存入具体的观察者对象，在具体主题的内部状态发
生改变时，给所有登记过的观察者发出通知。具体主题
角色通常用一个具体子类实现 */
class ConcreteSubject : public Subject
{
private:
string subjectState;
public:
string GetSubjectState() {
return subjectState;
}
void SetSubjectState(string newState) {
subjectState = newState;
}
};
/* ConcreteObserver类，具体观察者，实现抽象观察者角色
所要求的更新接口，一便使本身的状态与主题的状态相协调
。具体观察者角色可以保存一个指向具体主题对象的引用。
具体观察者角色通常用一个具体子类实现。 */
class ConcreteObserver : public Observer
{
private:
ConcreteSubject * p_subject;
string name;
string observerState;
public:
ConcreteObserver(ConcreteSubject * subject, string name) {
ConcreteObserver::p_subject = subject;
ConcreteObserver::name = name;
}
void Update() {
observerState = p_subject->GetSubjectState();
cout << "观察者/"" << name << "/"发现主题对象的新状态是/"" << observerState << "/""<<endl;
}
};
int main()
{
ConcreteSubject s;
s.SetSubjectState("上课了");
ConcreteObserver * pa = new ConcreteObserver(&s, "X");
ConcreteObserver * pb = new ConcreteObserver(&s, "Y");
ConcreteObserver * pc = new ConcreteObserver(&s, "Z");
s.Attach(pa);
s.Attach(pb);
s.Attach(pc);
s.Notify();
cout << endl;
s.Detach(pa);
s.SetSubjectState("上课中");
s.Notify();
cout << endl;
s.Detach(pc);
s.SetSubjectState("下课了");
s.Notify();
return 0;
}

再举一个实际的例子：

观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。它还有两个别名，依赖(Dependents)，发布-订阅(Publish-Subsrcibe)。可以举个博客订阅的例子，当博主发表新文章的时候，即博主状态发生了改变，那些订阅的读者就会收到通知，然后进行相应的动作，比如去看文章，或者收藏起来。博主与读者之间存在种一对多的依赖关系。下面给出相应的UML图设计。

可以看到博客类中有一个观察者链表（即订阅者），当博客的状态发生变化时，通过Notify成员函数通知所有的观察者，告诉他们博客的状态更新了。而观察者通过Update成员函数获取博客的状态信息。代码实现不难，下面给出C++的一种实现。

[cpp]view plaincopyprint? 
    
 //观察者  
 class Observer    
 {  
 public:  
     Observer() {}  
     virtual ~Observer() {}  
     virtual void Update() {}   
 };  
 //博客  
 class Blog    
 {  
 public:  
     Blog() {}  
     virtual ~Blog() {}  
     void Attach(Observer *observer) { m_observers.push_back(observer); }     //添加观察者  
     void Remove(Observer *observer) { m_observers.remove(observer); }        //移除观察者  
     void Notify() //通知观察者  
     {  
         list<Observer*>::iterator iter = m_observers.begin();  
         for(; iter != m_observers.end(); iter++)  
             (*iter)->Update();  
     }  
     virtual void SetStatus(string s) { m_status = s; } //设置状态  
     virtual string GetStatus() { return m_status; }    //获得状态  
 private:  
     list<Observer* > m_observers; //观察者链表  
 protected:  
     string m_status; //状态  
 };  

以上是观察者和博客的基类，定义了通用接口。博客类主要完成观察者的添加、移除、通知操作，设置和获得状态仅仅是一个默认实现。下面给出它们相应的子类实现。

[cpp]view plaincopyprint? 
    
 //具体博客类  
 class BlogCSDN : public Blog  
 {  
 private:  
     string m_name; //博主名称  
 public:  
     BlogCSDN(string name): m_name(name) {}  
     ~BlogCSDN() {}  
     void SetStatus(string s) { m_status = "CSDN通知 : " + m_name + s; } //具体设置状态信息  
     string GetStatus() { return m_status; }  
 };  
 //具体观察者  
 class ObserverBlog : public Observer     
 {  
 private:  
     string m_name;  //观察者名称  
     Blog *m_blog;   //观察的博客，当然以链表形式更好，就可以观察多个博客  
 public:   
     ObserverBlog(string name,Blog *blog): m_name(name), m_blog(blog) {}  
     ~ObserverBlog() {}  
     void Update()  //获得更新状态  
     {   
         string status = m_blog->GetStatus();  
         cout<<m_name<<"-------"<<status<<endl;  
     }  
 };  

客户的使用方式：

[cpp]view plaincopyprint? 
    
 //测试案例  
 int main()  
 {  
     Blog *blog = new BlogCSDN("wuzhekai1985");  
     Observer *observer1 = new ObserverBlog("tutupig", blog);  
     blog->Attach(observer1);  
     blog->SetStatus("发表设计模式C++实现（15）——观察者模式");  
     blog->Notify();  
     delete blog; delete observer1;  
     return 0;  

五山小新新

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式之观察者模式

1、观察者模式又叫做发布-订阅(Publish/Subscribe)模式。观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一主题对象，这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。UML图如下：
复制链接

扫一扫

专栏目录