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

一，概述

观察者<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）让耦合的双方都依赖于抽象，而不是依赖于具体。抽象不变，具体会变化