Go操作mysql实现增删改查及连接池

系统管理员 2023-10-17 18:21 92阅读 0赞

[-]

  1. 下载驱动
  2. 创建测试表
  3. 数据库连接
  4. 插入操作
  5. 查询操作
  6. 修改操作
  7. 删除操作
  8. 完整代码
  9. 小结
  10. 开启web服务
  11. db对象初始化
  12. 请求方法
  13. 小结

golang本身没有提供连接mysql的驱动，但是定义了标准接口供第三方开发驱动。这里连接mysql可以使用第三方库，第三方库推荐使用https://github.com/Go-SQL-Driver/MySQL这个驱动，更新维护都比较好。下面演示下具体的使用，完整代码示例可以参考最后。

下载驱动

  1. sudo go get github.com/go-sql-driver/mysql

如果提示这样的失败信息：cannot download, $GOPATH not set. For more details see: go help gopath，可以使用如下命令解决

  1. sudo env GOPATH=/Users/chenjiebin/golang go get github.com/go-sql-driver/mysql

GOPATH的值根据自行环境进行替换。

创建测试表

在mysql test库中创建测试表

  1. CREATE TABLE IF NOT EXISTS `test`.`user` (
  2.  `user_id` INT(11) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '用户编号',
  3.  `user_name` VARCHAR(45) NOT NULL COMMENT '用户名称',
  4.  `user_age` TINYINT(3) UNSIGNED NOT NULL DEFAULT 0 COMMENT '用户年龄',
  5.  `user_sex` TINYINT(3) UNSIGNED NOT NULL DEFAULT 0 COMMENT '用户性别',
  6.  PRIMARY KEY (`user_id`))
  7.  ENGINE = InnoDB
  8.  AUTO_INCREMENT = 1
  9.  DEFAULT CHARACTER SET = utf8
  10.  COLLATE = utf8_general_ci
  11.  COMMENT = '用户表'

数据库连接

数据库连接使用datebase/sql Open函数进行连接

  1. db, err := sql.Open("mysql", "user:password@tcp(localhost:5555)/dbname?charset=utf8")

其中连接参数可以有如下几种形式：

user@unix(/path/to/socket)/dbname?charset=utf8
user:password@tcp(localhost:5555)/dbname?charset=utf8
user:password@/dbname
user:password@tcp([de:ad:be:ef::ca:fe]:80)/dbname

通常我们都用第二种。

插入操作

  1. stmt, err := db.Prepare(`INSERT user (user_name,user_age,user_sex) values (?,?,?)`)
  2. checkErr(err)
  3. res, err := stmt.Exec("tony", 20, 1)
  4. checkErr(err)
  5. id, err := res.LastInsertId()
  6. checkErr(err)
  7. fmt.Println(id)

这里使用结构化操作，不推荐使用直接拼接sql语句的方法。

查询操作

  1. rows, err := db.Query("SELECT * FROM user")
  2. checkErr(err)
  4. for rows.Next() {
  5.     var userId int
  6.     var userName string
  7.     var userAge int
  8.     var userSex int
  9.     rows.Columns()
  10.     err = rows.Scan(&userId, &userName, &userAge, &userSex)
  11.     checkErr(err)
  12.     fmt.Println(userId)
  13.     fmt.Println(userName)
  14.     fmt.Println(userAge)
  15.     fmt.Println(userSex)
  16. }

这里查询的方式使用声明4个独立变量userId、userName、userAge、userSex来保存查询出来的每一行的值。在实际开发中通常会封装数据库的操作，对这样的查询通常会考虑返回字典类型。

  1. //构造scanArgs、values两个数组，scanArgs的每个值指向values相应值的地址
  2. columns, _ := rows.Columns()
  3. scanArgs := make([]interface{}, len(columns))
  4. values := make([]interface{}, len(columns))
  5. for i := range values {
  6.     scanArgs[i] = &values[i]
  7. }
  9. for rows.Next() {
  10.     //将行数据保存到record字典
  11.     err = rows.Scan(scanArgs...)
  12.     record := make(map[string]string)
  13.     for i, col := range values {
  14.         if col != nil {
  15.             record[columns[i]] = string(col.([]byte))
  16.         }
  17.     }
  18.     fmt.Println(record)
  19. }

修改操作

  1. stmt, err := db.Prepare(`UPDATE user SET user_age=?,user_sex=? WHERE user_id=?`)
  2. checkErr(err)
  3. res, err := stmt.Exec(21, 2, 1)
  4. checkErr(err)
  5. num, err := res.RowsAffected()
  6. checkErr(err)
  7. fmt.Println(num)

删除操作

  1. stmt, err := db.Prepare(`DELETE FROM user WHERE user_id=?`)
  2. checkErr(err)
  3. res, err := stmt.Exec(1)
  4. checkErr(err)
  5. num, err := res.RowsAffected()
  6. checkErr(err)
  7. fmt.Println(num)

修改和删除操作都比较简单，同插入数据类似，只是使用RowsAffected来获取影响的数据行数。

完整代码

  1. package main
  3. import (
  4.     "database/sql"
  5.     "fmt"
  6.     _ "github.com/go-sql-driver/mysql"
  7. )
  9. func main() {
  10.     insert()
  11. }
  13. //插入demo
  14. func insert() {
  15.     db, err := sql.Open("mysql", "root:@/test?charset=utf8")
  16.     checkErr(err)
  18.     stmt, err := db.Prepare(`INSERT user (user_name,user_age,user_sex) values (?,?,?)`)
  19.     checkErr(err)
  20.     res, err := stmt.Exec("tony", 20, 1)
  21.     checkErr(err)
  22.     id, err := res.LastInsertId()
  23.     checkErr(err)
  24.     fmt.Println(id)
  25. }
  27. //查询demo
  28. func query() {
  29.     db, err := sql.Open("mysql", "root:@/test?charset=utf8")
  30.     checkErr(err)
  32.     rows, err := db.Query("SELECT * FROM user")
  33.     checkErr(err)
  35.     //普通demo
  36.     //for rows.Next() {
  37.     //    var userId int
  38.     //    var userName string
  39.     //    var userAge int
  40.     //    var userSex int
  42.     //    rows.Columns()
  43.     //    err = rows.Scan(&userId, &userName, &userAge, &userSex)
  44.     //    checkErr(err)
  46.     //    fmt.Println(userId)
  47.     //    fmt.Println(userName)
  48.     //    fmt.Println(userAge)
  49.     //    fmt.Println(userSex)
  50.     //}
  52.     //字典类型
  53.     //构造scanArgs、values两个数组，scanArgs的每个值指向values相应值的地址
  54.     columns, _ := rows.Columns()
  55.     scanArgs := make([]interface{}, len(columns))
  56.     values := make([]interface{}, len(columns))
  57.     for i := range values {
  58.         scanArgs[i] = &values[i]
  59.     }
  61.     for rows.Next() {
  62.         //将行数据保存到record字典
  63.         err = rows.Scan(scanArgs...)
  64.         record := make(map[string]string)
  65.         for i, col := range values {
  66.             if col != nil {
  67.                 record[columns[i]] = string(col.([]byte))
  68.             }
  69.         }
  70.         fmt.Println(record)
  71.     }
  72. }
  74. //更新数据
  75. func update() {
  76.     db, err := sql.Open("mysql", "root:@/test?charset=utf8")
  77.     checkErr(err)
  79.     stmt, err := db.Prepare(`UPDATE user SET user_age=?,user_sex=? WHERE user_id=?`)
  80.     checkErr(err)
  81.     res, err := stmt.Exec(21, 2, 1)
  82.     checkErr(err)
  83.     num, err := res.RowsAffected()
  84.     checkErr(err)
  85.     fmt.Println(num)
  86. }
  88. //删除数据
  89. func remove() {
  90.     db, err := sql.Open("mysql", "root:@/test?charset=utf8")
  91.     checkErr(err)
  93.     stmt, err := db.Prepare(`DELETE FROM user WHERE user_id=?`)
  94.     checkErr(err)
  95.     res, err := stmt.Exec(1)
  96.     checkErr(err)
  97.     num, err := res.RowsAffected()
  98.     checkErr(err)
  99.     fmt.Println(num)
  100. }
  102. func checkErr(err error) {
  103.     if err != nil {
  104.         panic(err)
  105.     }
  106. }

小结

整体上来说都比较简单，就是查询那边使用字典来存储返回数据比较复杂一些。既然说到数据库连接，通常应用中都会使用连接池来减少连接开销，关于连接池下次整理一下再放上来。

参考资料：《go web编程》，go web编程中对数据库连接做了比较详细的解说，值得一看。

转载请注明：快乐编程 » golang连接mysql操作示例增删改查

golang内部自带了连接池功能，刚开始接触golang的时候不了解这个，还自己搞了一个 sql.Open的对象管理池，真的非常囧啊。

sql.Open函数实际上是返回一个连接池对象，不是单个连接。在open的时候并没有去连接数据库，只有在执行query、exce方法的时候才会去实际连接数据库。在一个应用中同样的库连接只需要保存一个sql.Open之后的db对象就可以了，不需要多次open。

golang中关于mysql的增删改查我在前面的一篇文章中有说明了，不了解的小伙们可以先去了解一下：golang连接mysql操作示例增删改查

因为普通程序执行完毕之后资源就会被释放掉，所以这里尝试使用web服务进行演示。

开启web服务

首页先启动一个web服务监听9090端口，比较简单不多做说明。

  1. func startHttpServer() {
  2.     http.HandleFunc("/pool", pool)
  3.     err := http.ListenAndServe(":9090", nil)
  4.     if err != nil {
  5.         log.Fatal("ListenAndServe: ", err)
  6.     }
  7. }

db对象初始化

声明一个全局的db对象，并进行初始化。

  1. var db *sql.DB
  3. func init() {
  4.     db, _ = sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/test?charset=utf8")
  5.     db.SetMaxOpenConns(2000)
  6.     db.SetMaxIdleConns(1000)
  7.     db.Ping()
  8. }

连接池的实现关键在于SetMaxOpenConns和SetMaxIdleConns，其中：

SetMaxOpenConns用于设置最大打开的连接数，默认值为0表示不限制。
SetMaxIdleConns用于设置闲置的连接数。

设置最大的连接数，可以避免并发太高导致连接mysql出现too many connections的错误。设置闲置的连接数则当开启的一个连接使用完成后可以放在池里等候下一次使用。

请求方法

上面开启http请求设置了请求/pool地址的执行方法

  1. func pool(w http.ResponseWriter, r *http.Request) {
  2.     rows, err := db.Query("SELECT * FROM user limit 1")
  3.     defer rows.Close()
  4.     checkErr(err)
  6.     columns, _ := rows.Columns()
  7.     scanArgs := make([]interface{}, len(columns))
  8.     values := make([]interface{}, len(columns))
  9.     for j := range values {
  10.         scanArgs[j] = &values[j]
  11.     }
  13.     record := make(map[string]string)
  14.     for rows.Next() {
  15.         //将行数据保存到record字典
  16.         err = rows.Scan(scanArgs...)
  17.         for i, col := range values {
  18.             if col != nil {
  19.                 record[columns[i]] = string(col.([]byte))
  20.             }
  21.         }
  22.     }
  24.     fmt.Println(record)
  25.     fmt.Fprintln(w, "finish")
  26. }
  28. func checkErr(err error) {
  29.     if err != nil {
  30.         fmt.Println(err)
  31.         panic(err)
  32.     }
  33. }

pool方法就是从user表中查出一条记录然后存放到map中，最后输出finish。代码到这里就算完了非常简单，下面来测试一下。首先启动http服务，然后使用ab进行并发测试访问：

  1. $ ab -c 100 -n 1000 'http://localhost:9090/pool'

在数据库中通过show processlist查看连接进程：

golang数据库连接池

golang数据库连接池

可以看到有100来个进程。

因为避免了重复创建连接，所以使用连接池可以很明显的提高性能。有兴趣的童靴可以去掉连接池代码自己测试一下。完整代码如下：

  1. //数据库连接池测试
  2. package main
  4. import (
  5.     "database/sql"
  6.     "fmt"
  7.     _ "github.com/go-sql-driver/mysql"
  8.     "log"
  9.     "net/http"
  10. )
  12. var db *sql.DB
  14. func init() {
  15.     db, _ = sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/test?charset=utf8")
  16.     db.SetMaxOpenConns(2000)
  17.     db.SetMaxIdleConns(1000)
  18.     db.Ping()
  19. }
  21. func main() {
  22.     startHttpServer()
  23. }
  25. func startHttpServer() {
  26.     http.HandleFunc("/pool", pool)
  27.     err := http.ListenAndServe(":9090", nil)
  28.     if err != nil {
  29.         log.Fatal("ListenAndServe: ", err)
  30.     }
  31. }
  33. func pool(w http.ResponseWriter, r *http.Request) {
  34.     rows, err := db.Query("SELECT * FROM user limit 1")
  35.     defer rows.Close()
  36.     checkErr(err)
  38.     columns, _ := rows.Columns()
  39.     scanArgs := make([]interface{}, len(columns))
  40.     values := make([]interface{}, len(columns))
  41.     for j := range values {
  42.         scanArgs[j] = &values[j]
  43.     }
  45.     record := make(map[string]string)
  46.     for rows.Next() {
  47.         //将行数据保存到record字典
  48.         err = rows.Scan(scanArgs...)
  49.         for i, col := range values {
  50.             if col != nil {
  51.                 record[columns[i]] = string(col.([]byte))
  52.             }
  53.         }
  54.     }
  56.     fmt.Println(record)
  57.     fmt.Fprintln(w, "finish")
  58. }
  60. func checkErr(err error) {
  61.     if err != nil {
  62.         fmt.Println(err)
  63.         panic(err)
  64.     }
  65. }

小结

golang这边实现的连接池只提供了SetMaxOpenConns和SetMaxIdleConns方法进行连接池方面的配置。在使用的过程中有一个问题就是数据库本身对连接有一个超时时间的设置，如果超时时间到了数据库会单方面断掉连接，此时再用连接池内的连接进行访问就会出错。

  1. packets.go:32: unexpected EOF
  2. packets.go:118: write tcp 192.168.3.90:3306: broken pipe

上面都是错误都是go-sql-drive本身的输出，有的时候还会出现bad connection的错误。多请求几次后连接池会重新打开新连接这时候就没有问题了。关于这个问题自己有初步的解决方法，但是感觉不太完美，下次再放上来。

转载请注明：快乐编程 » golang go-sql-drive mysql连接池的实现

来源:http://blog.csdn.net/kenkao/article/details/47857795

发表评论

表情：
评论列表 （有 0 条评论，92人围观）

还没有评论，来说两句吧...

相关阅读