[设计模式] 设计模式课程（十九）--职责链模式

概述

• 属于行为型
• 程序需要按顺序处理多个请求时
• 程序需要使用不同方式处理不同种类的请求，且请求类型和顺序预先未知时，将多个处理者连成一条链，接到请求后，询问每个处理者是否能对其进行处理
• 沿责任链传递请求，直到有一个对象处理为止。使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系

• 一个请求可能会被多个对象处理，但每个请求在运行时只能有一个接受者，如果显式指定，将必不可少地带来请求者与接受者的紧耦合
• 如何使请求的发送者不需要指定具体的接受者？让请求的接受者自己在运行时决定来处理请求，从而使二者解耦
• 使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系，将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止
• 使用多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系，将这些对象连成一条链，并沿着这条链传递请求，知道有一个对象处理它为止
• Chain of Responsibility 模式的应用场合在于“一个请求可能有多个接受者，但最后真正的接受者只有一个”，这时候请求发送者与接受者的耦合有可能出现“变化脆弱”的症状，职责链的目的就是将二者解耦，从而更好地应对变化
• 应用了Chain of Responsibility 模式后，对象的职责分派将更具灵活性，可在运行时动态添加/修改请求的处理职责
• 如果请求传递到职责链的末尾仍得不到处理，应该有一个合理的缺省机制，这也是每一个接收对象的职责，而不是发出请求的对象的责任

场景

• 拨打技术支持电话时，多名接听人员接力处理
• 为活动的GUI元素显示上下文帮助信息。当用户鼠标移动到某个元素并按下F1键时，程序检测到指针下的组件并对其发送帮助请求，该请求不断向上传递到该元素的所有容器，直到某个元素能显示帮助信息
• Struct2的拦截器
• jsp servlet 的 Filter
• Tomca 对 Encoding 的处理

结构

• 处理者：声明了所有具体处理者的通用接口
• 基础处理者：放置所有处理者共用的代码
• 具体处理者：处理请求的实际代码，处理者接到具体请求后，决定是否处理，是否沿着链传递请求
• 客户端：根据程序逻辑一次性或动态地生成链，请求可以发给链上的任一个处理者

 示例1

ChainofResponsibility.cpp

• 举例：windows界面
• 25行：用链表实现链，基类的多态指针指向自身，形成多态链表
• 38-45行：整体处理

示例2

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Request{
    public:
        string m_strContent;
        int m_nNumber;
};
class Manager{
    protected:
        Manager* manager;
        string name;
    public:
        Manager(string temp){
            name = temp;
        }
    void SetSuccessor(Manager* temp){
        manager = temp;
    } 
    virtual void GetRequest(Request* request)=0;
};
class CommonManager:public Manager{
    public:
        CommonManager(string strTemp):Manager(strTemp){}
        virtual void GetRequest(Request* request){
            if(request->m_nNumber>=0 && request->m_nNumber<10){
                cout<<name<<"处理了"<<request->m_nNumber<<"个请求"<<endl;
            }else{
                manager->GetRequest(request);
            }
        }
};
class MajorDomo:public Manager{
    public:
        MajorDomo(string name):Manager(name){}
        virtual void GetRequest(Request* request){
            if(request->m_nNumber>=10){
                cout<<name<<"处理了"<<request->m_nNumber<<"个请求"<<endl;
            }
        }
};
int main(){
    Manager* common = new CommonManager("张经理");
    Manager* major = new MajorDomo("李总监");
    common->SetSuccessor(major);
    Request* req = new Request();
    
    req->m_nNumber = 33;
    common->GetRequest(req);
    
    req->m_nNumber=3;
    common->GetRequest(req);
    
    return 0;
}

示例3

// 处理者接口声明了一个创建处理者链的方法。还声明了一个执行请求的方法。
interface ComponentWithContextualHelp is
    method showHelp()


// 简单组件的基础类。
abstract class Component implements ComponentWithContextualHelp is
    field tooltipText: string

    // 组件容器在处理者链中作为“下一个”链接。
    protected field container: Container

    // 如果组件设定了帮助文字，那它将会显示提示信息。如果组件没有帮助文字
    // 且其容器存在，那它会将调用传递给容器。
    method showHelp() is
        if (tooltipText != null)
            // 显示提示信息。
        else
            container.showHelp()


// 容器可以将简单组件和其他容器作为其子项目。链关系将在这里建立。该类将从
// 其父类处继承 showHelp（显示帮助）的行为。
abstract class Container extends Component is
    protected field children: array of Component

    method add(child) is
        children.add(child)
        child.container = this


// 原始组件应该能够使用帮助操作的默认实现...
class Button extends Component is
    // ...

// 但复杂组件可能会对默认实现进行重写。如果无法以新的方式来提供帮助文字，
// 那组件总是还能调用基础实现的（参见 Component 类）。
class Panel extends Container is
    field modalHelpText: string

    method showHelp() is
        if (modalHelpText != null)
            // 显示包含帮助文字的模态窗口。
        else
            super.showHelp()

// ...同上...
class Dialog extends Container is
    field wikiPageURL: string

    method showHelp() is
        if (wikiPageURL != null)
            // 打开百科帮助页面。
        else
            super.showHelp()


// 客户端代码。
class Application is
    // 每个程序都能以不同方式对链进行配置。
    method createUI() is
        dialog = new Dialog("预算报告")
        dialog.wikiPageURL = "http://..."
        panel = new Panel(0, 0, 400, 800)
        panel.modalHelpText = "本面板用于..."
        ok = new Button(250, 760, 50, 20, "确认")
        ok.tooltipText = "这是一个确认按钮..."
        cancel = new Button(320, 760, 50, 20, "取消")
        // ...
        panel.add(ok)
        panel.add(cancel)
        dialog.add(panel)

    // 想象这里会发生什么。
    method onF1KeyPress() is
        component = this.getComponentAtMouseCoords()
        component.showHelp()

示例4

#include <iostream>
#include <string> 
#include <vector>
/**
 * The Handler interface declares a method for building the chain of handlers.
 * It also declares a method for executing a request.
 */
class Handler {
 public:
  virtual Handler *SetNext(Handler *handler) = 0;
  virtual std::string Handle(std::string request) = 0;
};
/**
 * The default chaining behavior can be implemented inside a base handler class.
 */
class AbstractHandler : public Handler {
  /**
   * @var Handler
   */
 private:
  Handler *next_handler_;

 public:
  AbstractHandler() : next_handler_(nullptr) {
  }
  Handler *SetNext(Handler *handler) override {
    this->next_handler_ = handler;
    // Returning a handler from here will let us link handlers in a convenient
    // way like this:
    // $monkey->setNext($squirrel)->setNext($dog);
    return handler;
  }
  std::string Handle(std::string request) override {
    if (this->next_handler_) {
      return this->next_handler_->Handle(request);
    }

    return {};
  }
};
/**
 * All Concrete Handlers either handle a request or pass it to the next handler
 * in the chain.
 */
class MonkeyHandler : public AbstractHandler {
 public:
  std::string Handle(std::string request) override {
    if (request == "Banana") {
      return "Monkey: I'll eat the " + request + ".
";
    } else {
      return AbstractHandler::Handle(request);
    }
  }
};
class SquirrelHandler : public AbstractHandler {
 public:
  std::string Handle(std::string request) override {
    if (request == "Nut") {
      return "Squirrel: I'll eat the " + request + ".
";
    } else {
      return AbstractHandler::Handle(request);
    }
  }
};
class DogHandler : public AbstractHandler {
 public:
  std::string Handle(std::string request) override {
    if (request == "MeatBall") {
      return "Dog: I'll eat the " + request + ".
";
    } else {
      return AbstractHandler::Handle(request);
    }
  }
};
/**
 * The client code is usually suited to work with a single handler. In most
 * cases, it is not even aware that the handler is part of a chain.
 */
void ClientCode(Handler &handler) {
  std::vector<std::string> food = {"Nut", "Banana", "Cup of coffee"};
  for (const std::string &f : food) {
    std::cout << "Client: Who wants a " << f << "?
";
    const std::string result = handler.Handle(f);
    if (!result.empty()) {
      std::cout << "  " << result;
    } else {
      std::cout << "  " << f << " was left untouched.
";
    }
  }
}
/**
 * The other part of the client code constructs the actual chain.
 */
int main() {
  MonkeyHandler *monkey = new MonkeyHandler;
  SquirrelHandler *squirrel = new SquirrelHandler;
  DogHandler *dog = new DogHandler;
  monkey->SetNext(squirrel)->SetNext(dog);

  /**
   * The client should be able to send a request to any handler, not just the
   * first one in the chain.
   */
  std::cout << "Chain: Monkey > Squirrel > Dog

";
  ClientCode(*monkey);
  std::cout << "
";
  std::cout << "Subchain: Squirrel > Dog

";
  ClientCode(*squirrel);

  delete monkey;
  delete squirrel;
  delete dog;

  return 0;
}

Chain: Monkey > Squirrel > Dog

Client: Who wants a Nut?
  Squirrel: I'll eat the Nut.
Client: Who wants a Banana?
  Monkey: I'll eat the Banana.
Client: Who wants a Cup of coffee?
  Cup of coffee was left untouched.

Subchain: Squirrel > Dog

Client: Who wants a Nut?
  Squirrel: I'll eat the Nut.
Client: Who wants a Banana?
  Banana was left untouched.
Client: Who wants a Cup of coffee?
  Cup of coffee was left untouched.

参考

https://refactoringguru.cn/design-patterns/chain-of-responsibility