Wie verwende ich die benutzerdefinierte JSON-Serialisierung in Go?

Da moderne Programmiersprachen immer höhere Anforderungen an die Datenstruktur und Netzwerkübertragung stellen, ist das JSON-Format auch zu einem wichtigen Datenaustauschformat geworden. JSON kann Daten besser übertragen und die Go-Sprache erfreut sich aufgrund ihrer hohen Leistung und einfachen Anwendungsschnittstelle immer größerer Beliebtheit. In Go können Sie die JSON-Serialisierung anpassen, um den Datenübertragungsanforderungen besser gerecht zu werden. In diesem Artikel erfahren Sie, wie Sie die benutzerdefinierte JSON-Serialisierung in Go verwenden.

1. Was ist JSON-Serialisierung?

JSON-Serialisierung bezieht sich auf die Konvertierung eines Objekts in eine Zeichenfolge im JSON-Format und das Senden an andere Dienste oder Clients während der Netzwerkübertragung, damit diese das Objekt erfolgreich lesen und verwenden können. In der serialisierten JSON-Zeichenfolge wird jeder Attributname in eine Zeichenfolge konvertiert und jeder Wert wird in den entsprechenden Typ in JSON konvertiert, um ein universelles Datenübertragungsformat zwischen verschiedenen Sprachen sicherzustellen.

2. JSON-Serialisierung in Go

In der Go-Sprache kann die JSON-Serialisierung durch die Verwendung von „encoding/json“ in der Standardbibliothek erreicht werden. Wenn es sich bei der Datenstruktur um eine allgemeine Struktur und einen separaten Wert handelt, können Sie sie direkt mit der Marshal-Funktion der Standardbibliothek in die entsprechende JSON-Zeichenfolge konvertieren, wie unten gezeigt:

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

Die ausgegebene JSON-Zeichenfolge lautet:

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

Drei , Benutzerdefinierte JSON-Serialisierung

In der Go-Sprache können Sie die JSON-Serialisierung anpassen, indem Sie die Methoden MarshalJSON und UnmarshalJSON implementieren. Die MarshalJSON-Methode wird verwendet, um eine Struktur oder einen Typ in einen JSON-String zu konvertieren, während UnmarshalJSON einen JSON-String in die entsprechende Struktur oder den entsprechenden Typ konvertieren kann.

Bevor Sie die benutzerdefinierte JSON-Serialisierung implementieren, müssen Sie mehrere Struktur-Tags verstehen:

1. json: Beim Definieren der Struktur können Sie „json:“custom_name““ vor dem Feld hinzufügen, um den Namen des Felds in der Serialisierung als JSON zu definieren Zeichenfolge.
2. omitempty: Wenn der Feldwert nicht leer ist, wird das Feld während der Serialisierung einbezogen, und wenn das Feld leer ist, wird das Feld nicht einbezogen.

Nehmen Sie als Nächstes das Gehalt als Beispiel, um eine benutzerdefinierte JSON-Serialisierung zu implementieren.

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

Führen Sie den obigen Code aus und die ausgegebene JSON-Zeichenfolge lautet:

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

Hier haben wir eine benutzerdefinierte MarshalJSON-Methode implementiert. In Marsha wird der Wert nur dann ausgegeben, wenn dies der Fall ist 0, dieses Feld wird nicht ausgegeben.

4. Angepasste JSON-Formatierung

In der Go-Sprache können Sie die JSON-Formatierung auch anpassen, indem Sie die Methoden MarshalText und UnmarshalText implementieren. Die MarshalText-Methode wird zum Konvertieren einer Struktur oder eines Typs in Text im []Byte-Format verwendet, während UnmarshalText Text im []Byte-Format in die entsprechende Struktur oder den entsprechenden Typ konvertieren kann.

Nehmen Sie das Datum als Beispiel, passen Sie eine JSON-Formatierungsfunktion an und geben Sie ein Format ähnlich „2022-09-21“ aus.

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

Führen Sie den obigen Code aus und die ausgegebene JSON-Zeichenfolge lautet:

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

Wie aus dem obigen Beispiel ersichtlich ist, müssen Sie beim Anpassen der JSON-Serialisierung und -Deserialisierung die Prinzipien der JSON-Serialisierung und die Implementierung der Standardbibliothek verstehen. Nutzen Sie es flexibel in der tatsächlichen Entwicklung. Gleichzeitig können wir auch eine JSON-Formatierungsmethode definieren, die den Anforderungen unserer eigenen Objekte entspricht und grundlegende Tools und Unterstützung bietet, um die Datenübertragungsanforderungen in verschiedenen Szenarien besser zu erfüllen.

Das obige ist der detaillierte Inhalt vonWie verwende ich die benutzerdefinierte JSON-Serialisierung in Go?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!