（六）责任链模式-C++实现

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

责任链模式是使用多个对象处理用户请求的成熟模式，它的关键是将这处理对象组成一个链。每个对象含有后继对象的引用，如果不能处理目前的请求就把它传给后继对象处理。

该模式中有两种角色：

1、处理者：是一个接口或者抽象类，规定了具体处理者处理用户请求的方法，还有设置后继对象的方法

2、具体处理者：是具体的处理者的实现。

本例子中，是一个查询用户身份证号码的例子，不同的具体处理者代表不同的城市，然后对一个身份证号码的请求进行处理。有三个文件，Handler.h和Handler.cpp以及测试用的ResponsibilityChainTest.cpp

（1）Handler.h

 #ifndef _HANDLER_H_
 #define _HANDLER_H_
 #include <iostream>
 #include <list>
 #include <string>
 using namespace std;

 /*
 责任链模式
 有很多的对象可以处理请求，
 但是用户并不感知是那个对象处理了他的请求。
 */

 //抽象类
 class Handler{
 public:
     virtual void handleRequest(string number) = ;
     virtual void setNextHandler(Handler* handler) = ;
 };

 //具体处理者1
 class Beijing : public Handler{
 public:
     Beijing();
     void handleRequest(string number) override;
     void setNextHandler(Handler* handler) override;

 private:
     Handler *myHandler;
     list<string> numberList;
 };

 //具体处理者2
 class Shanghai : public Handler{
 public:
     Shanghai();
     void handleRequest(string number) override;
     void setNextHandler(Handler* handler) override;

 private:
     Handler *myHandler;
     list<string> numberList;
 };

 //具体处理者3
 class Tianjin : public Handler{
 public:
     Tianjin();
     void handleRequest(string number) override;
     void setNextHandler(Handler* handler) override;

 private:
     Handler *myHandler;
     list<string> numberList;
 };

 #endif

（2）Handler.cpp

 #include "Handler.h"

 Beijing::Beijing()
 {
     numberList.push_back("");
     numberList.push_back("");
     numberList.push_back("");
     numberList.push_back("");
 }

 void Beijing::handleRequest(string number)
 {
     list<string>::iterator it;
     it = find(numberList.begin(), numberList.end(), number);
     if (it != numberList.end())//存在
     {
         cout << "该人在北京居住" << endl;
     }
     else{
         cout << "该人不在北京居住" << endl;
         if (NULL != myHandler)
         {
             myHandler->handleRequest(number);
         }
     }
 }

 void Beijing::setNextHandler(Handler* handler)
 {
     myHandler = handler;
 }

 Shanghai::Shanghai()
 {
     numberList.push_back("");
     numberList.push_back("");
     numberList.push_back("");
     numberList.push_back("");
 }

 void Shanghai::handleRequest(string number)
 {
     list<string>::iterator it;
     it = find(numberList.begin(), numberList.end(), number);
     if (it != numberList.end())//存在
     {
         cout << "该人在上海居住" << endl;
     }
     else{
         cout << "该人不在上海居住" << endl;
         if (NULL != myHandler)
         {
             myHandler->handleRequest(number);
         }
     }
 }

 void Shanghai::setNextHandler(Handler* handler)
 {
     myHandler = handler;
 }

 Tianjin::Tianjin()
 {
     numberList.push_back("");
     numberList.push_back("");
     numberList.push_back("");
     numberList.push_back("");
 }

 void Tianjin::handleRequest(string number)
 {
     list<string>::iterator it;
     it = find(numberList.begin(), numberList.end(), number);
     if (it != numberList.end())//存在
     {
         cout << "该人在天津居住" << endl;
     }
     else{
         cout << "该人不在天津居住" << endl;
         if (NULL != myHandler)
         {
             myHandler->handleRequest(number);
         }
     }
 }

 void Tianjin::setNextHandler(Handler* handler)
 {
     myHandler = handler;
 }

（3）ResponsibilityChainTest.cpp

 #include "Handler.h"

 int main()
 {
     //创建责任链
     //一般将责任大（最有可能处理用户请求）的对象放在前面
     Handler *beijing = new Beijing();
     Handler *tianjin = new Tianjin();
     Handler *shanghai = new Shanghai();

     beijing->setNextHandler(tianjin);
     tianjin->setNextHandler(shanghai);

     //用户进行请求
     //从责任链的第一个对象开始
     beijing->handleRequest("");

     return ;
 }

责任链的优势：

1、责任链中对象只和自己的后继是耦合关系，和其他对象毫无关联

2、在处理中分配职责时，责任链给程序更多的灵活性（将责任大的对象放在责任链的前面）

3、应用程序可以动态增加或者删除处理者；也可以动态的改变处理者之间的先后顺序

4、使用责任链的用户不必知道处理者的信息。

适合责任链的场景：

1、有很多对象可以处理用户的请求，希望程序在运行时自动确定处理用户请求的那个对象。

2、程序希望动态定制可处理用户请求的对象集合。