目录
1、责任链模式（Chain of Responsibility Pattern）含义
2、责任链模式的UML图学习
3、责任链模式的应用场景
4、责任链模式的优缺点
5、C++实现责任链模式的实例
1、责任链模式（Chain of Responsibility Pattern）含义
责任链模式（Chain of Responsibility）：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。【DP】
责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它通过将请求的发送者和接收者解耦，使多个对象都有机会处理该请求。
每个接收者都包含对下一个接收者的引用，形成一个链条，当一个请求在链条上传递时，直到有一个接收者能够处理它为止。
2、责任链模式的UML图学习
责任链模式主要包含以下几个角色：
（1）抽象处理者（Handler）：定义了处理请求的接口，并持有下一个处理者的引用。
（2）具体处理者（Concrete Handler）：实现了抽象处理者的接口，具体处理请求的逻辑。如果自己无法处理请求，则将请求传递给下一个处理者。
3、责任链模式的应用场景
（1）有多个对象可以处理同一个请求，但具体处理者在运行时才能确定。
（2）需要动态地指定处理请求的顺序。
（3）发送者和接收者之间的关系应该被解耦。
4、责任链模式的优缺点
（1）优点：
1）解耦发送者和接收者：请求发送者不需要知道具体的接收者，只需要将请求发送给第一个处理者即可，由处理者之间的关系来决定谁来处理请求。
2）可扩展性：可以动态地增加或修改处理者，灵活地调整责任链的结构。
3）可配置性：可以通过配置文件或其他方式来确定责任链的顺序和组成。
（2）缺点：
1）请求可能无法被处理：如果没有合适的处理者来处理请求，请求可能会被忽略或丢失。
2）性能影响：由于请求需要在责任链上传递，可能会影响系统的性能。
5、C++实现责任链模式的实例
#include <iostream>
// 抽象处理者
class Handler
{
public:
virtual void setNext(Handler* handler) = 0;
virtual void handleRequest(int request) = 0;
};
// 具体处理者A
class ConcreteHandlerA : public Handler
{
private:
Handler* nextHandler;
public:
void setNext(Handler* handler) override
{
nextHandler = handler;
}
void handleRequest(int request) override
{
if (request >= 0 && request < 10)
{
std::cout << "ConcreteHandlerA 处理请求：" << request << std::endl;
}
else if (nextHandler != nullptr)
{
nextHandler->handleRequest(request);
}
}
};
// 具体处理者B
class ConcreteHandlerB : public Handler
{
private:
Handler* nextHandler;
public:
void setNext(Handler* handler) override
{
nextHandler = handler;
}
void handleRequest(int request) override
{
if (request >= 10 && request < 20)
{
std::cout << "ConcreteHandlerB 处理请求：" << request << std::endl;
}
else if (nextHandler != nullptr)
{
nextHandler->handleRequest(request);
}
}
};
// 具体处理者C
class ConcreteHandlerC : public Handler
{
private:
Handler* nextHandler;
public:
void setNext(Handler* handler) override
{
nextHandler = handler;
}
void handleRequest(int request) override
{
if (request >= 20 && request < 30)
{
std::cout << "ConcreteHandlerC 处理请求：" << request << std::endl;
}
else if (nextHandler != nullptr)
{
nextHandler->handleRequest(request);
}
}
};
int main()
{
// 创建具体处理者对象
ConcreteHandlerA handlerA;
ConcreteHandlerB handlerB;
ConcreteHandlerC handlerC;
// 设置责任链的顺序
handlerA.setNext(&handlerB);
handlerB.setNext(&handlerC);
// 发送请求
handlerA.handleRequest(5);
handlerA.handleRequest(15);
handlerA.handleRequest(25);
return 0;
}
在上述示例中，抽象处理者（Handler）定义了处理请求的接口和设置下一个处理者的方法。具体处理者（ConcreteHandler）继承自抽象处理者，并实现了处理请求的逻辑。每个具体处理者都持有下一个处理者的引用，在处理请求时，如果满足条件，则处理请求；否则将请求传递给下一个处理者。
