【设计方式】把风放哨，防老板 - 观察者模式

【设计模式】把风放哨，防老板 --- 观察者模式

一，概述

        观察者<Observer>模式（有时又被称为发布-订阅<Publish/Subscribe>模式、模型-视图<Model/View>模式、源-收听者<Source/Listener>模式或从属者<Dependents>模式）是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实作事件处理系统。

二，示例

        题目描述：公司里有的员工偷懒，看股票，看NBA。老板回来需要有人通知他们，然后再好好干活。通知大家的任务交给前台。

       1）双向耦合的代码 （读此代码之前先看两个类互相包含）       

             缺点：前台通知类和看股票者相互耦合。如果再想增加一个看NBA的类就违反“开放-- 封闭原则”

             StockObserver.h类（）

#include <iostream>#include <string>using namespace std;class Secretary;//看股票的同事 class StockObserver { private: string name; Secretary *sub; public: StockObserver(string name, Secretary *sub) { this->name = name;//这里一定要加上this this->sub = sub; } void Update() { //cout<<sub->getAction()<<name<<"关闭股票行情，继续工作！"<<endl;cout<<name<<"!!关闭股票行情，继续工作！"<<endl; } };

          Secretary.h

#include <iostream>#include <list>#include <algorithm>#include "StockObserver.h"using namespace std;template<typename T>struct display{void operator()( T &observer){observer.Update();}};class Secretary{ //同事列表 private: list<StockObserver> observers;// = new List<StockObserver>(); string action; public: //增加friend class StockObserver; void Attach(StockObserver observer) { observers.push_back(observer); } //减少 void Detach(StockObserver observer) { observers.pop_back(); } //通知 void Notify() { for_each(observers.begin(),observers.end(),display<StockObserver>()); } //前台状态 void SecretaryAction(string value) { action = value; } };

           main.cpp（客户端程序）

#include <iostream>#include "Secretary.h"using namespace std;int main(){ //前台小姐童子喆 Secretary *tongzizhe= new Secretary(); //看股票的同事 StockObserver tongshi1("魏关姹", tongzizhe); StockObserver tongshi2 ("易管查", tongzizhe); //前台记下了两位同事 tongzizhe->Attach(tongshi1); tongzizhe->Attach(tongshi2); //发现老板回来 tongzizhe->SecretaryAction( "老板回来了！"); //通知两个同事 tongzizhe->Notify(); getchar();//防止退出的 return 0;}

            2）解除耦合实践一：(C#)

        增加了抽象的观察者，方便扩展各种类型的扩展者。

                  3）解除耦合实践二：(C#)

                                    改进：由于老板来了会自己通知职员，前台也可以偷偷通知职员老板来了。所以增加一个通知者接口。

三，观察者模式

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

观察者基本代码：抽象通知者类，具体实现通知者类，抽象观察者类，具体实现观察者类

                             抽象通知者为具体实现者父类，负责通知注册的观察者类

              

    class Program
    {
        static void Main(string[] args)
        {
            ConcreteSubject s = new ConcreteSubject();

            s.Attach(new ConcreteObserver(s, "X"));
            s.Attach(new ConcreteObserver(s, "Y"));
            s.Attach(new ConcreteObserver(s, "Z"));

            s.SubjectState = "ABC";
            s.Notify();

            Console.Read();

        }
    }


    abstract class Subject             //抽象通知者
    {
        private IList<Observer> observers = new List<Observer>();

        //增加观察者
        public void Attach(Observer observer)
        {
            observers.Add(observer);
        }
        //移除观察者
        public void Detach(Observer observer)
        {
            observers.Remove(observer);
        }
        //通知
        public void Notify()
        {
            foreach (Observer o in observers)
            {
                o.Update();
            }
        }
    }

    //具体通知者
    class ConcreteSubject : Subject
    {
        private string subjectState;

        //具体通知者状态
        public string SubjectState
        {
            get { return subjectState; }
            set { subjectState = value; }
        }
    }


    abstract class Observer   //抽象观察者
    {
        public abstract void Update();
    }

    class ConcreteObserver : Observer  //具体观察者
    {
        private string name;
        private string observerState;
        private ConcreteSubject subject;

        public ConcreteObserver(
          ConcreteSubject subject, string name)
        {
            this.subject = subject;
            this.name = name;
        }
        //更新
        public override void Update()
        {
            observerState = subject.SubjectState;
            Console.WriteLine("观察者{0}的新状态是{1}",
              name, observerState);
        }

        public ConcreteSubject Subject
        {
            get { return subject; }
            set { subject = value; }
        }
    }

四，观察者模式的特点

         问题：

        1）将一个系统分割成一系列相互协作的类有一个不好的副作用：需要维护相对对象的一致性

        2）我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不便

        观察者优点：

         1）让耦合的双方都依赖于抽象，而不是依赖于具体。抽象不变，具体会变化