How to Unmarshal JSON into a Struct with a Field Tagged with \'json\'?

Unmarshaling JSON into a Struct with a Field Tagged with "json"

When trying to unmarshal JSON into a struct, you may encounter a scenario where a specific field has a "json" tag. This tag requires special handling to ensure the JSON data is correctly converted into the desired string format within the struct.

In the example provided, the struct A has a field S tagged with sql:"type:json". The goal is to unmarshal the value of "S" in the provided JSON data into a string format within the A struct.

Initially, you may have considered using reflection to check if a field tag contains the string "json" and then unmarshal the JSON data into that field as a string. However, a more efficient and elegant approach is to use Go's standard library features.

Using Custom Type and Marshal/Unmarshal Methods

One way to achieve this is by defining a custom type RawString and implementing MarshalJSON and UnmarshalJSON methods for it. These methods provide a way to control how JSON data is encoded and decoded, respectively.

In this example, the RawString type wraps a string value. The MarshalJSON method returns the string value as a byte slice, while the UnmarshalJSON method appends the received data to the existing RawString.

Marshaling and Unmarshaling the JSON

The next step is to define the A struct, which includes the I field (a 64-bit integer) and the S field of type RawString.

Using these custom types and methods, you can unmarshal the provided JSON data into the A struct. The following Go code demonstrates this:

<code class="go">import (
    "encoding/json"
    "fmt"
    "log"
)

// RawString is a raw encoded JSON object.
// It implements Marshaler and Unmarshaler and can
// be used to delay JSON decoding or precompute a JSON encoding.
type RawString string

// MarshalJSON returns *m as the JSON encoding of m.
func (m *RawString) MarshalJSON() ([]byte, error) {
    return []byte(*m), nil
}

// UnmarshalJSON sets *m to a copy of data.
func (m *RawString) UnmarshalJSON(data []byte) error {
    if m == nil {
        return errors.New("RawString: UnmarshalJSON on nil pointer")
    }
    *m += RawString(data)
    return nil
}

const data = `{"i":3, "S":{"phone": {"sales": "2223334444"}}}`

type A struct {
    I int64
    S RawString `sql:"type:json"`
}

func main() {
    a := A{}
    err := json.Unmarshal([]byte(data), &a)
    if err != nil {
        log.Fatal("Unmarshal failed", err)
    }
    fmt.Println("Done", a)
}</code>

By using this approach, you can effectively unmarshal JSON data into a struct with a field tagged with "json" and retain its original string format.

The above is the detailed content of How to Unmarshal JSON into a Struct with a Field Tagged with \'json\'?. For more information, please follow other related articles on the PHP Chinese website!