# 前言
**责任链模式**，是一种**行为设计模式**。它允许我们将一个请求沿着一条由多个处理器对象组成的链进行传递。链上的每个处理器都有机会处理这个请求，或者将其**传递给链中的下一个处理器**。
![Gemini_Generated_Image_n55otzn55otzn55o.png](https://developer.qcloudimg.com/http-save/yehe-1367556/467dd784e4ce854f8fe432638410a3d4.png)
# 问题
在软件开发中，我们常常会遇到一类场景：一个请求需要经过多个对象的处理，但这些处理逻辑紧密耦合在一起，导致代码难以维护和扩展。
1. **代码臃肿与“上帝函数”**：一个核心的处理函数里塞满了各种校验、过滤和业务逻辑，真是一坨屎山。任何小的修改都可能引发意想不到的错误，测试也变得异常困难。

2. **处理顺序僵化**：处理步骤的顺序被硬编码在逻辑中。当业务规则变化，需要调整步骤顺序或跳过某些步骤时，我们不得不深入修改核心代码，风险很高。
3. **难以复用处理逻辑**：不同的请求可能需要不同的处理组合。例如，API A需要“验证+授权”，而内部服务B只需要“日志记录”。由于所有逻辑都捆绑在一起，我们很难抽取和复用独立的处理单元。
4. **违反单一职责原则**：一个庞大的处理器类或函数承担了太多不同类型的职责，这使得它难以理解、修改和测试。

**核心矛盾**在于：我们既希望请求能被一系列处理器按需处理，又不想让发送请求的客户端与具体的处理逻辑，以及处理器之间产生紧密的耦合。

# 解决方案
**将每个处理步骤抽象为独立的对象（处理器），并将它们连接成一条链**。

- **处理器接口**：所有处理器都实现同一个接口，该接口通常包含一个处理请求的方法（如 `Handle(request)`）。

- **链式传递**：每个处理器都持有对下一个处理器的引用。当一个处理器收到请求时，它可以：
	- **自行处理**，然后结束传递。
	- **处理并传递**给下一个。
	- **直接传递**给下一个。
	- **无法处理**时，也传递给下一个（或根据规则结束）。

- **客户端解耦**：客户端只需要将请求发送给链中的第一个处理器，无需关心请求具体由谁、以及如何被处理。
# 应用场景
- **多级审批或工作流系统**：例如，一个报销申请需要经过“直属领导 -> 部门经理 -> 财务 -> CEO”的审批链，每个环节都可以批准、驳回或转交。

- **事件处理或消息过滤**：在图形用户界面（GUI）中，一个鼠标点击事件可能会沿着“按钮 -> 面板 -> 窗口”的组件树向上冒泡，直到有组件处理它。这正是责任链的典型应用。

- **中间件或过滤器链**：在Web开发中，HTTP请求通常需要经过一系列中间件（Middleware）的处理，如日志记录、身份验证、跨域处理、数据压缩等。每个中间件都是一个处理器。

- **按顺序执行多个处理器**：当你有多个处理器，且需要它们按特定顺序执行，但又不希望发送者与它们紧密耦合时。
# 实现步骤
让我们结合一个Web请求处理的例子，以Go语言为例，实现一个简单的责任链。
1. **定义处理器接口和基础结构**：
```
// handler.go
package main

// Handler 定义处理请求的接口
type Handler interface {
    SetNext(h Handler) Handler
    Handle(request *Request)
}

// BaseHandler 提供链式设置下一个处理器的默认实现
type BaseHandler struct {
    nextHandler Handler
}

func (b *BaseHandler) SetNext(h Handler) Handler {
    b.nextHandler = h
    return h // 支持链式调用，例如：auth.SetNext(logging).SetNext(business)
}

func (b *BaseHandler) Handle(request *Request) {
    if b.nextHandler != nil {
        b.nextHandler.Handle(request)
    }
}
```

2. **定义请求和响应对象**：
```
// request.go
package main

type Request struct {
    Path     string
    Token    string
    UserRole string
    Body     string
}

type Response struct {
    StatusCode int
    Message    string
}
```

3. **创建具体处理器**：
```
// authentication_handler.go
type AuthenticationHandler struct {
    BaseHandler
}

func (a *AuthenticationHandler) Handle(request *Request) {
    fmt.Println("AuthenticationHandler: 检查令牌...")
    if request.Token == "valid-token-123" {
        fmt.Println("  认证通过")
        a.BaseHandler.Handle(request) // 传递给链上的下一个处理器
    } else {
        fmt.Println("  认证失败，终止链")
        // 在实际场景中，可能会设置一个错误响应并停止传递
    }
}

// authorization_handler.go
type AuthorizationHandler struct {
    BaseHandler
}

func (az *AuthorizationHandler) Handle(request *Request) {
    fmt.Println("AuthorizationHandler: 检查权限...")
    if request.UserRole == "admin" {
        fmt.Println("  权限检查通过")
        az.BaseHandler.Handle(request)
    } else {
        fmt.Println("  权限不足，终止链")
    }
}

// business_handler.go
type BusinessHandler struct {
    BaseHandler
}

func (b *BusinessHandler) Handle(request *Request) {
    fmt.Println("BusinessHandler: 处理核心业务逻辑...")
    fmt.Printf("  处理请求路径: %s, 内容: %s\n", request.Path, request.Body)
    // 这里处理业务，例如读写数据库
}
```

4. **客户端组装链并发送请求**：
```
// main.go
func main() {
    // 1. 创建处理器
    auth := &AuthenticationHandler{}
    authz := &AuthorizationHandler{}
    business := &BusinessHandler{}

    // 2. 构建责任链: 认证 -> 授权 -> 业务处理
    auth.SetNext(authz).SetNext(business)

    // 3. 创建请求
    req := &Request{
        Path:     "/api/data",
        Token:    "valid-token-123",
        UserRole: "admin",
        Body:     "一些请求数据",
    }

    fmt.Println("开始处理请求...")
    // 4. 触发链，从第一个处理器开始
    auth.Handle(req)
    fmt.Println("请求处理流程结束。")
}
```
**输出结果**：
```
开始处理请求...
AuthenticationHandler: 检查令牌...
  认证通过
AuthorizationHandler: 检查权限...
  权限检查通过
BusinessHandler: 处理核心业务逻辑...
  处理请求路径: /api/data, 内容: 一些请求数据
请求处理流程结束。
```
![Gemini_Generated_Image_lvavbrlvavbrlvav.png](https://developer.qcloudimg.com/http-save/yehe-1367556/4bd9277029857f8f1bf8cbf3b0c010b7.png)
# 优缺点
## **优点**：
- **控制处理顺序**：你可以灵活地组织处理器的顺序，甚至动态地改变链。
- **符合单一职责原则**：每个处理器只负责一个具体的任务或检查，使得类变得短小、内聚，更容易理解和维护。
- **符合开闭原则**：你可以在不修改现有处理器或客户端代码的情况下，轻松地向链中添加新的处理器。
- **解耦发送者与接收者**：发送者无需知道请求将由谁处理，以及链的具体结构。
## **缺点**：
- **请求可能未被处理**：如果链配置不当，或者没有处理器能够（或愿意）处理请求，请求可能会到达链的末端而得不到任何处理。我们需要确保链的完整性或提供默认处理。
- **性能考虑**：较长的责任链可能会带来一些性能开销，因为请求需要经过多个对象的传递。对于性能敏感的场景，需要权衡。
- **调试难度**：由于行为分布在多个对象中，调试时追踪请求的传递路径可能比在单个函数中跟踪更复杂。你可能会问：“这会不会让问题排查变麻烦？”是的，但我们可以通过完善的日志记录来弥补，每个处理器清晰地记录自己的操作和决策，反而使流程更透明
# 总结
责任链模式就像为我们团队配备了一套**可插拔、可编排的“处理模块”**。它将复杂的顺序处理逻辑分解为一个个独立的、功能单一的组件，并通过链的方式将它们组织起来。

当你的代码中出现了长长的 `if-else` 或 `switch` 语句来处理各种情况，或者一个函数/类承担了过多不同性质的校验和操作时，就是考虑引入责任链模式的良好时机。

责任链模式，是一种行为设计模式。它允许我们将一个请求沿着一条由多个处理器对象组成的链进行传递。链上的每个处理器都有机会处理这个请求，或者将其传递给链中的下一个处理器。

责任链设计模式-使用go语言实现

十倍工程师

编程语言

架构设计

后端

责任链模式是一种行为设计模式，允许请求沿处理器链传递，每个处理器可处理或传递请求。它解耦发送者与接收者，支持灵活处理顺序，符合单一职责原则，适用于多级审批、事件处理等场景。实现简单，但需注意请求未被处理和性能开销问题。

身份验证

软件开发

中间件

数据库

AI驱动 智领未来

message-queue-catalog

tencentdb-catalog

人脸核身+人脸识别特惠活动0.6折起


faceid

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

责任链设计模式-使用go语言实现-腾讯云开发者社区-腾讯云

责任链设计模式-使用go语言实现

责任链设计模式-使用go语言实现

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐