解决 Gorm 中链式查询污染的问题有几种常见的解决方法

解决 Gorm 中链式查询污染的问题有几种常见的解决方法，关键在于如何确保每个查询链都独立，避免查询条件等状态的共享。下面列出几种常见的解决方法：

1. 使用 Session(&gorm.Session{}) 重置查询状态

Session 方法可以创建一个新的查询会话，用于确保每次查询都不会受到上一次查询的影响。你可以通过 Session(&gorm.Session{}) 创建一个新的会话实例，从而避免污染。

示例：

func (a Article) Get(db *gorm.DB) (Article, error) {
    article := &Article{}
    err := db.Session(&gorm.Session{}).Where("id = ? AND state = ? AND is_del = ?", a.ID, a.State, 0).First(article).Error
    if err != nil && err != gorm.ErrRecordNotFound {
        return *article, err
    }
    return *article, nil
}

• Session(&gorm.Session{}) 会创建一个新的会话，避免之前的查询状态影响当前查询。
• 每次查询时，调用 Session() 来清空先前的查询条件、事务等上下文信息。

2. 使用独立的 *gorm.DB 实例

另一个方法是在每个查询中创建一个新的 *gorm.DB 实例，这样每个查询就不会共享状态。可以通过在查询函数中直接传递新的 *gorm.DB 实例来实现。

示例：

func (d *Dao) GetArticle(id uint32, state uint8) (model.Article, error) {
    article := model.Article{Model: &model.Model{ID: id}, State: state}
    db := d.Engine.Session(&gorm.Session{}) // 创建新的会话实例
    return article.Get(db)
}

• 在每个查询中，使用 d.Engine.Session(&gorm.Session{}) 来创建一个新的数据库会话，并传递给 Get 方法。
• 这可以避免污染问题，确保每个查询都使用独立的会话和查询链。

3. 避免使用全局共享的 *gorm.DB 实例

尽量避免在多个查询间共享同一个全局 *gorm.DB 实例。特别是当你需要在多个查询间传递状态时，可以通过方法参数传递数据库实例，确保每个查询都能创建独立的会话。

示例：

func (svc *Service) GetArticle(param *ArticleRequest) (*Article, error) {
    db := svc.dao.Engine.Session(&gorm.Session{}) // 创建新的会话
    article, err := svc.dao.GetArticle(param.ID, param.State, db)
    if err != nil {
        return nil, err
    }
    articleTag, err := svc.dao.GetArticleTagByAID(article.ID, db)
    if err != nil {
        return nil, err
    }
    tag, err := svc.dao.GetTag(articleTag.TagID, model.STATE_OPEN, db)
    if err != nil {
        return nil, err
    }
    return &Article{
        ID:            article.ID,
        Title:         article.Title,
        Desc:          article.Desc,
        Content:       article.Content,
        CoverImageUrl: article.CoverImageUrl,
        State:         article.State,
        Tag:           &tag,
    }, nil
}

• 在每次调用数据库操作时，传入新的 *gorm.DB 实例，确保查询链互不干扰。

4. 事务管理（如果需要）

如果你在事务中执行多个查询，可以确保每个查询都在同一个事务中运行，而不发生链式污染。事务的管理可以确保在同一个事务内执行的一系列操作共享状态，但每个操作仍然在同一个事务上下文中独立。

示例： 手动管理事务（使用 Begin、Commit 和 Rollback）

你可以显式地管理事务，通过调用 Begin() 开始事务、Commit() 提交事务、以及 Rollback() 回滚事务。这个方法更加细粒度，适用于需要手动控制事务行为的场景。

示例：

func (svc *Service) GetArticleWithManualTransaction(param *ArticleRequest) (*Article, error) {
    // 开始一个新的事务
    tx := svc.dao.Engine.Begin()
    if tx.Error != nil {
        return nil, tx.Error
    }

    // 确保在方法结束时处理事务
    defer func() {
        if r := recover(); r != nil {
            tx.Rollback() // 发生错误时回滚事务
        }
    }()

    var article Article
    article, err := svc.dao.GetArticle(param.ID, param.State, tx)
    if err != nil {
        tx.Rollback() // 出现错误时回滚事务
        return nil, err
    }

    articleTag, err := svc.dao.GetArticleTagByAID(article.ID, tx)
    if err != nil {
        tx.Rollback()
        return nil, err
    }

    tag, err := svc.dao.GetTag(articleTag.TagID, model.STATE_OPEN, tx)
    if err != nil {
        tx.Rollback()
        return nil, err
    }

    // 提交事务
    if err := tx.Commit().Error; err != nil {
        return nil, err
    }

    // 返回处理后的结果
    article.Tag = &tag
    return &article, nil
}

说明：

• Begin()：显式开始一个事务。
• Commit()：事务成功时提交更改。
• Rollback()：出现错误时回滚事务，确保数据一致性。

通过显式管理事务，你可以在不同的查询之间灵活地控制事务行为，确保事务内的操作都在一个统一的事务上下文中执行。

带有显式错误处理的事务管理

可以通过直接处理错误，确保事务在出错时进行回滚，并在没有错误时进行提交。这种写法与 Transaction 方法非常类似，但更细化地控制事务的提交和回滚。

示例：

func (svc *Service) GetArticleWithExplicitTransaction(param *ArticleRequest) (*Article, error) {
    tx := svc.dao.Engine.Begin()
    if tx.Error != nil {
        return nil, tx.Error
    }

    var article Article
    if err := svc.dao.GetArticle(param.ID, param.State, tx); err != nil {
        tx.Rollback()
        return nil, err
    }

    articleTag, err := svc.dao.GetArticleTagByAID(article.ID, tx)
    if err != nil {
        tx.Rollback()
        return nil, err
    }

    tag, err := svc.dao.GetTag(articleTag.TagID, model.STATE_OPEN, tx)
    if err != nil {
        tx.Rollback()
        return nil, err
    }

    // 如果一切顺利，提交事务
    if err := tx.Commit().Error; err != nil {
        return nil, err
    }

    article.Tag = &tag
    return &article, nil
}

总结

• 使用 Session(&gorm.Session{})：创建新的会话实例，避免查询链共享状态。
• 传递独立的 *gorm.DB 实例：确保每个查询都使用不同的数据库会话，避免污染。
• 避免共享全局 *gorm.DB 实例：尽量确保每次查询都是独立的。
• 事务管理：对于需要多个查询的操作，可以使用事务来管理，但仍需注意每个查询的独立性。