誰有wap網(wǎng)站掌門一對一輔導官網(wǎng)
責任鏈模式的動機與意圖
動機：
在軟件開發(fā)中，經(jīng)常會遇到需要處理一系列請求或事件的情況。這些請求可能需要經(jīng)過多個處理對象，每個對象根據(jù)其職責決定是否處理請求或將其傳遞給下一個對象。責任鏈模式（Chain of Responsibility Pattern）提供了一種將請求的發(fā)送者和接收者解耦的方式，允許多個對象都有機會處理請求，從而避免了請求發(fā)送者與接收者之間的緊密耦合。
意圖：
責任鏈模式的意圖是使多個對象都有機會處理請求，從而避免請求的發(fā)送者與接收者之間的耦合。將這些對象連成一條鏈，并沿著這條鏈傳遞請求，直到有對象處理它為止。
適用場合
- 多個對象可以處理同一請求，但具體由哪個對象處理在運行時確定。
- 需要在不明確指定接收者的情況下，向多個對象中的一個提交請求。
- 需要動態(tài)指定一組對象處理請求，例如在運行時動態(tài)調(diào)整處理鏈。
責任鏈模式的變體
-
純責任鏈模式：
- 每個處理者要么處理請求，要么將請求傳遞給下一個處理者，但不能同時進行。
- 這種模式通常用于嚴格的鏈式處理，例如審批流程。
-
不純責任鏈模式：
- 處理者可以部分處理請求，然后將請求傳遞給下一個處理者。
- 這種模式允許處理者在處理請求的同時，繼續(xù)傳遞請求，適用于需要多個處理者共同完成任務的場景。
-
帶中斷的責任鏈模式：
- 處理者可以在處理請求后決定是否中斷鏈的傳遞。
- 這種模式適用于某些情況下，一旦請求被處理，就不需要繼續(xù)傳遞的場景。
-
帶優(yōu)先級的責任鏈模式：
- 處理者根據(jù)優(yōu)先級決定是否處理請求，優(yōu)先級高的處理者先處理請求。
- 這種模式適用于需要根據(jù)優(yōu)先級決定處理順序的場景。
以下是基于責任鏈模式的不同變體的 C++ 代碼示例。每個示例都展示了如何在 C++ 中實現(xiàn)責任鏈模式的不同形式。
1.?純責任鏈模式
在純責任鏈模式中，每個處理者要么處理請求，要么將請求傳遞給下一個處理者。處理者不會同時處理請求并傳遞請求。
#include <iostream>
#include <memory>class Handler {
public:virtual ~Handler() = default;virtual void setNext(std::shared_ptr<Handler>) = 0;virtual void handle(const std::string& request) = 0;
};class BaseHandler : public Handler {
protected:std::shared_ptr<Handler> nextHandler;public:void setNext(std::shared_ptr<Handler> handler) override {nextHandler = handler;}void handle(const std::string& request) override {if (nextHandler) {nextHandler->handle(request);}}
};class ConcreteHandlerA : public BaseHandler {
public:void handle(const std::string& request) override {if (request == "A") {std::cout << "ConcreteHandlerA handles request: " << request << std::endl;} else {BaseHandler::handle(request);}}
};class ConcreteHandlerB : public BaseHandler {
public:void handle(const std::string& request) override {if (request == "B") {std::cout << "ConcreteHandlerB handles request: " << request << std::endl;} else {BaseHandler::handle(request);}}
};int main() {auto handlerA = std::make_shared<ConcreteHandlerA>();auto handlerB = std::make_shared<ConcreteHandlerB>();handlerA->setNext(handlerB);handlerA->handle("B"); // ConcreteHandlerB handles request: BhandlerA->handle("A"); // ConcreteHandlerA handles request: AhandlerA->handle("C"); // No handler can process Creturn 0;
}
2.?不純責任鏈模式
在不純責任鏈模式中，處理者可以部分處理請求，然后將請求傳遞給下一個處理者。
#include <iostream>
#include <memory>class Handler {
public:virtual ~Handler() = default;virtual void setNext(std::shared_ptr<Handler>) = 0;virtual void handle(const std::string& request) = 0;
};class BaseHandler : public Handler {
protected:std::shared_ptr<Handler> nextHandler;public:void setNext(std::shared_ptr<Handler> handler) override {nextHandler = handler;}void handle(const std::string& request) override {if (nextHandler) {nextHandler->handle(request);}}
};class ConcreteHandlerA : public BaseHandler {
public:void handle(const std::string& request) override {if (request == "A") {std::cout << "ConcreteHandlerA handles request: " << request << std::endl;} else {std::cout << "ConcreteHandlerA partially processes request: " << request << std::endl;BaseHandler::handle(request);}}
};class ConcreteHandlerB : public BaseHandler {
public:void handle(const std::string& request) override {if (request == "B") {std::cout << "ConcreteHandlerB handles request: " << request << std::endl;} else {std::cout << "ConcreteHandlerB partially processes request: " << request << std::endl;BaseHandler::handle(request);}}
};int main() {auto handlerA = std::make_shared<ConcreteHandlerA>();auto handlerB = std::make_shared<ConcreteHandlerB>();handlerA->setNext(handlerB);handlerA->handle("B"); // ConcreteHandlerB handles request: BhandlerA->handle("A"); // ConcreteHandlerA handles request: AhandlerA->handle("C"); // ConcreteHandlerA partially processes request: C// ConcreteHandlerB partially processes request: Creturn 0;
}
3.?帶中斷的責任鏈模式
在帶中斷的責任鏈模式中，處理者可以在處理請求后決定是否中斷鏈的傳遞。
#include <iostream>
#include <memory>class Handler {
public:virtual ~Handler() = default;virtual void setNext(std::shared_ptr<Handler>) = 0;virtual bool handle(const std::string& request) = 0;
};class BaseHandler : public Handler {
protected:std::shared_ptr<Handler> nextHandler;public:void setNext(std::shared_ptr<Handler> handler) override {nextHandler = handler;}bool handle(const std::string& request) override {if (nextHandler) {return nextHandler->handle(request);}return false;}
};class ConcreteHandlerA : public BaseHandler {
public:bool handle(const std::string& request) override {if (request == "A") {std::cout << "ConcreteHandlerA handles request: " << request << std::endl;return true; // 中斷鏈式傳遞}return BaseHandler::handle(request);}
};class ConcreteHandlerB : public BaseHandler {
public:bool handle(const std::string& request) override {if (request == "B") {std::cout << "ConcreteHandlerB handles request: " << request << std::endl;return true; // 中斷鏈式傳遞}return BaseHandler::handle(request);}
};int main() {auto handlerA = std::make_shared<ConcreteHandlerA>();auto handlerB = std::make_shared<ConcreteHandlerB>();handlerA->setNext(handlerB);handlerA->handle("B"); // ConcreteHandlerB handles request: BhandlerA->handle("A"); // ConcreteHandlerA handles request: AhandlerA->handle("C"); // No handler can process Creturn 0;
}
4.?帶優(yōu)先級的責任鏈模式
在帶優(yōu)先級的責任鏈模式中，處理者根據(jù)優(yōu)先級決定是否處理請求，優(yōu)先級高的處理者先處理請求。
#include <iostream>
#include <memory>
#include <vector>
#include <algorithm>class Handler {
public:virtual ~Handler() = default;virtual int getPriority() const = 0;virtual void handle(const std::string& request) = 0;
};class BaseHandler : public Handler {
protected:int priority;public:BaseHandler(int p) : priority(p) {}int getPriority() const override {return priority;}void handle(const std::string& request) override {// 默認不處理}
};class ConcreteHandlerA : public BaseHandler {
public:ConcreteHandlerA(int p) : BaseHandler(p) {}void handle(const std::string& request) override {if (request == "A") {std::cout << "ConcreteHandlerA handles request: " << request << std::endl;}}
};class ConcreteHandlerB : public BaseHandler {
public:ConcreteHandlerB(int p) : BaseHandler(p) {}void handle(const std::string& request) override {if (request == "B") {std::cout << "ConcreteHandlerB handles request: " << request << std::endl;}}
};int main() {auto handlerA = std::make_shared<ConcreteHandlerA>(2);auto handlerB = std::make_shared<ConcreteHandlerB>(1);std::vector<std::shared_ptr<Handler>> handlers = {handlerA, handlerB};// 根據(jù)優(yōu)先級排序std::sort(handlers.begin(), handlers.end(), [](const auto& h1, const auto& h2) {return h1->getPriority() > h2->getPriority();});for (const auto& handler : handlers) {handler->handle("B"); // ConcreteHandlerB handles request: Bhandler->handle("A"); // ConcreteHandlerA handles request: A}return 0;
}
總結
以上代碼示例展示了責任鏈模式的四種不同變體：
- 純責任鏈模式：處理者要么處理請求，要么傳遞請求。
- 不純責任鏈模式：處理者可以部分處理請求并傳遞請求。
- 帶中斷的責任鏈模式：處理者可以中斷鏈的傳遞。
- 帶優(yōu)先級的責任鏈模式：處理者根據(jù)優(yōu)先級決定處理順序。
這些變體可以根據(jù)具體需求靈活選擇和實現(xiàn)，以滿足不同場景下的功能需求。
基于責任鏈模式特點的軟件架構模式
-
中間件架構：
- 在Web開發(fā)中，中間件架構通常使用責任鏈模式來處理HTTP請求。每個中間件都可以對請求進行處理，然后決定是否將請求傳遞給下一個中間件。
- 例如，Express.js中的中間件機制就是基于責任鏈模式實現(xiàn)的。
-
事件處理系統(tǒng)：
- 在GUI編程中，事件處理系統(tǒng)通常使用責任鏈模式來處理用戶事件。每個事件處理器可以處理事件，或者將事件傳遞給下一個處理器。
- 例如，Java AWT/Swing中的事件處理機制就是基于責任鏈模式實現(xiàn)的。
-
工作流引擎：
- 在工作流引擎中，責任鏈模式可以用于處理工作流中的各個步驟。每個步驟可以處理任務，或者將任務傳遞給下一個步驟。
- 例如，Activiti等工作流引擎中的任務處理機制就是基于責任鏈模式實現(xiàn)的。
-
過濾器鏈：
- 在Web應用中，過濾器鏈通常使用責任鏈模式來處理請求和響應。每個過濾器可以對請求或響應進行處理，然后將其傳遞給下一個過濾器。
- 例如，Java Servlet中的過濾器機制就是基于責任鏈模式實現(xiàn)的。
總結
責任鏈模式通過將請求的發(fā)送者和接收者解耦，提供了一種靈活的方式來處理請求。它適用于多個對象可以處理同一請求的場景，并且可以通過不同的變體來滿足不同的需求?；谪熑捂溎Ｊ降奶攸c，許多軟件架構模式（如中間件架構、事件處理系統(tǒng)、工作流引擎和過濾器鏈）都采用了這種模式來實現(xiàn)靈活的處理機制。