Go语言中解码JSON到嵌套Map的实践指南

package main

import (
    "encoding/json"
    "os"
    "fmt"
)

// Locker 结构体模拟一个包含嵌套map的数据存储
type Locker struct {
    data map[string]map[string]string
}

// Save 方法将 Locker 的数据保存为 JSON 文件
func (l *Locker) Save(filename string) error {
    file, err := os.Create(filename)
    if err != nil {
        return fmt.Errorf("创建文件失败: %w", err)
    }
    defer file.Close() // 确保文件在函数结束时关闭

    encoder := json.NewEncoder(file)
    // 使用 Encode 方法将 l.data 编码并写入文件
    return encoder.Encode(l.data)
}

func main() {
    // 示例数据
    locker := &Locker{
        data: map[string]map[string]string{
            "foo": {"bar": "new", "baz": "extra"},
            "bar": {"hello": "world"},
        },
    }

    filename := "output.json"
    err := locker.Save(filename)
    if err != nil {
        fmt.Printf("保存数据失败: %v\n", err)
        return
    }
    fmt.Printf("数据已成功保存到 %s\n", filename)

    // 清理测试文件
    defer os.Remove(filename)
}

// 错误的 Load 方法示例
func (l *Locker) Load(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer file.Close()

    decoder := json.NewDecoder(file)
    // 错误示范：直接传递 l.data (一个map值) 而非其地址
    return decoder.Decode(l.data) // 这通常会导致 l.data 保持为空
}

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    // 待解码的JSON数据（字节切片形式）
    srcJSON := []byte(`{"bar":{"hello":"world"},"foo":{"bar":"new","baz":"extra"}}`)
    fmt.Println("原始JSON数据：", string(srcJSON))

    // 声明一个目标map变量，用于存储解码后的数据
    // 注意：这里可以声明为 nil map，json.Unmarshal 会正确地为其分配内存
    var decodedData map[string]map[string]string

    // 使用 json.Unmarshal 进行解码
    // 关键点：必须传递 decodedData 变量的地址（指针）
    err := json.Unmarshal(srcJSON, &decodedData)
    if err != nil {
        fmt.Printf("JSON解码失败: %v\n", err)
        return
    }

    fmt.Println("\n解码成功！内容如下：")
    // 遍历并打印解码后的map内容
    for key, innerMap := range decodedData {
        fmt.Printf("主键: %s\n", key)
        for subKey, value := range innerMap {
            fmt.Printf("\t子键: %s, 值: %s\n", subKey, value)
        }
    }

    // 验证解码结果
    if val, ok := decodedData["bar"]["hello"]; ok {
        fmt.Printf("\n验证：decodedData[\"bar\"][\"hello\"] = %s\n", val) // 预期输出 "world"
    }
    if val, ok := decodedData["foo"]["baz"]; ok {
        fmt.Printf("验证：decodedData[\"foo\"][\"baz\"] = %s\n", val) // 预期输出 "extra"
    }
}

package main

import (
    "encoding/json"
    "os"
    "fmt"
)

// Locker 结构体模拟一个包含嵌套map的数据存储
type Locker struct {
    data map[string]map[string]string
}

// Save 方法将 Locker 的数据保存为 JSON 文件
func (l *Locker) Save(filename string) error {
    file, err := os.Create(filename)
    if err != nil {
        return fmt.Errorf("创建文件失败: %w", err)
    }
    defer file.Close()

    encoder := json.NewEncoder(file)
    return encoder.Encode(l.data)
}

// Load 方法从 JSON 文件加载数据到 Locker
func (l *Locker) Load(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return fmt.Errorf("打开文件失败: %w", err)
    }
    defer file.Close()

    decoder := json.NewDecoder(file)
    // 关键点：必须传递 l.data 字段的地址（指针）
    return decoder.Decode(&l.data)
}

func main() {
    // 1. 准备一个包含嵌套map数据的JSON文件
    initialData := map[string]map[string]string{
        "bar": {"hello": "world"},
        "foo": {"bar": "new", "baz": "extra"},
    }

    filename := "test_data.json"
    // 将数据保存到文件
    func() {
        file, err := os.Create(filename)
        if err != nil {
            fmt.Printf("创建测试文件失败: %v\n", err)
            return
        }
        defer file.Close()
        encoder := json.NewEncoder(file)
        if err := encoder.Encode(initialData); err != nil {
            fmt.Printf("写入测试文件失败: %v\n", err)
        } else {
            fmt.Printf("测试数据已写入 %s\n", filename)
        }
    }()

    // 确保在程序结束时清理测试文件
    defer os.Remove(filename)

    // 2. 使用 Locker 结构体加载数据
    locker := &Locker{} // 初始化 Locker 实例，其 data 字段默认为 nil map

    fmt.Printf("\n加载前 Locker.data: %v\n", locker.data)

    err := locker.Load(filename)
    if err != nil {
        fmt.Printf("从文件加载数据失败: %v\n", err)
        return
    }

    fmt.Println("加载后 Locker.data:")
    for k, v := range locker.data {
        fmt.Printf("主键: %s\n