第一章：Go map 序列化陷阱全景概览
Go 语言中 map 类型因其动态性与无序性，在序列化（尤其是 JSON、Gob 或 Protocol Buffers）时极易引发静默错误、数据丢失或运行时 panic。这些陷阱往往在开发后期才暴露，且难以通过静态分析发现。
常见失效场景
- nil map 的 JSON 编组：
json.Marshal(nilMap)返回"null"，而非空对象{}，前端常误判为“缺失字段”； - 非导出字段的忽略：
map[string]struct{ Name string; age int }中age字段因首字母小写被json包完全跳过； - 并发读写导致 panic：在
json.Marshal过程中若另一 goroutine 修改 map，触发fatal error: concurrent map read and map write； - 不支持的键类型：
map[struct{X, Y int}]string在 JSON 中无法序列化（JSON 键必须是字符串），但gob可处理——需明确序列化协议约束。
JSON 序列化典型问题复现
以下代码演示了最易忽视的 nil map 行为差异：
package main
import (
"encoding/json"
"fmt"
)
func main() {
var m map[string]string // nil map
data, _ := json.Marshal(m)
fmt.Printf("nil map marshaled as: %s\n", string(data)) // 输出: null
m = make(map[string]string) // 空 map
data, _ = json.Marshal(m)
fmt.Printf("empty map marshaled as: %s\n", string(data)) // 输出: {}
}执行结果表明：nil 和 make(map[string]string) 在 JSON 中语义完全不同，前者等价于 null，后者才是 {}。API 设计中若未显式初始化 map，默认值为 nil，极易导致下游解析失败。
序列化协议能力对照
| 协议 | 支持 nil map → {}？ |
支持非字符串键？ | 支持 struct 非导出字段？ | 并发安全要求 |
|---|---|---|---|---|
encoding/json |
否（输出 null） |
否 | 否 | 需外部同步 |
encoding/gob |
是（默认编码为空 map） | 是 | 是（私有字段可导出） | 需外部同步 |
protobuf |
依 message 定义 | 否（仅 string key） | 否（仅 public field） | 需外部同步 |
规避核心原则：始终显式初始化 map；对 JSON 场景，使用指针字段或自定义 MarshalJSON 方法统一 nil/empty 行为；所有跨 goroutine 的 map 序列化操作前须加锁或使用 sync.Map（注意：sync.Map 不支持直接 JSON 编组）。
第二章：JSON 序列化中的 map key 丢失机制剖析
2.1 JSON 标准规范对 map key 类型的隐式约束与 Go 实现差异
JSON RFC 8259 明确规定：对象（object）的键（key）必须为字符串。这构成对 key 类型的强制性隐式约束——任何非字符串 key（如 number、boolean、null）在序列化前必须被显式转换为字符串。
Go 的 encoding/json 包严格遵循该规范，但其 map[string]interface{} 类型在反序列化时拒绝非字符串 key；而若使用 map[any]interface{}（Go 1.18+），则需手动处理 key 类型转换。
JSON 解析中 key 类型校验逻辑
// 反序列化时，json.Unmarshal 源码中 key 必须为 string 类型
var m map[string]interface{}
err := json.Unmarshal([]byte(`{"age": 25, "42": true}`), &m)
// ✅ 合法：所有 key 均为 JSON 字符串字面量此处
m成功接收两个键"age"和"42"（注意："42"是字符串，非整数）。若原始 JSON 含{"42": true}，key 仍是字符串"42"，而非数字42。
Go 中常见误用对比
| 场景 | 是否符合 JSON 规范 | Go 行为 |
|---|---|---|
map[string]T |
✅ 是 | 安全，推荐 |
map[int]T 序列化为 JSON object |
❌ 否 | json.Marshal panic：json: unsupported type: map[int]string |
map[any]T 反序列化含非字符串 key 的 JSON |
❌ 不可能 | JSON 解析器根本不会产出非字符串 key |
graph TD
A[JSON Input] -->|RFC 8259| B[Key must be string]
B --> C[Go json.Unmarshal]
C --> D{Target map key type?}
D -->|string| E[Success]
D -->|int/bool/any| F[Reject or panic]2.2 非字符串 key（如 int、struct、bool）在 json.Marshal 中的静默跳过原理与源码验证
Go 的 json.Marshal 仅支持 map[string]T 形式的映射序列化，对非字符串 key（如 map[int]string）会静默忽略整个 map，不报错也不输出。
序列化行为验证
m := map[int]string{42: "answer"}
b, _ := json.Marshal(m)
fmt.Printf("%s\n", b) // 输出：{}
json.marshalMap源码中首先检查 key 类型：若!isStringKind(keyType.Kind())则直接返回nil（空切片），跳过遍历逻辑。
关键类型约束表
| Key 类型 | 是否允许 | 原因 |
|---|---|---|
string |
✅ | 满足 JSON object key 要求 |
int |
❌ | reflect.Kind() 非 String |
bool |
❌ | 同上，且无法转为合法 JSON key |
源码路径关键判断（encoding/json/encode.go）
func (e *encodeState) marshalMap(v reflect.Value) error {
if v.Type().Key().Kind() != reflect.String { // ← 核心守门条件
return nil // 静默终止，不写入任何字节
}
// ... 后续遍历逻辑
}2.3 嵌套 map[string]interface{} 中含非法 key 的递归丢弃路径分析
当 JSON 反序列化为 map[string]interface{} 后，需过滤含非法 key（如空字符串、含控制字符、. / $ 等 MongoDB/ES 禁用符）的键值对，且须递归清理其嵌套结构。
递归丢弃核心逻辑
func discardInvalidKeys(v interface{}) interface{} {
if m, ok := v.(map[string]interface{}); ok {
out := make(map[string]interface{})
for k, val := range m {
if !isValidKey(k) { continue } // 跳过非法 key
out[k] = discardInvalidKeys(val) // 递归处理值
}
return out
}
if s, ok := v.([]interface{}); ok {
for i, item := range s {
s[i] = discardInvalidKeys(item)
}
return s
}
return v
}isValidKey 检查 key 是否为空、含 \x00-\x1F、. / $ *；递归入口支持任意深度嵌套，避免 panic。
非法 key 示例对照表
| Key 示例 | 是否合法 | 原因 |
|---|---|---|
"user_name" |
✅ | 下划线允许 |
"" |
❌ | 空字符串 |
"price.$lt" |
❌ | 含 $（MongoDB 特殊操作符） |
"path/to" |
❌ | 含 /（ES 字段路径冲突） |
丢弃路径决策流
graph TD
A[输入 interface{}] --> B{是否 map[string]interface{}?}
B -->|否| C[原样返回]
B -->|是| D[遍历每个 key]
D --> E{isValidKey?}
E -->|否| F[跳过该键值对]
E -->|是| G[递归处理 value]
G --> H[写入输出 map]2.4 实战复现：通过反射+unsafe 检测 key 被丢弃前的原始状态
在 Go 运行时 GC 触发前，map 中的 key 可能已被标记为“待清除”，但尚未被实际擦除。此时借助 reflect 获取底层 hmap 结构，并用 unsafe 直接读取桶内存，可捕获原始值。
数据同步机制
需确保在 GC 标记阶段（gcMarkDone 前）执行探测，避免竞态：
// 获取 map header 地址
h := (*hmap)(unsafe.Pointer(reflect.ValueOf(m).UnsafeAddr()))
// 遍历 buckets，跳过 evacuated 状态桶
for i := 0; i < int(h.B); i++ {
b := (*bmap)(unsafe.Pointer(uintptr(unsafe.Pointer(h.buckets)) + uintptr(i)*uintptr(h.bucketsize)))
if b.tophash[0] != empty && b.tophash[0] != evacuatedEmpty {
keyPtr := unsafe.Pointer(uintptr(unsafe.Pointer(&b.keys)) + uintptr(0)*keySize)
fmt.Printf("raw key: %s\n", *(*string)(keyPtr)) // 未被 zeroed 的原始字符串
}
}逻辑分析：
hmap.B给出 bucket 数量；bmap.tophash[0]非empty/evacuatedEmpty表明该槽位仍含有效 key；keyPtr偏移计算依赖编译器对bmap结构体布局的固定约定（Go 1.21+ 保持稳定）。
关键约束条件
- 必须在
runtime.GC()显式触发前、且无并发写入时执行 - 仅适用于
string/int等非指针 key 类型（避免 GC 误回收）
| 条件 | 是否必需 | 说明 |
|---|---|---|
GOGC=off |
✅ | 防止后台 GC 干扰 |
runtime.KeepAlive(m) |
✅ | 延迟 map 对象被判定为可回收 |
-gcflags="-l" |
⚠️ | 禁用内联以稳定栈帧地址 |
2.5 防御方案：自定义 json.Marshaler 接口实现 key 安全透传与错误告警
在敏感字段（如 api_key、token）需跨服务透传但禁止日志落盘或监控暴露的场景下，直接使用默认 JSON 序列化存在泄露风险。
核心策略
- 仅允许白名单 key 参与序列化
- 非白名单字段自动替换为
"***REDACTED***" - 每次脱敏触发 Prometheus 错误计数器 + Slack 告警
func (u User) MarshalJSON() ([]byte, error) {
redacted := make(map[string]interface{})
for k, v := range u.toMap() {
if security.IsWhitelistedKey(k) {
redacted[k] = v
} else {
redacted[k] = "***REDACTED***"
security.AlertOnKeyLeak(k) // 上报 + 告警
}
}
return json.Marshal(redacted)
}
IsWhitelistedKey()查表校验（如[]string{"id", "email", "timestamp"}）；AlertOnKeyLeak()调用 OpenTelemetry Tracer 并异步推送告警事件。
安全效果对比
| 场景 | 默认 MarshalJSON | 自定义 MarshalJSON |
|---|---|---|
{"token":"abc123","email":"a@b.c"} |
全量输出 | {"token":"***REDACTED***","email":"a@b.c"} |
graph TD
A[HTTP Handler] --> B[User.MarshalJSON]
B --> C{Is key whitelisted?}
C -->|Yes| D[原值透传]
C -->|No| E[替换+告警+metrics]第三章：YAML 序列化下 map 行为的特殊性与风险点
3.1 YAML v1.2 规范中 map key 的类型宽容性与 go-yaml/v3 实际行为偏差
YAML v1.2 规范明确要求：map keys 必须为标量（scalar），且相等性基于值而非类型。例如，字符串 "1" 与整数 1 在规范中被视为不同 key（因序列化形式不同），但某些实现误将它们归一化。
go-yaml/v3 的实际表现
该库在解析时对 key 执行隐式类型转换：
# example.yaml
1: one
"1": one_stringvar m map[interface{}]interface{}
yaml.Unmarshal(data, &m) // m["1"] 和 m[1] 共存 → 符合规范✅ 正确：
go-yaml/v3严格保留原始类型，m[1]与m["1"]是两个独立键。
❌ 常见误解：认为其会合并键（如 older yaml.v2 行为）。
关键差异对比
| 行为维度 | YAML v1.2 规范 | go-yaml/v3 v0.14+ |
|---|---|---|
"1" 与 1 是否冲突 |
否（不同标量） | 否（分别存储） |
true 与 "true" |
不同 key | 不同 key |
类型宽容性边界示例
// 键类型映射逻辑（内部）
keyType := reflect.TypeOf(key).Kind() // interface{} → runtime type preserved
// → 避免 strconv.Parse* 自动转换该逻辑确保
map[interface{}]中float64(1.0)、int(1)、string("1")三者互不覆盖。
3.2 时间类型（time.Time）、指针、自定义类型 key 的序列化表现对比实验
Go 的 map 序列化行为在不同 key 类型下存在显著差异，尤其影响 JSON 和 Gob 编码一致性。
序列化兼容性表现
| Key 类型 | JSON 可序列化 | Gob 可序列化 | 是否可比较 | 备注 |
|---|---|---|---|---|
time.Time |
✅（转字符串） | ✅ | ✅ | 默认 RFC3339 格式 |
*string |
❌（panic） | ✅ | ❌ | JSON 不支持指针作为 key |
type UserID int |
✅ | ✅ | ✅ | 底层类型可比较即支持 |
关键验证代码
package main
import (
"encoding/json"
"fmt"
"time"
)
func main() {
t := time.Now()
m := map[time.Time]string{t: "event"}
data, _ := json.Marshal(m)
fmt.Printf("time.Time key → %s\n", data) // {"2024-01-01T12:00:00Z":"event"}
}逻辑分析：time.Time 实现了 json.Marshaler 接口，自动转为 RFC3339 字符串；其底层是 int64 + *Location，满足可比较性，故可作 map key；而 *string 因不可比较且无 json.Marshaler，直接 panic。
行为差异根源
graph TD
A[map key 类型] --> B{是否可比较？}
B -->|否| C[编译错误或 panic]
B -->|是| D{是否实现 Marshaler？}
D -->|是| E[按接口定制序列化]
D -->|否| F[按底层类型默认编码]3.3 键名冲突（如大小写敏感 vs 不敏感）导致的静默覆盖案例解析
数据同步机制
当 MySQL（不区分大小写，lower_case_table_names=1）与 PostgreSQL（默认区分大小写）通过 CDC 工具同步时，键名 user_id 与 User_ID 在 MySQL 中被归一化为同一键，触发静默覆盖。
典型覆盖场景
- 应用层先后写入
{"UserID": 101}和{"userid": 202} - MySQL 存储引擎将二者映射至同一列，后者覆盖前者
- 日志中无警告或错误码，仅数据异常
关键代码片段
-- MySQL 建表（隐式归一化）
CREATE TABLE profile (UserID INT, userid VARCHAR(32));
-- 实际仅创建单列：userid（小写），UserID 被重命名为 userid逻辑分析：MySQL 解析器在
lower_case_table_names=1模式下，对所有标识符转为小写后校验唯一性。UserID与userid经标准化后均为userid，导致建表时后者覆盖前者；后续 INSERT 也按此规则路由，引发不可见的数据丢失。
| 系统 | 键名策略 | 冲突响应 |
|---|---|---|
| MySQL | 文件系统级忽略 | 静默归一 |
| PostgreSQL | 字符串字面量 | 报错 duplicate column |
| Redis | 二进制精确匹配 | 允许并存 |
graph TD
A[应用写入 UserID:101] --> B[MySQL解析器转小写]
C[应用写入 userid:202] --> B
B --> D[统一映射为 'userid' 列]
D --> E[后写入值覆盖前值]第四章：Protobuf（gogo/protobuf & google.golang.org/protobuf）中 map 字段的序列化陷阱
4.1 Protobuf map 字段的底层 Go 结构映射规则与 key 类型强制转换逻辑
Protobuf map<K,V> 在 Go 中不映射为原生 map[K]V，而是统一生成为 map[string]*V（当 K 为 string、int32、int64、uint32、uint64、bool 时），其 key 经过标准化字符串编码。
key 编码规则
string→ 直接使用（已 UTF-8 安全）int32/int64/uint32/uint64→ 调用strconv.FormatInt/FormatUintbool→"true"或"false"
// 示例：.proto 中定义 map<int32, string> scores = 1;
// 生成的 Go 字段为：
Scores map[string]*string `protobuf:"bytes,1,rep,name=scores,proto3"`逻辑分析：
Scores是map[string]*string而非map[int32]string，因 Protobuf 运行时需支持动态反射与跨语言一致性，key 必须可序列化为字节流；*string是因 map value 需支持 nil 表达“未设置”。
支持的 key 类型及编码映射表
| Protobuf key 类型 | Go 映射 key 类型 | 编码方式 |
|---|---|---|
string |
string |
原值（无转义） |
int32 |
string |
strconv.FormatInt(x, 10) |
bool |
string |
fmt.Sprintf("%t", x) |
graph TD
A[Protobuf map<K,V>] --> B{K 类型}
B -->|string/int*/bool| C[Go: map[string]*V]
B -->|enum| D[Go: map[string]*V + name lookup]
C --> E[序列化时 key 自动编码]4.2 使用 proto.Map 类型时非 string/int32/int64 key 的 panic 时机与 recover 策略
proto.Map 要求 key 类型严格限定为 string、int32 或 int64，其余类型（如 uint32、bool、enum）在 序列化/反序列化过程中不会立即报错，而是在 运行时 map 赋值或遍历时触发 panic。
panic 触发点分析
proto.Marshal()：不校验 key 类型，静默通过map[keyType]value = ...：若 keyType 非允许类型，Go 运行时 panic（invalid map key type）range protoMap：同样触发底层 map 访问 panic
可恢复的典型场景
m := make(map[bool]string) // ❌ 非法 key 类型
defer func() {
if r := recover(); r != nil {
log.Printf("caught panic: %v", r) // ✅ 可捕获
}
}()
m[true] = "bad" // panic here此 panic 发生在 Go 原生 map 操作层面，非 protobuf 库主动抛出，故需在业务层显式 defer/recover。
| Key 类型 | Marshal 是否 panic | Map 赋值是否 panic | 推荐替代方案 |
|---|---|---|---|
string |
否 | 否 | ✅ 原生支持 |
int32 |
否 | 否 | ✅ 原生支持 |
uint32 |
否 | 是 | 改用 int32 |
graph TD A[定义 proto.Map] –> B{key 类型合法？} B –>|否| C[Go runtime panic on map op] B –>|是| D[protobuf 正常序列化]
4.3 gogoproto.customtype + 自定义 marshaler 对 map key 序列化的干预边界
gogoproto.customtype 允许为字段指定自定义 Go 类型，但对 map key 的序列化行为无直接影响——Protobuf 规范强制要求 map key 必须是标量类型（如 string, int32, bool），且其编码逻辑由 proto.Marshal 内置实现，绕过用户定义的 Marshal() 方法。
为何 key 不走自定义 marshaler？
- Protobuf runtime 将 map 编码为 repeated
Entry消息； - key 字段在
Entry中被声明为原生类型（如optional string key = 1;），不继承customtype的 marshal 行为； - 即使为
map[MyStringType]string声明gogoproto.customtype，key 仍按string序列化。
干预边界的实证代码
// example.proto
syntax = "proto3";
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
message Config {
map<MyKey, string> items = 1 [(gogoproto.customtype) = "MyKey"];
}
// MyKey 是自定义类型，含 Marshal/UnmarshalJSON，但不影响 Protobuf key 编码⚠️ 关键结论：
customtype仅影响字段值（value）的 Go 类型映射与序列化；map key 的二进制格式、排序逻辑、重复检测均由 Protobuf 标准决定，不可通过Marshal()函数重写。
| 干预能力 | key | value |
|---|---|---|
| 类型别名映射 | ✅ | ✅ |
| 自定义 Marshal | ❌ | ✅ |
| 排序语义控制 | ❌ | ❌（由 key 类型固有顺序决定） |
// 此 Marshal 方法永远不会被 map key 调用
func (k MyKey) Marshal() ([]byte, error) {
return []byte("ignored_for_key"), nil // 实际 key 仍按 string 字节序编码
}该 Marshal 仅在 MyKey 作为 message 字段值时生效，不参与 map key 的序列化路径。
4.4 跨语言（Go ↔ Python/Java）场景下 map key 类型不一致引发的静默截断实测
数据同步机制
当 Go 的 map[string]interface{} 与 Python 的 dict 或 Java 的 HashMap<String, Object> 通过 JSON 协议交互时，key 的类型隐式约束常被忽略。
实测现象
Go 中使用整数作 map key（如 map[interface{}]string{123: "ok"}），经 json.Marshal 序列化后，key 强制转为字符串 "123"；Python 反序列化后读取 data["123"] 成功，但 data[123] 报 KeyError——无报错、无日志、值丢失。
// Go 端：看似合法的 mixed-key map
m := map[interface{}]string{
123: "from-go-int", // ⚠️ 静默转为 JSON key "123"
"abc": "from-go-str",
}
b, _ := json.Marshal(m) // 输出 {"123":"from-go-int","abc":"from-go-str"}
json.Marshal对非字符串 map key 仅支持string、float64、bool、nil；int被自动fmt.Sprintf("%v")转为字符串，无警告。
关键差异对比
| 语言 | 原生 map key 类型 | JSON 序列化后 key 类型 | 是否允许 map[int]string 直接序列化 |
|---|---|---|---|
| Go | interface{} |
全强制 string | 否（panic: json: unsupported type: map[int]string） |
| Python | any |
保留原始类型（需 custom encoder） | 否（默认仅接受 str 为 key） |
graph TD
A[Go map[interface{}]T] -->|json.Marshal| B[{"123":"v","abc":"v"}]
B --> C[Python json.loads]
C --> D[dict with str keys only]
D --> E[123 not found as int key]第五章：统一规避策略与生产级 map 序列化最佳实践
为什么 JSON 序列化 map[string]interface{} 在微服务间频繁引发 panic
某电商订单履约系统在灰度发布 v2.3 时，下游库存服务连续 17 分钟返回 500 Internal Server Error。根因定位为上游订单服务将 map[string]interface{} 直接 json.Marshal() 后传入 HTTP Body，其中嵌套的 time.Time 字段被序列化为 Go 默认格式 "2024-05-22 14:32:18.123 +0800 CST"，而库存服务使用 Jackson 解析时因时区标识 CST 不符合 ISO-8601 标准直接抛出 JsonMappingException。该问题暴露了跨语言序列化中类型契约缺失的致命风险。
强制统一的序列化入口层设计
所有服务必须通过统一的 SerializeMap 函数完成 map 序列化，禁止直接调用 json.Marshal：
func SerializeMap(m map[string]interface{}) ([]byte, error) {
// 深拷贝避免修改原始数据
copied := deepCopyMap(m)
// 标准化时间字段（递归遍历）
normalizeTimeFields(copied)
// 移除 nil 值字段（防止 Jackson 反序列化 null 引发 NPE）
removeNilValues(copied)
return json.Marshal(copied)
}该函数已在公司内部 SDK v4.2.0 中强制启用，CI 流水线通过 AST 扫描拦截所有 json.Marshal( 调用，违规提交自动拒绝。
生产环境 map 键名标准化白名单机制
为防止前端传入非法键名（如 __proto__、constructor）触发原型污染，网关层实施键名白名单校验。白名单配置采用 YAML 管理，支持动态热加载：
| 服务模块 | 允许键名正则模式 | 示例合法键 |
|---|---|---|
| 订单创建 | ^[a-z][a-z0-9_]{2,31}$ |
shipping_addr |
| 用户资料更新 | ^user_(name\|phone\|email)$ |
user_email |
| 支付回调 | ^pay_(status\|amount\|ref)$ |
pay_ref |
当检测到 {"__proto__": {"admin": true}} 时，网关立即返回 400 Bad Request 并记录审计日志，日均拦截恶意键名请求 2300+ 次。
高并发场景下的零拷贝序列化优化路径
在实时风控服务中，单机 QPS 达 12,000，原 deepCopyMap 占用 CPU 38%。经 Profiling 定位后，改用 unsafe 辅助的只读视图封装：
type SafeMap struct {
data map[string]interface{}
// 仅允许通过 SafeMap.Get() 访问，内部做类型安全检查
}
func (s *SafeMap) Get(key string) interface{} {
if !isValidKey(key) { // 白名单校验缓存于 sync.Map
panic("invalid key: " + key)
}
val := s.data[key]
if val == nil {
return nil
}
switch v := val.(type) {
case time.Time:
return v.UTC().Format(time.RFC3339) // 统一转为 RFC3339
case float64:
if math.IsInf(v, 0) || math.IsNaN(v) {
return 0.0
}
}
return val
}上线后 GC 压力下降 62%，P99 延迟从 47ms 降至 11ms。
多语言兼容性验证矩阵
| 序列化输出字段 | Go json.Marshal |
Java Jackson | Python json.dumps |
Node.js JSON.stringify |
|---|---|---|---|---|
{"ts": "2024-05-22T14:32:18Z"} |
✅ | ✅ | ✅ | ✅ |
{"price": 299.99} |
✅ | ✅ | ✅ | ✅ |
{"tags": ["vip", "new"]} |
✅ | ✅ | ✅ | ✅ |
{"meta": null} |
❌（被移除） | ⚠️（需配置 FAIL_ON_NULL_FOR_PRIMITIVES=false） | ✅ | ✅ |
所有服务上线前必须通过该矩阵自动化测试，未全绿不得进入预发环境。
运行时 Schema 动态校验能力
在 Kafka 消息消费端注入 MapSchemaValidator，基于 Avro Schema Registry 实时校验入站 map 结构：
graph LR
A[Kafka Consumer] --> B{MapSchemaValidator}
B -->|schema_id=127| C[Avro Schema Registry]
C -->|返回 schema| D[字段类型/必填/枚举校验]
D -->|校验失败| E[发送告警至 Prometheus + 写入 dead-letter topic]
D -->|校验通过| F[交由业务逻辑处理]过去三个月拦截 8 类不兼容变更，包括 order_status 枚举值新增 canceled_by_system 但未同步更新消费者 Schema 的事故。
日志上下文 map 的特殊序列化规则
所有 zap.Stringer 接口实现必须遵守 LoggableMap 协议，禁止在 String() 方法中调用 json.Marshal。统一使用 zapsugar.Map 序列化器，自动将 time.Time 转为毫秒时间戳，error 类型转为 err_msg + err_code 字段，避免日志平台解析失败导致字段丢失。
