在Golang中将MySQL连接作为中间件用于其他包

在Golang中，将MySQL连接作为共享资源供多个包使用的最佳实践是通过依赖注入的方式。以下是实现方案：

1. 创建数据库连接池

// database/database.go
package database

import (
    "database/sql"
    "fmt"
    "log"
    "sync"
    _ "github.com/go-sql-driver/mysql"
)

var (
    db   *sql.DB
    once sync.Once
)

// InitDB 初始化数据库连接池
func InitDB(dataSourceName string) error {
    var err error
    
    once.Do(func() {
        db, err = sql.Open("mysql", dataSourceName)
        if err != nil {
            return
        }
        
        // 设置连接池参数
        db.SetMaxOpenConns(25)
        db.SetMaxIdleConns(10)
        db.SetConnMaxLifetime(5 * time.Minute)
        
        // 测试连接
        if err = db.Ping(); err != nil {
            db.Close()
            return
        }
        
        log.Println("Database connection established")
    })
    
    return err
}

// GetDB 获取数据库连接实例
func GetDB() *sql.DB {
    return db
}

// CloseDB 关闭数据库连接
func CloseDB() error {
    if db != nil {
        return db.Close()
    }
    return nil
}

2. 创建中间件处理程序

// middleware/db_middleware.go
package middleware

import (
    "context"
    "database/sql"
    "net/http"
    "yourproject/database"
)

type contextKey string

const dbContextKey contextKey = "db"

// DBMiddleware 将数据库连接注入到请求上下文中
func DBMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        db := database.GetDB()
        ctx := context.WithValue(r.Context(), dbContextKey, db)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

// GetDBFromContext 从上下文中获取数据库连接
func GetDBFromContext(ctx context.Context) *sql.DB {
    if db, ok := ctx.Value(dbContextKey).(*sql.DB); ok {
        return db
    }
    return nil
}

3. 在HTTP处理器中使用

// handlers/user_handler.go
package handlers

import (
    "database/sql"
    "encoding/json"
    "net/http"
    "yourproject/middleware"
)

type UserHandler struct {
    db *sql.DB
}

// NewUserHandler 构造函数，支持依赖注入
func NewUserHandler(db *sql.DB) *UserHandler {
    return &UserHandler{db: db}
}

// GetUsers 使用注入的数据库连接
func (h *UserHandler) GetUsers(w http.ResponseWriter, r *http.Request) {
    rows, err := h.db.Query("SELECT id, name, email FROM users")
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer rows.Close()
    
    // 处理查询结果...
}

// GetUsersFromContext 从上下文中获取数据库连接
func GetUsersFromContext(w http.ResponseWriter, r *http.Request) {
    db := middleware.GetDBFromContext(r.Context())
    if db == nil {
        http.Error(w, "Database connection not found", http.StatusInternalServerError)
        return
    }
    
    rows, err := db.Query("SELECT id, name, email FROM users")
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer rows.Close()
    
    // 处理查询结果...
}

4. 主程序配置

// main.go
package main

import (
    "log"
    "net/http"
    "yourproject/database"
    "yourproject/handlers"
    "yourproject/middleware"
)

func main() {
    // 初始化数据库连接
    err := database.InitDB("user:password@tcp(localhost:3306)/dbname?parseTime=true")
    if err != nil {
        log.Fatal("Failed to connect to database:", err)
    }
    defer database.CloseDB()
    
    // 创建处理器实例
    db := database.GetDB()
    userHandler := handlers.NewUserHandler(db)
    
    // 设置路由
    mux := http.NewServeMux()
    
    // 使用依赖注入的方式
    mux.HandleFunc("/users", userHandler.GetUsers)
    
    // 使用中间件的方式
    mux.Handle("/users-context", middleware.DBMiddleware(
        http.HandlerFunc(handlers.GetUsersFromContext),
    ))
    
    // 启动服务器
    log.Println("Server starting on :8080")
    if err := http.ListenAndServe(":8080", mux); err != nil {
        log.Fatal("Server failed:", err)
    }
}

5. 仓库模式示例

// repositories/user_repository.go
package repositories

import (
    "database/sql"
    "yourproject/models"
)

type UserRepository struct {
    db *sql.DB
}

func NewUserRepository(db *sql.DB) *UserRepository {
    return &UserRepository{db: db}
}

func (r *UserRepository) FindAll() ([]models.User, error) {
    rows, err := r.db.Query("SELECT id, name, email FROM users")
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    var users []models.User
    for rows.Next() {
        var user models.User
        if err := rows.Scan(&user.ID, &user.Name, &user.Email); err != nil {
            return nil, err
        }
        users = append(users, user)
    }
    
    return users, nil
}

func (r *UserRepository) FindByID(id int) (*models.User, error) {
    var user models.User
    err := r.db.QueryRow("SELECT id, name, email FROM users WHERE id = ?", id).
        Scan(&user.ID, &user.Name, &user.Email)
    if err != nil {
        return nil, err
    }
    return &user, nil
}

这个实现方案提供了两种方式：

1. 依赖注入：通过构造函数将数据库连接传递给处理器或仓库
2. 中间件模式：通过请求上下文传递数据库连接

两种方式都能确保整个应用程序共享同一个数据库连接池，避免了重复创建连接的开销。sync.Once 保证了连接只初始化一次，连接池参数可以根据实际需求调整。