设计模式之观察者模式

一、基本定义：

    何谓观察者模式？观察者模式定义了对象之间的一对多依赖关系，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并且自动更新。
在这里，发生改变的对象称之为观察目标，而被通知的对象称之为观察者。一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系，所以可以根据需要增加和删除观察者，使得系统更易于扩展。
    观察者模式又称为发布-订阅模式。

二、基本结构

UML类图：

分析：

Subject：主题。为所有具体观察者定义一个接口，他把所有对观察者对象的引用保存在一个集合里，每一个主题都可以有多个观察者。

Observer：观察者。为所有的具体观察者定义一个接口，在得到主题的通知时能够及时的更新自己。

ConcreteSubject：具体主题。将有关状态存入具体观察者对象。在具体主题发生改变时，给所有的观察者发出通知。

ConcreteObserver:具体观察者。实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题状态相协调。

三、实例：气象观测站

    在气象观测站中，它能够追踪目前的天气状况，包括温度、适度、气压。需要实现一个布告板，能够分别显示目前的状态，气象统计和简单的预报。当气象站中获取最新的测量数据时，三种布告板必须实时更新。

代码：

    //测试
    class Program
    {
        static void Main(string[] args)
        {
            ISubject weatherData = new WeatherData();
            IObserver currentConditionDisplay = new CurrentConditionDisplay(weatherData);

            //气象站更新天气状况,则每个观察者均会受到通知，并更新布告板的显示
            ((WeatherData)weatherData).SetMeasurements(80, 65, 30.4f);
            ((WeatherData)weatherData).SetMeasurements(82, 70, 29.2f);

            Console.ReadKey();
        }
    }

    /// <summary>
    /// 主题接口
    /// </summary>
    public interface ISubject
    {
        /// <summary>
        /// 注册观察者
        /// </summary>
        void RegisterObserver(IObserver observer);
        /// <summary>
        /// 删除观察者
        /// </summary>
        /// <param name="observer"></param>
        void RemoveObserver(IObserver observer);

        /// <summary>
        /// 当主题状态发生变化时，这个方法需要被调用，以通知 所有 观察者
        /// </summary>
        void NotifyObserver();
    }
    /// <summary>
    /// 观察者接口
    /// </summary>
    public interface IObserver
    {
        void Update(float temp, float humidity, float pressure);
    }

    /// <summary>
    /// 具体主题
    /// </summary>
    public class WeatherData : ISubject
    {
        //观察者集合
        private List<IObserver> observers;

        private float _templature;
        private float _pressure;
        private float _humidity;

        public float Templature
        {
            get { return _templature; }
            set { _templature = value; }
        }
        public float Pressure
        {
            get { return _pressure; }
            set { _pressure = value; }
        }
        public float Humidity
        {
            get { return _humidity; }
            set { _humidity = value; }
        }
        public WeatherData()
        {
            observers = new List<IObserver>();
        }
        /// <summary>
        /// 当主题状态发生变化时，这个方法需要被调用，以通知 所有 观察者
        /// </summary>
        /// <param name="observer"></param>
        public void NotifyObserver()
        {
            foreach (IObserver observer in observers)
            {
                //调用每个观察者自身的update方法，将参数传递过去
                observer.Update(_templature, _humidity, _pressure);
            }
        }

        public void RegisterObserver(IObserver observer)
        {
            observers.Add(observer);
        }

        public void RemoveObserver(IObserver observer)
        {
            if (observers.Contains(observer))
            {
                observers.Remove(observer);
            }

        }
        /// <summary>
        /// 气象站得到更新的数据时，通知观察者
        /// </summary>
        public  void MeasurementChanged()
        {
            NotifyObserver();
        }

        public void SetMeasurements(float templature, float humidity, float pressure)
        {
            this._templature = templature;
            this._humidity = humidity;
            this._pressure = pressure;
            MeasurementChanged();
        }
    }

    /// <summary>
    /// 布告板显示接口
    /// </summary>
    public interface IDisplayElement
    {
        void Display();
    }
    /// <summary>
    /// 具体的观察者（天气布告板）
    /// </summary>
    public class CurrentConditionDisplay : IObserver,IDisplayElement
    {
        //指向主题的引用
        private ISubject subject;

        private float _templature;
        private float _pressure;
        private float _humidity;

        public float Templature
        {
            get { return _templature; }
            set { _templature = value; }
        }
        public float Pressure
        {
            get { return _pressure; }
            set { _pressure = value; }
        }
        public float Humidity
        {
            get { return _humidity; }
            set { _humidity = value; }
        }
        public CurrentConditionDisplay(ISubject subject)
        {
            this.subject = subject;
            //注册观察者（订阅主题）
            subject.RegisterObserver(this);
        }
        public void Update(float temp, float humidity, float pressure)
        {
            this._templature = temp;
            this._humidity = humidity;
            this._pressure = pressure;
            Display();
        }

        public void Display()
        {
            Console.WriteLine("Current conditions:" + _templature + "F degrees and " + _humidity + "% humidity");
        }

    }

结果：

四、优缺点：

优点：

1、当两个对象之间送耦合，他们依然可以交互，但是不太清楚彼此的细节。观察者模式提供了一种对象设计，让主题和观察者之间送耦合。主题所知道只是一个具体的观察者列表，每一个具体观察者都符合一个抽象观察者的接口。主题并不认识任何一个具体的观察者，它只知道他们都有一个共同的接口。

2、观察者模式支持“广播通信”。主题会向所有的观察者发出通知。

3、观察者模式符合“开闭原则”的要求。

缺点：

1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。

2、 如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进 行循环调用，可能导致系统崩溃。

3、 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

五、适用场景：

1、一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。

2、一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。

3、一个对象必须通知其他对象，而并不知道这些对象是谁。需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。

五、总结：

1、观察者模式定义了对象之间的一对多关系。多个观察者监听同一个被观察者，当该被观察者的状态发生改变时，会通知所有的观察者。

2、观察者模式中包含四个角色。主题，它指被观察的对象。具体主题是主题子类，通常它包含有经常发生改变的数据，当它的状态发生改变时，向它的各个观察者发出通知；观察者，将对观察主题的改变做出反应；具体观察者中维护一个指向具体目标对象的引用，它存储具体观察者的有关状态，这些状态需要和具体目标的状态保持一致。

3、主题用一个共同的接口来更新观察者。

4、观察者与被观察者之间用松耦合方式结合。

5、有多个观察者时，不可以依赖特定的通知次序。

6、使用观察者模式，可以从被观察者处推或者拉数据。