属于“数据结构”模式，因为责任链实际是一个单链表的形式。
还有：

  1. Composite：构成一个树形结构
  2. Iterator：处理容器内部数据结构和外部依赖关系的过程，是一个遍历的动作

动机

在软件构建过程中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接受者，如果显示指定，将必不可少地带来请求者与接受者的紧耦合。

如何使请求者不需要指定具体的接受者？让请求的接受者自己在运行时决定谁来处理请求，从而使两者解耦。

模式定义

使多个对象都有机会处理请求，从而避免请求者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。——《设计模式》GoF。

代码

  1. #include <iostream>
  2. #include <string>
  4. using namespace std;
  6. //请求类型
  7. enum class RequestType
  8. {
  9.     REQ_HANDLER1,
  10.     REQ_HANDLER2,
  11.     REQ_HANDLER3
  12. };
  14. //请求
  15. class Reqest
  16. {
  17.     string description;        //描述
  18.     RequestType reqType;    //请求类型
  19. public:
  20.     Reqest(const string & desc, RequestType type) : description(desc), reqType(type) {}
  21.     //得到请求类型
  22.     RequestType getReqType() const { return reqType; }
  23.     const string& getDescription() const { return description; }
  24. };
  26. //责任链
  27. //核心逻辑：责任链上有很多个处理类，如果当前节点不能处理，则交给下一个处理，直到处理完成
  28. class ChainHandler{
  29.     ChainHandler *nextChain; //下一个处理者
  31.     //将请求发送给下一个请求者
  32.     void sendReqestToNextHandler(const Reqest & req)
  33.     {
  34.         if (nextChain != nullptr)
  35.             nextChain->handle(req);
  36.     }
  37. protected:
  38.     //this能否处理这个请求
  39.     virtual bool canHandleRequest(const Reqest & req) = 0;
  40.     //用this处理这个请求
  41.     virtual void processRequest(const Reqest & req) = 0;
  42. public:
  43.     ChainHandler() { nextChain = nullptr; }
  44.     //设置下一个节点
  45.     void setNextChain(ChainHandler *next) { nextChain = next; }
  46.        //处理
  47.     void handle(const Reqest & req)
  48.     {
  49.         //this是否能处理这个请求
  50.         if (canHandleRequest(req))
  51.             //可以 -> 处理这个请求
  52.             processRequest(req);
  53.         else
  54.             //不可以，发送给下一个
  55.             sendReqestToNextHandler(req);
  56.     }
  57. };
  59. //第一个处理者
  60. class Handler1 : public ChainHandler{
  61. protected:
  62.     bool canHandleRequest(const Reqest & req) override
  63.     {
  64.         //this是处理RequestType::REQ_HANDLER1类型的请求
  65.         return req.getReqType() == RequestType::REQ_HANDLER1;
  66.     }
  67.     void processRequest(const Reqest & req) override
  68.     {
  69.         //处理
  70.         cout << "Handler1 is handle reqest: " << req.getDescription() << endl;
  71.     }
  72. };
  74. //第二个处理者
  75. class Handler2 : public ChainHandler{
  76. protected:
  77.     bool canHandleRequest(const Reqest & req) override
  78.     {
  79.         return req.getReqType() == RequestType::REQ_HANDLER2;
  80.     }
  81.     void processRequest(const Reqest & req) override
  82.     {
  83.         cout << "Handler2 is handle reqest: " << req.getDescription() << endl;
  84.     }
  85. };
  87. //第三个处理者
  88. class Handler3 : public ChainHandler{
  89. protected:
  90.     bool canHandleRequest(const Reqest & req) override
  91.     {
  92.         return req.getReqType() == RequestType::REQ_HANDLER3;
  93.     }
  94.     void processRequest(const Reqest & req) override
  95.     {
  96.         cout << "Handler3 is handle reqest: " << req.getDescription() << endl;
  97.     }
  98. };
  100. int main(){
  101.     //创建责任链
  102.     Handler1 h1;
  103.     Handler2 h2;
  104.     Handler3 h3;
  105.     h1.setNextChain(&h2);
  106.     h2.setNextChain(&h3);
  107.     //创建一个请求
  108.     Reqest req("process task ... ", RequestType::REQ_HANDLER3);
  109.     //用责任链处理请求
  110.     h1.handle(req);
  112.     return 0;
  113. }

结构

image.png

要点总结

要点一

【要点一】职责链模式的应用场景在于“一个请求可能有多个接受者，但是最后真正的接受者只有一个”
这时候请求发送者与接受者的耦合有可能出现“变化脆弱”的症状，职责链的目的就是将二者解耦，从而更好地应对变化。

【核心思想】请求者，只需把球踢给第一个处理者，至于以后怎么办，具体是谁处理的。请求者并不关心，他只关心你处理的结果。

要点二

【要点二】应用了职责链模式后，对象的职责分派将更具有灵活性。如果可以在运行时动态添加/修改请求的处理职责。

要点三

【要点三】如果请求传递到职责链的末尾仍得不到处理，应该有一个合理的缺省机制。这也是每个接受对象的责任，而不是发出请求对象的责任。