职责链模式-C++实现

职责链模式是一种行为型设计模式，它允许多个对象以链式的方式处理请求，避免了请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理请求为止，也就是说如果当前对象不处理请求，那就继续向前传递。

职责链模式有三个角色：

1、抽象处理者（Handler）：定义一个处理请求的接口，包含一个指向下一个处理者的引用。

2、具体处理者（ConcreteHandler）：实现处理请求的接口，处理自己负责的请求，如果自己无法处理，则将请求传递给下一个处理者。

3、客户端：创建职责链，并将请求发送给第一个处理者。

举例：

我们现在有三个请求A、B、C，处理这些请求的方法各不同。

#include 
#include 

enum RequestType
{
	REQUEST_A = 0,
	REQUEST_B,
	REQUEST_C,
};

// 抽象处理者
class IHandler
{
public:

	virtual ~IHandler() {}

	virtual void SetNext(std::shared_ptr<IHandler> _nextHandler) = 0;

	virtual void ProcessRequest(const std::string& _msg, RequestType _type) = 0;

protected:
	std::shared_ptr<IHandler> nexthandler_;
};

// 具体处理者A
class ConcreteHandlerA
	: public IHandler
{
public:

	virtual void SetNext(std::shared_ptr<IHandler> _nextHandler) override
	{
		nexthandler_ = _nextHandler;
	}

	virtual void ProcessRequest(const std::string& _msg, RequestType _type) override
	{
		if (_type == REQUEST_A)
			std::cout << "这是处理者A的请求：" << _msg << std::endl;
		else if (nexthandler_)
			nexthandler_->ProcessRequest(_msg, _type);
	}
};

// 具体处理者A
class ConcreteHandlerB
	: public IHandler
{
public:

	virtual void SetNext(std::shared_ptr<IHandler> _nextHandler) override
	{
		nexthandler_ = _nextHandler;
	}

	virtual void ProcessRequest(const std::string& _msg, RequestType _type) override
	{
		if (_type == REQUEST_B)
			std::cout << "这是处理者B的请求：" << _msg << std::endl;
		else if (nexthandler_)
			nexthandler_->ProcessRequest(_msg, _type);
	}
};

// 具体处理者A
class ConcreteHandlerC
	: public IHandler
{
public:

	virtual void SetNext(std::shared_ptr<IHandler> _nextHandler) override
	{
		nexthandler_ = _nextHandler;
	}

	virtual void ProcessRequest(const std::string& _msg, RequestType _type) override
	{
		if (_type == REQUEST_C)
			std::cout << "这是处理者C的请求：" << _msg << std::endl;
		else if (nexthandler_)
			nexthandler_->ProcessRequest(_msg, _type);
	}
};

代码示例中，我们创建了一个抽象处理者，定义了SetNext()和ProcessRequest()方法，分别用于设置下一个处理者和处理请求。然后我们又创建了三个具体处理者实现这两个方法。

测试：

void TestHandler()
{
	// 创建具体处理对象
	std::shared_ptr<IHandler> handlerA = std::make_shared<ConcreteHandlerA>();
	std::shared_ptr<IHandler> handlerB = std::make_shared<ConcreteHandlerB>();
	std::shared_ptr<IHandler> handlerC = std::make_shared<ConcreteHandlerC>();

	// 设置处理者之间的链式关系
	handlerA->SetNext(handlerB);
	handlerB->SetNext(handlerC);
	handlerC->SetNext(nullptr);

	// 发送请求
	handlerA->ProcessRequest("你好", REQUEST_B);

	handlerA->ProcessRequest("Hello", REQUEST_C);

	handlerA->ProcessRequest("你好", REQUEST_A);
}

我们创建了三个处理者对象，并设置了它们的链式关系：A->B->C。最后模拟发送请求，依次发送B、C、A处理的请求。

输出结果：

这是处理者B的请求：你好
这是处理者C的请求：Hello
这是处理者A的请求：你好

职责链模式遵循哪些设计原则：

1、单一职责原则：每个处理者只负责处理自己的请求，符合单一职责原则。

2、开放封闭原则：职责链模式可以通过新增或修改处理器节点，而不需要修改已有的节点，从而实现对扩展开放、对修改关闭。

3、依赖倒置原则：职责链模式中，节点之间是松耦合的，节点之间的通信是通过抽象的方式。

优点：

1、解耦请求发送者和接收者：请求发送者无需直到具体哪个处理者处理请求，只需要把请求发送给第一个处理者，之后就通过链式传递处理请求。

2、可动态配置职责链：可以动态地增加、删除或调整职责链中的节点、灵活性高

3、提高代码的可维护性：每个节点只负责自己的请求，易维护和理解

缺点：

1、无法保证请求一定会被处理：如果职责链上的节点都无法处理这个请求，那么这个请求就会被忽略。

2、职责链过长可能会影响性能：当职责链过长时，节点之间的消息传递可能会消耗更多的时间，影响性能。

3、可能引起系统的复杂性增加：如果使用不当，职责链模式可能会导致系统中节点数量过大，导致系统的复杂性提高。