Go HTTP服务器中非并发安全依赖注入与请求ID日志实现问题

你现有代码的核心问题在于：LoggingService实例被所有请求共享，且持有RequestID这个请求级状态。由于每个HTTP请求在独立goroutine中处理，并发请求时会同时修改同一个LoggingService的RequestID，导致日志的请求ID被混用，出现竞态条件。

同时你希望保留依赖注入的清晰性，避免用context.Context隐藏依赖，还要复用SomethingService这类持有并发安全资源（如数据库连接）的服务实例，避免重复创建造成资源浪费。

以下是两种满足需求的实现方案，均能保证并发安全、依赖清晰，且复用共享服务实例：

方案一：显式传递请求上下文结构体 #

核心思路 #

将请求级信息（如RequestID）封装到独立的RequestContext结构体中，所有需要日志的服务方法显式接收该结构体作为参数。共享服务实例（如SomethingService、LoggingService）保持无状态，仅在方法调用时接收请求上下文，彻底避免竞态。

代码示例 #

package main

import (
    "crypto/rand"
    "fmt"
    mrand "math/rand"
    "net/http"
    "time"
)

func main() {
    logger := &LoggingService{}
    somethingSvc := &SomethingService{Logger: logger}
    handler := &Handler{
        SomethingSvc: somethingSvc,
        Logger:       logger,
    }

    http.Handle("/", handler)
    http.ListenAndServe("localhost:3333", nil)
}

// RequestContext 封装请求级上下文信息，仅包含请求相关的状态
type RequestContext struct {
    RequestID string
}

type Handler struct {
    SomethingSvc *SomethingService
    Logger       *LoggingService
}

func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    reqCtx := RequestContext{RequestID: generateRequestID()}
    h.Logger.Log(reqCtx, "A request")
    out := h.SomethingSvc.DoSomething(reqCtx, "nothing")
    w.Write([]byte(out))
}

func generateRequestID() string {
    buf := make([]byte, 10)
    rand.Read(buf)
    return fmt.Sprintf("%x", buf)
}

// SomethingService 共享业务服务，持有并发安全的资源（如数据库连接）
type SomethingService struct {
    Logger *LoggingService
    // db *sql.DB // 示例：并发安全的数据库连接
}

func (s *SomethingService) DoSomething(reqCtx RequestContext, input string) string {
    s.Logger.Log(reqCtx, fmt.Sprintf("Let's do something with %s", input))
    mrand.Seed(time.Now().UnixNano())
    n := mrand.Intn(3)
    s.Logger.Log(reqCtx, fmt.Sprintf("Sleeping %d seconds...", n))
    time.Sleep(time.Duration(n) * time.Second)
    s.Logger.Log(reqCtx, "Done")

    return "something"
}

// LoggingService 全局无状态日志服务，仅负责日志格式化输出
type LoggingService struct{}

func (l *LoggingService) Log(reqCtx RequestContext, msg string) {
    fmt.Printf("[%s] %s\n", reqCtx.RequestID, msg)
}

优缺点 #

• 优点：依赖关系完全清晰，方法签名明确展示所需的请求上下文；共享服务实例复用性高，无任何竞态风险。
• 缺点：所有需要日志的方法都需添加RequestContext参数，调用时需显式传递。

方案二：请求级服务包装器 #

核心思路 #

共享服务实例（如SharedSomethingService）保持无状态，持有并发安全资源；每个请求创建一个服务包装器，包装器持有共享服务实例和请求专属的日志器，且实现与共享服务相同的接口。上层调用无需感知包装器的存在，既复用了共享资源，又隐藏了请求上下文的传递细节。

代码示例 #

package main

import (
    "crypto/rand"
    "fmt"
    mrand "math/rand"
    "net/http"
    "time"
)

func main() {
    logger := &LoggingService{}
    sharedSomethingSvc := &SharedSomethingService{}
    handler := &Handler{
        SharedSomethingSvc: sharedSomethingSvc,
        Logger:             logger,
    }

    http.Handle("/", handler)
    http.ListenAndServe("localhost:3333", nil)
}

// SomethingService 定义业务服务接口，确保包装器与共享服务实现一致
type SomethingService interface {
    DoSomething(input string) string
}

type Handler struct {
    SharedSomethingSvc *SharedSomethingService
    Logger             *LoggingService
}

func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    reqID := generateRequestID()
    // 创建请求专属的日志器
    reqLogger := &RequestLogger{reqID: reqID, logger: h.Logger}
    // 创建请求级服务包装器，复用共享服务实例
    reqSomethingSvc := &RequestScopedSomethingService{
        sharedSvc: h.SharedSomethingSvc,
        logger:    reqLogger,
    }

    reqLogger.Log("A request")
    out := reqSomethingSvc.DoSomething("nothing")
    w.Write([]byte(out))
}

func generateRequestID() string {
    buf := make([]byte, 10)
    rand.Read(buf)
    return fmt.Sprintf("%x", buf)
}

// SharedSomethingService 共享业务服务，持有并发安全资源（如数据库连接）
type SharedSomethingService struct {
    // db *sql.DB // 示例：并发安全的数据库连接
}

// DoSomethingCore 核心业务逻辑，接收请求日志器
func (s *SharedSomethingService) DoSomethingCore(input string, logger *RequestLogger) string {
    logger.Log(fmt.Sprintf("Let's do something with %s", input))
    mrand.Seed(time.Now().UnixNano())
    n := mrand.Intn(3)
    logger.Log(fmt.Sprintf("Sleeping %d seconds...", n))
    time.Sleep(time.Duration(n) * time.Second)
    logger.Log("Done")

    return "something"
}

// RequestScopedSomethingService 请求级服务包装器，实现SomethingService接口
type RequestScopedSomethingService struct {
    sharedSvc *SharedSomethingService
    logger    *RequestLogger
}

func (s *RequestScopedSomethingService) DoSomething(input string) string {
    return s.sharedSvc.DoSomethingCore(input, s.logger)
}

// LoggingService 全局无状态日志服务，负责日志格式化输出
type LoggingService struct{}

func (l *LoggingService) LogWithRequestID(reqID, msg string) {
    fmt.Printf("[%s] %s\n", reqID, msg)
}

// RequestLogger 请求专属日志器，持有RequestID和全局日志服务
type RequestLogger struct {
    reqID  string
    logger *LoggingService
}

func (rl *RequestLogger) Log(msg string) {
    rl.logger.LogWithRequestID(rl.reqID, msg)
}

优缺点 #

• 优点：复用共享资源的同时，隐藏了请求上下文的传递细节；依赖关系清晰，上层调用无需修改原有逻辑。
• 缺点：需要为每个业务服务编写对应的包装器，增加少量代码量。

两种方案均解决了并发安全问题，且保留了依赖注入的清晰性：

• 若追求代码简洁、直接，优先选择方案一；
• 若希望减少参数传递、保持业务方法的纯净性，优先选择方案二。

内容的提问来源于stack exchange，提问作者MadsRC