Go语言中如何关联两个独立事务并处理回滚场景？

你的场景核心是因为表A的自增ID需要提交事务后才能获取，导致不得不拆分两个独立事务，但这会引发数据一致性风险——当表A记录创建成功，但表B更新失败时，需要删除表A的记录来保证数据一致。你考虑用defer实现补偿逻辑是可行的，但需要注意细节处理，同时也可以看看是否能优化事务模型来避免这种补偿操作。

方案一：用defer实现补偿回滚 #

核心思路 #

1. 让第一个事务函数返回创建成功的表A记录ID，方便后续定位要删除的记录。
2. 在主函数中注册defer函数，只有当第二个事务执行失败时，才触发删除表A记录的补偿操作。
3. 补偿操作也要用事务保证原子性，同时处理可能的删除失败情况。

代码实现 #

package main

import (
    "database/sql"
    "log"
    "github.com/google/uuid"
    _ "github.com/go-sql-driver/mysql" // 根据你的数据库驱动调整
)

var db *sql.DB

func init() {
    // 初始化数据库连接，这里示例用MySQL
    var err error
    db, err = sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
    if err != nil {
        log.Fatalf("数据库连接失败: %v", err)
    }
}

func main() {
    var aID int
    // 执行第一个事务：创建表A记录
    aID, err := createARecord()
    if err != nil {
        log.Fatalf("创建表A记录失败: %v", err)
    }

    // 注册补偿逻辑：后续操作失败则删除表A的这条记录
    defer func() {
        if err != nil {
            if delErr := deleteARecord(aID); delErr != nil {
                // 补偿失败需记录日志，人工介入处理
                log.Printf("补偿删除表A记录失败，ID: %d，错误: %v", aID, delErr)
            }
        }
    }()

    // 执行第二个事务：更新表B记录
    err = updateBRecord(aID)
    if err != nil {
        log.Fatalf("更新表B记录失败: %v", err)
    }

    log.Println("所有操作执行成功")
}

// createARecord: 第一个事务，创建表A记录并返回ID
func createARecord() (int, error) {
    tx, err := db.Begin()
    if err != nil {
        return 0, err
    }
    defer tx.Rollback()

    res, err := tx.Exec("INSERT INTO A (UUID, NAME) VALUES (?, ?)", uuid.NewString(), "示例名称A")
    if err != nil {
        return 0, err
    }

    lastID, err := res.LastInsertId()
    if err != nil {
        return 0, err
    }

    if err := tx.Commit(); err != nil {
        return 0, err
    }

    return int(lastID), nil
}

// updateBRecord: 第二个事务，用A.ID更新表B记录
func updateBRecord(aID int) error {
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    defer tx.Rollback()

    // 这里假设根据NAME定位要更新的表B记录，可根据实际业务调整条件
    _, err = tx.Exec("UPDATE B SET A_ID = ? WHERE NAME = ?", aID, "示例名称B")
    if err != nil {
        return err
    }

    if err := tx.Commit(); err != nil {
        return err
    }
    return nil
}

// deleteARecord: 补偿操作，删除指定ID的表A记录
func deleteARecord(aID int) error {
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    defer tx.Rollback()

    _, err = tx.Exec("DELETE FROM A WHERE ID = ?", aID)
    if err != nil {
        return err
    }

    if err := tx.Commit(); err != nil {
        return err
    }
    return nil
}

注意事项 #

• 幂等性：补偿的删除操作要保证幂等，比如根据ID删除，即使重复执行也不会产生异常（可以忽略「记录不存在」的错误）。
• 异常兜底：如果补偿操作失败（比如数据库临时不可用），一定要记录详细日志并触发告警，避免数据不一致的情况长期存在。

方案二：优化事务模型（更优） #

其实大部分数据库（比如MySQL、PostgreSQL）都支持在未提交的事务内获取刚插入的自增ID，不需要拆分两个事务。把创建表A和更新表B放在同一个事务里，天然保证原子性，要么全部成功，要么全部回滚，不需要额外的补偿逻辑。

代码实现 #

func combinedTransaction() error {
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    defer tx.Rollback()

    // 插入表A并获取ID，无需提交事务
    res, err := tx.Exec("INSERT INTO A (UUID, NAME) VALUES (?, ?)", uuid.NewString(), "示例名称A")
    if err != nil {
        return err
    }
    aID, err := res.LastInsertId()
    if err != nil {
        return err
    }

    // 同一事务内更新表B
    _, err = tx.Exec("UPDATE B SET A_ID = ? WHERE NAME = ?", aID, "示例名称B")
    if err != nil {
        return err
    }

    // 提交整个事务
    return tx.Commit()
}

// 主函数调用简化为：
func main() {
    if err := combinedTransaction(); err != nil {
        log.Fatalf("事务执行失败: %v", err)
    }
    log.Println("所有操作执行成功")
}

这个方案更简洁可靠，推荐优先采用，除非你的业务场景有特殊限制必须拆分事务。

内容的提问来源于stack exchange，提问作者mradul garg