defer防止panic
利用 Commit() 之后 Rollback() 不会真正执行的特性,可以在创建tx时使用defer防止panic出现没有释放tx
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
|
package main
import (
"database/sql"
"x/log.v7"
)
func logRollback(tx *sql.Tx) {
err := tx.Rollback()
if err != tx.ErrTxDone && err != nil {
log.Error()
}
}
func main() {
tx, err := sql.DB.Begin()
if err != nil {
log.Error()
return
}
defer sql.Rollback(tx)
//如果不添加defer，只在最后Commit后check错误err后再rollback，那么当doSomething发生异常的时候，函数就退出了，此时还没有执行到tx.Commit。这样就导致事务的连接没有关闭，事务也没有回滚。
if result, err := tx.Exec(query1); err != nil {
log.Error()
return
}
doSomething()
if row, err := tx.Query(query2); err != nil {
//tx.Rollback() 没必要加,会自动进入defer
log.Error()
return
}
if err := tx.Commit(); err != nil {
log.Error()
return
}
}
|
增加日志
官网文档用的时候就不判断错误，不判断错误如果rollback出错了，没日志，定位会很难，数据不一致问题也非常严重.但有一个弊端,就是即使commit成功后,依旧会进行rollback,并打印日志,此时应该加一个tag操作符,如果commit成功,tag置1,如果tag为1,不执行rollback
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
|
package main
import (
"database/sql"
"x/log.v7"
)
func logRollback(tx *sql.Tx) {
err := tx.Rollback()
if err != tx.ErrTxDone && err != nil {
log.Error()
}
}
func main() {
tx, err := sql.DB.Begin()
if err != nil {
log.Error()
return
}
defer logRollback(tx)
if result, err := tx.Exec(query1); err != nil {
log.Error()
return
}
doSomething()
if row, err := tx.Query(query2); err != nil {
log.Error()
return
}
if err := tx.Commit(); err != nil {
log.Error()
return
}
}
|
我的写法
经过总结和实验，我采用了下面这种写法，defer tx.Rollback() 使得事务回滚始终得到执行。 当 tx.Commit() 执行后，tx.Rollback() 起到关闭事务的作用， 当程序因为某个错误中止，tx.Rollback() 起到回滚事务，同事关闭事务的作用。
普通场景
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
func DoSomething() (err error) {
tx, _ := db.Begin()
defer tx.Rollback()
if _, err = tx.Exec(...); err != nil {
return
}
if _, err = tx.Exec(...); err != nil {
return
}
// ...
err = tx.Commit()
return
}
|
循环场景
(1) 小事务 每次循环提交一次 在循环内部使用这种写法的时候，defer 不能使用，所以要把事务部分抽离到独立的函数当中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
func DoSomething() (err error) {
tx, _ := db.Begin()
defer tx.Rollback()
if _, err = tx.Exec(...); err != nil {
return
}
if _, err = tx.Exec(...); err != nil {
return
}
// ...
err = tx.Commit()
return
}
for {
if err := DoSomething(); err != nil{
// ...
}
}
|
(2) 大事务 批量提交 大事务的场景和普通场景是一样的，没有任何区别
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
func DoSomething() (err error) {
tx, _ := db.Begin()
defer tx.Rollback()
for{
if _, err = tx.Exec(...); err != nil {
return
}
if _, err = tx.Exec(...); err != nil {
return
}
// ...
}
err = tx.Commit()
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
|
func DoSomething() (err error) {
tx, err := db.Begin()
if err != nil {
return
}
}
defer func() {
if p := recover(); p != nil {
tx.Rollback()
panic(p) // re-throw panic after Rollback
}
}()
if _, err = tx.Exec(...); err != nil {
//tx.Rollback() 没必要加,会自动进入defer
return
}
if _, err = tx.Exec(...); err != nil {
//tx.Rollback()
return
}
// ...
err = tx.Commit()
return
}
|