设计模式之职责链模式(Chain of Responsibility)

转自:waringgh

意图:

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

 

举例:

辛辛苦苦了工作了一年,终于可以加薪了,向主管提交了加薪申请,主管一看不得了,自己职权不够,批不了,主管把申请上交总监,总监发现自己也批不了,申请到了总经理手中,总经理一看,小伙子口气不小了,有胆识敢申请,先来谈下心。预知后事如何,请看下回分解。


注:每次都是提交你的请求给你的上级就行了,再由你的上级提交给你的上级。


这就是典型的职责链模式,请求的处理形成了一条链,直到有一个对象处理请求。责任链模式是一种对象的行为模式。在责任链模式里,很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递,直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求,这使得系统可以在不影响客户端的情况下动态地重新组织链和分配责任。


UML类图:


抽象处理者(Handler)角色:定义出一个处理请求的接口。如果需要,接口可以定义出一个方法,以设定和返回对下家的引用。这个角色通常由一个抽象类或接口实现。

具体处理者(ConcreteHandler)角色:具体处理者接到请求后,可以选择将请求处理掉,或者将请求传给下家。由于具体处理者持有对下家的引用,因此,如果需要,具体处理者可以访问下家。

 

代码实现:

[cpp]  view plain copy
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. class Handler  
  5. {  
  6. protected:  
  7.     Handler *successor;  
  8. public:  
  9.     Handler() : successor(NULL){}  
  10.     void SetSuccessor(Handler *successor)  
  11.     {  
  12.         this->successor = successor;  
  13.     }  
  14.     virtual void HandleRequest(int request) = 0;  
  15. };  
  16.   
  17. class ConcreteHandler1 : public Handler  
  18. {  
  19.     virtual void HandleRequest(int request)  
  20.     {  
  21.         if (request>=0 && request<10) {  
  22.             cout<<"ConcreteHandler1处理请求"<<request<<endl;  
  23.         } else if (successor) {  
  24.             successor->HandleRequest(request);  
  25.         }  
  26.     }  
  27. };  
  28.   
  29. class ConcreteHandler2 : public Handler  
  30. {  
  31.     virtual void HandleRequest(int request)  
  32.     {  
  33.         if (request>=10 && request<20) {  
  34.             cout<<"ConcreteHandler2处理请求"<<request<<endl;  
  35.         } else if (successor) {  
  36.             successor->HandleRequest(request);  
  37.         }  
  38.     }  
  39. };  
  40.   
  41. class ConcreteHandler3 : public Handler  
  42. {  
  43.     virtual void HandleRequest(int request)  
  44.     {  
  45.         if (request>=20 && request<30) {  
  46.             cout<<"ConcreteHandler3处理请求"<<request<<endl;  
  47.         } else if (successor) {  
  48.             successor->HandleRequest(request);  
  49.         }  
  50.     }  
  51. };  
  52.   
  53. int main(int argc, char **argv)  
  54. {  
  55.     Handler *h1 = new ConcreteHandler1();  
  56.     Handler *h2 = new ConcreteHandler2();  
  57.     Handler *h3 = new ConcreteHandler3();  
  58.   
  59.     h1->SetSuccessor(h2);  
  60.     h2->SetSuccessor(h3);  
  61.     int request[9] = {2,5,14,22,18,3,27,20,33};  
  62.     for (int i=0; i<9; ++i) {  
  63.         h1->HandleRequest(request[i]);  
  64.     }  
  65.     system("pause");  
  66.     return 0;  
  67. }  

大话设计模式中的例子:

[cpp]  view plain copy
  1. #include <iostream>  
  2. #include <string>  
  3. using namespace std;  
  4.   
  5. class Request  
  6. {  
  7. private:  
  8.     string requestType;  
  9.     string requestContent;  
  10.     int requestNum;  
  11. public:  
  12.     void SetRequestType(string requestType)   
  13.     {  
  14.         this->requestType = requestType;  
  15.     }  
  16.   
  17.     string GetRequestType() const  
  18.     {  
  19.         return requestType;  
  20.     }  
  21.   
  22.     void SetRequestContent(string requestContent)  
  23.     {  
  24.         this->requestContent = requestContent;  
  25.     }  
  26.   
  27.     string GetRequestContent() const  
  28.     {  
  29.         return requestContent;  
  30.     }  
  31.   
  32.     void SetRequestNum(int requestNum)  
  33.     {  
  34.         this->requestNum = requestNum;  
  35.     }  
  36.   
  37.     int GetRequestNum() const  
  38.     {  
  39.         return requestNum;  
  40.     }  
  41.   
  42. };  
  43.   
  44. class Manager  
  45. {  
  46. protected:  
  47.     string name;  
  48.     Manager *superior;  
  49. public:  
  50.     Manager(string name) : name(name), superior(NULL){}  
  51.     void SetSuperior(Manager *superior)  
  52.     {  
  53.         this->superior = superior;  
  54.     }  
  55.     virtual void RequestApplications(Request *request) = 0;  
  56. };  
  57.   
  58. class CommonManager : public Manager  
  59. {  
  60. public:  
  61.     CommonManager(string name) : Manager(name){}  
  62.     virtual void RequestApplications(Request *request)  
  63.     {  
  64.         if (request->GetRequestType()=="请假" && request->GetRequestNum()<=2) {  
  65.             cout<<name<<":"<<request->GetRequestContent()<<"数量"  
  66.                 <<request->GetRequestNum()<<"被批准"<<endl;  
  67.         } else {  
  68.             if(superior) {  
  69.                 superior->RequestApplications(request);  
  70.             }  
  71.         }  
  72.     }  
  73. };  
  74.   
  75. class Majordomo : public Manager  
  76. {  
  77. public:  
  78.     Majordomo(string name) : Manager(name){}  
  79.     virtual void RequestApplications(Request *request)  
  80.     {  
  81.         if (request->GetRequestType()=="请假" && request->GetRequestNum()<=5) {  
  82.             cout<<name<<":"<<request->GetRequestContent()<<"数量"  
  83.                 <<request->GetRequestNum()<<"被批准"<<endl;  
  84.         } else {  
  85.             if(superior) {  
  86.                 superior->RequestApplications(request);  
  87.             }  
  88.         }  
  89.     }  
  90. };  
  91.   
  92. class GeneralManager : public Manager  
  93. {  
  94. public:  
  95.     GeneralManager(string name) : Manager(name){}  
  96.     virtual void RequestApplications(Request *request)  
  97.     {  
  98.         if (request->GetRequestType()=="请假" ) {  
  99.             cout<<name<<":"<<request->GetRequestContent()<<"数量"  
  100.                 <<request->GetRequestNum()<<"被批准"<<endl;  
  101.         } else if (request->GetRequestType()=="加薪" && request->GetRequestNum()<=500) {  
  102.             cout<<name<<":"<<request->GetRequestContent()<<"数量"  
  103.                 <<request->GetRequestNum()<<"被批准"<<endl;  
  104.         } else  if (request->GetRequestType()=="加薪" && request->GetRequestNum()>500) {  
  105.             cout<<name<<":"<<request->GetRequestContent()<<"数量"  
  106.                 <<request->GetRequestNum()<<"再说吧"<<endl;  
  107.             }  
  108.         }  
  109. };  
  110.   
  111. int main(int argc, char **argv)  
  112. {  
  113.     CommonManager *Zhangsan = new CommonManager("张三");  
  114.     Majordomo *Lisi = new Majordomo("李四");  
  115.     GeneralManager *Wangwu = new GeneralManager("王五");  
  116.     Zhangsan->SetSuperior(Lisi);  
  117.     Lisi->SetSuperior(Wangwu);  
  118.   
  119.     Request *request = new Request();  
  120.     request->SetRequestType("请假");  
  121.     request->SetRequestContent("hlj请假");  
  122.     request->SetRequestNum(2);  
  123.     Zhangsan->RequestApplications(request);  
  124.   
  125.     Request *request1 = new Request();  
  126.     request1->SetRequestType("请假");  
  127.     request1->SetRequestContent("hlj请假");  
  128.     request1->SetRequestNum(4);  
  129.     Zhangsan->RequestApplications(request1);  
  130.   
  131.     Request *request2 = new Request();  
  132.     request2->SetRequestType("加薪");  
  133.     request2->SetRequestContent("hlj请求加薪");  
  134.     request2->SetRequestNum(500);  
  135.     Zhangsan->RequestApplications(request2);  
  136.   
  137.     Request *request3 = new Request();  
  138.     request3->SetRequestType("加薪");  
  139.     request3->SetRequestContent("hlj请求加薪");  
  140.     request3->SetRequestNum(1000);  
  141.     Zhangsan->RequestApplications(request3);  
  142.   
  143.     system("pause");  
  144.     return 0;  
  145. }  

要点与实现:

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

2.责任链模式并不创建责任链。责任链的创建必须由系统的其它部分创建出来。

3.责任链模式降低了请求的发送端和接收端之间的耦合,使多个对象都有机会处理这个请求。一个链可以是一条线,一个树,也可以是一个环。如下图所示,责任链是一个树结构的一部分。




评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值