Go语言如何反序列化包含接口类型字段的JSON数据？

问题描述 #

定义了如下Response结构体：

type Response struct {
    Data          Data   `json:"data"`
    Error         string `json:"error,omitempty"`
    NextPageToken string `json:"next_page_token,omitempty"`
}

其中Data是一个接口类型，拥有多个实现（如示例中的TypeA、TypeB）：

type Data interface{
    Foo()
}

type TypeA struct {
    Field1 string `json:"field1"`
    Field2 int    `json:"field2"`
}

func (a *TypeA) Foo() {}

type TypeB struct {
    Field3 float64 `json:"field3"`
}

func (b *TypeB) Foo() {}

直接使用json.Unmarshal反序列化时，会触发错误：error: json: cannot unmarshal object into Go struct field Response.data of type main.Data。

错误原因 #

Go标准库的json包无法自动推断接口类型的具体实现。接口本身不包含任何字段信息，反序列化时不知道要把JSON对象解析成哪个具体的结构体实例，因此抛出上述错误。

解决方案 #

方案1：添加类型标识字段（推荐） #

在JSON的data对象中加入一个类型标识字段（比如type），然后为Response结构体自定义UnmarshalJSON方法，根据这个标识创建对应的具体类型实例，再完成反序列化。

修改后的代码示例：

package main

import (
    "encoding/json"
    "fmt"
)

type Response struct {
    Data          Data   `json:"data"`
    Error         string `json:"error,omitempty"`
    NextPageToken string `json:"next_page_token,omitempty"`
}

type Data interface {
    Foo()
}

type TypeA struct {
    Type   string `json:"type"` // 新增类型标识
    Field1 string `json:"field1"`
    Field2 int    `json:"field2"`
}

func (a *TypeA) Foo() {}

type TypeB struct {
    Type   string  `json:"type"` // 新增类型标识
    Field3 float64 `json:"field3"`
}

func (b *TypeB) Foo() {}

// 为Response自定义反序列化方法
func (r *Response) UnmarshalJSON(data []byte) error {
    // 定义临时结构体，先解析data的原始JSON和其他字段
    type TempResponse struct {
        Data          json.RawMessage `json:"data"`
        Error         string          `json:"error,omitempty"`
        NextPageToken string          `json:"next_page_token,omitempty"`
    }

    var temp TempResponse
    if err := json.Unmarshal(data, &temp); err != nil {
        return err
    }

    // 解析data中的类型标识
    var typeInfo struct {
        Type string `json:"type"`
    }
    if err := json.Unmarshal(temp.Data, &typeInfo); err != nil {
        return err
    }

    // 根据类型创建对应Data实例
    var dataObj Data
    switch typeInfo.Type {
    case "TypeA":
        dataObj = &TypeA{}
    case "TypeB":
        dataObj = &TypeB{}
    default:
        return fmt.Errorf("unknown data type: %s", typeInfo.Type)
    }

    // 将data的JSON反序列化到对应实例
    if err := json.Unmarshal(temp.Data, dataObj); err != nil {
        return err
    }

    // 赋值给原Response结构体
    r.Data = dataObj
    r.Error = temp.Error
    r.NextPageToken = temp.NextPageToken
    return nil
}

func main() {
    jsonStr := `{
        "data": {
            "type": "TypeA",
            "field1": "some string",
            "field2": 123
        },
        "error": "",
        "next_page_token": ""
    }`

    var response Response
    err := json.Unmarshal([]byte(jsonStr), &response)
    if err != nil {
        fmt.Println("error:", err)
        return
    }

    switch data := response.Data.(type) {
    case *TypeA:
        fmt.Println("TypeA:", data.Field1, data.Field2)
    case *TypeB:
        fmt.Println("TypeB:", data.Field3)
    default:
        fmt.Println("Unknown type")
    }
}

方案2：根据字段特征判断类型 #

如果无法修改JSON结构添加类型标识，可以先把data反序列化为map[string]interface{}，通过检查是否存在特定字段来判断具体类型，再反序列化到对应的结构体。

代码示例：

package main

import (
    "encoding/json"
    "fmt"
)

type Response struct {
    Data          Data   `json:"data"`
    Error         string `json:"error,omitempty"`
    NextPageToken string `json:"next_page_token,omitempty"`
}

type Data interface {
    Foo()
}

type TypeA struct {
    Field1 string `json:"field1"`
    Field2 int    `json:"field2"`
}

func (a *TypeA) Foo() {}

type TypeB struct {
    Field3 float64 `json:"field3"`
}

func (b *TypeB) Foo() {}

func (r *Response) UnmarshalJSON(data []byte) error {
    type TempResponse struct {
        Data          json.RawMessage `json:"data"`
        Error         string          `json:"error,omitempty"`
        NextPageToken string          `json:"next_page_token,omitempty"`
    }

    var temp TempResponse
    if err := json.Unmarshal(data, &temp); err != nil {
        return err
    }

    // 将data解析为map，检查字段特征
    var dataMap map[string]interface{}
    if err := json.Unmarshal(temp.Data, &dataMap); err != nil {
        return err
    }

    var dataObj Data
    if _, hasField1 := dataMap["field1"]; hasField1 {
        dataObj = &TypeA{}
    } else if _, hasField3 := dataMap["field3"]; hasField3 {
        dataObj = &TypeB{}
    } else {
        return fmt.Errorf("unknown data type")
    }

    if err := json.Unmarshal(temp.Data, dataObj); err != nil {
        return err
    }

    r.Data = dataObj
    r.Error = temp.Error
    r.NextPageToken = temp.NextPageToken
    return nil
}

func main() {
    jsonStr := `{
        "data": {
            "field1": "some string",
            "field2": 123
        },
        "error": "",
        "next_page_token": ""
    }`

    var response Response
    err := json.Unmarshal([]byte(jsonStr), &response)
    if err != nil {
        fmt.Println("error:", err)
        return
    }

    switch data := response.Data.(type) {
    case *TypeA:
        fmt.Println("TypeA:", data.Field1, data.Field2)
    case *TypeB:
        fmt.Println("TypeB:", data.Field3)
    default:
        fmt.Println("Unknown type")
    }
}

说明 #

• 方案1的类型标识字段是最可靠的方式，避免因字段重叠导致的判断错误。
• 方案2依赖字段特征，若不同类型存在相同字段，会出现判断失误，仅适用于类型字段差异明显的场景。

内容的提问来源于stack exchange，提问作者andrewlaguna824