


想象你在一家餐厅点餐：

- **中间件模式** = 多位服务员接力传递：迎宾员 → 点单员 → 厨师 → 传菜员
- **嵌入式委托** = 一位全能主厨：亲自迎客、点单、烹饪，只在必要时呼叫助手

## 一、中间件堆叠：层层包裹

典型写法是将处理器像俄罗斯套娃一样层层包裹：

```go
// 日志中间件：记录每笔“订单”
func logging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("📝 记录请求:", r.URL.Path)
        next.ServeHTTP(w, r) // 传递给下一位
    })
}

// 特殊路由中间件：拦截“隐藏菜单”
func special(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.URL.Path == "/secret-menu" {
            w.Write([]byte("🍣 今日隐藏菜单：三文鱼刺身"))
            return // 拦截请求，不再传递
        }
        next.ServeHTTP(w, r)
    })
}

// 启动服务：套娃式组装
mux := http.NewServeMux()
mux.HandleFunc("/", func(w http.ResponseWriter, _ *http.Request) {
    w.Write([]byte("🍔 普通菜单：汉堡套餐"))
})

// 堆叠顺序：越靠外的中间件越先执行
handler := logging(special(mux)) 
http.ListenAndServe(":8080", handler)
```

**痛点**：中间件超过 5 层后，调用栈变得像迷宫，调试时需逐层追踪 `next.ServeHTTP` 的流向。

## 二、嵌入式委托：一位“全能主厨”

通过结构体嵌入 `http.ServeMux`，重写 `ServeHTTP` 实现集中控制：

```go
// CustomMux = 全能主厨
type CustomMux struct {
    *http.ServeMux // 嵌入标准路由器作为“基础技能”
}

// 主厨亲自处理每笔订单
func (cm *CustomMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 1️⃣ 先记录订单
    fmt.Println("👨‍🍳 主厨接单:", r.URL.Path)
    
    // 2️⃣ 检查是否要点“隐藏菜单”
    if r.URL.Path == "/secret-menu" {
        w.Write([]byte("🍣 今日隐藏菜单：三文鱼刺身"))
        return // 亲自完成，不呼叫助手
    }
    
    // 3️⃣ 普通订单交给基础技能处理
    cm.ServeMux.ServeHTTP(w, r)
}

// 启动：简洁明了
mux := &CustomMux{ServeMux: http.NewServeMux()}
mux.HandleFunc("/", func(w http.ResponseWriter, _ *http.Request) {
    w.Write([]byte("🍔 普通菜单：汉堡套餐"))
})
http.ListenAndServe(":8080", mux)
```

**优势**：请求流一目了然，无需在多层函数间跳跃。

## 三、混合策略：主厨+专业助手

实际项目中可灵活组合：

```go
// 主厨专注“隐藏菜单”逻辑（业务核心）
type RouteMux struct{ *http.ServeMux }
func (rm *RouteMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path == "/secret-menu" {
        w.Write([]byte("🍣 隐藏菜单"))
        return
    }
    rm.ServeMux.ServeHTTP(w, r)
}

// 专业助手处理横切关注点（日志、认证等）
func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if !isValidToken(r) {
            http.Error(w, "❌ 未授权", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    })
}

// 组装：主厨处理业务 + 助手处理通用逻辑
mux := &RouteMux{ServeMux: http.NewServeMux()}
mux.HandleFunc("/", homeHandler)
handler := authMiddleware(logging(mux)) // 仅2层中间件
```

## 四、何时选择哪种模式？

| 场景                     | 推荐模式         | 理由                                     |
|--------------------------|------------------|------------------------------------------|
| 路由逻辑定制（如特殊路径） | 嵌入式委托       | 逻辑集中，避免中间件堆叠                 |
| 横切关注点（日志/认证）   | 中间件           | 可复用、可插拔，符合关注点分离           |
| 小型服务（<5个路由）      | 嵌入式委托       | 简单直接，无过度设计                     |
| 大型微服务               | 混合模式         | 核心路由用委托，通用能力用中间件         |

 
**核心思想**：让请求流像阅读故事一样线性自然，而非在层层嵌套中迷失方向。嵌入式委托是“少即是多”的实践——当简单方案足够时，不必过早引入复杂抽象。

痛点：中间件超过 5 层后，调用栈变得像迷宫，调试时需逐层追踪 next.ServeHTTP 的流向。

中间件 vs 嵌入式委托：Go HTTP 处理的两种哲学

数据库

中间件模式与嵌入式委托是Go语言处理HTTP请求的两种方式。中间件模式通过多层嵌套实现功能扩展，适合横切关注点；嵌入式委托则集中控制请求流程，适合业务逻辑定制。混合使用两种模式可兼顾灵活性与可维护性，提升代码可读性和调试效率。

中间件

路由器

路由

2026新春采购季

message-queue-catalog

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

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

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

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

社区新版编辑器体验调研

中间件 vs 嵌入式委托：Go HTTP 处理的两种哲学-腾讯云开发者社区-腾讯云

中间件 vs 嵌入式委托：Go HTTP 处理的两种哲学

中间件 vs 嵌入式委托：Go HTTP 处理的两种哲学

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐