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

问题

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

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

ChainOfResponsibility

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

解析：

Handle：抽象基类，定义一个处理请求的接口，在图中这个接口就是HandleRequest(),这个类同时有一个指向Handler对象的指针，指向后续的处理请求的对象(如果有的话)。

ChainOfResponsibility模式中ConcreteHandler将自己的后继对象(向下传递消息的对象)记录在自己的后续表中，当一个请求到来时，ConcreteHandler会先检查看自己有没有匹配的处理程序，如果有就自己处理，否则传递给它的后继。当然这里示例程序中为了简化，ConcreteHandler只是简单的检查看自己有没有后继，有的话将请求传递给后继进行处理。

小demo

chainOfResponsibility.h

#ifndef CHAINOFRESPONSIBILITY_H
#define CHAINOFRESPONSIBILITY_H

#include <stdio.h>

// 抽象基类,定义一个处理请求的接口
class Handler
{
public:
	Handler(Handler *pSuccessor = NULL);
	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();//没有后继对象，就得自己处理了
	delete p2;
	system("pause");
	return 0;
}

输出结果：

 

ChainOfResponsibility模式的最大的一个特点就是给系统降低了耦合性，请求的发送者完全不必知道该请求会被哪个应答对象处理，极大地降低了系统的耦合性。