如何创建可被Gin序列化为JSON的有序键值映射？

Go原生的map[string]T在JSON序列化时会按键的字典序排序，无法保留自定义顺序，你可以通过以下两种方案解决：

方案一：使用支持有序序列化的第三方Map库 #

选择实现了json.Marshaler接口的有序Map库，比如elliotchance/orderedmap，它能在序列化时严格保持键的插入顺序：

1. 安装依赖：

go get github.com/elliotchance/orderedmap

2. 修改数据模型：

import "github.com/elliotchance/orderedmap"

type TopicBundle struct {
    // 保留你的其他字段
    Content *orderedmap.OrderedMap `json:"content"`
}

3. 构建有序内容并返回：

// 初始化有序Map
content := orderedmap.NewOrderedMap()
// 按你需要的顺序插入键值对
content.Set("1.4.5.", Topic{
    id:      "1.4.5.",
    content: "some content",
    title:   "title",
})
content.Set("1.4.6.", Topic{
    id:      "1.4.6.",
    content: "another content",
    title:   "another title",
})

// 组装TopicBundle并返回
tb := TopicBundle{
    // 赋值其他字段
    Content: content,
}
c.JSON(200, tb)

方案二：自定义JSON序列化逻辑 #

如果不想依赖第三方库，可给TopicBundle实现json.Marshaler接口，手动控制序列化顺序：

1. 修改数据模型，添加存储键顺序的字段：

type TopicBundle struct {
    // 你的其他字段（如ID、Name等）
    ID          string           `json:"id"`
    Name        string           `json:"name"`
    Content     map[string]Topic `json:"-"` // 忽略默认序列化
    OrderedKeys []string         `json:"-"` // 存储键的自定义顺序
}

2. 实现MarshalJSON方法：

import (
    "bytes"
    "encoding/json"
)

func (tb TopicBundle) MarshalJSON() ([]byte, error) {
    var buf bytes.Buffer
    // 序列化基础字段
    buf.WriteString(`{"id":`)
    idBytes, err := json.Marshal(tb.ID)
    if err != nil {
        return nil, err
    }
    buf.Write(idBytes)

    buf.WriteString(`,"name":`)
    nameBytes, err := json.Marshal(tb.Name)
    if err != nil {
        return nil, err
    }
    buf.Write(nameBytes)

    // 序列化有序的Content字段
    buf.WriteString(`,"content":{`)
    first := true
    for _, key := range tb.OrderedKeys {
        if !first {
            buf.WriteString(",")
        }
        first = false
        // 序列化键
        keyBytes, err := json.Marshal(key)
        if err != nil {
            return nil, err
        }
        buf.Write(keyBytes)
        buf.WriteString(":")
        // 序列化对应的Topic值
        topicBytes, err := json.Marshal(tb.Content[key])
        if err != nil {
            return nil, err
        }
        buf.Write(topicBytes)
    }
    buf.WriteString("}}")

    return buf.Bytes(), nil
}

3. 组装数据并返回：

// 从你的有序Map中提取键顺序和内容
orderedKeys := sm.Keys()
contentMap := make(map[string]Topic, len(orderedKeys))
for _, key := range orderedKeys {
    strKey := key.(string)
    contentMap[strKey] = first(sm.Get(key)).(Topic)
}

tb := TopicBundle{
    ID:          "你的BundleID",
    Name:        "你的Bundle名称",
    Content:     contentMap,
    OrderedKeys: orderedKeys,
}
c.JSON(200, tb)

这两种方案都能让你严格控制JSON响应中content字段的键顺序，选择哪种取决于你是否愿意引入第三方依赖。

内容的提问来源于stack exchange，提问作者Vitaly Sazanovich