[设计模式]ChainOfResponsibility责任链模式

最新推荐文章于 2022-05-13 10:08:23 发布

ouyangshima

最新推荐文章于 2022-05-13 10:08:23 发布

阅读量2.9k

点赞数

分类专栏：模式架构

本文链接：https://blog.csdn.net/shimazhuge/article/details/8491285

版权

模式架构专栏收录该内容

42 篇文章 2 订阅

订阅专栏

顾名思义，责任链模式是一条链，链上有多个节点，每个节点都有各自的责任。当有输入时，第一个责任节点看自己能否处理该输入，如果可以就处理。如果不能就交由下一个责任节点处理。依次类推，直到最后一个责任节点。

问题

熟悉VC/MFC的都知道，vc是”基于消息，事件驱动”，消息在vc开发中起着举足轻重的作用。在MFC中，消息是通过一个向上递交的方式进行处理，例如一个WM_Command消息的查出来流程可能为

1）MDI主窗口收到命令消息WM_Command,其ID位ID_XXX
2）MDI主窗口将消息传给当前活动的MDI子窗口
3）MDI子窗口给自己的子窗口(View)一个处理机会，将消息交给View
4）View检查自己MessageMap
5）如果View没有发现处理该消息的程序，则将该消息传其对应的Document对象；否则View处理，消息流程结束
6）Document检查自己MessageMap，如果没有该消息的处理程序，则该消息传给其对象的DocumentTemplate处理，否则自己处理，消息流程结束
7）如果在6）中消息没有得到处理，则将消息返回给view
8）View再传回给MDI子窗口
9）MID子窗口将该消息传给CwinApp对象，CwinApp为所有无主的消息提供了处理

MFC提供了消息的处理的链式处理策略，处理消息的请求将沿着预先定义好的路径依次进行处理。消息的发送者并不知道该消息最后是由哪个具体对象处理的，当然它也无须也不想知道，但是结果是该消息被某个对象处理了，或者一直到一个终极的对象进行处理了。

普通员工发起一个请假申请，当请假天数小于3天时只需要得到主管批准即可；当请假天数大于3天时，主管批准后还需要提交给经理审批，经理审批通过，若请假天数大于7天还需要进一步提交给总经理审批。

ChainOfResponsibility模式描述其实就是这样一类问题将可能处理一个请求的对象链接成一个链，并将请求在这个链上传递，直到对象处理该请求。

ChainOfResponsibility

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。 顾名思义，责任链模式为请求创建了一个接收者对象的链。对请求的发送者和接收者进行解耦。

抽象处理者(Handler)角色：定义出一个处理请求的接口。如果需要，接口可以定义出一个方法以设定和返回对下家的引用。因此抽象处理者本身还包含了一个本身的引用（ successor）作为其对下家的引用，以便将处理者链成一条链；
具体处理者(ConcreteHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

关键代码：Handler里面聚合它自己，在 HandlerRequest 里判断是否合适，如果没达到条件则向下传递，向谁传递之前先 set 进去。
优点：降低耦合度。它将请求的发送者和接收者解耦。
使用场景：有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定；需要动态指定处理者的时候
适用于：链条式处理事情。工作流程化、消息处理流程化、事物流程化；
应用实例： 1、红楼梦中的"击鼓传花"。 2、JS 中的事件冒泡
缺点：因为对象不知道是其它哪一个对象处理其请求的，所以职责链模式不保证对象被接收。

对责任链的理解，关键在于对链的理解，即包含如下两点：

链是一系列节点的集合，在责任链中，节点实质上是指请求的处理者；
链的各节点可灵活拆分再重组，在责任链中，实质上就是请求发送者与请求处理者的解耦。

小demo

chainOfResponsibility.h

#ifndef CHAINOFRESPONSIBILITY_H
#define CHAINOFRESPONSIBILITY_H

#include <stdio.h>

// 抽象基类,定义一个处理请求的接口
class Handler
{
public:
	Handler(Handler *pSuccessor = NULL);//设置参数，下一个待处理者，可以形成链
        //构造函数中传参，也可以改赵成一个独立的函数
        void setHandlerSuccessor(Handler *pSuccessor = NULL)
        {
            m_pSuccessor = pSuccessor;
        }

	virtual ~Handler();

	// 纯虚函数,由派生类实现
	virtual void HandleRequset() = 0;
protected:
	Handler* m_pSuccessor;
};

class ConcreateHandler1 : public Handler
{
public:
	ConcreateHandler1(Handler *pSuccessor = NULL) : Handler(pSuccessor){}
	virtual ~ConcreateHandler1(){}

	virtual void HandleRequset();
};

class ConcreateHandler2 : public Handler
{
public:
	ConcreateHandler2(Handler *pSuccessor = NULL) : Handler(pSuccessor){}
	virtual ~ConcreateHandler2(){}

	virtual void HandleRequset();
};

#endif

chainOfResponsibility.cpp

#include "ChainOfResponsibility.h"
#include <iostream>

Handler::Handler(Handler *pSuccessor /* = NULL*/) 	: m_pSuccessor(pSuccessor)
{
}

Handler::~Handler()
{
	delete m_pSuccessor;
	m_pSuccessor = NULL;
}

void ConcreateHandler1::HandleRequset()
{
	if (NULL != m_pSuccessor)
	{
		m_pSuccessor->HandleRequset();
		std::cout << "ConcreateHandler1::HandleRequset()\n";
	}
	else
	{
		std::cout << "HandleRequset by ConcreateHandler1\n";
	}
}

void ConcreateHandler2::HandleRequset()
{
	if (NULL != m_pSuccessor)
	{
		m_pSuccessor->HandleRequset();
		std::cout << "ConcreateHandler2::HandleRequset()\n";
	}
	else
	{
		std::cout << "HandleRequset by ConcreateHandler2\n";
	}
}

main.cpp

#include "ChainOfResponsibility.h"
#include <stdlib.h>

int main()
{
	Handler *p1 = new ConcreateHandler1();
	Handler *p2 = new ConcreateHandler2(p1);
	p2->HandleRequset();

	p1->HandleRequset();//没有后继对象，就得自己处理了
        
        // p1->setHandlerSuccessor(p2);//可以让用户来自己设置
	delete p2;
	system("pause");
	return 0;
}

输出结果：