设计模式，责任链模式详解，c++实现

责任链模式
定义：使多个对象都有机会处理请求，避免请求的发送者和接受者的耦合关系，将处理对象连成链，并沿着这条链传递该请求，直到有对象处理它为止。
重点在于“链”，由一条链处理相似的请求，在链中决定谁来处理这个请求，适合用于处理有等级限制的需求时。

通用类图

处理者Handler的三个职责：
1.定义一个请求的处理等级判断方法handle()用于判断处理还是推向下一级，这应该是处理者唯一对外开放的方法，应该用final修饰使其不被更改，因在基类中确定了等级判断函数，故也用到了模板模式。
2.定义一个链的编排方法setNext()用于设置“链”的下一级。
3.定义自己的处理等级，定义对请求的解决方法echo()。

优点：
将请求和处理分开，请求者不必知道谁处理，处理者不用知道谁请求的，两者解耦，提高系统的灵活性。

缺点：
很明显的两点，一是性能，每个请求都是从头遍历到尾，如果链条很长就很不方便；二是调试不便，判断处理等级时运用了递归方式，逻辑复杂，递归带来的时间与内存损耗会因链条的加长而显著提升。

注意事项：
因缺点显著，故最应重视控制链条节点的数量，一般可以在基类中设置一个最大节点数，在setNext()方法中判断是否超过了阈值，超过了则不允许建立该链，避免无意识的破坏系统性能。

c++代码示例

//需求类，是待处理的类
class request
{
public:
	request(string& Data, const int& HandlerLevel)
	{
		mstrData = Data;
		miHandlerLevel = HandlerLevel;
		cout << "任务已创建，处理等级为" << miHandlerLevel << endl;
	}

	int getHandlerLevel()
	{
		return miHandlerLevel;
	}

	void setHandlerLevel(int &HandlerLevel)
	{
		miHandlerLevel = HandlerLevel;
	}

	string getData()
	{
		return mstrData;
	}

protected:
	int miHandlerLevel;
	string mstrData;
};

//处理类的基类，确定处理等级，用子类实现处理需求的具体方式
class handler
{
public:
	handler(const int& handlerLevel) :miHandlerLevel(handlerLevel), mNext(nullptr)
	{

	}

	void Judge_Handle(request* Request)
	{
		if (getHandlerLevel() == Request->getHandlerLevel())
		{
			handle(Request);
		}
		else if(mNext != nullptr)
		{
			cout << "该等级无法处理，递交至下一位" << endl;
			mNext->Judge_Handle(Request);
		}
		else
		{
			cout << "该命令无法被处理" << endl;
		}
	}

	void setNext(handler* Handler)
	{
		mNext = Handler;
	}

protected:
	virtual void handle(request* Request)
	{

	}

	int getHandlerLevel()
	{
		return miHandlerLevel;
	}

	handler* mNext;
	int miHandlerLevel;
};

class employee :public handler
{
public:
	employee(const int& handlerLevel):handler(handlerLevel)
	{
		cout << "处理人员已创建，等级为" << miHandlerLevel << endl;
	}

protected:
	virtual void handle(request* Resquest)
	{
		cout << Resquest->getData() << "处理等级为" << Resquest->getHandlerLevel() << "，已被" << getHandlerLevel() << "等级处理人员处理" << endl;
	}
};

//测试函数
void func()
{
	//确定等级
	const int LEVEL1 = 1;
	const int LEVEL2 = 2;
	const int LEVEL3 = 3;
	const int LEVEL4 = 4;

	//组合处理链
	handler* Handler1 = new employee(LEVEL1);
	handler* Handler2 = new employee(LEVEL2);
	handler* Handler3 = new employee(LEVEL3);
	Handler1->setNext(Handler2);
	Handler2->setNext(Handler3);

	//生成不同等级的需求需求
	string data = "mission1";
	request* Request1 = new request(data, LEVEL1);
	data = "mission2";
	request* Request2 = new request(data, LEVEL2);
	data = "mission3";
	request* Request3 = new request(data, LEVEL3);
	data = "mission4";
	request* Request4 = new request(data, LEVEL4);

	//只需要让处理链的第一位处理所有任务即可
	Handler1->Judge_Handle(Request1);
	Handler1->Judge_Handle(Request2);
	Handler1->Judge_Handle(Request3);
	Handler1->Judge_Handle(Request4);
}

int main()
{
	func();
	return 0;
}