如何使用依赖注入在 golang 中正确设置 defer .close

来到golang学习网的大家，相信都是编程学习爱好者，希望在这里学习Golang相关编程知识。下面本篇文章就来带大家聊聊《如何使用依赖注入在 golang 中正确设置 defer .close》，介绍一下，希望对大家的知识积累有所帮助，助力实战开发！

我想设置 defer xxx.close() 来关闭 golang 中的连接。

但如果我在 insert sql 方法之后设置 defer xxx.close() ，则其结果为 null。

如果我在 insert sql 方法之后删除 defer xxx.close()，其结果将返回正确的值。

我设置了 defer xxx.close() 以避免连接限制和崩溃。但现在如果我删除 defer xxx.close()，就无法避免这种情况。

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

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 中设置了依赖注入样式。 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 没有返回正确的值。

我想知道如何避免连接限制和崩溃而不出现此问题。

解决方案

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

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

这里可能还有一些关于 defer 的混淆。 defer 在函数末尾触发，因此返回时会触发：

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

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

作为参考，here 是有关在结果集上调用 clos​​e() 时具体发生的情况的文档。

到这里，我们也就讲完了《如何使用依赖注入在 golang 中正确设置 defer .close》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！