10 责任链模式

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

例如客户把一个请求交给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;
}

运行结果如下：