职责链 -

职责链模式为请求创建了一个接受者兑现的链。这种模式给予请求的类型，对请求的发送者和接受者进行解耦。

这种模式中，通常每个接受者都包含对另一个接受者的应用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接受者，以此类推。

1. 介绍

意图：避免请求发送者与接受者耦合在一起，让多个对象都有可能接受请求，将这些对象连成一条链传递请求，知道有对象处理它为止。

主要解决：职责链上的处理者负责处理对象请求，客户只需要将请求发送给职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理着解耦了。

何时使用：在处理消息的时候过滤很多道。

如何解决：拦截的类都实现统一接口。

关键代码：Handler 里面聚合它自己，在 HandlerRequest 里判断是否合适，如果没达到条件则向下传递，向谁传递之前 set 进去。

应用实例： 1、红楼梦中的"击鼓传花"。 2、JS 中的事件冒泡。 3、JAVA WEB 中 Apache Tomcat 对 Encoding 的处理，Struts2 的拦截器，jsp servlet 的 Filter。

优点： 1、降低耦合度。它将请求的发送者和接收者解耦。 2、简化了对象。使得对象不需要知道链的结构。 3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。 4、增加新的请求处理类很方便。

缺点： 1、不能保证请求一定被接收。 2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。 3、可能不容易观察运行时的特征，有碍于除错。

使用场景： 1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。 2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 3、可动态指定一组对象处理请求。

注意事项：在 JAVA WEB 中遇到很多应用。

2. 实例

2.1. C++实现

#include <stdio.h>
#include <memory>
#include <vector>
#include <map>

class CHandle {
public:
	CHandle( ) : m_ptrHandle( nullptr ){}
	CHandle(std::shared_ptr< CHandle > nexthandle) : m_ptrHandle(nexthandle){}

	~CHandle(){}

	void SetNext(std::shared_ptr<CHandle> handle) {
		m_ptrHandle = handle;
	}

	std::shared_ptr<CHandle> GetNext() { return m_ptrHandle; }
	
	virtual void HandleRequest(int request) = 0;

protected:
	std::shared_ptr<CHandle> m_ptrHandle;
};

class CConcreateHandle1 : public CHandle{
public:
	CConcreateHandle1(){}
	CConcreateHandle1(std::shared_ptr<CHandle> nextHandle) : CHandle(nextHandle){}

	void HandleRequest(int request) override {
		if(request> 0 && request < 10)
		{
			std::cout << "First node develop it\n" << std::endl;
		}
		else if (m_ptrHandle)
		{
			m_ptrHandle->HandleRequest(request);
		}
	}
};

class CConcreateHeadle2 : public CHandle {
public:
	CConcreateHeadle2() {}
	CConcreateHeadle2(std::shared_ptr<CHandle> nextHandle) : CHandle(nextHandle) {}

	void HandleRequest(int request) override {
		if (request > 10 && request < 20)
		{
			std::cout << "Second node develop it\n" << std::endl;
		}
		else if(m_ptrHandle)
		{
			m_ptrHandle->HandleRequest(request);
		}
	}
};

class CConcreateHeadle3 : public CHandle {
public:
	CConcreateHeadle3() {}
	CConcreateHeadle3(std::shared_ptr<CHandle> nextHandle) : CHandle(nextHandle) {}

	void HandleRequest(int request) override {
		if (request > 30)
			std::cout << "Sird node develop it \n" << std::endl;
	}
};

#include <stdio.h>
#include <iostream>
#include <string>
#include "game.h"

int main(int argc, char** argv)
{
	std::shared_ptr<CConcreateHeadle3> handle3 = std::make_shared< CConcreateHeadle3>();
	std::shared_ptr<CConcreateHeadle2> handle2 = std::make_shared<CConcreateHeadle2>(handle3);
	std::shared_ptr<CConcreateHandle1> handle1 = std::make_shared<CConcreateHandle1>();
	handle1->SetNext(handle2);

	int request[] = { 2, 5, 14, 44, 22, 15, 23, 12, -5 };
	for (auto i : request) {
		handle1->HandleRequest(i);
		std::cout << std::string(30, '-') << std::endl;
	}

	system("pause");
	return 0;
}