（二）详解观察者模式

一.使用场景

当我们需要一个类，在他的内部元素发生变化的时候可以主动通知其他类的时候，同时要保持良好的可拓展性，可以采用观察者模式。

二.核心

观察者模式=出版者+订阅者

我们拥有一个主题对象，和一些其他对象，包括注册成观察者的类和没有注册成观察者的类。当主题对象内部的元素发生改变，主题对象会通知所有注册成观测者的类。同时任何类可以随时注册成观测者或注销自己的观测者身份。

观测模式定义对象之间的一对多依赖，这样一来当一个对象改变时他的所有依赖着都会受到通知并自动更新。

观测者模式应该做到松耦合，主题唯一知道的事情是，观察者提供了观察者接口。我们可以随时添加新的观测者。同时在添加新的观测者的时候不需要修改主题，可以彼此独立的复用主题或观察者。改变主题或观察者其中一方不会影响另一方

三.例子

假设我们需要一款检测气象的类，在观察到气象数据发生变化后，主动向用户展示当前气象状态。

首先我们需要一个观测者类，任何对象都只要继承了观测者类并实现了更新方法都可以当作当作者来实现。

namespace weather {
  class Observer {
  public:
    virtual ~Observer() = default;
    virtual void update(float temp, float humidity, float pressure) = 0;    //提供一个虚接口让想成为观测者的对象自己实现更新行为
  };
}

我们还需要一个主题接口，用来给所有观测者提供更新的业务逻辑。这个主题需要具有接受新注册观测者和溢出观测者的能力，还有具有通知所有观测者信息发生改变的能力。

namespace weather {
  class Observer; // 前置声明
  class Subject {
  public:
    virtual ~Subject() = default;
    virtual void registerObserver(Observer* o) = 0;    //接受新注册的观测者
    virtual void removeObserver(Observer* o) = 0;       //注销当前任意观测者
    virtual void notifyObservers() = 0;        //通知所有观测者信息已发生改变
  };
}

为了方便观察我们还可以给所欲需要显示元素创建一个接口，当需要显示的时候，实现这个接口，并直接调用他即可

namespace weather {
  class DisplayElement {
  public:
    virtual ~DisplayElement() = default;
    virtual void display() const = 0;    //给需要实现显示的类提供接口
  };
}

 实现完了所有所需接口，我们可以针对应用逻辑设计当前所需要的类了。这对目前要求我们需要一个能主动通知观察者的气象类，我们可以让他作为一个主题类。并管理所有当前观测者，在天气发生变化的时候，调用所有观测者的更新函数进行更新。

namespace weather {
  class WeatherData : public Subject {
    
  public:
    WeatherData() = default;
    virtual ~WeatherData() = default;
    
    void registerObserver(Observer* o)     //注册观测者
    {
        observers.push_back(o);
    }
    
    virtual void removeObserver(Observer* o) //删除观测者
    {
        for(auto beg = observers.begin(); beg < observers.end(); beg++)
        {
            if(*beg == o)
            {
                beg = observers.erase(beg);
            }
        }
    }
    
    virtual void notifyObservers()   //通知所有观测者信息发生改变
    {
        for (auto observer : observers) //遍历所有的观测者
        {
            observer->update(temperature, humidity, pressure);    //调用所有观测者自己提供的更新函数
        }
    }
 
    void measurementsChanged()    //当气象信息发生改变时，会调用这个函数。给下一层提供，由下 一层调用。
    {
        notifyObservers();        //通知所有观测者
    } 
    
    void setMeasurements(float temperature, float humidity, float pressure);    //设置天气值，便于调试
    {
         temperature = temp;
         humidity = h;
         pressure = p;
         measurementsChanged();
    }
    
  private:
    std::vector observers;   //管理所有观测者
 
    float temperature;  //当前天气的的信息
    float humidity;
    float pressure;
  };
}

接下来我们可以创建一个观测者对象用于在天气温度变化时打印出来当前值。观测者对象可以无限拓展。

namespace weather {
  class StatisticsDisplay : public Observer, public DisplayElement {
  private:
    float maxTemp = 0.0f;
    float minTemp = 200;
    float tempSum= 0.0f;
    int numReadings;
    Subject& weatherData;
  public:
    explicit StatisticsDisplay(Subject& inWeatherData)    //通过构造函数把它注册为观察者
    : maxTemp(0.0f)
    , minTemp(200)
    , tempSum(0.0f)
    , numReadings(0)
    , weatherData(weatherData)
    {
         weatherData.registerObserver(this);    
    }
 
    ~StatisticsDisplay()
    {
        weatherData.removeObserver(this);    //将当前类从观察者中移除
    }
 
    void update(float temperature, float humidity, float pressure)    //获取到更新后的值后和当前值进行对比
    {
        tempSum += temp;
        numReadings++;
    
        if (temp > maxTemp) 
        {
          maxTemp = temp;
        }
    
        if (temp < minTemp) 
        {
          minTemp = temp;
        }
    
        display();    //打印显示
    }
 
    void display() const //提供自己的打印方法
    {
        std::cout << "Avg/Max/Min temperature = " << (tempSum / numReadings)<< "/" << maxTemp << "/" << minTemp << std::endl;
    }
  };
}

我们可以根据这样的模板根据需求提供不同的的观察者。

四.优化

按照上面的逻辑去写，每次发生任意一个元素的改变，都会推送给所有的观测者。不论这个观测者需不需要这些数据。我们可以让观测者根据需求从主题类里拉取需要的元素。我们可以在主题类调用观察者类的update函数的时候不传任何参数。然后我们修改主题类，在内部提供get函数用于获取自己的参数。最后我们在update函数被调用的时候通过调用get函数，去向主题类索取自己需要的元素。

总而言之，就是指让观测者知道值已经发生改变。让观测者自己去要具体哪个值。