Golang数据库事务操作错误处理技巧

defer

tx, err := db.BeginTx(ctx, nil)

defer tx.Rollback()

defer

func PerformComplexTransaction(ctx context.Context, db *sql.DB) (err error) {
    tx, err := db.BeginTx(ctx, nil)
    if err != nil {
        return fmt.Errorf("无法开始事务: %w", err)
    }

    // 这是核心的错误处理逻辑：确保在函数退出时，如果事务未成功提交，则尝试回滚。
    // 即使发生panic，也能尝试回滚，防止连接泄露。
    defer func() {
        if r := recover(); r != nil { // 捕获可能发生的panic
            if rbErr := tx.Rollback(); rbErr != nil {
                log.Printf("事务发生panic，回滚失败: %v, panic: %v", rbErr, r)
            } else {
                log.Printf("事务发生panic，已成功回滚, panic: %v", r)
            }
            panic(r) // 重新抛出panic
        }
        if err != nil { // 如果函数返回了错误，说明事务未成功，需要回滚
            if rbErr := tx.Rollback(); rbErr != nil {
                // 记录回滚失败的错误，但原始错误通常更重要
                err = fmt.Errorf("事务执行失败: %w, 且回滚也失败: %v", err, rbErr)
            } else {
                err = fmt.Errorf("事务执行失败: %w", err)
            }
        }
    }()

    // ---------------------------------------------------------------------
    // 接下来是具体的业务操作
    // ---------------------------------------------------------------------

    // 示例1: 插入用户
    _, err = tx.ExecContext(ctx, "INSERT INTO users (name, email) VALUES (?, ?)", "Alice", "alice@example.com")
    if err != nil {
        // 这里我们给错误加上了上下文，非常重要
        return fmt.Errorf("插入用户失败: %w", err)
    }

    // 示例2: 更新账户余额
    // 假设这里有个业务逻辑判断，比如余额不足
    currentBalance := 100.0 // 假设从数据库查询得到
    amountToDebit := 150.0
    if currentBalance < amountToDebit {
        // 业务逻辑错误也应该导致事务回滚
        return fmt.Errorf("账户余额不足，无法扣款")
    }
    _, err = tx.ExecContext(ctx, "UPDATE accounts SET balance = balance - ? WHERE user_id = ?", amountToDebit, 1)
    if err != nil {
        return fmt.Errorf("更新账户余额失败: %w", err)
    }

    // ---------------------------------------------------------------------
    // 所有操作成功，尝试提交事务
    // ---------------------------------------------------------------------

    // 如果提交失败，`err`会被设置，从而触发上面的defer回滚逻辑
    if commitErr := tx.Commit(); commitErr != nil {
        err = fmt.Errorf("提交事务失败: %w", commitErr)
        return err // 显式返回提交错误，触发defer
    }

    return nil // 事务成功提交，`err`为nil，defer不会执行回滚
}

defer

PerformComplexTransaction

defer

err

Rollback()

string

package domain

import "errors"

// ErrInsufficientFunds 余额不足错误
var ErrInsufficientFunds = errors.New("余额不足")

// ErrUserNotFound 用户不存在错误
type UserNotFoundError struct {
    UserID int
}

func (e *UserNotFoundError) Error() string {
    return fmt.Sprintf("用户ID %d 不存在", e.UserID)
}

// Is 实现 errors.Is 接口，允许 errors.Is(err, domain.ErrUserNotFound)
func (e *UserNotFoundError) Is(target error) bool {
    // 允许通过 errors.Is(err, &domain.UserNotFoundError{}) 来判断
    _, ok := target.(*UserNotFoundError)
    return ok
}

// ... 在 PerformComplexTransaction 内部 ...
// 假设这里是根据用户ID查询余额的伪代码
// if user.Balance < amountToDebit {
//     return domain.ErrInsufficientFunds // 返回预定义的错误
// }

// 假设这里是查询用户，如果用户不存在
// if user == nil {
//     return &domain.UserNotFoundError{UserID: userID} // 返回自定义结构体错误
// }

PerformComplexTransaction

err := PerformComplexTransaction(ctx, db)
if err != nil {
    if errors.Is(err, domain.ErrInsufficientFunds) {
        log.Println("业务错误：余额不足，通知用户")
        // 返回给前端特定的错误码
    } else if errors.As(err, &domain.UserNotFoundError{}) {
        var userNotFoundErr *domain.UserNotFoundError
        errors.As(err, &userNotFoundErr)
        log.Printf("业务错误：用户 %d 不存在，可能是ID错误", userNotFoundErr.UserID)
        // 返回给前端用户不存在的错误
    } else {
        log.Printf("未知事务错误: %v", err)
        // 返回通用错误
    }
}

fmt.Errorf("...: %w", err)

errors.Is

errors.As