Go语言中高效处理JSON数据：使用结构体进行解析

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil" // 用于文件读取，如果JSON来自文件
    "os"        // 用于命令行参数，如果JSON文件路径来自参数
)

// Data 结构体用于匹配JSON数据 {"key": "..."}
// Key 字段是导出的（首字母大写），以便json包可以访问。
// `json:"key"` tag 指示JSON数据中的"key"字段应映射到此结构体的Key字段。
type Data struct {
    Key string `json:"key"`
}

func main() {
    // 示例1: 从字符串直接解码JSON
    fmt.Println("--- 示例1: 从字符串解码JSON ---")
    jsonString := `{ "key": "2073933158088" }`
    jsonDataFromStr := []byte(jsonString)

    var data1 Data // 创建Data结构体实例，用于接收解码后的数据
    err := json.Unmarshal(jsonDataFromStr, &data1)
    if err != nil {
        fmt.Printf("Error unmarshaling JSON from string: %v\n", err)
        os.Exit(1)
    }
    fmt.Println("Extracted Key (from string):", data1.Key) // 成功访问：data1.Key

    fmt.Println("\n--- 示例2: 从文件解码JSON (模拟) ---")
    // 示例2: 模拟从文件读取JSON数据，这与原始问题中从payload文件读取类似
    // 实际应用中，您可能从HTTP请求体、消息队列或文件中获取JSON。
    // 为了演示，我们假设有一个名为 "payload.json" 的文件，内容为 `{ "key": "file_value_12345" }`
    // 您可以手动创建这个文件来测试，或者直接使用内存中的字节切片。

    // 模拟文件内容
    fileContent := `{ "key": "file_value_12345" }`
    // 假设我们从文件中读取到了这些内容
    jsonDataFromFile := []byte(fileContent)

    // 在实际场景中，这部分代码会从文件系统读取：
    /*
    // 假设通过命令行参数传入文件路径
    payloadFilePath := ""
    for i, arg := range os.Args {
        if arg == "-payload" && i+1 < len(os.Args) {
            payloadFilePath = os.Args[i+1]
            break
        }
    }

    if payloadFilePath == "" {
        fmt.Println("Usage: go run your_program.go -payload <path_to_json_file>")
        // 为了演示，如果没有提供文件路径，我们使用默认的字符串数据
        // os.Exit(1) // 实际应用中可能会退出
    } else {
        jsonDataFromFile, err = ioutil.ReadFile(payloadFilePath)
        if err != nil {
            fmt.Printf("Error reading file '%s': %v\n", payloadFilePath, err)
            os.Exit(1)
        }
    }
    */

    var data2 Data // 另一个Data结构体实例
    err = json.Unmarshal(jsonDataFromFile, &data2)
    if err != nil {
        fmt.Printf("Error unmarshaling JSON from file data: %v\n", err)
        os.Exit(1)
    }
    fmt.Println("Extracted Key (from file data):", data2.Key) // 成功访问：data2.Key
}

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    jsonString := `{ "key": "2073933158088" }`
    var rawData interface{} // 解码到interface{}

    err := json.Unmarshal([]byte(jsonString), &rawData)
    if err != nil {
        fmt.Printf("Error unmarshaling JSON: %v\n", err)
        return
    }

    // 尝试直接访问字段会导致编译错误或运行时恐慌，例如 rawData.key 或 rawData["key"] 是无效的
    // 必须先进行类型断言
    if m, ok := rawData.(map[string]interface{}); ok {
        if keyValue, found := m["key"]; found {
            // keyValue的类型是interface{}，可能还需要进一步断言为string
            if strValue, isString := keyValue.(string); isString {
                fmt.Println("Key (from interface{} with type assertion):", strValue)
            } else {
                fmt.Println("Key value is not a string.")
            }
        } else {
            fmt.Println("Key 'key' not found in map.")
        }
    } else {
        fmt.Println("rawData is not a map[string]interface{}.")
    }
}