1. 观察者模式（Observer Pattern）的定义
（1）定义：定义对象间的一种一对多的依赖关系。当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
（2）观察者模式的结构和说明（拉模型）
①Subject：目标对象，通常具如的功能：一个目标可以被多个观察者观察；目标提供对观察者的注册和退订的维护；当目标的状态发生变化时，目标负责通知所有注册的、有效的观察者。
②Observer：定义观察者的接口，提供目标通知时对应的更新方法，这个更新方法进行相应的业务处理，可以在这个方法里面回调目标对象，以获取目标对象的数据。
③ConcreteSubject：具体的目标实现对象，用来维护目标状态，当目标对象的状态发生改变时，通知所有注册的、有效的观察者，让观察者执行相应的处理。
④ConcreteObserver：观察者的具体实现对象，用来接收目标的通知，并进行相应的后续处理，比如更新自身状态以保持和目标的相应状态一致。
【编程实验】图书促销活动
//行为型模式——观察者模式
//场景：图书促销活动(拉模型)
/*
观察者模式在现实的应用系统中也有好多应用，比如像当当网、京东商城一类的电子商务网站，
如果你对某件商品比较关注，可以放到收藏架，那么当该商品降价时，系统给您发送手机短信或邮件。
这就是观察者模式的一个典型应用，商品是被观察者，有的叫主体；关注该商品的客户就是观察者
*/
#include <iostream>
#include <string>
#include <list>
using namespace std;
class Subject; //前向声明（被观察者）
//******************************观察者接口********************************
class Observer
{
public:
virtual void update(Subject* subject) = 0;
};
//******************************目标对象（Subject）***************************
//抽象目标对象（被观察者）
class Subject //Java中命名为Observable
{
private:
bool changed;
list<Observer*> obs;
public:
void setChanged()
{
changed = true;
}
void clearChanged()
{
changed = false;
}
bool hasChanged()
{
return changed;
}
void addObserver(Observer* o)
{
obs.push_back(o);
}
void delObserver(Observer* o)
{
obs.remove(o);
}
void notifyObservers()
{
list<Observer*>::iterator iter = obs.begin();
while(iter != obs.end())
{
(*iter)->update(this);
++iter;
}
}
};
//书——被观察者
class Book : public Subject
{
private:
string name;
double price;
public:
string& getName()
{
return name;
}
void setName(string value)
{
name = value;
}
double getPrice()
{
return price;
}
void setPrice(double value)
{
price = value;
}
//当书的价格修改时调用该方法
void modifyPrice()
{
//调用父类方法，改变被观察者的状态
setChanged();
//通知客户该书己降价
notifyObservers();
}
};
//*****************************具体的观察者*****************************
//具体观察者(一般顾客，假设只留手机号码)
class Buyer : public Observer
{
private:
string buyerId;
string mobileNo;
public:
string& getBuyerId(){return buyerId;}
void setBuyerId(string value) {buyerId = value;}
string& getMobileNo(){return mobileNo;}
void setMobileNo(string value){mobileNo = value;}
//收到通知时要进行的操作
void update(Subject* s)
{
Book* b = (Book*)s;
cout <<"给一般顾客(" <<buyerId <<")发的手机短信:"<< b->getName()
<<"降价了，目前的价格为" << b->getPrice()<<"元" << endl;
}
};
//具体观察者(新华书店，假设只留email）
class BookStore : public Observer
{
private:
string buyerId;
string email;
public:
string& getBuyerId(){return buyerId;}
void setBuyerId(string value) {buyerId = value;}
string& getEmail(){return email;}
void setEmail(string value){email = value;}
//收到通知时要进行的操作
void update(Subject* s)
{
Book* b = (Book*)s;
cout <<"给新华书店(" <<buyerId <<")发的电子邮件:"<< b->getName()
<<"降价了，目前的价格为" << b->getPrice()<<"元" << endl;
}
};
int main()
{
//书促销活动
Book bk;
bk.setName("《设计模式:可复用面向对象软件的基础》");
bk.setPrice(45.00); //假设原价是60，现在是降价促销
//一般客户
Buyer by;
by.setBuyerId("001");
by.setMobileNo("1359912XXXX");
//新华书店
BookStore bs;
bs.setBuyerId("002");
bs.setEmail("[email protected]");
//增加观察者，在实际应用中就是哪些人对该书做了关注
bk.addObserver(&by); //一般客户对该对做了关注
bk.addObserver(&bs); //新华书店对该书做了关注
//发送降价通知
bk.modifyPrice();
return 0;
}
/*
给一般顾客(001)发的手机短信:《设计模式:可复用面向对象软件的基础》降价了，目前的价格为45元
给新华书店(002)发的电子邮件:《设计模式:可复用面向对象软件的基础》降价了，目前的价格为45元
*/2. 思考观察者模式
（1）观察者模式的本质：触发联动。当修改目标对象的状态时，就会触发相应的通知，然后会循环调用所有观察者对象的相应方法，通知这些观察者，让其做相应的反应。其实就相当于联动调用这些观察者的方法。它将目标对象与观察者解耦，这样目标对象与观察者可以独立变化，但又可以正确联动起来。
（2）目标对象和观察者之间的关系
①一个目标只有一个观察者，也可以被多个观察者观察。
②一个观察者可以观察多个目标对象，但这里一般观察者内要提供不同的update方法，以便让不同的目标对象来回调。
③在观察者模式中，观察者和目标是单向依赖的，只有观察者依赖于目标，而目标是不依赖于具体的观察者（只依赖于接口）。
④它们之间的联系主动权掌握在目标对象手中，只有目标对象知道什么时候需要通知观察者。在整个过程中，观察者始终是被动地等待目标对象的通知。
⑤对于目标对象而言，所有的观察者都是一样的，会一视同仁。但也可以在目标对象里面进行控制，实现有区别的对待观察者。
（3）基本的实现说明
①具体的目标实现对象要能维护观察者的注册信息，最简单的实现方案就是采用链表来保存观察者的注册信息。
②具体的目标实现对象需要维护引起通知的状态，一般情况下是目标自身的状态。变形使用的情况下，也可以是别的对象的状态。
③具体的观察者实现对象需要能接收目标的通知，能够接收目标传递的数据或主动去获取目标的数据，并进行后续处理。
④如果是一个观察者观察多个目标，那在观察者的更新方法里面，需要去判断是来自哪一个目标的通知。一种简音的解决方案是扩展update方法，比哪里在方法里多传递一个参数进行区分。还有一种更简单的方法，就是定义不同的回调方法。
（4）触发通知的时机
①一般是在完成状态维护后触发，因为通知会传递数据，不能够先通知后改数据，这很容易导致观察者和目标对象的状态不一致。
②可能出错的示例代码片段
（5）相互观察
在某些应用中，可能会出现目标和观察者相互观察的情况。这种情况要防止可能出现的死循环现象。
3. 推模型和拉模型
（1）推模型：目标对象主动向观察者推送目标的详细信息，不管观察者是否需要，推送的消息通常是目标对象的全部或部分数据。相当于是在广播通知。
（2）拉模型：目标对象在通知观察者的时候，只传递少量信息。如果观察者需要更具体的信息，由观察者主动到目标对象中获取，相当于是观察者从目标对象中拉数据。一般这种模型的实现中，会把目标对象自己通过update方法传递给观察者，这样在观察者需要获取数据的时候，就可以通过这个引用来获取。
（3）关于两种模型的比较
①推模型是假定目标对象知道观察者需要的数据；而拉模型是目标对象不知道观察者具体需要什么数据，在没有办法的情况下，干脆把自身传递给观察者，让观察者自己去按需取值。
②推模式可能会使观察者对象难以复用，因为观察者定义的update方法是按需定义的，可能无法兼顾没有考虑到的情况。这意味者出现新的情桨叶时，就可以需要提供新的update方法。或干脆重新实现观察者。而拉模式不会造成这种情况，因为update方法的参数是目标对象本身。这基本上是目标对象能传递的最大数据集合，基本可以适应各种情况的需要。
【编程实验】模拟事件监听系统（推模型）
//行为型模式——观察者模式
//场景——模拟事件监听系统（推模型）
//Switch：事件源（开关），相当于具体的Subject角色
//EventListener：事件监听接口，相当于Observer角色
//Light：监听者，相当于具体的Observer角色
//SwitchEvent：事件对象，用于当事件发生时向监听者发送的数据类型（含事件源对象，源的状态等）。
#include <iostream>
#include <string>
#include <list>
using namespace std;
class Switch; //前向声明
//******************************辅助类（用于事件源向监听者传递的数据类型）********************
typedef void Object;
//事件类(主要用来记录触发事件的源对象)
class EventObject
{
Object* source; //记录事件源对象
public:
EventObject(Object* source)
{
this->source = source;
}
Object* EventSource()
{
return source;
}
};
//开关事件，用于向监听者发生的数据
class SwitchEvent: public EventObject
{
string switchState; //表示开关的状态
public:
SwitchEvent(Switch* source, string switchState):EventObject(source)
{
this->switchState = switchState;
}
void setSwitchState(string switchState)
{
this->switchState = switchState;
}
string& getSwitchState()
{
return switchState;
}
};
//***************************************Observer(观察者)***************************
class EventListener
{
public:
virtual void handleEvent(SwitchEvent* switchEvent) = 0;
};
//具体的监听者（相当于具体观察者）
class Light : public EventListener
{
public:
void handleEvent(SwitchEvent* switchEvent)
{
cout <<"the light receive a switch(" << switchEvent->EventSource()
<<") emit \""<<switchEvent->getSwitchState() <<"\" signal"<< endl;
}
};
//****************************************Subject（被观察者）***********************
//抽象目标对象类
class Subject
{
list<EventListener*> switchListeners;
public:
void addListener(EventListener* listener)
{
switchListeners.push_back(listener);
}
void removeListener(EventListener* listener)
{
switchListeners.remove(listener);
}
void notifyListeners(SwitchEvent* switchEvent)
{
list<EventListener*>::iterator iter = switchListeners.begin();
while(iter != switchListeners.end())
{
(*iter)->handleEvent(switchEvent);
++iter;
}
}
};
//具体的目标对象，电源开关（事件源对象）
class Switch : public Subject
{
SwitchEvent* switchEvent;
public:
Switch()
{
switchEvent = new SwitchEvent(this, "close");
}
void open()
{
switchEvent->setSwitchState("open");
notifyListeners(switchEvent);
}
void close()
{
switchEvent->setSwitchState("close");
notifyListeners(switchEvent);
}
~Switch()
{
delete switchEvent;
}
};
int main()
{
Switch sw; //开关，被监听对象
Light lg; //灯，监听器
sw.addListener(&lg); //加入开关的监听队列
//打开Switch
sw.open();
//关闭Switch
sw.close();
return 0;
}
/*
the light receive a switch(0x23fea4) emit "open" signal
the light receive a switch(0x23fea4) emit "close" signal
*/4. 观察者模式的优缺点
（1）优点
①观察者模式实现了观察者和目标之间的抽象耦合
②实现了动态联动。由于观察者模式对观察者的注册实行管理，那就可以在运行期间，通过动态地控制注册的观察者，来控制某个动作的联动范围，从而实现动态联动。
③支持广播通信
（2）缺点
可能会引起无谓的操作。由于观察者模式每次都是广播通信，不管观察者需不需要，每个观察者都会被调用update方法。如果观察者不需要执行相应处理，那这次操作就浪费了，甚至可能会误操作。如本应在执行这次状态更新前把某个观察者删除掉，但现在这个观察者都还没删除，消息就又到达了，那么就会引起误操作。
5. 观察者模式的应用场景
（1）聊天室程序，服务器转发给所有客户端，群发消息等
（2）网络游戏（多人联机对战）场景中，服务器将客户端的状态进行分发。
（3）事件处理模型，基于观察者模式的委派事件模型（事件源：目标对象；事件监听器：观察者）
【编程实验】区别对待观察者（变式观察者模式）
//行为型模式——观察者模式
//场景：水质监测系统（拉模型）
/*、
说明：
1、水质正常时：只通知监测人员做记录
2、轻度污染时：除了通知监测人员做记录外，还要通知预警人员，判断是否需要预警
3、中度或重度污染时：除了通知以上两人种外，还要通知部门领导做相应的处理
解决方式：
1、每次污染时，目标可以通知所有观察者，由观察者决定是否属自己处理的情况
2、每次污染时，在目标里进行判断，然后只通知相应的观察者（本例采用这种方式）
*/
#include <iostream>
#include <string>
#include <list>
using namespace std;
class WatcherObserver; //前向声明
//定义水质监测的目标对象
class WaterQualitySubject
{
protected:
list<WatcherObserver*> obs;
public:
void attach(WatcherObserver* observer)
{
obs.push_back(observer);
}
void detach(WatcherObserver* observer)
{
obs.remove(observer);
}
//通知相应的观察者对象(这里为抽象方法，由子类去实现区别对象观察者)
virtual void notifyWatchers() = 0;
//获取水质污染的级别
virtual int getPolluteLevel() = 0;
};
//水质观察者接口定义
class WatcherObserver
{
public:
//被通知时的处理方法，参数为被观察的目标对象
virtual void update(WaterQualitySubject* subject) = 0;
//设置和获取观察人员的职务
virtual void setJob(string job) = 0;
virtual string& getJob() = 0;
};
//具体的观察者
class Watcher : public WatcherObserver
{
private:
string job;
public:
void setJob(string job){this->job = job;}
string& getJob(){return job;}
//收到通知时的处理过程
void update(WaterQualitySubject* subject) //拉模型
{
cout <<job << "获取到通知，当前污染级别为:"
<< subject->getPolluteLevel() << endl;
}
};
//具体的水质监测对象
class WaterQuality : public WaterQualitySubject
{
private:
int polluteLevel; //0正常，1轻度污染，2中度污染，3重度污染
public:
WatcherQuality(){polluteLevel = 0;}
int getPolluteLevel()
{
return polluteLevel;
}
void setPolluteLevel(int value)
{
polluteLevel = value;
notifyWatchers(); //通知相应的观察者
}
//通知相应的观察者对象
void notifyWatchers()
{
list<WatcherObserver*>::iterator iter = obs.begin();
while (iter != obs.end())
{
//根据污染级别判断是否需要通知
//通知监测员记录
if(polluteLevel >=0)
{
if((*iter)->getJob()=="监测人员")
{
(*iter)->update(this);
}
}
//通知预警人员
if(polluteLevel >=1)
{
if((*iter)->getJob()=="预警人员")
{
(*iter)->update(this);
}
}
//通知监测部门领导
if(polluteLevel >=2)
{
if((*iter)->getJob()=="监测部门领导")
{
(*iter)->update(this);
}
}
++iter;
}
}
};
int main()
{
//创建水质主题对象
WaterQuality subject;
//创建几个观察者
WatcherObserver* watcher1 = new Watcher();
watcher1->setJob("监测人员");
WatcherObserver* watcher2 = new Watcher();
watcher2->setJob("预警人员");
WatcherObserver* watcher3 = new Watcher();
watcher3->setJob("监测部门领导");
//注册观察者
subject.attach(watcher1);
subject.attach(watcher2);
subject.attach(watcher3);
//填写水质报告
cout << "当水质正常的时候---------------------------" << endl;
subject.setPolluteLevel(0);
cout << endl;
cout << "当水质轻度污染的时候-----------------------" << endl;
subject.setPolluteLevel(1);
cout << endl;
cout << "当水质中度污染的时候-----------------------" << endl;
subject.setPolluteLevel(2);
delete watcher1;
delete watcher2;
delete watcher3;
return 0;
}
/*输出结果：
当水质正常的时候---------------------------
监测人员获取到通知，当前污染级别为:0
当水质轻度污染的时候-----------------------
监测人员获取到通知，当前污染级别为:1
预警人员获取到通知，当前污染级别为:1
当水质中度污染的时候-----------------------
监测人员获取到通知，当前污染级别为:2
预警人员获取到通知，当前污染级别为:2
监测部门领导获取到通知，当前污染级别为:2
*/6. 相关模式
（1）观察者与状态模式
①这两者有相似之处。观察者模式是当目标状态发生改变时，触发并通知观察者，让观察者去执行相应的操作。而状态模式是根据不同的状态，选择不同的实现，这个实现类的主要功能是针对状态进行相应的操作，它不像观察者，观察者本身还有很多其他的功能，接收通知并执行相应处理只是观察者的部分功能。
②这两者可以结合使用。观察者模式的重心在触发联动，但到底决定哪些观察者会被联动，这里可以采用状态模式来实现，也可以使用策略模式来选择需要联动的观察者。
（2）观察者与中介者模式
如把一个界面所有的事件用一个中介者对象封装处理，当一个组件触发事件以后，只需要通知中介者，由于中介者封装了需要操作其他组件的动作。这样就可以实现目标对象与观察者之间的联动。