Go语言与MongoDB：使用mgo驱动高效构建和插入BSON文档

{
    "_id" : ObjectId("53439d6b89e4d7ca240668e5"),
    "balanceamount" : 3,
    "type" : "reg",
    "authentication" : {
      "authmode" : "10",
      "authval" : "sd",
      "recovery" : {
         "mobile" : "sdfsd",
         "email" : "user@example.com"
       }
     },
    "stamps" : {
       "in" : "x",
       "up" : "y"
    }
}

// account.go
package account

import (
    "labix.org/v2/mgo/bson" // 确保导入正确的mgo/bson包
)

// RecoveryInfo 嵌套结构体，对应authentication.recovery
type RecoveryInfo struct {
    Mobile string `bson:"mobile"`
    Email  string `bson:"email"`
}

// Authentication 嵌套结构体，对应authentication
type Authentication struct {
    AuthMode string       `bson:"authmode"`
    AuthVal  string       `bson:"authval"`
    Recovery RecoveryInfo `bson:"recovery"`
}

// Stamps 嵌套结构体，对应stamps
type Stamps struct {
    In string `bson:"in"`
    Up string `bson:"up"`
}

// Account 主结构体，对应MongoDB文档
type Account struct {
    ID            bson.ObjectId  `bson:"_id,omitempty"` // _id 字段使用bson.ObjectId类型，omitempty表示如果为空则不写入BSON
    BalanceAmount int            `bson:"balanceamount"`
    Type          string         `bson:"type"`
    Authentication Authentication `bson:"authentication"`
    Stamps        Stamps         `bson:"stamps"`
    // 其他字段...
}

// dbEngine.go
package dbEngine

import (
    "log"
    "time"

    "labix.org/v2/mgo"
)

// MgoSession 存储mgo会话，方便管理
var MgoSession *mgo.Session

// InitDB 初始化MongoDB连接
func InitDB(mongoURL string) error {
    var err error
    MgoSession, err = mgo.DialWithTimeout(mongoURL, 10*time.Second)
    if err != nil {
        return err
    }
    // 可选：设置连接模式
    MgoSession.SetMode(mgo.Monotonic, true)
    return nil
}

// Insert 通用插入方法
// document 参数接受一个interface{}，但实际传入的应该是Go结构体的指针
func Insert(dbName, collectionName string, document interface{}) error {
    if MgoSession == nil {
        return mgo.ErrSessionClosed
    }

    // 复制会话，每个请求使用独立的会话，用完后关闭
    session := MgoSession.Copy()
    defer session.Close() // 确保会话在使用完毕后关闭

    c := session.DB(dbName).C(collectionName)
    err := c.Insert(document)
    if err != nil {
        log.Printf("Failed to insert document into %s.%s: %v", dbName, collectionName, err)
        return err
    }
    log.Printf("Document successfully inserted into %s.%s", dbName, collectionName)
    return nil
}

// main.go (或其他调用处)
package main

import (
    "log"
    "fmt"

    "your_project_path/account" // 替换为你的account包路径
    "your_project_path/dbEngine" // 替换为你的dbEngine包路径
    "labix.org/v2/mgo/bson"
)

func main() {
    // 1. 初始化数据库连接
    mongoURL := "mongodb://localhost:27017" // 根据实际情况修改
    err := dbEngine.InitDB(mongoURL)
    if err != nil {
        log.Fatalf("Failed to connect to MongoDB: %v", err)
    }
    defer dbEngine.MgoSession.Close() // 确保主会话在程序退出时关闭

    // 2. 创建Account结构体实例并填充数据
    newAccount := account.Account{
        ID:            bson.NewObjectId(), // 为新文档生成一个唯一的_id
        BalanceAmount: 3,
        Type:          "reg",
        Authentication: account.Authentication{
            AuthMode: "10",
            AuthVal:  "sd",
            Recovery: account.RecoveryInfo{
                Mobile: "sdfsd",
                Email:  "user@example.com",
            },
        },
        Stamps: account.Stamps{
            In: "x",
            Up: "y",
        },
    }

    // 3. 调用dbEngine的Insert方法，传入结构体指针
    err = dbEngine.Insert("db_name", "collection_name", &newAccount) // 传入&newAccount，即Account结构体的指针
    if err != nil {
        log.Fatalf("Failed to insert account: %v", err)
    }

    fmt.Printf("Account inserted successfully with ID: %s\n", newAccount.ID.Hex())

    // 示例：插入另一个没有手动设置_id的文档
    anotherAccount := account.Account{
        BalanceAmount: 10,
        Type:          "premium",
        // ... 其他字段
    }
    // 因为_id字段有omitempty标签，且我们没有手动设置，mgo会在插入时自动生成
    err = dbEngine.Insert("db_name", "collection_name", &anotherAccount)
    if err != nil {
        log.Fatalf("Failed to insert another account: %v", err)
    }
    fmt.Printf("Another account inserted successfully with ID: %s\n", anotherAccount.ID.Hex())
}