Comment créer une carte clé-valeur triée qui peut être sérialisée en json par Gin ?

Lors du développement d'applications Web à l'aide du langage Go, cela implique souvent de sérialiser les données au format JSON. Pour la sérialisation du mappage clé-valeur trié, nous pouvons utiliser le framework Gin et la structure de données cartographiques de Golang pour y parvenir. Dans cet article, l'éditeur PHP Banana vous présentera en détail comment créer une carte clé-valeur triée qui peut être sérialisée en JSON par Gin, rendant votre application Web plus flexible et efficace. Jetons un coup d'œil à la méthode de mise en œuvre spécifique !

Contenu de la question

J'utilise Gin pour créer une API REST. La réponse que j'essaie de créer est une carte json de valeurs clés comme :

"content": {
        "1.4.5.": {
            "id": "1.4.5.",
            "content": "some content",
            "title": "title"
        },
        "1.4.6.": {
            "id": "1.4.6.",
            "content": "another content",
            "title": "another title"
        },

Le modèle de données que j'utilise est :

type TopicBundle struct {
  ...
  Content      map[string]Topic `json:"content"`
}

et il est correctement sérialisé en json :

c.JSON(200, topicBundle)

Presque.

map[string]Topic n'obtient jamais ses valeurs dans le bon ordre. Je le crée à partir d'une carte triée. Mais cela n'aide pas.

var contentMap = make(map[string]Topic, sm.Len())
    for _, key := range sm.Keys() {
        contentMap[key.(string)] = first(sm.Get(key)).(Topic)
    }

À un moment donné, cette carte semble avoir été recréée et l'ordre des touches a légèrement changé. Je ne peux penser à aucune autre alternative, car Gin semble seulement sérialiser correctement cette carte clé-valeur brute. La carte triée de github.com/umpc/go-sortedmap n'est pas du tout sérialisée.

Alors comment conserver l'ordre des clés dans cette structure originale (native ?) ? Ou devrais-je écrire un sérialiseur personnalisé pour Gin ?

J'ai essayé de trouver une solution sur Internet.

Solution de contournement

Ma solution était d'écrire un wrapper autour de sortedmap.SortedMap et d'écrire un MarshalJSON personnalisé pour ce wrapper :

type TopicBundle struct {
    Content      SortedMapWrapper `json:"content"`
}
type SortedMapWrapper struct {
    topics *sortedmap.SortedMap
}

func (wrapper SortedMapWrapper) MarshalJSON() ([]byte, error) {
    var sb strings.Builder
    var counter = 0
    sb.WriteString("{")
    for _, key := range wrapper.topics.Keys() {
        sb.WriteString("\"")
        sb.WriteString(key.(string))
        sb.WriteString("\":")
        sb.Write(first(json.Marshal(first(wrapper.topics.Get(key)))))
        counter += 1
        if counter < wrapper.topics.Len() {
            sb.WriteString(",")
        }
    }
    sb.WriteString("}")
    return []byte(sb.String()), nil
}
func loadTopic(c *gin.Context) {
    var contentMap = sortedmap.New(1, comparisonFunc)
    contentMap.Insert("val1", Topic{"val1", "val2", "val3"})
    contentMap.Insert("val33", Topic{"val1", "val2", "val3"})
    var topicBundle = TopicBundle{}
    topicBundle.Content = SortedMapWrapper{contentMap}
    c.JSON(200, topicBundle)
}

Veuillez noter que la définition de MarshalJSON doit utiliser SortedMapWrapper (au lieu de *SortedMapWrapper). Sinon, il est introuvable.

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!