基于Golang与mongo-go-driver的CRUD图书应用操作日志实现方案及钩子功能咨询

Hey there! Let's tackle your question about building a Go-based book CRUD app with mongo-go-driver that logs all operations to a history collection.

先直接回答你的钩子问题 #

mongo-go-driver没有内置的钩子功能（也就是类似ORM框架里的before/after操作触发机制）。所以咱们得通过代码层面的设计来实现操作日志的需求，下面是几个靠谱的方案：

方案1：封装CRUD函数 + 事务（最适合小型应用） #

这是最直观的做法：把每个CRUD操作和对应的日志写入逻辑封装到同一个函数里，并且用MongoDB事务来保证两个操作（比如插入图书+写入创建日志）的原子性——要么都成功，要么都失败，避免数据不一致。

举个创建图书的代码例子：

import (
    "context"
    "time"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "go.mongodb.org/mongo-driver/mongo"
)

// 定义图书和历史记录的结构体
type Book struct {
    ID     primitive.ObjectID `bson:"_id,omitempty"`
    Title  string             `bson:"title"`
    Author string             `bson:"author"`
}

type History struct {
    ID        primitive.ObjectID `bson:"_id,omitempty"`
    BookID    primitive.ObjectID `bson:"bookId"`
    EventType string             `bson:"eventType"`
    Timestamp time.Time          `bson:"timestamp"`
}

func CreateBook(ctx context.Context, client *mongo.Client, book Book) error {
    // 启动MongoDB会话，用于事务
    session, err := client.StartSession()
    if err != nil {
        return err
    }
    defer session.EndSession(ctx)

    // 定义事务执行逻辑
    txnFunc := func(sCtx mongo.SessionContext) (interface{}, error) {
        // 1. 插入图书到book集合
        booksColl := client.Database("library").Collection("book")
        insertResult, err := booksColl.InsertOne(sCtx, book)
        if err != nil {
            return nil, err
        }
        bookID := insertResult.InsertedID.(primitive.ObjectID)

        // 2. 插入创建事件到history集合
        historyColl := client.Database("library").Collection("history")
        _, err = historyColl.InsertOne(sCtx, History{
            BookID:    bookID,
            EventType: "book.created",
            Timestamp: time.Now(),
        })
        return nil, err
    }

    // 执行事务
    _, err = session.WithTransaction(ctx, txnFunc)
    return err
}

优点：简单易懂，代码直接，容易调试维护；注意：MongoDB事务需要副本集/分片集群环境，如果是单节点本地开发，可能需要先配置副本集。

方案2：中间件/装饰器模式（适合中大型应用，解耦业务与日志） #

如果你的应用有很多CRUD操作，不想重复写日志逻辑，可以用装饰器模式把日志功能抽离出来，和核心业务逻辑解耦。

首先定义核心业务的接口，然后实现基础的CRUD服务，再写一个带日志功能的装饰器包裹它：

// 定义图书服务接口
type BookService interface {
    Create(ctx context.Context, book Book) (primitive.ObjectID, error)
    Update(ctx context.Context, bookID primitive.ObjectID, updates map[string]interface{}) error
    Delete(ctx context.Context, bookID primitive.ObjectID) error
}

// 基础图书服务，只处理核心CRUD逻辑
type DefaultBookService struct {
    client *mongo.Client
}

func (s *DefaultBookService) Create(ctx context.Context, book Book) (primitive.ObjectID, error) {
    coll := s.client.Database("library").Collection("book")
    res, err := coll.InsertOne(ctx, book)
    if err != nil {
        return primitive.NilObjectID, err
    }
    return res.InsertedID.(primitive.ObjectID), nil
}

// 实现Update、Delete等其他接口方法...

// 带日志功能的装饰器服务
type BookServiceWithHistory struct {
    inner  BookService
    client *mongo.Client
}

func NewBookServiceWithHistory(inner BookService, client *mongo.Client) *BookServiceWithHistory {
    return &BookServiceWithHistory{inner: inner, client: client}
}

func (s *BookServiceWithHistory) Create(ctx context.Context, book Book) (primitive.ObjectID, error) {
    // 先执行核心创建逻辑
    bookID, err := s.inner.Create(ctx, book)
    if err != nil {
        return bookID, err
    }

    // 写入创建日志
    historyColl := s.client.Database("library").Collection("history")
    _, err = historyColl.InsertOne(ctx, History{
        BookID:    bookID,
        EventType: "book.created",
        Timestamp: time.Now(),
    })
    return bookID, err
}

// 同理实现Update（记录book.updated）、Delete（记录book.deleted）的日志逻辑...

优点：业务逻辑和日志逻辑完全分离，代码复用性高，后续扩展其他操作日志很方便；缺点：需要设计接口，比方案1稍微复杂一点，但长期维护更省心。

方案3：MongoDB Atlas触发器（无代码侵入，适合云托管场景） #

如果你用的是MongoDB Atlas托管数据库，可以用Atlas Database Triggers——当book集合发生插入、更新、删除操作时，自动触发一个JavaScript函数，向history集合写入日志。

这种方式完全不需要修改Go代码，直接在Atlas控制台配置触发器：

• 选择监听book集合的insert/update/delete事件
• 编写触发函数，比如插入history文档的逻辑
• 配置触发条件和权限

优点：代码无侵入，不用在Go里处理日志逻辑；缺点：依赖Atlas服务，本地开发环境可能无法复用这个逻辑，而且触发逻辑用JavaScript编写，和Go代码分离。

总结选择建议 #

• 小型应用/快速原型：选方案1，简单直接；
• 中大型应用/注重代码架构：选方案2，解耦易维护；
• 云托管Atlas用户：可以考虑方案3，减少代码复杂度。

内容的提问来源于stack exchange，提问作者Shawn Yeung