设计模式之责任链模式
责任链模式，使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象练成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。该模式很好理解，其UML图如下：
每个ConcreteHandler都有一定的请求处理能力，当自己处理不了的时候就把请求转移给自己的后继者。所以每个ConcreteHandler都有一个Handler的引用。示例代码如下：
1 // ChainofResponsibilityModel.h文件
2 #pragma once
3 #include <iostream>
4
5 class Handler
6 {
7 protected:
8 Handler * m_sucessor;
9 public:
10 void setSucessor(Handler * p)
11 {
12 m_sucessor = p;
13 }
14 virtual void processRequest(int n) = 0;
15 };
16
17 class ConcreteHandler_0 : public Handler
18 {
19 public:
20 void processRequest(int n)
21 {
22 if (n > 0 && n <= 10)
23 {
24 std::cout << "ConcreteHandler_0 process the request!" << std::endl;
25 }
26 else if (nullptr != m_sucessor)
27 {
28 m_sucessor->processRequest(n);
29 }
30 else
31 {
32 std::cout << "Cannot process the request!" << std::endl;
33 }
34 }
35 };
36
37 class ConcreteHandler_1 : public Handler
38 {
39 public:
40 void processRequest(int n)
41 {
42 if (n > 10 && n <= 20)
43 {
44 std::cout << "ConcreteHandler_1 process the request!" << std::endl;
45 }
46 else if (nullptr != m_sucessor)
47 {
48 m_sucessor->processRequest(n);
49 }
50 else
51 {
52 std::cout << "Cannot process the request!" << std::endl;
53 }
54 }
55 };
56
57 class ConcreteHandler_2 : public Handler
58 {
59 public:
60 void processRequest(int n)
61 {
62 if (n > 20 && n <= 30)
63 {
64 std::cout << "ConcreteHandler_2 process the request!" << std::endl;
65 }
66 else if (nullptr != m_sucessor)
67 {
68 m_sucessor->processRequest(n);
69 }
70 else
71 {
72 std::cout << "Cannot process the request!" << std::endl;
73 }
74 }
75 };
测试代码如下：
#include <iostream>
#include "ChainofResponsibilityModel.h"
int main()
{
using namespace std;
// 责任链模式
Handler *p = new ConcreteHandler_0();
Handler * p1 = new ConcreteHandler_1();
Handler * p2 = new ConcreteHandler_2();
p->setSucessor(p1);
p1->setSucessor(p2);
p->processRequest(10);
p->processRequest(26);
p->processRequest(15);
p->processRequest(100);
delete p1;
delete p2;
delete p;
getchar();
return 0;
}
其测试结果如下图：
责任链模式的优点是当客户提交一个请求时，请求时沿链传递直至有一个ConcreteHandler对象负责处理它。这就使得接收者和发送者都没有对方的明确信息，且链中的对象自己也不知道链的结构。结果是责任链可简化对象的相互连接，它们仅需保持一个指向后继的引用，而不需保持它素有的候选接收者的引用。而链的结构是由客户端来定义的。可以随时增加或修改吃力一个请求的结构。增强了给对象指派职责的灵活性。