C++设计模式实现--职责链(Chain of Responsibility)模式

一. 概述

职责链模式：

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

二. 举个例子

员工要求加薪

公司的管理者一共有三级：总经理、总监、经理，如果一个员工要求加薪，应该向主管的经理申请，如果加薪的数量在经理的职权内，那么经理可以直接批准，否则将申请上交给总监。总监的处理方式也一样，总经理可以处理所有请求。这就是典型的职责链模式，请求的处理形成了一条链，直到有一个对象处理请求。

结构图如下：

假设：

经理可以处理薪水的范围在：0~500
总监可以处理薪水的范围在：500~1000
总经理可以处理薪水的范围在：1000~2000

则代码如下：

[cpp]  view plain copy

1. //  
2. //抽象处理类  
3. class Handle  
4. {  
5. public:  
6.     virtual ~Handle()  
7.     {  
8.         delete _succ;  
9.     }  
10.   
11.     virtual void HandleRequest(int request) = 0;  
12.       
13.     //设置其上级  
14.     void SetSuccessor(Handle* succ)  
15.     {  
16.         _succ = succ;  
17.     }  
18.   
19.     Handle* GetSuccessor()  
20.     {  
21.         return _succ;  
22.     }  
23.   
24. protected:  
25.     Handle()  
26.     {  
27.         _succ = NULL;  
28.     }  
29.   
30. private:  
31.     Handle* _succ;  
32. };  
33.   
34. //具体处理类 A  
35. class ConcreteHandleA: public Handle  
36. {  
37. public:  
38.     void HandleRequest(int request)  
39.     {  
40.         if (request >= 0 && request < 500)  
41.         {  
42.             cout << "ConcreteHandleA deal with: " << request <<endl;  
43.         }  
44.         else if (this->GetSuccessor() != NULL)  
45.         {  
46.             this->GetSuccessor()->HandleRequest(request);  
47.         }  
48.         else  
49.         {  
50.             cout << "Can't deal with " << request << endl;  
51.         }  
52.     }  
53. };  
54.   
55. //具体处理类 B  
56. class ConcreteHandleB: public Handle  
57. {  
58. public:  
59.     void HandleRequest(int request)  
60.     {  
61.         if (request >= 500 && request < 1000)  
62.         {  
63.             cout << "ConcreteHandleB deal with: " << request <<endl;  
64.         }  
65.         else if (this->GetSuccessor() != NULL)  
66.         {  
67.             this->GetSuccessor()->HandleRequest(request);  
68.         }  
69.         else  
70.         {  
71.             cout << "Can't deal with " << request << endl;  
72.         }  
73.     }  
74. };  
75.   
76. //具体处理类 C  
77. class ConcreteHandleC: public Handle  
78. {  
79. public:  
80.     void HandleRequest(int request)  
81.     {  
82.         if (request >= 1000 && request < 2000)  
83.         {  
84.             cout << "ConcreteHandleC deal with: " << request <<endl;  
85.         }  
86.         else if (this->GetSuccessor() != NULL)  
87.         {  
88.             this->GetSuccessor()->HandleRequest(request);  
89.         }  
90.         else  
91.         {  
92.             cout << "Can't deal with " << request << endl;  
93.         }  
94.     }  
95. };  
96.   
97. //  
98. //测试   
99. int main()    
100. {  
101.     Handle* h1 = new ConcreteHandleA();  
102.     Handle* h2 = new ConcreteHandleB();  
103.     Handle* h3 = new ConcreteHandleC();  
104.   
105.     //设置其上级  
106.     h1->SetSuccessor(h2);  
107.     h2->SetSuccessor(h3);  
108.   
109.     h1->HandleRequest(300);  
110.     h1->HandleRequest(600);  
111.     h1->HandleRequest(1500);  
112.     h1->HandleRequest(3000);  
113.   
114.     delete h1;  
115.     delete h2;  
116.     delete h3;  
117.   
118.     return 0;   
119. }  

三. 说明

1. 职责链的特点是：当客户提交一个请求时，请求是沿链传递直至有一个ConcreteHandler对象负责处理它。

2. 职责链的好处是：请求者不用管哪个对象来处理，反正该请求会被处理。它只需保持一个后继者即可。

3. 要注意的是：一个请求到链的最后可能也没有处理，所以一定要配置得当。