C++设计模式-责任链模式

版权声明：若无来源注明，Techie亮博客文章均为原创。 转载请以链接形式标明本文标题和地址：
本文标题：C++设计模式-责任链模式本文地址：http://techieliang.com/2017/12/811/

文章目录

• 1. 介绍
• 2. 范例

1. 介绍

• 抽象处理者 Handler
  定义一个请求的处理方法handleMessage，唯一对外开放的方法；定义一个链的编排方法setNext，设置下一个处理者；定义了具体的请求者必须实现的两个方法：定义自己能够处理的级别getHandlerLevel和具体的处理任务echo
• 具体处理者 ConcreteHandler
  实现抽象方法
• 请求发出者Client
  发出请求

优点： 请求和处理分开

缺点：

• 性能问题，每个请求都是从链头遍历到链尾，特别是在链比较长的时候。
• 调试不很方便，采用了类似递归的方式，调试的时候逻辑可能比较复杂

避免出现超长链的情况， 一般的做法是在Handler中设置一个最大节点数量， 在setNext方法中判断是否已经是超过其阈值， 超过则不允许该链建立， 避免无意识地破坏系统性能

2. 范例

抽象处理者

1. #ifndef HANDLER_H
2. #define HANDLER_H
3. #include "request.h"
4. #include "response.h"
5. class Handler {
6. private:
7. Handler *nextHandler;
8. //每个处理者都必须对请求做出处理
9. public:
10. virtual Response handleMessage(Request *request) final{
11. Response response;
12. //判断是否是自己的处理级别
13. if(getHandlerLevel() == request->getRequestLevel()){
14. response = echo(request);
15. }else{ //不属于自己的处理级别
16. }
17. //判断是否有下一个处理者
18. //注意此处如果已经符合了级别并处理完成了消息还会继续向下传
19. //若只需要当前级别消息被一次处理只需要将下属判断你放到上面的else内
20. if(nextHandler != nullptr){
21. response = nextHandler->handleMessage(request);
22. }else{//没有其他的处理者
23. }
24. return response;
25. }
26. //设置下一个处理者是谁
27. voidsetNext(Handler *handler){
28. nextHandler = handler;
29. }
30. protected:
31. //每个处理者都有一个处理级别
32. virtual Level getHandlerLevel() = 0;
33. //每个处理者都必须实现处理任务
34. virtual Response echo(Request *request) = 0;
35. };
36. #endif // HANDLER_H

处理者

1. #ifndef CONCRETEHANDLER_H
2. #define CONCRETEHANDLER_H
3. #include "handler.h"
4. #include "level.h"
5. #include "response.h"
6. class ConcreteHandler1 : public Handler {
7. protected:
8. Response echo(Request *request) override {
9. qDebug()<<"Handler1 echo request";
10. //处理请求并返回结果
11. returnResponse();
12. }
13. //设置自己的处理级别
14. Level getHandlerLevel() override {
15. return Level1;
16. }
17. };
18. //还有第二第三个省略了
19. #endif // CONCRETEHANDLER_H

处理请求的级别

1. #ifndef LEVEL_H
2. #define LEVEL_H
3. enum Level {
4. Level1 = 0,
5. Level2,
6. };
7. #endif // LEVEL_H

抽象处理请求和具体处理请求

1. #ifndef REQUEST_H
2. #define REQUEST_H
3. #include "level.h"
4. class Request {
5. public:
6. virtual Level getRequestLevel() = 0;
7. };
8. class Request1 : public Request{
9. public:
10. Level getRequestLevel() override {
11. return Level1;
12. }
13. };
14. class Request2 : public Request{
15. public:
16. Level getRequestLevel() override {
17. return Level2;
18. }
19. };
20. #endif // REQUEST_H

处理结果

1. #ifndef RESPONSE_H
2. #define RESPONSE_H
3. #include "QDebug"
4. class Response {
5. public:
6. voidtext(){
7. qDebug()<<"get text";
8. }
9. };
10. #endif // RESPONSE_H

main

1. #include "concretehandler.h"
2. #include "request.h"
3. #include "response.h"
4. intmain(int argc, char *argv[]){
5. //声明所有的处理节点
6. Handler *handler1 = newConcreteHandler1();
7. Handler *handler2 = newConcreteHandler2();
8. Handler *handler3 = newConcreteHandler3();
9. //设置链中的阶段顺序1-->2-->3
10. handler1->setNext(handler2);
11. handler2->setNext(handler3);
12. //提交请求， 返回结果
13. Response response = handler1->handleMessage(newRequest1());
14. response = handler1->handleMessage(newRequest2());
15. }

结果

1. Handler1 echo request
2. Handler3 echo request
3. Handler2 echo request

上述例子一共发了两次请求有三个响应是因为在抽象处理者中，无论是否消息已处理均向下传播保证消息遍历所有处理者，可以在处理成功后直接结束避免一个请求被多个不同处理者处理

源码GitHub：CppDesignPattern
相关链接：C++设计模式

转载请以链接形式标明本文标题和地址：Techie亮博客 » C++设计模式-责任链模式