mysql - 如何使用依赖注入(inject)在 golang 中正确设置 defer .close

Question

我想设置defer xxx.Close()来关闭golang中的连接。
但是如果我在INSERT SQL方法之后设置defer xxx.Close()，它的结果是null。
如果我在 INSERT SQL 方法之后删除 defer xxx.Close()，其结果将返回正确的值。
我设置了 defer xxx.Close() 以避免连接限制和崩溃。但现在，如果我删除 defer xxx.Close()，就无法避免这种情况。

• 我在 golang 中设置了依赖注入(inject)。
  

dao.go

package dao

import (
    "database/sql"
    "log"
)

type Dao struct {
    database *sql.DB
}

func NewDao(database *sql.DB) *Dao {
    objs := &Dao{database: database}
    return objs
}

type DaoInterface interface {
    GetEmployeeListDao() *sql.Rows
    RegisterEmployeeDao(employee model.RegisterEmployee, uu string, encrypted string)
}

func (d *Dao) GetEmployeeListDao() *sql.Rows {

    results, err := d.database.Query("SELECT id, name, email, isDisplay FROM employee")
    if err != nil {
        panic(err.Error())
    }
    //it returns nothing.
    //If removing defer results.Close(), results returns correct value
    defer results.Close()
    return results
}

func (d *Dao) RegisterEmployeeDao(employee model.RegisterEmployee, uu string, encrypted string) {
    ins, err := d.database.Prepare("INSERT INTO employee(name, email, password, isDisplay) VALUES(?,?,?,?)")
    if err != nil {
        log.Fatal(err)
    }
    //same problem will occure here.
    defer ins.Close()
    _, err = ins.Exec(uu, employee.NAME, employee.EMAIL, encrypted, employee.ISDISPLAY)
    if err != nil {
        log.Fatal(err)
    }
}

service.go

package service

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/base64"
    "io"

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

type Service struct {
    dao dao.DaoInterface
}

func NewService(dao dao.DaoInterface) *Service {
    return &Service{dao: dao}
}

type ServiceInterface interface {
    GetEmployeeListService() []model.Employee
    RegisterEmployeeService(c *gin.Context)
}

func (s Service) GetEmployeeListService() []model.Employee {
    var employee []model.Employee

    results := s.dao.GetEmployeeListDao()

    singleEmployee := model.Employee{}
    for results.Next() {
        err := results.Scan(&singleEmployee.ID, &singleEmployee.NAME, &singleEmployee.EMAIL, &singleEmployee.ISDISPLAY)
        if err != nil {
            panic(err.Error())
        } else {
            employee = append(employee, singleEmployee)
        }
    }

    defer results.Close()

    var displayEmployee []model.Employee

    for _, e := range employee {
        if e.ISDISPLAY == true {
            displayEmployee = append(displayEmployee, e)
        }
    }

    return displayEmployee
}

func (s Service) RegisterEmployeeService(c *gin.Context) {
    var employee model.RegisterEmployee
    c.BindJSON(&employee)

    block, err := aes.NewCipher([]byte("aes-secret-key-1"))
    if err != nil {
        panic(err)
    }
    b := base64.StdEncoding.EncodeToString([]byte(employee.PASSWORD))
    cipt := make([]byte, aes.BlockSize+len(b))
    iv := cipt[:aes.BlockSize]
    if _, err := io.ReadFull(rand.Reader, iv); err != nil {
        panic(err)
    }
    cfb := cipher.NewCFBEncrypter(block, iv)
    cfb.XORKeyStream(cipt[aes.BlockSize:], []byte(b))
    encrypted := base64.StdEncoding.EncodeToString(cipt)

    s.dao.RegisterEmployeeDao(employee, encrypted)
}

我在 api 中设置了依赖注入(inject)样式。main.go

package main

import (
    "os"
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    db := db.NewDatabase(os.Getenv("MYSQL_USER"), os.Getenv("MYSQL_PASSWORD"), os.Getenv("MYSQL_HOST"))
    dao := dao.NewDao(db.DATABASE)
    service := service.NewService(dao)
    cntlr := controller.NewController(service)
    router := handler.NewHandler(cntlr)

    router.Router.Run(":8080")
}

我希望 defer xxx.Close() 没有问题，并且插入和选择 sql 返回正确的值。
但问题是因为 defer xxx.Close() insert 和 select sql 没有返回正确的值。
我想知道如何避免连接限制和崩溃而不出现此问题。

Answer 1

我认为您期望的是结果集立即作为数组或类似的东西返回。这种情况不会发生，因为客户端很懒 - 在您明确尝试使用 Next() 读取行之前，它不会给您结果。这是有充分理由的 - 如果结果集包含数百万行，那么通过网络连接传输数据会非常慢，甚至可能会耗尽运行查询的机器的内存。为了避免这种情况，结果集实际上更像是一个“句柄”，允许您在需要时从数据库中获取更多行，而不是结果本身。

当您对结果集调用 Close() 时，它表示您不再需要任何更多数据。

这里对于defer也可能存在一些混淆。 defer 在函数末尾触发，因此返回时会触发:

defer results.Close()
return results  // defer is triggered here, which will close the result set

然后，当您尝试从中读取内容时，它是一个封闭的结果集，因此您实际上无法从中读取任何内容。

仅供引用，here是有关在结果集上调用 Close() 时具体发生的情况的文档。