如何为FX框架实现请求作用域的MySQL临时数据库连接？

核心思路 #

通过Gin中间件统一管理请求级别的数据库连接生命周期：请求开始时创建连接并存入上下文，请求过程中所有仓储从上下文复用该连接，请求结束后自动关闭连接，结合Fx的依赖注入保持组件解耦。

步骤1：实现请求级连接管理的Gin中间件 #

创建中间件负责连接的创建、上下文存储和销毁，确保每个请求对应唯一连接：

import (
    "context"
    "database/sql"
    "log"
    "net/http"

    "github.com/gin-gonic/gin"
)

// 定义上下文键常量，避免魔法字符串
const DBConnKey = "request_db_conn"

func DBConnectionMiddleware(dbFactory func() (*sql.DB, error)) gin.HandlerFunc {
    return func(c *gin.Context) {
        // 调用工厂函数创建数据库连接
        db, err := dbFactory()
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": "无法创建数据库连接"})
            c.Abort()
            return
        }

        // 将连接存入请求上下文
        c.Set(DBConnKey, db)

        // 请求结束后关闭连接（无论成功/失败）
        defer func() {
            if closeErr := db.Close(); closeErr != nil {
                log.Printf("警告：关闭数据库连接失败: %v", closeErr)
            }
        }()

        // 继续处理请求
        c.Next()
    }
}

步骤2：调整仓储实现，从上下文复用连接 #

不再在仓储构造函数中硬编码注入连接，改为从请求上下文获取连接，或通过统一的连接获取器解耦：

方式1：仓储方法直接从上下文取连接（简洁版）

import "fmt"

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

type UserRepo struct{}

func (r *UserRepo) GetUser(c context.Context, userID int) (*User, error) {
    // 从上下文获取连接
    db, ok := c.Value(DBConnKey).(*sql.DB)
    if !ok {
        return nil, fmt.Errorf("请求上下文中未找到数据库连接")
    }

    // 执行数据库操作（使用带上下文的方法，支持请求取消）
    var user User
    err := db.QueryRowContext(c, "SELECT id, name FROM users WHERE id = ?", userID).Scan(&user.ID, &user.Name)
    return &user, err
}

方式2：通过连接获取器解耦（适合复杂项目）

定义接口封装上下文取连接的逻辑，注入到仓储中，提升可测试性：

import "fmt"

// DBGetter 定义从上下文获取连接的接口
type DBGetter interface {
    Get(c context.Context) (*sql.DB, error)
}

// ContextDBGetter 实现DBGetter接口
type ContextDBGetter struct{}

func (g *ContextDBGetter) Get(c context.Context) (*sql.DB, error) {
    db, ok := c.Value(DBConnKey).(*sql.DB)
    if !ok {
        return nil, fmt.Errorf("请求上下文中未找到数据库连接")
    }
    return db, nil
}

// 仓储依赖DBGetter接口
type UserRepo struct {
    dbGetter DBGetter
}

// NewUserRepo 通过Fx注入DBGetter实例
func NewUserRepo(getter DBGetter) *UserRepo {
    return &UserRepo{dbGetter: getter}
}

func (r *UserRepo) GetUser(c context.Context, userID int) (*User, error) {
    db, err := r.dbGetter.Get(c)
    if err != nil {
        return nil, err
    }

    var user User
    err = db.QueryRowContext(c, "SELECT id, name FROM users WHERE id = ?", userID).Scan(&user.ID, &user.Name)
    return &user, err
}

步骤3：Fx整合与路由配置 #

将中间件、DB工厂、仓储等组件通过Fx注册，构建完整的应用：

import (
    "strconv"

    "go.uber.org/fx"
)

func main() {
    fx.New(
        fx.Provide(
            // 注册你的DB工厂函数New（返回*sql.DB和error）
            New,
            // 注册DBGetter实现
            func() DBGetter { return &ContextDBGetter{} },
            // 注册用户仓储
            NewUserRepo,
            // 注册Gin引擎并应用中间件
            func(dbFactory func() (*sql.DB, error), userRepo *UserRepo) *gin.Engine {
                r := gin.Default()
                // 全局应用DB连接中间件
                r.Use(DBConnectionMiddleware(dbFactory))

                // 注册业务路由
                r.GET("/users/:id", func(c *gin.Context) {
                    userID, err := strconv.Atoi(c.Param("id"))
                    if err != nil {
                        c.JSON(http.StatusBadRequest, gin.H{"error": "无效的用户ID"})
                        return
                    }

                    user, err := userRepo.GetUser(c, userID)
                    if err != nil {
                        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                        return
                    }

                    c.JSON(http.StatusOK, user)
                })

                return r
            },
        ),
        // 启动Gin引擎
        fx.Invoke(func(engine *gin.Engine) {
            if err := engine.Run(":8080"); err != nil {
                log.Fatalf("启动服务失败: %v", err)
            }
        }),
    ).Run()
}

关键注意事项 #

• 所有数据库操作必须使用带上下文的方法（如QueryRowContext），确保请求取消时能正确终止数据库操作。
• 中间件中的defer db.Close()会在请求处理完成后执行，无论请求是否成功，避免连接泄漏。
• 如果需要使用连接池而非每个请求创建新连接，可调整工厂函数返回连接池中的连接，中间件改为放回连接池而非关闭，但需注意连接池的配置和复用逻辑。

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