Go语言中将JSON反序列化到接口变量并匹配具体类型的方法

type ConcreteImplementation struct {
    FieldA string
    FieldB string
}

func (c ConcreteImplementation) Key() string {
    return c.FieldA // ConcreteImplementation 实现了 genericValue 接口
}

type genericValue interface {
    Key() string
}

{"FieldA":"foo","FieldB":"bar"}

type Unmarshaler interface {
    UnmarshalJSON(data []byte) error
}

package main

import (
    "encoding/json"
    "fmt"
)

// ConcreteImplementation 是一个具体的类型
type ConcreteImplementation struct {
    FieldA string
    FieldB string
}

// Key 方法使 ConcreteImplementation 实现 genericValue 接口
func (c ConcreteImplementation) Key() string {
    return c.FieldA
}

// UnmarshalJSON 方法为 ConcreteImplementation 实现了 json.Unmarshaler 接口
// 注意：接收者必须是指针类型 (*ConcreteImplementation)，以便修改原始实例
func (c *ConcreteImplementation) UnmarshalJSON(j []byte) error {
    // 1. 定义一个临时的数据结构（通常是map或匿名struct）来解析JSON原始数据
    // 这里我们使用 map[string]string，假设所有字段都是字符串
    m := make(map[string]string)
    err := json.Unmarshal(j, &m)
    if err != nil {
        return fmt.Errorf("无法将JSON解析到临时map: %w", err)
    }

    // 2. 将解析出的数据赋值给 ConcreteImplementation 的字段
    if v, ok := m["FieldA"]; ok {
        c.FieldA = v
    }
    if v, ok := m["FieldB"]; ok {
        c.FieldB = v
    }
    return nil
}

// genericValue 接口现在嵌入了 json.Unmarshaler 接口
// 这意味着任何实现 genericValue 的类型也必须实现 Unmarshaler
type genericValue interface {
    Key() string
    json.Unmarshaler // 嵌入 json.Unmarshaler 接口
}

// decode 函数接受 JSON 字节数组和一个 genericValue 接口变量
// 它会调用接口变量的 UnmarshalJSON 方法
func decode(jsonStr []byte, v genericValue) error {
    return json.Unmarshal(jsonStr, v)
}

func main() {
    jsonString := `{"FieldA":"foo","FieldB":"bar"}`

    // 创建一个 ConcreteImplementation 的实例，并将其作为 genericValue 传递
    // 注意：这里必须传递一个指针，因为 UnmarshalJSON 方法是作用于指针接收者的
    var myConcreteValue ConcreteImplementation
    err := decode([]byte(jsonString), &myConcreteValue) // 传递 &myConcreteValue
    if err != nil {
        fmt.Println("解码错误:", err)
        return
    }

    fmt.Printf("成功解码到 ConcreteImplementation: %+v\n", myConcreteValue)
    fmt.Printf("Key: %s\n", myConcreteValue.Key())

    // 验证是否真的可以当作 genericValue 使用
    var gv genericValue = &myConcreteValue
    fmt.Printf("通过 genericValue 访问 Key: %s\n", gv.Key())

    // 尝试解码一个不匹配的JSON（如果 UnmarshalJSON 逻辑处理得当，会反映出来）
    jsonString2 := `{"UnknownField":"baz"}`
    var anotherConcreteValue ConcreteImplementation
    err = decode([]byte(jsonString2), &anotherConcreteValue)
    if err != nil {
        fmt.Println("解码错误 (不匹配的JSON):", err) // 实际上这里不会报错，只会导致字段为空
    }
    fmt.Printf("解码不匹配的JSON到 ConcreteImplementation: %+v\n", anotherConcreteValue)
}