深入理解Go语言中JSON反序列化与MongoDB数据存储的陷阱

c1 := `{
    "mw" : 42.0922,
    "ΔfH°gas" : {
      "value" : 372.38,
      "units" : "kJ/mol"
    },
    "S°gas" : {
      "value" : 216.81,
      "units" : "J/mol×K"
    },
    "index" : [
      {"name" : "mw", "value" : 42.0922},
      {"name" : "ΔfH°gas", "value" : 372.38},
      {"name" : "S°gas", "value" : 216.81}
    ]
    }`

c2 := `{
    "name": "silicon",
    "mw": 32.1173,
    "index": [
      {
    "name": "mw",
    "value": 32.1173
      }
    ]
    }`

func insertEntry(j *map[string]interface{}, entry string) {
    err := json.Unmarshal([]byte(entry), j)
    if err != nil {
        panic(err)
    }
}

func main() {
    // ... c1, c2 定义 ...

    m := make(map[string]interface{})

    insertEntry(&m, c1) // 第一次反序列化
    insertEntry(&m, c2) // 第二次反序列化

    // ... MongoDB 存储操作 ...
}

package main

import (
    "encoding/json"
    "fmt"
    "log"

    "gopkg.in/mgo.v2" // 注意：labix.org/v2/mgo 已更新为 gopkg.in/mgo.v2
    "gopkg.in/mgo.v2/bson"
)

// unmarshalJSONToMap 是一个辅助函数，用于将JSON字符串反序列化到新的map中
func unmarshalJSONToMap(jsonString string) (map[string]interface{}, error) {
    m := make(map[string]interface{})
    err := json.Unmarshal([]byte(jsonString), &m)
    if err != nil {
        return nil, fmt.Errorf("failed to unmarshal JSON: %w", err)
    }
    return m, nil
}

func main() {
    c1JSON := `{
    "mw" : 42.0922,
    "ΔfH°gas" : {
      "value" : 372.38,
      "units" : "kJ/mol"
    },
    "S°gas" : {
      "value" : 216.81,
      "units" : "J/mol×K"
    },
    "index" : [
      {"name" : "mw", "value" : 42.0922},
      {"name" : "ΔfH°gas", "value" : 372.38},
      {"name" : "S°gas", "value" : 216.81}
    ]
    }`

    c2JSON := `{
    "name": "silicon",
    "mw": 32.1173,
    "index": [
      {
    "name": "mw",
    "value": 32.1173
      }
    ]
    }`

    // 连接MongoDB
    session, err := mgo.Dial("localhost")
    if err != nil {
        log.Fatalf("Failed to connect to MongoDB: %v", err)
    }
    defer session.Close()

    // 可选：设置会话模式为单调读写
    session.SetMode(mgo.Monotonic, true)

    // 获取集合
    c := session.DB("test").C("chemicals")

    // 清理旧数据，方便测试
    _, err = c.RemoveAll(nil)
    if err != nil && err != mgo.ErrNotFound {
        log.Printf("Warning: Failed to remove old documents: %v", err)
    }

    // 处理 c1 JSON
    m1, err := unmarshalJSONToMap(c1JSON)
    if err != nil {
        log.Fatalf("Error processing c1: %v", err)
    }
    err = c.Insert(&m1)
    if err != nil {
        log.Fatalf("Failed to insert m1 into MongoDB: %v", err)
    }
    fmt.Println("Inserted document for c1.")

    // 处理 c2 JSON
    m2, err := unmarshalJSONToMap(c2JSON)
    if err != nil {
        log.Fatalf("Error processing c2: %v", err)
    }
    err = c.Insert(&m2)
    if err != nil {
        log.Fatalf("Failed to insert m2 into MongoDB: %v", err)
    }
    fmt.Println("Inserted document for c2.")

    // 验证数据
    fmt.Println("\n--- Verifying inserted documents ---")

    // 查找 c1 对应的文档 (假设它没有 'name' 字段，我们可能需要其他字段来识别)
    // 这里我们尝试查找包含 "ΔfH°gas" 字段的文档
    var result1 map[string]interface{}
    err = c.Find(bson.M{"ΔfH°gas": bson.M{"$exists": true}}).One(&result1)
    if err != nil {
        log.Printf("Failed to find c1 document: %v", err)
    } else {
        fmt.Printf("Found c1 document (partial): %v\n", result1)
    }

    // 查找 c2 对应的文档
    var result2 map[string]interface{}
    err = c.Find(bson.M{"name": "silicon"}).One(&result2)
    if err != nil {
        log.Fatalf("Failed to find c2 document: %v", err)
    }
    fmt.Printf("Found c2 document: %v\n", result2)
    fmt.Printf("c2 document mw: %v\n", result2["mw"])

    // 尝试访问 c1 的特定字段，如果它被正确插入
    if result1 != nil {
        if val, ok := result1["ΔfH°gas"].(map[string]interface{}); ok {
            fmt.Printf("c1 document ΔfH°gas value: %v\n", val["value"])
            fmt.Printf("c1 document ΔfH°gas units: %v\n", val["units"])
        }
    }
}

{
  "chemical1": {
    "mw" : 42.0922,
    "ΔfH°gas" : { ... },
    "S°gas" : { ... },
    "index" : [ ... ]
  },
  "chemical2": {
    "name": "silicon",
    "mw": 32.1173,
    "index": [ ... ]
  }
}