Go JSON 序列化性能优化：标准库、jsoniter、easyjson 对比与工程实践

type Order struct {
    ID     int64   `json:"id"`
    UserID int64   `json:"user_id"`
    Amount float64 `json:"amount"`
    Items  []Item  `json:"items,omitempty"`
}

// 每次 json.Marshal 都会：
//   1. reflect.TypeOf 遍历 struct 所有字段
//   2. 对每个字段按 tag 解析名字、找方法
//   3. 为中间结果分配大量 buffer
//   4. 数字转字符串、字符串转义……逐字段组装
data, _ := json.Marshal(order)

// 对特殊类型实现接口，跳过反射
type OrderID int64

func (id OrderID) MarshalJSON() ([]byte, error) {
    // 自定义编码（比如 时间戳/格式化）
    return []byte(strconv.FormatInt(int64(id), 10)), nil
}

// 别每次申请新 bytes.Buffer
var bufPool = sync.Pool{
    New: func() interface{} { return new(bytes.Buffer) },
}

func marshalToPool(v interface{}) []byte {
    buf := bufPool.Get().(*bytes.Buffer)
    buf.Reset()
    defer bufPool.Put(buf)

    if err := json.NewEncoder(buf).Encode(v); err != nil {
        return nil
    }
    // Encoder 自动加 \n，去尾部换行
    return bytes.TrimSuffix(buf.Bytes(), []byte("\n"))
}

// ✅ 用 omitempty 减少空字段输出
// ✅ 别序列化整个嵌套对象，用自定义方法投影
type OrderView struct {
    ID  int64  `json:"id"`
    ... // 只投影需要的字段
}

// ❌ 避免 map[string]interface{}（反射最贵 + 无法优化）
// ❌ 避免 interface{} 字段（丢失类型，序列化最慢）

import jsoniter "github.com/json-iterator/go"

var json = jsoniter.ConfigCompatibleWithStandardLibrary
// 之后的 json.Marshal / json.Unmarshal 用法与标准库一致
// 但内部缓存了解码器/编码器，避免反复反射

data, err := json.Marshal(order)
var order2 Order
json.Unmarshal(data, &order2)

jsoniter 做了什么：
  - 首次遇到某类型时，反射出编码/解码器并缓存
  - 之后用缓存的能力，不再逐次反射
  - 内部用 unsafe 减少拷贝、复用内存

适用：
  - 结构类型固定、要反复序列化（API 网关、HTTP handler）
  - 想零代码迁移，直接换 import 即可

不适用：
  - 类型反射动态变化极多（尽量少用 interface{} 路径）
  - 追求极致性能时不如 easyjson 的代码生成

# 安装生成器
go get -u github.com/mailru/easyjson/...
# 在结构体上标记，然后生成
go run github.com/mailru/easyjson -all ./model.go
# 生成 model_easyjson.go，包含 MarshalJSON / UnmarshalJSON

//easyjson:json
type Order struct {
    ID     int64   `json:"id"`
    UserID int64   `json:"user_id"`
    Amount float64 `json:"amount"`
    Items  []Item  `json:"items,omitempty"`
}

// 直接调用生成的快路径
data, _ := easyjson.Marshal(order)
var out Order
easyjson.Unmarshal(data, &out)

// 性能：约标准库 2~4 倍，分配减少 90%+
// 本质：生成面向该 struct 的手写 marshal 代码，零反射

大 JSON（几 MB ~ 几百 MB）一次性 Unmarshal 的代价：
  - 整块载入内存，GC 压力大
  - 解析出完整对象树，即使只关心个别字段

Streaming 思路：
  - json.Decoder 逐 token 解析，不建整棵对象树
  - 边读边处理，内存 O(字段数) 而非 O(全文件)

dec := json.NewDecoder(reader)
for dec.More() {          // 数组还有更多元素
    var item Record
    if err := dec.Decode(&item); err != nil {
        break
    }
    process(item)         // 逐条处理，内存可控
}

// 大型对象里只想拿某个 key，用 Decoder.Token 跳过无关部分
dec := json.NewDecoder(reader)
// 走到目标字段再 Decode，其余 token 直接跳过
for dec.Token() != nil {
    // ...
}

□ 别用 map[string]interface{} 存业务结构（反射最贵 + 无类型安全）
□ tag 变更要平滑，避免线上格式破坏
□ 大字段用流式/分片，别一次载入
□ 复用 buffer 用 sync.Pool，注意 Reset
□ 数字精度丢失：金额用 string/decimal，别用 float
□ 忽略错误：Unmarshal 失败时静默返回零值，务必处理 err
□ 高频路径用 easyjson 前先压测对比，别盲目引入