Go序列化时如何扁平化结构体中的map？

针对你遇到的大量结构体需要将普通字段与内部Map键值扁平化到同一JSON层级的问题，提供两种更高效的解决方案：

1. 通用反射工具函数（快速实现） #

通过反射自动提取结构体的非Map字段，再合并Map的键值对，无需为每个结构体重复编写序列化逻辑，新增字段也不会遗漏。

实现代码 #

import (
    "encoding/json"
    "reflect"
    "unicode"
)

// FlattenMarshalJSON 通用扁平化序列化函数，适配含单个待扁平化Map的结构体
func FlattenMarshalJSON(v interface{}) ([]byte, error) {
    val := reflect.ValueOf(v)
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }
    structMap := make(map[string]interface{})
    typ := val.Type()

    // 遍历提取非Map字段，保留JSON标签或自动转蛇形命名
    for i := 0; i < typ.NumField(); i++ {
        field := typ.Field(i)
        if field.Type.Kind() != reflect.Map {
            jsonTag := field.Tag.Get("json")
            if jsonTag == "" {
                jsonTag = toSnakeCase(field.Name)
            }
            structMap[jsonTag] = val.Field(i).Interface()
        }
    }

    // 找到并合并Map字段的键值
    var mapField reflect.Value
    for i := 0; i < typ.NumField(); i++ {
        field := typ.Field(i)
        if field.Type.Kind() == reflect.Map {
            mapField = val.Field(i)
            break // 假设每个结构体仅含一个需扁平化的Map字段
        }
    }

    if mapField.IsValid() {
        iter := mapField.MapRange()
        for iter.Next() {
            key := iter.Key().String()
            structMap[key] = iter.Value().Interface()
        }
    }

    return json.Marshal(structMap)
}

// toSnakeCase 大驼峰转蛇形命名的简易实现，可替换为成熟第三方库（如strcase）
func toSnakeCase(s string) string {
    var result []rune
    for i, r := range s {
        if i > 0 && unicode.IsUpper(r) {
            result = append(result, '_')
        }
        result = append(result, unicode.ToLower(r))
    }
    return string(result)
}

结构体适配用法 #

只需为每个结构体实现MarshalJSON并调用通用函数：

type MyStruct struct {
    SomeField  int                  `json:"some_field"`
    SomeField2 string               `json:"some_field_2"`
    SomeMap    map[string]SomeOtherStruct
}

func (m MyStruct) MarshalJSON() ([]byte, error) {
    return FlattenMarshalJSON(m)
}

2. 代码生成（高性能场景） #

若反射的性能无法满足需求，可通过go generate结合模板自动生成序列化代码，既避免手动编写的疏漏，又能获得接近手写代码的性能。

核心思路 #

1. 编写代码生成模板，定义序列化逻辑的结构
2. 用Go的AST解析包遍历结构体字段，自动填充模板
3. 在结构体所在文件添加//go:generate指令，运行go generate即可生成对应代码

示例模板（flatmarshal.tmpl）：

package {{.Package}}

import "encoding/json"

func (m {{.StructName}}) MarshalJSON() ([]byte, error) {
    base := map[string]interface{}{
        {{range .NonMapFields}}
        "{{.JSONTag}}": m.{{.Name}},
        {{end}}
    }
    for k, v := range m.{{.MapFieldName}} {
        base[k] = v
    }
    return json.Marshal(base)
}

注意事项 #

• 若结构体含多个Map字段，可通过自定义标签（如flatten:"true"）标记需扁平化的字段，在工具函数或代码生成逻辑中识别处理
• 蛇形命名转换推荐使用成熟第三方库（如github.com/iancoleman/strcase），避免自定义实现的边界问题
• 反射工具函数可根据实际需求扩展，支持指针、嵌套结构体等复杂场景

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