Golang中JSON Unmarshal的用法解析

在Go中，当使用interface{}作为json.Unmarshal的目标时，JSON包会默认将数据解析为map[string]interface{}。要解决这个问题，你需要使用类型断言或反射来明确指定目标结构体类型。以下是几种解决方案：

方法1：使用类型断言（推荐）

type API1 struct {
    MyTarget string `json:"target"`
}

type API2 struct {
    MyTarget2 string `json:"target2"`
}

func unmarshalWithTypeAssertion() {
    data := []byte(`{"target": "value1", "other": "ignored"}`)
    
    // 根据API类型选择不同的结构体
    var result interface{}
    apiType := "api1"
    
    switch apiType {
    case "api1":
        var api1 API1
        json.Unmarshal(data, &api1)
        result = api1
        fmt.Printf("API1: %+v\n", api1)
    case "api2":
        var api2 API2
        json.Unmarshal(data, &api2)
        result = api2
        fmt.Printf("API2: %+v\n", api2)
    }
}

方法2：使用函数映射

var unmarshalFuncs = map[string]func([]byte) (interface{}, error){
    "api1": func(data []byte) (interface{}, error) {
        var api1 API1
        err := json.Unmarshal(data, &api1)
        return api1, err
    },
    "api2": func(data []byte) (interface{}, error) {
        var api2 API2
        err := json.Unmarshal(data, &api2)
        return api2, err
    },
}

func main() {
    data := []byte(`{"target": "value1", "other": "ignored"}`)
    
    if unmarshalFunc, ok := unmarshalFuncs["api1"]; ok {
        result, err := unmarshalFunc(data)
        if err == nil {
            fmt.Printf("Result: %+v\n", result)
        }
    }
}

方法3：使用反射（更灵活）

var typeRegistry = map[string]reflect.Type{
    "api1": reflect.TypeOf(API1{}),
    "api2": reflect.TypeOf(API2{}),
}

func unmarshalWithReflection(apiType string, data []byte) (interface{}, error) {
    if t, ok := typeRegistry[apiType]; ok {
        v := reflect.New(t).Interface()
        err := json.Unmarshal(data, v)
        return reflect.ValueOf(v).Elem().Interface(), err
    }
    return nil, fmt.Errorf("type not found: %s", apiType)
}

func main() {
    data := []byte(`{"target": "value1", "other": "ignored"}`)
    
    result, err := unmarshalWithReflection("api1", data)
    if err == nil {
        fmt.Printf("Result: %+v\n", result)
        if api1, ok := result.(API1); ok {
            fmt.Printf("MyTarget: %s\n", api1.MyTarget)
        }
    }
}

方法4：使用泛型（Go 1.18+）

func unmarshalGeneric[T any](data []byte) (*T, error) {
    var result T
    err := json.Unmarshal(data, &result)
    return &result, err
}

func main() {
    data := []byte(`{"target": "value1", "other": "ignored"}`)
    
    // 明确指定类型
    api1, err := unmarshalGeneric[API1](data)
    if err == nil {
        fmt.Printf("API1: %+v\n", api1)
    }
}

修正你的原始代码

type API1 struct {
    MyTarget string `json:"target"`
}

type API2 struct {
    MyTarget2 string `json:"target2"`
}

var APISlice = map[string]interface{}{
    "api1": API1{},
    "api2": API2{},
}

func main() {
    data := []byte(`{"target": "value1", "other": "ignored"}`)
    apiKey := "api1"
    
    // 获取对应类型的零值，然后创建指针
    switch target := APISlice[apiKey].(type) {
    case API1:
        var result API1
        json.Unmarshal(data, &result)
        fmt.Printf("API1 result: %+v\n", result)
    case API2:
        var result API2
        json.Unmarshal(data, &result)
        fmt.Printf("API2 result: %+v\n", result)
    }
}

关键点：

1. json.Unmarshal需要知道具体的类型信息
2. 使用interface{}时，JSON包无法推断具体结构体类型
3. 需要通过类型断言、反射或明确的类型声明来指定目标类型
4. 结构体标签json:"field_name"仍然有效，只会解析标记的字段