【设计模式】【行为型模式（Behavioral Patterns）】之责任链模式（Chain of Responsibility Pattern）

春风十里不如你95272024-11-27 14:51

1. 设计模式原理说明

责任链模式（Chain of Responsibility Pattern） 是一种行为设计模式，它允许你将请求沿着处理者链进行发送。每个处理者都可以处理请求，或者将其传递给链上的下一个处理者。这种模式使得多个对象都有机会处理请求，而无需提前指定具体的处理者。这样可以减少请求发送者和接收者之间的耦合。

主要角色
  1. Handler（抽象处理者）：定义了一个处理请求的接口，通常包含一个后继连接，用于指向下一个处理者。
  2. ConcreteHandler（具体处理者）：实现了处理请求的方法，判断是否处理该请求，如果不能处理则将请求转发给下一个处理者。
  3. Client（客户端）：创建处理者对象并组织成一条链，向链中的第一个处理者提交请求。

2. UML 类图及解释

UML 类图
复制代码 
+-----------------+
|    Handler      |
|-----------------|
| - successor: Handler |
| - setSuccessor(successor: Handler) |
| - handleRequest(request: Request) |
+-----------------+
           ^
           |
           |
           v
+-----------------+
| ConcreteHandlerA|
|-----------------|
| - handleRequest(request: Request) |
+-----------------+
           ^
           |
           |
           v
+-----------------+
| ConcreteHandlerB|
|-----------------|
| - handleRequest(request: Request) |
+-----------------+
类图解释
  • Handler：定义了处理请求的接口，包含一个后继连接（successor），用于指向下一个处理者。
  • ConcreteHandlerA 和 ConcreteHandlerB：实现了处理请求的方法，判断是否处理该请求，如果不能处理则将请求转发给下一个处理者。
  • Client：创建处理者对象并组织成一条链，向链中的第一个处理者提交请求。

3. 代码案例及逻辑详解

Java 代码案例
复制代码 
// 抽象处理者
abstract class Handler {
    protected Handler successor;

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public abstract void handleRequest(int request);
}

// 具体处理者 A
class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 0 && request < 10) {
            System.out.println("ConcreteHandlerA handled request " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 具体处理者 B
class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 10 && request < 20) {
            System.out.println("ConcreteHandlerB handled request " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        handlerA.setSuccessor(handlerB);

        handlerA.handleRequest(5);  // 应由 ConcreteHandlerA 处理
        handlerA.handleRequest(15); // 应由 ConcreteHandlerB 处理
        handlerA.handleRequest(25); // 没有处理者可以处理
    }
}
C++ 代码案例
复制代码 
#include <iostream>

// 抽象处理者
class Handler {
protected:
    Handler* successor;
public:
    void setSuccessor(Handler* successor) {
        this->successor = successor;
    }
    virtual void handleRequest(int request) = 0;
};

// 具体处理者 A
class ConcreteHandlerA : public Handler {
public:
    void handleRequest(int request) override {
        if (request >= 0 && request < 10) {
            std::cout << "ConcreteHandlerA handled request " << request << std::endl;
        } else if (successor != nullptr) {
            successor->handleRequest(request);
        }
    }
};

// 具体处理者 B
class ConcreteHandlerB : public Handler {
public:
    void handleRequest(int request) override {
        if (request >= 10 && request < 20) {
            std::cout << "ConcreteHandlerB handled request " << request << std::endl;
        } else if (successor != nullptr) {
            successor->handleRequest(request);
        }
    }
};

// 客户端
int main() {
    Handler* handlerA = new ConcreteHandlerA();
    Handler* handlerB = new ConcreteHandlerB();

    handlerA->setSuccessor(handlerB);

    handlerA->handleRequest(5);  // 应由 ConcreteHandlerA 处理
    handlerA->handleRequest(15); // 应由 ConcreteHandlerB 处理
    handlerA->handleRequest(25); // 没有处理者可以处理

    delete handlerA;
    delete handlerB;
    return 0;
}
Python 代码案例
复制代码 
# 抽象处理者
class Handler:
    def __init__(self):
        self.successor = None

    def set_successor(self, successor):
        self.successor = successor

    def handle_request(self, request):
        pass

# 具体处理者 A
class ConcreteHandlerA(Handler):
    def handle_request(self, request):
        if 0 <= request < 10:
            print(f"ConcreteHandlerA handled request {request}")
        elif self.successor is not None:
            self.successor.handle_request(request)

# 具体处理者 B
class ConcreteHandlerB(Handler):
    def handle_request(self, request):
        if 10 <= request < 20:
            print(f"ConcreteHandlerB handled request {request}")
        elif self.successor is not None:
            self.successor.handle_request(request)

# 客户端
if __name__ == "__main__":
    handlerA = ConcreteHandlerA()
    handlerB = ConcreteHandlerB()

    handlerA.set_successor(handlerB)

    handlerA.handle_request(5)  # 应由 ConcreteHandlerA 处理
    handlerA.handle_request(15) # 应由 ConcreteHandlerB 处理
    handlerA.handle_request(25) # 没有处理者可以处理
Go 代码案例
复制代码 
package main

import (
	"fmt"
)

// 抽象处理者
type Handler interface {
	setSuccessor(successor Handler)
	handleRequest(request int)
}

// 具体处理者 A
type ConcreteHandlerA struct {
	successor Handler
}

func (h *ConcreteHandlerA) setSuccessor(successor Handler) {
	h.successor = successor
}

func (h *ConcreteHandlerA) handleRequest(request int) {
	if request >= 0 && request < 10 {
		fmt.Printf("ConcreteHandlerA handled request %d\n", request)
	} else if h.successor != nil {
		h.successor.handleRequest(request)
	}
}

// 具体处理者 B
type ConcreteHandlerB struct {
	successor Handler
}

func (h *ConcreteHandlerB) setSuccessor(successor Handler) {
	h.successor = successor
}

func (h *ConcreteHandlerB) handleRequest(request int) {
	if request >= 10 && request < 20 {
		fmt.Printf("ConcreteHandlerB handled request %d\n", request)
	} else if h.successor != nil {
		h.successor.handleRequest(request)
	}
}

// 客户端
func main() {
	handlerA := &ConcreteHandlerA{}
	handlerB := &ConcreteHandlerB{}

	handlerA.setSuccessor(handlerB)

	handlerA.handleRequest(5)  // 应由 ConcreteHandlerA 处理
	handlerA.handleRequest(15) // 应由 ConcreteHandlerB 处理
	handlerA.handleRequest(25) // 没有处理者可以处理
}

4. 总结

责任链模式 是一种行为设计模式，它允许你将请求沿着处理者链进行发送。每个处理者都可以处理请求，或者将其传递给链上的下一个处理者。这种模式使得多个对象都有机会处理请求，而无需提前指定具体的处理者。通过这种方式，可以减少请求发送者和接收者之间的耦合。

主要优点
  1. 解耦：请求的发送者和接收者之间没有直接的耦合关系，提高了系统的灵活性。
  2. 增强可扩展性：可以动态地增加或改变处理者的数量和顺序，而不会影响客户端。
  3. 支持多个处理者：多个处理者可以依次处理同一个请求，增加了系统的灵活性和可配置性。
主要缺点
  1. 调试困难：由于请求的处理过程是动态的，调试时可能难以跟踪请求的处理路径。
  2. 性能开销：如果链过长，可能会导致性能下降，尤其是在每个处理者都需要执行某些操作时。
适用场景
  • 当一个请求需要被多个对象中的一个或多个处理时。
  • 当处理者的选择需要在运行时动态决定时。
  • 当需要在不明确指定接收者的情况下，向多个对象中的一个发送请求时。
  • 当需要创建一个可灵活配置的处理流程时。
相关推荐
2301_780789666 小时前
跨平台适配！SDK 游戏盾兼容全终端游戏场景
java·网络·ddos
学长毕设7 小时前
基于springboot的食品仓库管理系统
java·spring boot·后端
步行cgn7 小时前
FormHttpMessageConverter 详解：Spring MVC 中表单数据的读写转换器
java·spring·mvc
龙亘川8 小时前
构建城市公共安全数字底座：亘川智城智慧安防系统全维度解读
java·大数据·开发语言·人工智能·信息可视化
金銀銅鐵8 小时前
[Java] 用 CLI 展示 EnumMap 增删键值对时的内部变化
java·源码·ai编程
秋天的怀念_David8 小时前
第二十二夜 · 数字迷雾
java·程序人生·算法
Raas1008 小时前
AI网关部署方案？从部署到上线全流程
java·开发语言·人工智能·gateway·ai网关·企业级ai网关·企业级ai产品
niucloud-admin9 小时前
NIUCLOUD PHP SAAS上门家政使用文档：城市管理
java·前端·php
霸道流氓气质9 小时前
智能客服组件：分层意图识别、RAG Advisor 与人工转接状态机的 Vue3 + Spring AI 生产级实战
java·人工智能·spring
captain37610 小时前
MyBatis操作数据库（入门2）
java·数据库·spring boot·后端·spring·mybatis
热门推荐
01如何新建文件夹？ 电脑新建文件夹的4种方法02国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）03GitHub 镜像站点04历年考研数学一、数学二、数学三真题试卷及答案PDF05几个好用的ip纯净度检测网站06Android 屏幕适配系列开篇：核心概念、官方机制与主流方案07Dify：一站式AI应用开发平台全解析与Windows部署指南08苹果iPA游戏软件资源下载网站09昇腾910B系列芯片完全指南：四款型号对比、服务器选型与大模型部署实战10蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接