Comment aplatir les champs d'interface anonymes dans la sérialisation Go JSON ?

Aplatissement des structures JSON avec des membres anonymes dans Go

Dans Go, les champs de structure anonymes sont généralement marshalés comme si leurs champs exportés internes étaient des champs dans la structure externe. Cependant, cela peut conduire à un comportement inattendu lors du marshaling de structures avec des membres anonymes de type interface{}.

Le problème

Considérez l'exemple suivant :

<code class="go">type User struct {
    Id   int    `json:"id"`
    Name string `json:"name"`
}

type Session struct {
    Id     int `json:"id"`
    UserId int `json:"userId"`
}

type Anything interface{}

type Hateoas struct {
    Anything
    Links map[string]string `json:"_links"`
}

func MarshalHateoas(subject interface{}) ([]byte, error) {
    h := &Hateoas{subject, make(map[string]string)}
    switch s := subject.(type) {
    case *User:
        h.Links["self"] = fmt.Sprintf("http://user/%d", s.Id)
    case *Session:
        h.Links["self"] = fmt.Sprintf("http://session/%d", s.Id)
    }
    return json.MarshalIndent(h, "", "    ")
}

func main() {
    u := &User{123, "James Dean"}
    s := &Session{456, 123}
    json, err := MarshalHateoas(u)
    if err != nil {
        panic(err)
    } else {
        fmt.Println("User JSON:")
        fmt.Println(string(json))
    }
    json, err = MarshalHateoas(s)
    if err != nil {
        panic(err)
    } else {
        fmt.Println("Session JSON:")
        fmt.Println(string(json))
    }
}</code>

Lors de l'exécution ce code, le JSON résultant n'est pas comme prévu :

<code class="json">User JSON:
{
    "Anything": {
        "id": 123,
        "name": "James Dean"
    },
    "_links": {
        "self": "http://user/123"
    }
}
Session JSON:
{
    "Anything": {
        "id": 456,
        "userId": 123
    },
    "_links": {
        "self": "http://session/456"
    }
}</code>

Comme vous pouvez le voir, le membre anonyme Anything est traité comme un champ nommé dans le JSON, ce qui n'est pas le comportement prévu.

La solution

Pour aplatir le membre anonyme et obtenir la structure JSON souhaitée, nous pouvons utiliser le package Reflect pour parcourir les champs de la structure et les mapper à une interface map[string]{}. Cela nous permet de conserver la structure plate de la structure d'origine sans introduire de nouveaux champs.

Le code mis à jour est le suivant :

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

// ... (rest of the code remains the same)

func MarshalHateoas(subject interface{}) ([]byte, error) {
    links := make(map[string]string)
    out := make(map[string]interface{})
    subjectValue := reflect.Indirect(reflect.ValueOf(subject))
    subjectType := subjectValue.Type()
    for i := 0; i <p>Avec cette modification, le JSON résultant est correctement aplati : </p>
<pre class="brush:php;toolbar:false"><code class="json">User JSON:
{
    "id": 123,
    "name": "James Dean",
    "_links": {
        "self": "http://user/123"
    }
}
Session JSON:
{
    "id": 456,
    "userId": 123,
    "_links": {
        "self": "http://session/456"
    }
}</code>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!