4. Go HTTP 基础：net/http 包、路由处理、中间件模式

在构建 BFF（Backend For Frontend）层时，HTTP 服务是承载所有请求入口的核心载体。Go 标准库 net/http 提供了简洁而强大的基础能力，理解其路由处理与中间件模式，是实现权限验证拦截的前提。本章将深入剖析这三个关键要素，为后续的权限中间件开发打下坚实基础。

4.1 net/http 核心组件

net/http 包的设计围绕两个核心接口展开：Handler 和 HandlerFunc。任何实现了 ServeHTTP(ResponseWriter, *Request) 方法的对象都可以作为 HTTP 处理器。

组件 类型 说明
Handler 接口 定义 ServeHTTP(ResponseWriter, *Request) 方法，所有 HTTP 处理器的统一抽象。
HandlerFunc 函数类型 将普通函数适配为 Handler 的适配器，是编写路由处理函数最常用的方式。
ServeMux 结构体 默认的多路复用器，负责将请求 URL 匹配到注册的 Handler。
Server 结构体 配置监听地址、超时、TLS 等参数，并启动 HTTP 服务。
关键认知： BFF 层通常不会直接使用 ServeMux 作为路由核心，而是选择更灵活的路由库（如 gorilla/mux 或 chi），但理解标准库的底层机制是掌握任何路由框架的基础。

4.2 路由处理：从标准库到模式匹配

标准库 ServeMux 仅支持路径前缀匹配，不支持路径参数（如 /users/:id）和方法路由。在 BFF 场景中，我们需要更精细的路由控制。

4.2.1 标准库路由示例

package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, BFF!")
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/hello", helloHandler)

    server := &http.Server{
        Addr:    ":8080",
        Handler: mux,
    }
    server.ListenAndServe()
}

4.2.2 使用 chi 实现 RESTful 路由

在 BFF 实践中，推荐使用 chi 路由库，它轻量、兼容 net/http 标准接口，并原生支持中间件链和路径参数。

import (
    "github.com/go-chi/chi/v5"
    "net/http"
)

func getUserHandler(w http.ResponseWriter, r *http.Request) {
    userID := chi.URLParam(r, "userID")
    // 处理用户查询逻辑
}

func main() {
    r := chi.NewRouter()
    r.Get("/users/{userID}", getUserHandler)
    r.Post("/users", createUserHandler)
    r.Put("/users/{userID}", updateUserHandler)
    r.Delete("/users/{userID}", deleteUserHandler)

    http.ListenAndServe(":8080", r)
}
实践建议： 在 BFF 项目中，始终使用支持方法路由和路径参数的路由库。这能让权限验证中间件更精确地匹配到需要保护的资源路径。

4.3 中间件模式：请求处理管道

中间件是 Go HTTP 生态中最强大的模式之一。它将横切关注点（如日志、认证、权限检查）从业务处理中剥离，形成可组合的处理管道。

4.3.1 中间件的本质

一个中间件本质上是一个接收 Handler 并返回 Handler 的函数。通过链式调用，多个中间件可以串联执行。

// 中间件签名
type Middleware func(http.Handler) http.Handler

// 日志中间件示例
func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 前置处理
        log.Printf("Request: %s %s", r.Method, r.URL.Path)

        // 调用下一个处理器
        next.ServeHTTP(w, r)

        // 后置处理
        log.Printf("Response completed for %s", r.URL.Path)
    })
}

4.3.2 中间件链的执行顺序

中间件的执行顺序遵循“洋葱模型”：最先注册的中间件最外层包裹，最后注册的中间件最靠近业务处理器。

中间件洋葱模型执行顺序 请求入口 → 中间件 1（日志） 中间件 2（认证） 中间件 3（权限验证） 业务处理器 （获取用户数据） 中间件 3（权限验证）← 响应返回 中间件 2（认证） 中间件 1（日志）→ 响应出口

4.4 在 chi 中构建中间件链

chi 提供了 Use 方法注册全局中间件，以及 With 方法为特定路由组添加中间件。这是实现 BFF 权限隔离的关键手段。

func main() {
    r := chi.NewRouter()

    // 全局中间件：所有路由都会经过
    r.Use(LoggingMiddleware)
    r.Use(RecovererMiddleware)

    // 公开路由组：不需要认证
    r.Group(func(r chi.Router) {
        r.Get("/health", healthHandler)
        r.Post("/login", loginHandler)
    })

    // 受保护路由组：需要认证和权限验证
    r.Group(func(r chi.Router) {
        r.Use(AuthMiddleware)       // 认证中间件
        r.Use(PermissionMiddleware) // 权限验证中间件

        r.Get("/api/users/{userID}", getUserHandler)
        r.Post("/api/orders", createOrderHandler)
    })

    http.ListenAndServe(":8080", r)
}
权限隔离要点： 在 BFF 架构中，务必为不同角色（如管理员、普通用户、第三方应用）创建独立的路由组，并应用不同的中间件链。避免在业务处理器内部重复进行权限判断。

4.5 自定义中间件：上下文传递

中间件之间以及中间件与业务处理器之间，通过 context.Context 传递数据。这是 Go 中传递请求级数据的标准方式，也是权限验证结果传递的核心机制。

// 定义上下文键类型，避免冲突
type contextKey string

const (
    UserIDKey contextKey = "userID"
    RoleKey   contextKey = "role"
)

// 认证中间件：解析 Token 并将用户信息注入上下文
func AuthMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token == "" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }

        // 解析 Token，获取用户信息（示例简化）
        userID := "user-123"
        role := "admin"

        // 将用户信息注入上下文
        ctx := context.WithValue(r.Context(), UserIDKey, userID)
        ctx = context.WithValue(ctx, RoleKey, role)

        // 传递带有上下文的请求
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

// 业务处理器：从上下文中提取用户信息
func getUserHandler(w http.ResponseWriter, r *http.Request) {
    userID := r.Context().Value(UserIDKey).(string)
    role := r.Context().Value(RoleKey).(string)

    // 使用用户信息处理业务逻辑
    // ...
}

4.6 中间件模式与权限验证的映射

在 BFF 权限验证体系中，中间件模式天然适合实现以下横切关注点：

中间件层级 职责 在权限链中的位置
日志中间件 记录请求来源、路径、耗时 最外层，所有请求必经
认证中间件 验证 Token 有效性，提取用户身份 第二层，确定“你是谁”
权限中间件 检查用户是否具有操作资源的权限 第三层，确定“你能做什么”
限流中间件 防止滥用，保护后端服务 可在认证前或认证后
业务处理器 执行具体的业务逻辑 最内层，信任上下文中的用户信息
BFF 请求处理管道（中间件链） 客户端请求 日志中间件 记录请求信息 认证中间件 验证 Token 权限中间件 检查 RBAC/ABAC 业务处理器 执行逻辑 响应 上下文传递：userID, role, permissions 每个中间件可以向 context 注入数据，供后续中间件和业务处理器使用 认证失败 权限不足 返回 401 Unauthorized 返回 403 Forbidden

4.7 本章小结

  • net/http 基础：理解 Handler、HandlerFunc、ServeMux 是掌握 Go HTTP 生态的基石。
  • 路由处理：BFF 项目应使用支持方法路由和路径参数的路由库（如 chi），以实现精确的权限匹配。
  • 中间件模式：通过洋葱模型实现横切关注点的解耦，权限验证是中间件最典型的应用场景之一。
  • 上下文传递：利用 context.Context 在中间件链中传递用户身份和权限信息，避免全局变量污染。
  • 管道构建：在 chi 中通过 Use 和 With 方法构建分层中间件链，实现认证、权限、限流等能力的灵活组合。
← 上一章 📖 返回目录 下一章 →