脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Golang - golang操作连接数据库实现mysql事务示例

golang操作连接数据库实现mysql事务示例

2022-09-15 14:04Jeff的技术栈 Golang

这篇文章主要为大家介绍了golang操作连接数据库实现mysql事务示例，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步早日升职加薪

MySQL是业界常用的关系型数据库，本文介绍了database/sql库以及Go语言如何操作MySQL数据库。

mysql驱动

?
1
_ "github.com/go-sql-driver/mysql"

posgre驱动

?
1
_ "github.com/lib/pq"

连接postgres

Go语言中的database/sql包提供了保证SQL或类SQL数据库的泛用接口，并不提供具体的数据库驱动。使用database/sql包时必须注入（至少）一个数据库驱动。

我们常用的数据库基本上都有完整的第三方实现。例如：MySQL驱动

?
1
2
3
4
5
6
7
func Open(driverName, dataSourceName string) (*DB, error)
import (
    "database/sql"
    "fmt"
    _ "github.com/lib/pq"
)
Db, _ := sql.Open("postgres", "postgres://postgres:iLoveShark@127.0.0.1:3432/master?sslmode=disable&fallback_application_name=bikesvc")

连接mysql

Open打开一个dirverName指定的数据库，dataSourceName指定数据源，一般至少包括数据库文件名和其它连接必要的信息。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
)
func main() {
   // DSN:Data Source Name
    dsn := "user:password@tcp(127.0.0.1:3306)/dbname"
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        panic(err)
    }
    defer db.Close()  // 注意这行代码要写在上面err判断的下面
}

初始化连接

Open函数可能只是验证其参数格式是否正确，实际上并不创建与数据库的连接。如果要检查数据源的名称是否真实有效，应该调用Ping方法。

返回的DB对象可以安全地被多个goroutine并发使用，并且维护其自己的空闲连接池。因此，Open函数应该仅被调用一次，很少需要关闭这个DB对象。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// 定义一个全局对象db
var db *sql.DB
// 定义一个初始化数据库的函数
func initDB() (err error) {
    // DSN:Data Source Name
    dsn := "user:password@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
    // 不会校验账号密码是否正确
    // 注意！！！这里不要使用:=，我们是给全局变量赋值，然后在main函数中使用全局变量db
    db, err = sql.Open("mysql", dsn)
    if err != nil {
        return err
    }
    // 尝试与数据库建立连接（校验dsn是否正确）
    err = db.Ping()
    if err != nil {
        return err
    }
    return nil
}
func main() {
    err := initDB() // 调用输出化数据库的函数
    if err != nil {
        fmt.Printf("init db failed,err:%v\n", err)
        return
    }
}

其中sql.DB是表示连接的数据库对象（结构体实例），它保存了连接数据库相关的所有信息。它内部维护着一个具有零到多个底层连接的连接池，它可以安全地被多个goroutine同时使用。

SetMaxOpenConns

?
1
func (db *DB) SetMaxOpenConns(n int)

SetMaxOpenConns设置与数据库建立连接的最大数目。 如果n大于0且小于最大闲置连接数，会将最大闲置连接数减小到匹配最大开启连接数的限制。 如果n<=0，不会限制最大开启连接数，默认为0（无限制）。

SetMaxIdleConns

?
1
func (db *DB) SetMaxIdleConns(n int)

SetMaxIdleConns设置连接池中的最大闲置连接数。 如果n大于最大开启连接数，则新的最大闲置连接数会减小到匹配最大开启连接数的限制。 如果n<=0，不会保留闲置连接。

CRUD

查询

为了方便查询，我们事先定义好一个结构体来存储user表的数据。

?
1
2
3
4
5
6
7
8
9
10
type Info struct {
    Id      int    `json:"id"`
    Code    string `json:"code"`
    HwCode  string `json:"hw_code"`
    Name    string `json:"name"`
    Des     string `json:"des"`
    Created int64  `json:"created"`
    Updated int64  `json:"updated"`
    BrandId int64  `json:"brand_id"`
}

单行查询QueryRow

单行查询db.QueryRow()执行一次查询，并期望返回最多一行结果（即Row）。QueryRow总是返回非nil的值，直到返回值的Scan方法被调用时，才会返回被延迟的错误。（如：未找到结果）

?
1
func (db *DB) QueryRow(query string, args ...interface{}) *Row

具体示例代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
func (o object) QueryInfo(id int) *Info {
    r := new(Info)
    var qstr string
    switch {
    case id > 0:
        qstr += fmt.Sprintf(" and id = %d", id)
    default:
        o.Log.Error("invalid param")
        return nil
    }
    sqlstr := `
    select
    coalesce(id,0) as id,
    coalesce(code,'') as code,
    coalesce(hw_code,'') as hw_code,
    coalesce(name,'') as name,
    coalesce(des,'') as des,
    coalesce(created,0) as created,
    coalesce(updated,0) as updated,
    coalesce(brand_id,0) as brand_id
    from test_table
    where 1=1
    `
    sqlstr += qstr
    err := o.DbRo.QueryRow(sqlstr).Scan(&r.Id, &r.Code, &r.HwCode, &r.Name, &r.Des, &r.Created, &r.Updated, &r.BrandId)
    if err != nil {
        fmt.Println(err)
        o.Log.Errorf("param=%d,sql=%s,err=%v", id, sqlstr, err)
        return nil
    }
    return r
}

多行查询Query-rows

多行查询db.Query()执行一次查询，返回多行结果（即Rows），一般用于执行select命令。参数args表示query中的占位参数。

?
1
func (db *DB) Query(query string, args ...interface{}) (*Rows, error)

具体示例代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
func (o object) QueryList(brandId int) (list []Info) {
    list = make([]Info, 0)
    var qstr string
    switch {
    case brandId > 0:
        qstr += fmt.Sprintf(" and brand_id = %d", brandId)
    default:
        o.Log.Error("invalid param")
        return nil
    }
    sqlstr := `
    select
    coalesce(id,0) as id,
    coalesce(code,'') as code,
    coalesce(hw_code,'') as hw_code,
    coalesce(name,'') as name,
    coalesce(des,'') as des,
    coalesce(created,0) as created,
    coalesce(updated,0) as updated,
    coalesce(brand_id,0) as brand_id
    from bike_color
    where 1=1
    `
    sqlstr += qstr
    rows, err := o.DbRo.Query(sqlstr)
    if err != nil {
        o.Log.Error(err)
        return
    }
    defer rows.Close()
  // rows.Next()获取下一条结果
    for rows.Next() {
        var r = new(Info)
        err = rows.Scan(&r.Id, &r.Code, &r.HwCode, &r.Name, &r.Des, &r.Created, &r.Updated, &r.BrandId)
        if err != nil {
            o.Log.Error(err, brandId)
            continue
        }
        list = append(list, *r)
    }
    return
}

插入和更新和删除Exec

插入、更新和删除操作都使用Exec方法。

?
1
func (db *DB) Exec(query string, args ...interface{}) (Result, error)

Exec执行一次命令（包括查询、删除、更新、插入等），返回的Result是对已执行的SQL命令的总结。参数args表示query中的占位参数。

影响的行数

?
1
2
3
sqlStr := "update user set age=? where id = ?"
ret, _:= db.Exec(sqlStr, 39, 3)
n, _ := ret.RowsAffected() // 操作影响的行数

插入

具体插入数据示例代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
func (o object) Insert(i *Info) (r int) {
    sqlstr := `insert into bike_model(name,ctrl_tmpl,batt_support,bike_class,pics,code,brand_id,hw_code)
    values('%v',%d,%d,%d,'%v','%v',%d,'%v')
    returning id`
    sqlstr = fmt.Sprintf(sqlstr, i.Name, i.CtrlTmpl, i.BattSupport, i.BikeClass, i.Pics, i.Code, i.BrandId, i.HwCode)
    fmt.Println(sqlstr)
    err := o.Db.QueryRow(sqlstr).Scan(&r)
    if err != nil {
        fmt.Println(err)
        o.Log.Errorf("param=%+v,sql=%s,err=%v", i, sqlstr, err)
        return
    }
    return
}

更新

具体更新数据示例代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
func (o object) Update(i *Info) (r int) {
    sqlstr := fmt.Sprintf("update bike_model set ")
    if i.Id <= 0 {
        o.Log.Error("invalid param")
        return
    }
    if len(i.Name) > 0 {
        sqlstr += fmt.Sprintf("name = '%v',", i.Name)
    }
    if i.CtrlTmpl > 0 {
        sqlstr += fmt.Sprintf("ctrl_tmpl = '%d',", i.CtrlTmpl)
    }
    if i.BattSupport > 0 {
        sqlstr += fmt.Sprintf("batt_support = '%d',", i.BattSupport)
    }
    if i.BikeClass > 0 {
        sqlstr += fmt.Sprintf("bike_class = '%d',", i.BikeClass)
    }
    if len(i.Pics) > 0 {
        sqlstr += fmt.Sprintf("hw_code = '%v',", i.Pics)
    }
    if len(i.Code) > 0 {
        sqlstr += fmt.Sprintf("code = '%v',", i.Code)
    }
    if i.BrandId > 0 {
        sqlstr += fmt.Sprintf("brand_id = %d,", i.BrandId)
    }
    if len(i.HwCode) > 0 {
        sqlstr += fmt.Sprintf("hw_code = '%v',", i.HwCode)
    }
  // 拼接sql字符串
    sqlstr = strings.TrimRight(sqlstr, ",")
    sqlstr += fmt.Sprintf("where id = %d returning id", i.Id)
    err := o.Db.QueryRow(sqlstr).Scan(&r)
    if err != nil {
        o.Log.Errorf("param=%+v,sql=%s,err=%v", i, sqlstr, err)
        return
    }
    return
}

删除

具体删除数据的示例代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func (o object) Delete(id int) (r int) {
    sqlstr := `delete from bike_model where id = $1`
    res, err := o.Db.Exec(sqlstr, id)
    if err != nil {
        o.Log.Errorf("param=%d,sql=%s,err=%v", id, sqlstr, err)
        return
    }
  // 影响的行数
    ra, _ := res.RowsAffected()
    if ra != 1 {
        o.Log.Warnf("param=%d,sql=%s,rowsAftected=%d", id, sqlstr, ra)
        return int(ra)
    }
    return
}

MySQL预处理

普通SQL语句执行过程：

  • 客户端对SQL语句进行占位符替换得到完整的SQL语句。
  • 客户端发送完整SQL语句到MySQL服务端
  • MySQL服务端执行完整的SQL语句并将结果返回给客户端。

预处理执行过程：

  • 把SQL语句分成两部分，命令部分与数据部分。
  • 先把命令部分发送给MySQL服务端，MySQL服务端进行SQL预处理。
  • 然后把数据部分发送给MySQL服务端，MySQL服务端对SQL语句进行占位符替换。
  • MySQL服务端执行完整的SQL语句并将结果返回给客户端。

为什么要预处理？

  • 优化MySQL服务器重复执行SQL的方法，可以提升服务器性能，提前让服务器编译，一次编译多次执行，节省后续编译的成本。
  • 避免SQL注入问题。

Go实现MySQL预处理

database/sql中使用下面的Prepare方法来实现预处理操作。

?
1
func (db *DB) Prepare(query string) (*Stmt, error)

Prepare方法会先将sql语句发送给MySQL服务端，返回一个准备好的状态用于之后的查询和命令。返回值可以同时执行多个查询和命令。

查询操作的预处理示例代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// 预处理查询示例
func prepareQueryDemo() {
    sqlStr := "select id, name, age from user where id > ?"
    stmt, err := db.Prepare(sqlStr)
    if err != nil {
        fmt.Printf("prepare failed, err:%v\n", err)
        return
    }
    defer stmt.Close()
    rows, err := stmt.Query(0)
    if err != nil {
        fmt.Printf("query failed, err:%v\n", err)
        return
    }
    defer rows.Close()
    // 循环读取结果集中的数据
    for rows.Next() {
        var u user
        err := rows.Scan(&u.id, &u.name, &u.age)
        if err != nil {
            fmt.Printf("scan failed, err:%v\n", err)
            return
        }
        fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
    }
}

插入、更新和删除操作的预处理十分类似，这里以插入操作的预处理为例：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 预处理插入示例
func prepareInsertDemo() {
    sqlStr := "insert into user(name, age) values (?,?)"
    stmt, err := db.Prepare(sqlStr)
    if err != nil {
        fmt.Printf("prepare failed, err:%v\n", err)
        return
    }
    defer stmt.Close()
    _, err = stmt.Exec("小王子", 18)
    if err != nil {
        fmt.Printf("insert failed, err:%v\n", err)
        return
    }
    _, err = stmt.Exec("沙河娜扎", 18)
    if err != nil {
        fmt.Printf("insert failed, err:%v\n", err)
        return
    }
    fmt.Println("insert success.")
}

SQL注入问题

我们任何时候都不应该自己拼接SQL语句！

这里我们演示一个自行拼接SQL语句的示例，编写一个根据name字段查询user表的函数如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
// sql注入示例
func sqlInjectDemo(name string) {
    sqlStr := fmt.Sprintf("select id, name, age from user where name='%s'", name)
    fmt.Printf("SQL:%s\n", sqlStr)
    var u user
    err := db.QueryRow(sqlStr).Scan(&u.id, &u.name, &u.age)
    if err != nil {
        fmt.Printf("exec failed, err:%v\n", err)
        return
    }
    fmt.Printf("user:%#v\n", u)
}

此时以下输入字符串都可以引发SQL注入问题：

?
1
2
3
sqlInjectDemo("xxx' or 1=1#")
sqlInjectDemo("xxx' union select * from user #")
sqlInjectDemo("xxx' and (select count(*) from user) <10 #")

补充：不同的数据库中，SQL语句使用的占位符语法不尽相同。

数据库 占位符语法
MySQL ?
PostgreSQL $1, ​​​​​​​$2等
SQLite ? 和$1
Oracle :name

Go实现MySQL事务

什么是事务？

事务：一个最小的不可再分的工作单元；通常一个事务对应一个完整的业务(例如银行账户转账业务，该业务就是一个最小的工作单元)，同时这个完整的业务需要执行多次的DML(insert、update、delete)语句共同联合完成。A转账给B，这里面就需要执行两次update操作。

在MySQL中只有使用了Innodb数据库引擎的数据库或表才支持事务。事务处理可以用来维护数据库的完整性，保证成批的SQL语句要么全部执行，要么全部不执行。

事务的ACID

通常事务必须满足4个条件（ACID）：原子性（Atomicity，或称不可分割性）、一致性（Consistency）、隔离性（Isolation，又称独立性）、持久性（Durability）。

条件 解释
原子性 一个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。
一致性 在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以自发性地完成预定的工作。
隔离性 数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务隔离分为不同级别，包括读未提交（Read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串行化（Serializable）。
持久性 事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

事务相关方法

Go语言中使用以下三个方法实现MySQL中的事务操作。 开始事务

?
1
func (db *DB) Begin() (*Tx, error)

提交事务

?
1
func (tx *Tx) Commit() error

回滚事务

?
1
func (tx *Tx) Rollback() error

事务示例

下面的代码演示了一个简单的事务操作，该事物操作能够确保两次更新操作要么同时成功要么同时失败，不会存在中间状态。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// 事务操作示例
func transactionDemo() {
    tx, err := db.Begin() // 开启事务
    if err != nil {
        if tx != nil {
            tx.Rollback() // 回滚
        }
        fmt.Printf("begin trans failed, err:%v\n", err)
        return
    }
    sqlStr1 := "Update user set age=30 where id=?"
    ret1, err := tx.Exec(sqlStr1, 2)
    if err != nil {
        tx.Rollback() // 回滚
        fmt.Printf("exec sql1 failed, err:%v\n", err)
        return
    }
    affRow1, err := ret1.RowsAffected()
    if err != nil {
        tx.Rollback() // 回滚
        fmt.Printf("exec ret1.RowsAffected() failed, err:%v\n", err)
        return
    }
    sqlStr2 := "Update user set age=40 where id=?"
    ret2, err := tx.Exec(sqlStr2, 3)
    if err != nil {
        tx.Rollback() // 回滚
        fmt.Printf("exec sql2 failed, err:%v\n", err)
        return
    }
    affRow2, err := ret2.RowsAffected()
    if err != nil {
        tx.Rollback() // 回滚
        fmt.Printf("exec ret1.RowsAffected() failed, err:%v\n", err)
        return
    }
    fmt.Println(affRow1, affRow2)
    if affRow1 == 1 && affRow2 == 1 {
        fmt.Println("事务提交啦...")
        tx.Commit() // 提交事务
    } else {
        tx.Rollback()
        fmt.Println("事务回滚啦...")
    }
    fmt.Println("exec trans success!")
}

以上就是golong操作连接数据库实现mysql事务示例的详细内容，更多关于golong操作实现mysql事务的资料请关注服务器之家其它相关文章！

原文链接：https://www.cnblogs.com/guyouyin123/p/14480533.html

  • golang
  • mysql
  • 事务

    • 延伸 · 阅读

    精彩推荐
    • Golanggo语言中iota和左移右移的使用说明

      go语言中iota和左移右移的使用说明

      这篇文章主要介绍了go语言中iota和左移右移的使用说明，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      Coldestmonth10392021-06-23
    • GolangGo语言实现的web爬虫实例

      Go语言实现的web爬虫实例

      这篇文章主要介绍了Go语言实现的web爬虫,实例分析了web爬虫的原理与Go语言的实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下 ...

      Go语言编程实例3772020-04-18
    • GolangGo 面试题：Go interface 的一个 “坑” 及原理分析

      Go 面试题：Go interface 的一个 “坑” 及原理分析

      前几天在读者交流群里看到一位小伙伴，针对 interface 的使用有了比较大的疑惑。Go interface 是 Go 语言中最常用的类型之一，大家用惯了 if err != nil 就很容易...

      脑子进煎鱼了10312021-03-17
    • Golang从Node.js 转到 Go平台

      从Node.js 转到 Go平台

      回顾过去的一年，我们在技术栈上的最大改变就是从 Node.js 切换到 Go 。我们的联合创始人，Steve Kaliski， 在 Poptip 把 Node.js 切换成了 Go，可惜他没有学习到...

      脚本之家2152020-04-25
    • GolangGo语言使用MySql的方法

      Go语言使用MySql的方法

      这篇文章主要介绍了Go语言使用MySql的方法,实例分析了Go语言操作MySQL的技巧,具有一定参考借鉴价值,需要的朋友可以参考下 ...

      不吃皮蛋3052020-04-14
    • GolangGolang连接池的几种实现案例小结

      Golang连接池的几种实现案例小结

      这篇文章主要介绍了Golang连接池的几种实现案例小结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们...

      Xiao淩求个好运气5242020-06-06
    • Golang用go gin server来做文件上传服务

      用go gin server来做文件上传服务

      今天小编就为大家分享一篇关于用go gin server来做文件上传服务，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编...

      stpeace3162020-05-25
    • GolangGo语言中关闭带缓冲区的频道实例分析

      Go语言中关闭带缓冲区的频道实例分析

      这篇文章主要介绍了Go语言中关闭带缓冲区的频道,实例分析了带缓冲区频道的原理与用法,以及关闭带缓冲区频道的技巧,具有一定参考借鉴价值,需要的朋友...

      Go语言编程实例4982020-04-18
    最近更新
    编辑推荐
    阅读排行
    热门标签
    信道处理 　 指针类型 　 new() 　 make() 　 并发模型 　 切片 　 静态WEB服务器 　 端口扫描器 　 Go语言入门教程 　 基础语 　 Slices 　 Maps 　 Golang编程 　 panic 　 接受者类型 　 嵌入类型 　 Slice 　 Golang教程 　 Golang项目 　 内存模型 　 开发环境搭建 　 大小端判断 　 代码组织结构 　 复合类型 　 GOPATH 　 工作目录 　 实例 　 struct类型 　 并发技术 　 buffered 　
    © 2019-2022 脚本之家 | 服务器之家(www.tuohang.net)旗下站点 版权所有关于我们联系我们版权申明网站地图