Observer

Observer

动机
  • 在软件构建过程中,我们需要为某些对象建立一种“通知依赖关系”——一个对象(目标对象)的状态发生改变,所有的依赖对象(观察者对象)都将得到通知。如果这样的依赖关系过于紧密, 将使软件不能很好地抵御变化。
  • 使用面向对象技术,可以将这种依赖关系弱化,并形成一种稳定的依赖关系。从而实现软件体系结构的松耦合
模式定义

定义对象间的一种一对多(变化)的依赖关系,以便当一个对象(Subject)的状态发生改变时,所有依赖于它的对象都得到通知并自动更新。

Observer_第1张图片

#include 
#include //或者List

class Subject; // 稳定的

class Observer // 稳定的
{
public:
    virtual ~Observer() {}

    virtual int getState() = 0;
    virtual void update(Subject *subject) = 0;
    // ...
};

class ConcreteObserver : public Observer
{
public:
    ConcreteObserver(const int state) : observer_state(state) {}

    ~ConcreteObserver() {}

    int getState()
    {
        return observer_state;
    }
	
    void update(Subject *subject);
    // ...

private:
    int observer_state;
    // ...
};

class Subject // 稳定的
{
public:
    virtual ~Subject() {}

    void attach(Observer *observer)
    {
        observers.push_back(observer);
    }

    void detach(const int index)
    {
        observers.erase(observers.begin() + index);
    }

    void notify()
    {
        for (unsigned int i = 0; i < observers.size(); i++)
        {
            //自动更新
            observers.at(i)->update(this);
        }
    }

    virtual int getState() = 0;
    virtual void setState(const int s) = 0;
    // ...

private:
    std::vector observers;
    // ...
};

class ConcreteSubject : public Subject
{
public:
    ~ConcreteSubject() {}

    int getState()
    {
        return subject_state;
    }

    void setState(const int s)
    {
        subject_state = s;
    }
    // ...

private:
    int subject_state;
    // ...
};

void ConcreteObserver::update(Subject *subject)
{
    observer_state = subject->getState();
    std::cout << "Observer state updated." << std::endl;
}

int main()
{
    ConcreteObserver observer1(1);
    ConcreteObserver observer2(2);

    std::cout << "Observer 1 state: " << observer1.getState() << std::endl;
    std::cout << "Observer 2 state: " << observer2.getState() << std::endl;

    Subject *subject = new ConcreteSubject();
    subject->attach(&observer1); // push_back
    subject->attach(&observer2);

    subject->setState(10);
    subject->notify();

    std::cout << "Observer 1 state: " << observer1.getState() << std::endl;
    std::cout << "Observer 2 state: " << observer2.getState() << std::endl;

    delete subject;
    return 0;
    
}
/*
Observer 1 state: 1
Observer 2 state: 2
Observer state updated.
Observer state updated.
Observer 1 state: 10
Observer 2 state: 10
*/
使用场景
  • 当抽象有两个方面,一个依赖于另一个方面
  • 当对一个对象的更改需要更改其他对象,而你不知道需要更改多少个对象时
  • 当一个对象应该能够通知其他对象而不假设这些对象是谁时
总结
  • 使用面向对象的抽象,Observer模式使得我们可以独立地改变目标与观察者,从而使二者之间的依赖关系达致松耦合。
  • 目标发送通知时,无需指定观察者,通知(可以携带通知信息作为参数)会自动传播。
  • 观察者自己决定是否需要订阅通知,目标对象对此一无所知。
  • Observer模式是基于事件的UI框架中非常常用的设计模式,也是 MVC模式的一个重要组成部分。

你可能感兴趣的:(设计模式,观察者模式)