mysql连接池设置多大 gin mysql 连接池

利用 gin 项目搭建一个简易的后端系统。

一个简易的 HTTP 响应接口

首先在 go 工作区的终端输入这条指令：

go get -u github.com/gin-gonic/gin

将 gin 项目的相关依赖保存到本地。

在终端生成 go mod 包管理文件：

go mod init

再创建一个 main.go 文件：

package main

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

func main() {
    r := gin.Default()
    r.GET("/test", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "test",
        })
    })
    r.Run(":9999") // 运行在9999端口
}

因为我是在 wsl 运行这个项目，所以还需要先获取虚拟机的 ip，然后用 curl 测试：

curl http://<ip>:9999/ping

返回结果：

{"message":"test"}

连接 MySQL

关于 MySQL 操作这部分，一开始想着简单，只学了查询数据库部分，大多数踩得坑都是在查询部分，后面觉得要举一反三，就在原来基础上又写了添加的部分，在添加数据这一块写的不是很详细。

添加

先把基本的框架写出来，这里我连接的数据库结构体如下：

type SqlUser struct {
	User_id       string `json:"user_id" from:"user_id"`	
	User_name     string `json:"user_name" from:"user_name"`
}

添加单条数据：

Db, _ := sql.Open("mysql", "<username>:<password>@(localhost:3306)/<yourDatabase>")
router.POST("/add", func(c *gin.Context) {
    User_id := c.Request.FormValue("User_id")
	User_name := c.Request.FormValue("User_name")
    result, err := db.SqlDB.Exec("INSERT INTO t_user (user_id,user_name) VALUE(?,?)", u.User_id, u.User_name)
    if err != nil {
        log.Fatalln(err)
    }
    id, err := result.LastInsertId()
    if err != nil {
        log.Fatalln(err)
    }
    msg := fmt.Sprintf("insert successfully %d", id)
    c.JSON(http.StatusOK, gin.H{
        "msg": msg,
        "user_name": User_name,
    })
})
r.Run(":9999")

执行非 query 操作，使用 Exec 方法，使用 curl 进行测试：

curl -X POST http://<ip>:9999/add -d "User_id=2&User_name=aaa"

返回结果如下：

{"msg":"insert successfully 1","user_name":"test"}

查询

单条查询如下

r.GET("/test/:id", func(c *gin.Context) {
    id: c.Param("id")
    var u SqlUser
    err := Db.QueryRow("select user_id,user_name from t_user where user_id =?", id).Scan(&u.user_id, &u.user_name)
    if err != nil {
        log.Fatalln(err)
        c.JSON(http.StatusOK, gin.H{
            "user": nil,
        })
        return
    }
    c.JSON(http.StatusOK, gin.H{
        "user": u.user_name,
    })
})

然后用 curl 命令去测试：

curl http://<ip>:9999/test/1

会得到之前在 MySQL 中预先保存的条目，样例结构如下：

{"user":"test"}

然而，最开始我不是这样写的，当时的我，没整理好这个框架，直接在单文件里封装函数，下面是我的错误示范：

var Db *sql.DB
func QueryData(c *gin.Context) {
    id := c.Param("id")
    var u SqlUser
    err := Db.QueryRow("select user_id,user_name from t_user where user_id =?", id).Scan(&u.user_id, &u.user_name)
    if err != nil {
        log.Fatalln(err)
        c.JSON(200, gin.H{
            "user": nil,
        })
        return
    }
    c.JSON(200, gin.H{
        "user": u.user_name,
    })
}

func main() {
    Db, _ = sql.Open("/*mysql link*/")
    // 略去了这个问题相关的代码
    r.GET("/test/:id", QueryData)
    r.Run(":9999")
}

然后就出现这样的错误：

runtime error: invalid memory address or nil pointer dereference

必应上的结果是：指针声明后未初始化就赋值。

这个 bug 困扰了我一整天，然后就开始了痛苦的 debug，main 函数的 router 应该是没问题的，接口测试正常，那问题应该是出在 QueryData 上，那只能一个个打印变量测试吧，测试到 Db 时，发现这个变量为 nil，然后紧接着抛出刚才提到的错误。好吧，这个错误我在之前也偶尔犯过，虽然在 main 中对其赋了值，但作用域不一样，所以还是无法传值，那只好去考虑下框架了。

修改

修改单条数据：

router.PUT("/person/:id", func(c *gin.Context) {
    cid := c.Param("id")
    id, err := strconv.Atoi(cid)
    person := Person{Id: id}
    err = c.Bind(&person)
    if err != nil {
        log.Fatalln(err)
    }
    stmt, err := Db.Prepare("UPDATE person SET user_name=? where user_id=?")
    
    if err != nil {
        log.Fatalln(err)
    }
    defer stmt.Close()
    rs, err := stmt.Exec(person.user_name, person.user_id)
    if err != nil {
        log.Fatalln(err)
    }
    ra, err := rs.RowsAffected()
    if err != nil {
        log.Fatalln(err)
    }
    msg := fmt.Sprintf("UPDATE person %d successful %d", person.user_id, ra)
    c.JSON(http.StatusOK, gin.H{
        "msg": msg,
    })
})

urlencode 方式更新：

curl -X PUT http://<ip>:9999/person/1 -d "user_id=1&user_name=temp"

json 方式更新：

curl -X PUT http://<ip>:9999/person/1 -H "Content-Type: application/json" -d '{"user_name":"temp"}'

删除

router.DELETE("person/:id", func(c *gin.Context) {
    cid := c.Param("id")
    id, err := strconv.Atoi(cid)
    if err != nil {
        log.Fatalln(err)
    }
    rs, err := db.Exec("DELETE FROM person from where user_id=?", id)
    if err != nil {
        log.Fatalln(err)
    }
    ra, err := rs.RowsAffected()
    if err != nil {
        log.Fatalln(err)
    }
    msg := fmt.Sprintf("DELETE person %d successful %d", id, ra)
    c.JSON(http.StatusOK, gin.H{
        "msg": msg,
    })
})

直接使用删除接口

curl -X "DELETE" http://<ip>:9999/person/1

这里的 DELETE 参数必须在双引号内，不然不会被识别为 delete 请求。

搭建框架

参考了大佬的做法 ¹，我也来创建我的目录：

ginExample tree
.
├── api
│   └── query.go
├── database
│   └── mysql.go
├── main.go
├── models
│   └── queryUser.go
├── router.go
├── go.mod
└── go.sum

这里的话以添加、查询功能为例，增删改同理，具体可以查看文末的参考链接。

api 存放 handler 函数，model 存放数据模型。

数据库处理

// mysql.go
package database

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

var SqlDB *sql.DB

func init() {
    var err error
	SqlDB, err = sql.Open("mysql", "root:jaydenmysql@(127.0.0.1:3306)/microtest")
	if err != nil {
		log.Fatalln(err.Error())
	}
	err = SqlDB.Ping()
	if err != nil {
		log.Fatalln(err.Error())
	}
}

因为在别的包会用到 SqlDB 这个变量，因此必须大写 (golang 只有大写开头变量才是 public 类变量)

数据 model 封装

抽离出 SqlUser 结构体以及对应的方法：

package models

import (
	db "ginExample/database"
	"log"
)

type SqlUser struct {
	User_id       string `json:"user_id" from:"user_id"`	
	User_name     string `json:"user_name" from:"user_name"`
}

func (u *SqlUser) GetUser(id string) SqlUser {
	err := db.SqlDB.QueryRow("select user_id,user_name from t_user where user_id =?", id).Scan(&u.User_id, &u.User_name)
	if err != nil {
		log.Println(err)
		u.User_name = "nil"
		return *u
	}
	return *u
}

func (u *SqlUser) AddUser() (id int64, err error) {
    result, err := db.SqlDB.Exec("INSERT INTO t_user (user_id,user_name) VALUE(?,?)", u.User_id, u.User_name)
    if err != nil {
		log.Fatalln(err)
		return
	}
	id, err = result.LastInsertId()
	if err != nil {
		log.Fatalln(err)
		return
	}
	fmt.Println(id)
	return id, err
}

func (u *SqlUser) UpdateUser() int64 {
    stmt, err := db.SqlDB.Prepare("UPDATE t_user SET user_name=? where user_id=?")
	if err != nil {
		log.Fatalln(err)
	}
	rs, err := stmt.Exec(u.User_name, u.User_id)
	if err != nil {
		log.Fatalln(err)
	}
	ra, err := rs.RowsAffected()
	if err != nil {
		log.Fatalln(err)
	}
	return ra
}

func (u *SqlUser) DeleteUser(id string) int64 {
	rs, err := db.SqlDB.Exec("DELETE FROM t_user where user_id=?", id)
	if err != nil {
		log.Fatalln(err)
	}
	ra, err := rs.RowsAffected()
	if err != nil {
		log.Fatalln(err)
	}
	return ra
}

handler

然后把具体的 handler 封装到 api 中，handler 操作数据库，因此会引用 model 包。

package api

import (
	"fmt"
	"net/http"

	. "ginExample/models"

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

func IndexApi(c *gin.Context) {
	c.String(http.StatusOK, "It works")
}

func GetUserApi(c *gin.Context) {
	var u SqlUser
	id := c.Param("id")
	u = u.GetUser(id)
	c.JSON(200, gin.H{
		"user": u.User_name,
	})
}

func AddUserApi(c *gin.Context) {
	User_id := c.Request.FormValue("User_id")
	User_name := c.Request.FormValue("User_name")
    // 这里的大小写一定要对应上结构体内的变量名

	u := models.SqlUser{User_id: User_id, User_name: User_name}

	rows, err := u.AddUser()
	if err != nil {
		log.Fatalln(err)
	}
	msg := fmt.Sprintf("insert successfully %d\n", rows)
	c.JSON(200, gin.H{
		"msg":       msg,
		"user_name": User_name,
	})
}

func UpdateUserApi(c *gin.Context) {
	User_id := c.Request.FormValue("User_id")
	User_name := c.Request.FormValue("User_name")

	u := models.SqlUser{User_id: User_id, User_name: User_name}
	row := u.UpdateUser()
	msg := fmt.Sprintf("update successful %d", row)
	c.JSON(200, gin.H{
		"msg": msg,
	})
}

func DeleteUserApi(c *gin.Context) {
	var u models.SqlUser
	id := c.Param("id")
	row := u.DeleteUser(id)
	msg := fmt.Sprintf("DELETE user successful %d", row)
	c.JSON(200, gin.H{
		"msg": msg,
	})
}

router

最后就是把路由抽离出来：

//router.go
package main

import (
    "github.com/gin-gonic/gin"
    . "ginExample/api"
)

func initRouter() *gin.Engine {
    router := gin.Default()
    router.GET("/", IndexApi)
    router.GET("/query/:id", GetUserApi)
    router.POST("/add", api.AddUserApi)
	router.PUT("/update/:id", api.UpdateUserApi)
	router.DELETE("/delete/:id", api.DeleteUserApi)
    return router
}

app 入口

最后就是 main 的 app 入口，将路由导入，同时在 main 即将结束时，关闭全局数据库连接池。

package main

import db "ginExample/database"

func main() {
    defer db.SqlDB.Close()
    router := initRouter()
    router.Run(":9999")
}

这里运行项目的话，不能像之前简单地使用 go run main.go ，因为 main 包含 main.go 和 router.go，因此要运行 go run *.go，如果最终编译二进制项目，则运行 go build -o app。

测试结果和上面是一样的，至此，基本的访问、操作数据库功能实现。

参考链接

---

1. Gin实战：Gin+Mysql简单的Restful风格的API - 简书 (jianshu.com) ↩︎