基于Golang的六边形架构应用实现与日志中间件集成

在六边形架构中避免上下文传递的常见做法是使用上下文传播机制。以下是几种Go语言中的实现方案：

方案一：使用context.Context传递请求ID

// 中间件设置请求ID
func RequestIDMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        requestID := generateRequestID()
        c.Set("X-Request-ID", requestID)
        
        // 创建带请求ID的context
        ctx := context.WithValue(c.Request.Context(), "requestID", requestID)
        c.Request = c.Request.WithContext(ctx)
        c.Next()
    }
}

// 领域层使用（不依赖Gin）
type UserService struct {
    repo UserRepository
}

func (s *UserService) GetUser(ctx context.Context, userID string) (*User, error) {
    // 从context获取请求ID
    if requestID, ok := ctx.Value("requestID").(string); ok {
        log.Printf("[%s] Getting user %s", requestID, userID)
    }
    return s.repo.FindByID(ctx, userID)
}

// 仓库实现
type UserRepositoryImpl struct {
    db *sql.DB
}

func (r *UserRepositoryImpl) FindByID(ctx context.Context, userID string) (*User, error) {
    // 从context获取请求ID用于日志
    if requestID, ok := ctx.Value("requestID").(string); ok {
        log.Printf("[%s] Querying database for user %s", requestID, userID)
    }
    // 数据库操作...
}

方案二：使用goroutine本地存储（类似ThreadLocal）

// 定义请求上下文键类型
type contextKey string

const requestIDKey contextKey = "requestID"

// 上下文管理器
type RequestContext struct{}

func (rc *RequestContext) SetRequestID(ctx context.Context, requestID string) context.Context {
    return context.WithValue(ctx, requestIDKey, requestID)
}

func (rc *RequestContext) GetRequestID(ctx context.Context) string {
    if id, ok := ctx.Value(requestIDKey).(string); ok {
        return id
    }
    return ""
}

// 日志包装器
type Logger struct {
    context *RequestContext
}

func (l *Logger) Info(ctx context.Context, msg string, fields ...interface{}) {
    requestID := l.context.GetRequestID(ctx)
    log.Printf("[%s] %s", requestID, fmt.Sprintf(msg, fields...))
}

// 使用示例
func main() {
    router := gin.Default()
    ctxManager := &RequestContext{}
    logger := &Logger{context: ctxManager}
    
    router.Use(func(c *gin.Context) {
        requestID := generateRequestID()
        ctx := ctxManager.SetRequestID(c.Request.Context(), requestID)
        c.Request = c.Request.WithContext(ctx)
        c.Next()
    })
    
    router.GET("/users/:id", func(c *gin.Context) {
        userID := c.Param("id")
        svc := NewUserService(ctxManager, logger)
        
        // 传递context到领域层
        user, err := svc.GetUser(c.Request.Context(), userID)
        if err != nil {
            c.JSON(500, gin.H{"error": err.Error()})
            return
        }
        c.JSON(200, user)
    })
}

方案三：结构化日志与依赖注入

// 日志接口定义在领域层
package domain

type Logger interface {
    Info(msg string, fields ...interface{})
    WithRequestID(requestID string) Logger
}

// 适配器层实现
package infrastructure

type StructuredLogger struct {
    requestID string
    logger    *log.Logger
}

func (l *StructuredLogger) Info(msg string, fields ...interface{}) {
    entry := fmt.Sprintf("[%s] %s", l.requestID, msg)
    l.logger.Printf(entry, fields...)
}

func (l *StructuredLogger) WithRequestID(requestID string) Logger {
    return &StructuredLogger{
        requestID: requestID,
        logger:    l.logger,
    }
}

// 应用服务使用
package application

type UserService struct {
    repo   domain.UserRepository
    logger domain.Logger
}

func NewUserService(repo domain.UserRepository, logger domain.Logger) *UserService {
    return &UserService{
        repo:   repo,
        logger: logger,
    }
}

func (s *UserService) GetUser(userID string) (*domain.User, error) {
    s.logger.Info("Getting user", "userID", userID)
    return s.repo.FindByID(userID)
}

// HTTP处理器
package adapter

type GinHandler struct {
    userService *application.UserService
    logger      domain.Logger
}

func (h *GinHandler) GetUser(c *gin.Context) {
    requestID := c.GetString("X-Request-ID")
    userID := c.Param("id")
    
    // 创建带请求ID的logger实例
    requestLogger := h.logger.WithRequestID(requestID)
    
    // 注入到服务（可通过工厂或依赖注入容器）
    userService := application.NewUserService(
        h.userService.repo,
        requestLogger,
    )
    
    user, err := userService.GetUser(userID)
    if err != nil {
        c.JSON(500, gin.H{"error": err.Error()})
        return
    }
    c.JSON(200, user)
}

方案四：使用OpenTelemetry进行分布式追踪

import (
    "context"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/trace"
)

// 中间件设置追踪
func TracingMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        tracer := otel.Tracer("gin-server")
        ctx, span := tracer.Start(c.Request.Context(), c.Request.URL.Path)
        defer span.End()
        
        // 从span获取TraceID作为请求ID
        traceID := span.SpanContext().TraceID().String()
        ctx = context.WithValue(ctx, "requestID", traceID)
        
        c.Request = c.Request.WithContext(ctx)
        c.Next()
    }
}

// 在任何地方获取追踪ID
func logWithTrace(ctx context.Context, msg string) {
    if span := trace.SpanFromContext(ctx); span.IsRecording() {
        traceID := span.SpanContext().TraceID().String()
        log.Printf("[%s] %s", traceID, msg)
    }
}

推荐使用方案一或方案二，它们保持了六边形架构的边界清晰，同时避免了上下文对象的过度传递。context.Context是Go语言标准库提供的标准解决方案，适合在请求处理链中传递请求范围的值。