Golang中数据库连接打开与关闭的最佳实践

在Golang中，最佳实践是在应用启动时创建单个数据库连接池，并在整个应用生命周期中复用这个连接池。sql.Open()实际上创建的是一个连接池，而不是单个连接。每个函数都调用sql.Open()和db.Close()会导致性能问题和资源浪费。

以下是改进后的代码结构：

main.go

package main

import (
    "database/sql"
    "log"
    "net/http"
    
    "github.com/gorilla/mux"
    "your-project/controllers"
    "your-project/repository"
)

var db *sql.DB

func main() {
    // 初始化数据库连接
    var err error
    db, err = sql.Open("driverName", "connectionString")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    
    // 测试连接
    err = db.Ping()
    if err != nil {
        log.Fatal(err)
    }
    
    // 设置连接池参数
    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(25)
    db.SetConnMaxLifetime(5 * time.Minute)
    
    // 将db实例传递给repository层
    repo := repository.NewRepository(db)
    controller := controllers.NewController(repo)
    
    router := mux.NewRouter()
    router.HandleFunc("/protectedEndpoint", controller.GetStudents).Methods("GET")
    router.HandleFunc("/signup", controller.GetBook).Methods("GET")
    router.HandleFunc("/login", controller.GetReports).Methods("GET")
    
    log.Fatal(http.ListenAndServe(":8080", router))
}

repository.go

package repository

import (
    "database/sql"
    "log"
)

type Repository struct {
    db *sql.DB
}

func NewRepository(db *sql.DB) *Repository {
    return &Repository{db: db}
}

func (r *Repository) GetStudents(studentId int) {
    row, err := r.db.Query("SELECT * FROM student WHERE studentId = ?", studentId)
    if err != nil {
        log.Printf("Query error: %v", err)
        return
    }
    defer row.Close()
    
    // 处理结果
    for row.Next() {
        // 扫描数据
    }
}

func (r *Repository) GetBook(bookId int) {
    row, err := r.db.Query("SELECT * FROM book WHERE bookId = ?", studentId)
    if err != nil {
        log.Printf("Query error: %v", err)
        return
    }
    defer row.Close()
    
    // 处理结果
    for row.Next() {
        // 扫描数据
    }
}

func (r *Repository) GetReports(studentId int) {
    row, err := r.db.Query("SELECT * FROM reports WHERE studentId = ?", studentId)
    if err != nil {
        log.Printf("Query error: %v", err)
        return
    }
    defer row.Close()
    
    // 处理结果
    for row.Next() {
        // 扫描数据
    }
}

controller.go

package controllers

import (
    "net/http"
    "strconv"
    
    "your-project/repository"
)

type Controller struct {
    repo *repository.Repository
}

func NewController(repo *repository.Repository) *Controller {
    return &Controller{repo: repo}
}

func (c *Controller) GetStudents(w http.ResponseWriter, r *http.Request) {
    studentIdStr := r.URL.Query().Get("id")
    studentId, err := strconv.Atoi(studentIdStr)
    if err != nil {
        http.Error(w, "Invalid student ID", http.StatusBadRequest)
        return
    }
    
    c.repo.GetStudents(studentId)
    // 处理响应
}

func (c *Controller) GetBook(w http.ResponseWriter, r *http.Request) {
    bookIdStr := r.URL.Query().Get("id")
    bookId, err := strconv.Atoi(bookIdStr)
    if err != nil {
        http.Error(w, "Invalid book ID", http.StatusBadRequest)
        return
    }
    
    c.repo.GetBook(bookId)
    // 处理响应
}

func (c *Controller) GetReports(w http.ResponseWriter, r *http.Request) {
    studentIdStr := r.URL.Query().Get("id")
    studentId, err := strconv.Atoi(studentIdStr)
    if err != nil {
        http.Error(w, "Invalid student ID", http.StatusBadRequest)
        return
    }
    
    c.repo.GetReports(studentId)
    // 处理响应
}

这种架构的优势：

1. 连接池在应用启动时创建一次，避免重复开销
2. 通过依赖注入将数据库连接传递给repository层
3. 连接池参数可配置，优化性能
4. 资源管理更高效，避免频繁打开关闭连接
5. 支持连接复用，提高并发性能

注意：sql.DB是并发安全的，可以在多个goroutine中安全使用。defer db.Close()应该只在main函数中调用，在应用退出时关闭所有连接。