责任链模式也叫做职责链模式、职责连锁模式。在该模式下,很多对象由每一个对象对其下家的引用而连接起来形成一条链,请求在这个链上传递,直到某个对象处理了该请求。在链上的处理者有两个选择,一个是处理该请求,一个是将请求推给下一家。一个请求最终可能会出现没有被处理的情况。

例如客户把一个请求交给A,A完成了a部分之后,把任务交给B,B完成了b部分交给C,C完成了c部分后,交给D。此时D判断能否完成d部分,能完成,则完成它,不能完成,则不完成,然后将结果通知客户。

优点:

  • 责任的分担。每个类只需要处理自己负责的工作即可,不能处理的推给下一个对象,明确了各类的责任范围,符合类的最小封装原则。

  • 可以根据需要自由组合工作流程。如果工作流程发生变化,可通过重新分配对象链便可重新适用新的工作流程

  • 类和类直接按以松耦合的形式加以组织。

缺点:

  • 不能保证请求一定被接收

  • 系统性能将受到一定影响,而且在进行代码调试时不太方便,可能会造成循环调用

  • 可能不容易观察运行时的特征,有碍于除错

类图如下:


示例代码如下:

#include <iostream>

using namespace std;

/* 抽象基类 */
class Handle
{
public:
	virtual ~Handle() { }

	virtual void HandleRequest() = 0;

	/* 设置下一对象地址 */
	void SetSuccessor(Handle *succ)
	{
		_succ = succ;
	}

	Handle* GetSuccessor()const
	{
		return _succ;
	}

protected:
	Handle() { _succ = NULL; }

	Handle(Handle* succ)
	{
		_succ = succ;
	}
private:
	Handle* _succ;
};

/* 具体实现子类A */
class ConcreteHandleA :public Handle
{
public:
	ConcreteHandleA() { }

	ConcreteHandleA(Handle* succ) :Handle(succ)
	{
		;
	}

	void HandleRequest()
	{
		if (this->GetSuccessor() != NULL)
		{
			/*处理自己负责的部分后,推给下一对象*/
			cout << "ConcreteHandleA--Successor" << endl;
			GetSuccessor()->HandleRequest();
		}
		else
		{
			/*处理自己负责的部分,此时不存在下一对象*/
			cout << "ConcreteHandleA::HandleRequest" << endl;
		}
	}
};

/* 具体实现子类B */
class ConcreteHandleB :public Handle
{
public:
	ConcreteHandleB() { }

	ConcreteHandleB(Handle* succ) :Handle(succ)
	{
		;
	}

	void HandleRequest()
	{
		if (this->GetSuccessor() != NULL)
		{
			/*处理自己负责的部分后,推给下一对象*/
			cout << "ConcreteHandleB--Successor" << endl;
			GetSuccessor()->HandleRequest();
		}
		else
		{
			/*处理自己负责的部分,此时不存在下一对象*/
			cout << "ConcreteHandleB::HandleRequest" << endl;
		}
	}
};

int main()
{
	Handle *h1 = new ConcreteHandleA();
	Handle *h2 = new ConcreteHandleB();
	h1->SetSuccessor(h2);

	h1->HandleRequest();

	delete h1;
	delete h2;

	cin.get();
	cin.get();
	return 0;
}

运行结果如下: