【行为型】Chain of responsibility模式

职责链模式将对象的请求处理组成链式结构,并将请求按链式结构逐个传递下去,直接被其中的某个处理者处理为止。由此可知,职责链模式的适用场合是对指定请求,可以有多个请求处理者(或称为请求响应者),但用户并不知道(也不需要知道--------此如做到请求者与响应者的解耦合)当时运行环境下该请求会被具体的哪个处理者处理(又或者说完全都没有被响应)。请求者只是抛出一个请求,响应链内部(即:模式内部)自己决定是否能处理以及谁能处理该请求。该模式的类结构图参考如下:

模式的编码结构参考如下:

 1 namespace chain_of_responsibility
 2 {
 3     class IHandler
 4     {
 5     public:
 6         IHandler(IHandler* pNextHandler) : m_pNextHandler(pNextHandler) {}
 7         virtual ~IHandler() {}
 8         virtual bool handleRequest(/*requester type parameters here........*/) { /*do something here........*/return false; }
 9
10     private:
11         IHandler* m_pNextHandler;
12
13     };//class IHandler
14
15     class ConcreteHandler1 : public IHandler
16     {
17     public:
18         // some code here........
19         virtual bool handleRequest(/*requester type parameters here........*/) {
20             /*
21             if (can handle this request) {
22                 do something here........
23                 return true;
24             } else if (nullptr != m_pNextHandler) {
25                 return m_pNextHandler->handleRequest(the parameters........);
26             }
27             */
28             return false;
29         }
30
31     };//class ConcreteHandler1
32
33     class ConcreteHandler2 : public IHandler
34     {
35     public:
36         // some code here........
37         virtual bool handleRequest(/*requester type parameters here........*/) {
38             /*
39             if (can handle this request) {
40             do something here........
41                 return true;
42             } else if (nullptr != m_pNextHandler) {
43                 return m_pNextHandler->handleRequest(the parameters........);
44             }
45             */
46             return false;
47         }
48
49     };//class ConcreteHandler2
50
51     class IRequester {};
52
53     class Client
54     {
55     public:
56         void test() {
57             //
58             // they are test code below.
59             //
60             auto pRequester = new (std::nothrow) IRequester();
61             auto pHandler1 = new (std::nothrow) ConcreteHandler1(nullptr);
62             auto pHandler2 = new (std::nothrow) ConcreteHandler2(pHandler1);
63             pHandler1->handleRequest(pRequester);
64         }
65
66     };//class Client
67
68 }//namespace chain_of_responsibility

职责链模式编码结构参考

职责链主要适合于对某个问题有多种解方式,并且是要在具体的环境下才能具体确定解方式。只是在设计层面上,将所有解方式链成一条链的形式,从链头到链尾逐个传递下去直到问题被某中的某个(当然也有可能都没有)解给处理掉,然后终止。即:只要有解,则解完成后传递终止,否则直至链尾。

职责链模式的好处是,将请求与请求的处理解耦合掉,使得客户不需要依赖于所有解对象,也不需要关心最终请求是被哪个解给处理,客户只关心结果。但是职责链模式在设计上,一定要注意:有些问题的解是要按具体到一般化方向链接的,否则就会出现逻辑上的问题。举例:旅游经费审批问题。

1) 当旅游经费开支 <= 1000RMB时,只需要团队的项目经理审批即可;

2) 当旅游经费开支 > 1000RMB 并且 <= 2000RMB时,需要部门主管审批才可;

3) 当旅游经费 > 2000RMB 并且 <= 3000RMB时,需要区域经理审批才可;

4) 当旅游经费高于 3000RMB时,则需要集团总裁审批。

从以上审批权限来看,项目经理的权限最低,而越往上,职位地高审批的经费额度越大。因此,假如现在开支是2345RMB,则明显的需要区域经理或更高级别的(集团总栽)审批才可以。此时问题就来了,那现在是要让集团总裁审批还是要让区域经理审批了?因为区域经理对具体的业务肯定会比集团总裁更了解,他也肯定更加清楚这笔经费的消费具体细节,理论上,是要区域经理批就可以了。而集团总栽他更注重的应该是集团公司的更大层面的问题,而不应该是这些小问题上,要不集团总栽就没有必要把审批权限开给区域经理了。所以,理论上,该笔消费应该要让区域经理来审批,只有数额大到区域经理审批不了(权限不足)时,才需要进一步上报给集团总栽,由总栽来审批。

另外,如果问题的解有非常多的情况下,其实也会给程序在调试上带来一定的影响。往往需要将所有解都要设置断点(即:断点要打很多个地方)。

时间: 2024-08-03 23:20:24

【行为型】Chain of responsibility模式的相关文章

Java 实现责任链(Chain of Responsibility)模式

类图 /** * 抽象责任 * @author stone * */ public abstract class IFilter { private IFilter successor; public IFilter getSuccessor() { return successor; } public void setSuccessor(IFilter successor) { this.successor = successor; } public abstract void handleF

Chain of Responsibility模式

消息传递是面向对象开发中经常用到的机制,例如异常的传递,如果当前函数/类无法处理异常,可以将其抛到上一层.消息传递类似,如果一个类收到消息,如果当前类无法处理,可以将消息按照预先定义好的路径传递下去,直到有类可以处理这个消息.这就是Chain of Responsibility模式. Handle类中持有自己的指针/引用,指向某一个派生类.如果当前类无法处理消息,则调用派生类来处理. 实现: Handle.h #ifndef _HANDLE_H_ #define _HANDLE_H_ class

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

一. 概述 职责链模式: 使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系.将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止. 二. 举个例子 员工要求加薪 公司的管理者一共有三级:总经理.总监.经理,如果一个员工要求加薪,应该向主管的经理申请,如果加薪的数量在经理的职权内,那么经理可以直接批准,否则将申请上交给总监.总监的处理方式也一样,总经理可以处理所有请求.这就是典型的职责链模式,请求的处理形成了一条链,直到有一个对象处理请求. 结构图如下: 假

Behavioral模式之Chain of Responsibility模式

1.意图 使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系,将这些对象连成一条链,并沿着这条链传递改请求,知道有一个对象处理它为止. 2.别名 无 3.动机 考虑一个图形用户界面中的上下文有关的帮助机制.用户在界面的任一部分上点击就可以以得到帮助信息,所提供的帮助依赖于点击的是界面的哪一部分以及其上下文. 4.适用性 以下情况使用Responsibility模式: 有多个的对象可以处理一个请求,哪个对象处理该请求运行时刻自动确定. 你想在不明确指定接收者的情况下,向多个对象

设计模式之Chain of Responsibility模式(笔记)

职责链模式:使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系.将这些对象连成一条链,沿着该条链处理请求,直到有一个对象处理它为止. 首先定义一个Handle抽象类,定义处理请求的接口 public abstract class Handler { protected Handler superior;//上级 //设置上级 public void setSuperior(Handler superior){ this.superior=superior; } public

设计模式19:Chain Of Responsibility 职责链模式(行为型模式)

Chain Of Responsibility 职责链模式(行为型模式) 请求的发送者与接受者 某些对象请求的接受者可能有多种多样,变化无常…… 动机(Motivation) 在软件构建过程中,一个请求可能被多个对象处理,但是每个请求在运行时只能有一个接受者,如果显示指定,将必不可少地带来请求发送者与接受者的紧耦合. 如何使请求的发送者不需要指定具体的接受者?让请求的接受者自己在运行时决定来处理请求,从而使两者解耦. 意图(Intent) 使多个对象都有机会处理请求,从而避免请求的发送者和接受者

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

23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于怎样创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而一个对象创建型模式将实例化托付给还有一个对象.创建型模式有两个不断出现的主旋律.第一,它们都将关于该系统使用哪些详细的类的信息封装起来.第二,它们隐藏了这些类的实例是怎样被创建和放在一起的.整个系统关于这些对象所知道的是由抽象类所定义的接口.因此,创建型模式在什么被创建,谁创建它,它是怎样被创建的,

23种设计模式之责任链模式(Chain of Responsibility)

责任链模式是一种对象的行为型模式,避免请求发送者与接收者耦合在一起,让多个对象都有可能接收请求,将这些对象连接成一条链,并且沿着这条链传递请求,直到有对象处理它为止.责任链模式不保证每个请求都被接受,由于一个请求没有明确的接收者,那么就不能保证它一定会被处理. 优点: 1)降低了耦合度. 2)增加向对象指定责任的灵活性. 3)由于在一个类中产生的事件可以被发送到组成中的其它类处理器上,类的集合可以作为一个整体. 使用场景: 1)多个对象可以处理一个请求,而其处理器却是未知的. 2)想要在不指定确

Chain of Responsibility Pattern

1.Chain of Responsibility模式:将可能处理一个请求的对象链接成一个链,并将请求在这个链上传递,直到有对象处理该请求(可能需要提供一个默认处理所有请求的类,例如MFC中的CwinApp类). 2.Chain of Responsibility Pattern 结构图 3.实现 1 #ifndef _HANDLE_H_ 2 #define _HANDLE_H_ 3 4 class Handle 5 { 6 public: 7 virtual ~Handle(); 8 virt