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）触发通知的时机
①一般是在完成状态维护后触发，因为通知会传递数据，不能够先通知后改数据，这很容易导致观察者和目标对象的状态不一致。
②可能出错的示例代码片段
void setContent(string content)
{
//目标先发出通知，再修改自己的数据，会造成问题
notifyAllObservers(); //先发通知（此时可能有的观察者就来取数据，结果
//目标的数据还没更新）。
this->content = content; //再修改自身数据
}
（5）相互观察
在某些应用中，可能会出现目标和观察者相互观察的情况。这种情况要防止可能出现的死循环现象。
3. 推模型和拉模型
（1）推模型：目标对象主动向观察者推送目标的详细信息，不管观察者是否需要，推送的消息通常是目标对象的全部或部分数据。相当于是在广播通知。
（2）拉模型：目标对象在通知观察者的时候，只传递少量信息。如果观察者需要更具体的信息，由观察者主动到目标对象中获取，相当于是观察者从目标对象中拉数据。一般这种模型的实现中，会把目标对象自己通过update方法传递给观察者，这样在观察者需要获取数据的时候，就可以通过这个引用来获取。
（3）关于两种模型的比较
①推模型是假定目标对象知道观察者需要的数据；而拉模型是目标对象不知道观察者具体需要什么数据，在没有办法的情况下，干脆把自身传递给观察者，让观察者自己去按需取值。
②推模式可能会使观察者对象难以复用，因为观察者定义的update方法是按需定义的，可能无法兼顾没有考虑到的情况。这意味者出现新的情桨叶时，就可以需要提供新的update方法。或干脆重新实现观察者。而拉模式不会造成这种情况，因为update方法的参数是目标对象本身。这基本上是目标对象能传递的最大数据集合，基本可以适应各种情况的需要。
4. 观察者模式的优缺点
（1）优点
①观察者模式实现了观察者和目标之间的抽象耦合
②实现了动态联动。由于观察者模式对观察者的注册实行管理，那就可以在运行期间，通过动态地控制注册的观察者，来控制某个动作的联动范围，从而实现动态联动。
③支持广播通信
（2）缺点
可能会引起无谓的操作。由于观察者模式每次都是广播通信，不管观察者需不需要，每个观察者都会被调用update方法。如果观察者不需要执行相应处理，那这次操作就浪费了，甚至可能会误操作。如本应在执行这次状态更新前把某个观察者删除掉，但现在这个观察者都还没删除，消息就又到达了，那么就会引起误操作。
5. 观察者模式的应用场景
（1）聊天室程序，服务器转发给所有客户端，群发消息等
（2）网络游戏（多人联机对战）场景中，服务器将客户端的状态进行分发。
（3）事件处理模型，基于观察者模式的委派事件模型（事件源：目标对象；事件监听器：观察者）
6. 相关模式
（1）观察者与状态模式
①这两者有相似之处。观察者模式是当目标状态发生改变时，触发并通知观察者，让观察者去执行相应的操作。而状态模式是根据不同的状态，选择不同的实现，这个实现类的主要功能是针对状态进行相应的操作，它不像观察者，观察者本身还有很多其他的功能，接收通知并执行相应处理只是观察者的部分功能。
②这两者可以结合使用。观察者模式的重心在触发联动，但到底决定哪些观察者会被联动，这里可以采用状态模式来实现，也可以使用策略模式来选择需要联动的观察者。
（2）观察者与中介者模式
如把一个界面所有的事件用一个中介者对象封装处理，当一个组件触发事件以后，只需要通知中介者，由于中介者封装了需要操作其他组件的动作。这样就可以实现目标对象与观察者之间的联动。