（六）责任链模式-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) = 0;
    virtual void setNextHandler(Handler* handler) = 0;
};


//具体处理者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("11129812340930034");
    numberList.push_back("11129812340930035");
    numberList.push_back("11129812340930036");
    numberList.push_back("11129812340930037");
}

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("10129812340930031");
    numberList.push_back("10129812340930032");
    numberList.push_back("10129812340930036");
    numberList.push_back("10129812340930037");
}

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("10029812340930031");
    numberList.push_back("10029812340930032");
    numberList.push_back("10029812340930036");
    numberList.push_back("10029812340930037");
}

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("10129812340930037");

    return 0;
}

    责任链的优势：

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

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

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

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

    适合责任链的场景：

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

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