Go / 系统课时

为处理器注入服务依赖

为处理器注入服务依赖

HTTP 处理器通常需要配置、日志器、数据库访问或业务服务。如果在每次请求中临时创建这些对象,生命周期和测试边界都会变得混乱。本节把依赖在启动阶段组装完成,再显式交给处理器,并演示如何在测试场景替换业务服务。

学习目标

  • 使用应用结构体和构造函数向处理器传递长期依赖
  • 理解启动期依赖与请求期数据的生命周期边界
  • 通过接口替换依赖,使处理器可以独立验证

先把依赖从处理器里拿出来

数据库连接池、业务服务和配置通常属于应用级对象,应在程序启动时创建并长期复用。处理器只负责接收请求、提取输入、调用已有服务并组织 HTTP 响应,不应在每次请求到来时重新构造整套业务依赖。

处理器依赖与生命周期关系

应用结构体适合集中保存多个长期依赖;构造函数负责一次性检查这些依赖是否完整。处理器方法随后通过结构体字段访问服务,不必依赖包级全局变量。

用应用结构体固定依赖

下面的示例把问候业务抽象为 Greeter。生产实例注入真实服务,另一个实例注入假服务;两者复用完全相同的路由和处理器代码。

go
package main

import (
    "context"
    "errors"
    "fmt"
    "net/http"
    "net/http/httptest"
    "strings"
)

type Greeter interface {
    Greet(context.Context, string) (string, error)
}

type greeterService struct {
    prefix string
}

func (s *greeterService) Greet(_ context.Context, name string) (string, error) {
    return s.prefix + " " + name, nil
}

type App struct {
    greeter Greeter
}

func NewApp(greeter Greeter) (*App, error) {
    // 构造阶段拒绝缺失的必需依赖,避免请求到来后才暴露问题。
    if greeter == nil {
        return nil, errors.New("greeter is required")
    }
    return &App{greeter: greeter}, nil
}

func (a *App) Routes() http.Handler {
    mux := http.NewServeMux()
    mux.HandleFunc("GET /hello/{name}", a.hello)
    return mux
}

func (a *App) hello(w http.ResponseWriter, r *http.Request) {
    name := strings.TrimSpace(r.PathValue("name"))
    if name == "" {
        http.Error(w, "name is required", http.StatusBadRequest)
        return
    }

    // 请求上下文继续传入业务层,取消请求时下游也能及时停止工作。
    message, err := a.greeter.Greet(r.Context(), name)
    if err != nil {
        http.Error(w, "service unavailable", http.StatusInternalServerError)
        return
    }
    fmt.Fprint(w, message)
}

type fakeGreeter struct{}

func (fakeGreeter) Greet(_ context.Context, name string) (string, error) {
    return "test:" + name, nil
}

func call(label string, handler http.Handler, target string) {
    req := httptest.NewRequest(http.MethodGet, target, nil)
    rec := httptest.NewRecorder()
    handler.ServeHTTP(rec, req)
    fmt.Printf("%s -> %d %s\n", label, rec.Code, strings.TrimSpace(rec.Body.String()))
}

func main() {
    prod, err := NewApp(&greeterService{prefix: "hello"})
    if err != nil {
        panic(err)
    }

    testApp, err := NewApp(fakeGreeter{})
    if err != nil {
        panic(err)
    }

    call("prod", prod.Routes(), "/hello/alice")
    call("test", testApp.Routes(), "/hello/bob")
}

预期输出

text
prod -> 200 hello alice
test -> 200 test:bob

这里没有为了测试修改处理器。变化只发生在程序组装阶段:生产代码提供 greeterService,测试代码提供 fakeGreeter。这就是依赖注入最重要的边界——处理器依赖能力,而不是自己决定具体实现。

三种常用注入方式

方式 适合场景 主要特点
应用结构体 处理器较多、共享多个服务 依赖集中,方法处理器易于组织
构造函数 必需依赖需要启动时校验 创建路径明确,可阻止不完整实例
闭包 少量处理器、依赖很少 局部且简洁,但依赖增多后参数容易膨胀

这三种方式并不互斥。常见做法是用构造函数创建应用结构体;对于非常局部的处理器,也可以由一个接收服务参数的函数返回 http.HandlerFunc 闭包。关键不是形式统一,而是依赖必须显式可见。

划清生命周期和并发边界

应用结构体会被多个请求并发使用,因此其中适合保存线程安全、可长期复用的服务,例如数据库连接池、只读配置和无请求状态的业务对象。不要把当前用户、请求体、临时缓冲区等单次请求数据写进共享结构体字段,它们应保留在局部变量或 Request.Context 所代表的请求生命周期内。

接口也不需要覆盖所有类型。只有当处理器需要与具体实现解耦、存在多个实现,或测试确实需要替换依赖时,再在调用边界引入小接口。这样既能获得清晰的测试替换点,又不会为了“可注入”制造大量没有实际价值的抽象。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

为处理器注入服务依赖

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通