How to use custom JSON serialization in Go?

As modern programming languages ​​have higher and higher requirements for data structure and network transmission, JSON format has also become an important data exchange format. JSON can transmit data better, and the Go language is becoming more and more popular because of its high performance and simple application interface. In Go, you can customize JSON serialization to better meet data transmission needs. This article will explore how to use custom JSON serialization in Go.

1. What is JSON serialization?

JSON serialization refers to converting an object into a string in JSON format and sending it to other services or clients during network transmission so that they can successfully read and use the object. In the serialized JSON string, each attribute name will be converted to a string, and each value will be converted to the corresponding type in JSON to ensure universal data between different languages. Transmission format.

2. JSON serialization in Go

In the Go language, JSON serialization can be achieved by using ‘encoding/json’ in the standard library. When the data structure is a general structure and a separate value, you can directly use the Marshal function of the standard library to convert it into the corresponding JSON string, as shown below:

type User struct {
    Username string `json:"username"`
    Password string `json:"password"`
}

func main() {
    user := User{"Amy", "123456"}
    jsonStr, err := json.Marshal(user)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(jsonStr))
}

The output JSON string is:

{"username":"Amy","password":"123456"}

3. Custom JSON serialization

In Go language, you can customize JSON serialization by implementing the MarshalJSON and UnmarshalJSON methods. The MarshalJSON method is used to convert a structure or type into a JSON string, while UnmarshalJSON can convert a JSON string into the corresponding structure or type.

Before implementing custom JSON serialization, you need to understand several structure tags:

1. json: When defining a structure, you can add 'json:" before the field. custom_name"' to define the name of the field when serializing the JSON string.
2. omitempty: When the field value is non-empty, the field will be included during serialization, and when the field is empty, the field will not be included.

Next, take salary as an example to implement a custom JSON serialization.

type Salary struct {
    Basic int `json:"basic,omitempty"`
    Bonus int `json:"bonus,omitempty"`
}

func (s Salary) MarshalJSON() ([]byte, error) {
    var result string
    if s.Bonus != 0 {
        result = fmt.Sprintf(""basic":%d,"bonus":%d", s.Basic, s.Bonus)
    } else {
        result = fmt.Sprintf(""basic":%d", s.Basic)
    }
    return []byte("{" + result + "}"), nil
}

func main() {
    salary := Salary{
        Basic:  10000,
        Bonus:  5000,
    }
    jsonStr, err := json.Marshal(salary)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(jsonStr))
}

Run the above code, the output JSON string is:

{"basic":10000,"bonus":5000}

Here, we implement a custom MarshalJSON method, in Marsha, only when the Bonus field is not 0 , the value is output only; when it is 0, the field is not output.

4. Customized JSON formatting

In Go language, you can also customize JSON formatting by implementing the MarshalText and UnmarshalText methods. The MarshalText method is used to convert a structure or type into text in []byte format, while UnmarshalText can convert text in []byte format into the corresponding structure or type.

Taking date as an example, customize a JSON formatting function to output a format similar to "2022-09-21".

type Date struct {
    time.Time
}

func (d Date) MarshalText() ([]byte, error) {
    return []byte(d.Time.Format("2006-01-02")), nil
}

func (d *Date) UnmarshalText(text []byte) error {
    parse, err := time.Parse("2006-01-02", string(text))
    if err != nil {
        return err
    }
    d.Time = parse
    return nil
}

func main() {
    date := Date{time.Now()}
    jsonStr, err := json.Marshal(date)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(jsonStr))

    var newDate Date
    err = json.Unmarshal([]byte(""2022-09-21""), &newDate)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(newDate.Time)
}

Run the above code, the output JSON string is:

"2022-09-21"
2022-09-21 00:00:00 +0000 UTC

As can be seen from the above example, when customizing JSON serialization and deserialization, you need to understand JSON serialization The principles and implementation of the standard library can be flexibly applied in actual development. At the same time, we can also define a JSON formatting method that meets the requirements for our own objects, which provides basic tools and support to better meet the data transmission needs in different scenarios.

The above is the detailed content of How to use custom JSON serialization in Go?. For more information, please follow other related articles on the PHP Chinese website!