Golang 事务处理：自动 Commit 与 Rollback 方法

本文旨在提供一种简洁高效的 Golang 数据库事务处理方式，避免手动追踪事务状态。通过封装事务处理逻辑，可以确保事务在出现错误时自动回滚，成功时自动提交，并优雅地处理潜在的 panic 情况，从而提高代码的可读性和健壮性。

在 Golang 中使用 database/sql 包处理数据库事务时，手动管理 Commit 和 Rollback 可能会变得繁琐且容易出错。尤其是在复杂的业务逻辑中，需要多次执行数据库操作，并确保在任何错误发生时都能够正确回滚事务。一种常见的做法是使用 defer 语句来确保事务最终被提交或回滚。

传统的事务处理方式

以下是一个常见的事务处理模式：

func (s Service) DoSomething() (err error) {
    tx, err := s.db.Begin()
    if err != nil {
        return
    }
    defer func() {
        if err != nil {
            tx.Rollback()
            return
        }
        err = tx.Commit()
    }()
    if _, err = tx.Exec(...); err != nil {
        return
    }
    if _, err = tx.Exec(...); err != nil {
        return
    }
    // ...
    return
}

这种方式虽然可行，但存在一些问题：

• 代码重复： 每个需要事务的函数都需要重复这段逻辑。
• 可读性差： 事务处理逻辑与业务逻辑混杂在一起，降低了代码的可读性。
• 容易出错： 如果忘记在 defer 中处理 Rollback，或者在其他地方错误地修改了 err 变量，可能会导致事务处理不正确。

使用事务处理 Handler 简化事务管理

为了解决上述问题，可以创建一个通用的事务处理 Handler，将事务的 Begin、Commit 和 Rollback 逻辑封装起来。

func Transact(db *sql.DB, txFunc func(*sql.Tx) error) (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
        } else if err != nil {
            tx.Rollback() // err is non-nil; don't change it
        } else {
            err = tx.Commit() // err is nil; if Commit returns error update err
        }
    }()
    err = txFunc(tx)
    return err
}

这个 Transact 函数接收一个 sql.DB 对象和一个函数 txFunc 作为参数。txFunc 接收一个 sql.Tx 对象作为参数，并在其中执行实际的数据库操作。

Transact 函数的主要逻辑如下：

1. 开启事务： 使用 db.Begin() 开启一个新的事务。
2. Defer 处理： 使用 defer 语句定义一个匿名函数，该函数将在 Transact 函数返回之前执行。
3. Panic 处理： 在 defer 函数中使用 recover() 捕获任何 panic。如果发生 panic，则回滚事务并重新抛出 panic，以便上层调用者可以处理。
4. 错误处理： 如果 txFunc 返回一个非空的错误，则回滚事务。
5. 提交事务： 如果 txFunc 没有返回错误，则提交事务。
6. 执行 txFunc： 调用 txFunc 执行实际的数据库操作。

使用事务处理 Handler

使用 Transact 函数可以大大简化事务处理的代码：

func (s Service) DoSomething() error {
    return Transact(s.db, func(tx *sql.Tx) error {
        if _, err := tx.Exec(...); err != nil {
            return err
        }
        if _, err := tx.Exec(...); err != nil {
            return err
        }
        return nil
    })
}

可以看到，使用 Transact 函数后，DoSomething 函数的代码变得更加简洁和易读。所有事务处理的细节都被隐藏在 Transact 函数中，业务逻辑更加清晰。

注意事项

• Panic 处理： 在 Transact 函数中，使用 recover() 捕获 panic 并重新抛出。这可以确保在发生 panic 时，事务能够被正确回滚，并且 panic 能够被上层调用者处理。
• 错误处理： 在 defer 函数中，只有在 err 为 nil 时才会调用 tx.Commit()。这是因为如果 txFunc 返回了一个错误，则不需要再次调用 tx.Commit()。
• Return Value： 注意 defer 语句可以修改闭包中捕获的返回值。因此，在 Transact 函数中，使用 err = tx.Commit() 将 tx.Commit() 的返回值赋值给 err，以便将提交事务时可能发生的错误传递给上层调用者。

总结

通过使用事务处理 Handler，可以有效地简化 Golang 中的数据库事务管理。这种方式可以提高代码的可读性、可维护性和健壮性，并减少出错的可能性。建议在所有需要事务处理的场景中使用这种模式。