How to unmarshal JSON into fields using a common interface

php editor Xinyi introduces you how to use a common interface to unmarshal JSON into fields. In development, we often need to parse the received JSON data into fields so that the data can be easily manipulated and processed. Generic interfaces provide a simple and flexible way to achieve this goal. By using the common interface, we can pass a string containing JSON data to the unmarshalling method and get the parsed fields for subsequent processing. This method is not only simple and easy to use, but also suitable for various types of JSON data parsing. Let's learn how to unmarshal JSON into fields using a common interface!

Question content

I have a generic response object with the following structure:

type response struct {
    data          data   `json:"data"`
    error         string `json:"error,omitempty"`
    nextpagetoken string `json:"next_page_token,omitempty"`
}

data The type is an interface and has many implementations (such as pingresponse, etc.). How to unmarshal response to its underlying type? The complete example is as follows, it always triggers the error error: json: cannot unmarshal object into go struct field response.data of type main.data ：

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 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")
    }
}

Workaround

You must tell encoding/json which concrete type to unmarshal to. This package cannot do this for you.

Assume typea and typeb are defined as:

type typea struct {
    fielda string `json:"field"`
}

type typeb struct {
    fieldb string `json:"field"`
}

In this case, it is impossible to decide which type to unmarshal to.

Regarding your example, we can tell encoding/json the type to unmarshal as follows:

- var response response
+ response := response{data: &typea{}}

If you don't know the type beforehand, you can marshal it to map[string]interface{}:

type response struct {
-   data          data                   `json:"data"`
+   data          map[string]interface{} `json:"data"`
    error         string                 `json:"error,omitempty"` 
    nextpagetoken string                 `json:"next_page_token,omitempty"`
 }

And determine the type as follows:

if field1, ok := response.data["field1"]; ok {
    fmt.println("typea:", field1, response.data["field2"])
} else {
    if field3, ok := response.data["field3"]; ok {
        fmt.println("typeb:", field3)
    } else {
        fmt.println("unknown type")
    }
}

Another solution is to embed type information in json:

jsonStr := `{
     "data": {
         "field1": "some string",
         "field2": 123
     },
+    type": "A",
     "error": "",
     "next_page_token": ""
 }`

 type Response struct {
-   Data          Data            `json:"data"`
+   Data          json.RawMessage `json:"data"`
+   Type          string          `json:"type"`
    Error         string          `json:"error,omitempty"`
    NextPageToken string          `json:"next_page_token,omitempty"`
 }

Then decode response.data based on the value of response.type. See the example provided by encoding/json: https://pkg.go.dev/encoding/json#example-rawmessage-unmarshal.

The above is the detailed content of How to unmarshal JSON into fields using a common interface. For more information, please follow other related articles on the PHP Chinese website!