第一章：Go数据持久化避坑手册导论
在Go语言生态中，数据持久化看似简单——引入database/sql、配好驱动、执行Query或Exec即可。但真实项目中，连接泄漏、事务未回滚、SQL注入、空值处理异常、时区错乱等问题频发，往往在高并发或长时间运行后才暴露，排查成本极高。
Go的数据库抽象层不封装业务语义，开发者需主动管理生命周期与一致性边界。例如，未显式关闭*sql.Rows会导致底层连接长期占用；使用db.Query后若未遍历完结果集或调用rows.Close()，连接将无法归还连接池，最终触发sql.ErrConnDone或连接耗尽。
常见隐患速览
- 连接池配置缺失：默认
MaxOpenConns=0（无限制），MaxIdleConns=2（极易成为瓶颈） - 时间类型处理不当：
time.Time经json.Marshal默认序列化为RFC3339字符串，但数据库可能存为DATETIME且忽略时区，导致读写偏差 nil值误用：sql.NullString等类型未正确判空即取.String，引发panic- 事务嵌套误判：Go无原生嵌套事务支持，
tx.Begin()在已有事务内会返回错误，而非自动加入
立即生效的初始化检查项
// 推荐的连接池基础配置（以MySQL为例）
db, _ := sql.Open("mysql", "user:pass@tcp(127.0.0.1:3306)/test")
db.SetMaxOpenConns(25) // 避免瞬时高峰打垮DB
db.SetMaxIdleConns(25) // 保证空闲连接充足
db.SetConnMaxLifetime(5 * time.Minute) // 强制连接定期轮换，防长连接失效上述配置需在sql.Open之后、首次使用前完成。若跳过SetConnMaxLifetime，在云环境（如RDS连接超时自动断开）下，旧连接可能持续返回i/o timeout错误，而连接池仍将其视为有效。
| 风险点 | 安全实践 |
|---|---|
| SQL拼接 | 始终使用?占位符与db.Query(stmt, args...) |
| 批量插入 | 使用INSERT ... VALUES (...), (...)单语句替代循环Exec |
| 错误忽略 | 每个Query/Exec/Scan后必须检查err != nil |
数据持久化不是“能跑就行”的环节，而是系统稳定性的压舱石。本手册后续章节将逐层拆解各场景下的典型陷阱与可落地的防御方案。
第二章：JSON序列化与反序列化的精度陷阱
2.1 JSON数字类型与float64精度丢失的底层机理与实测验证
JSON规范不区分整数与浮点数，所有数字统一视为IEEE 754双精度浮点值（float64），导致超过2⁵³（9,007,199,254,740,992）的整数无法精确表示。
精度边界实测
// JavaScript环境（典型JSON解析器）
console.log(9007199254740991); // → 9007199254740991 ✅
console.log(9007199254740992); // → 9007199254740992 ✅
console.log(9007199254740993); // → 9007199254740992 ❌（舍入）
float64尾数仅52位，可精确表示的最大连续整数为2⁵³。9007199254740993二进制需53位有效位，超出后被舍入至最近偶数。
常见高危场景
- 订单ID、数据库主键（如MongoDB ObjectId时间戳部分）
- 区块链交易哈希截断值
- 微信/支付宝支付金额（虽用字符串传输，但误转number即失真）
| 输入整数 | JSON解析后值 | 是否精确 |
|---|---|---|
| 9007199254740991 | 9007199254740991 | ✅ |
| 9007199254740992 | 9007199254740992 | ✅ |
| 9007199254740993 | 9007199254740992 | ❌ |
防御性实践
- 后端序列化时对大整数字段使用
string类型（如Go的json.Number或Java的JsonNode） - 前端解析JSON时钩住
reviver函数，对关键字段强制保留字符串形式
2.2 struct标签控制与omitempty引发的字段丢失风险实战分析
数据同步机制中的隐性陷阱
当结构体字段标记 json:",omitempty" 时，零值（如 , "", nil）在序列化时被完全剔除，导致下游服务因缺失字段而解析失败。
type User struct {
ID int `json:"id"`
Name string `json:"name,omitempty"`
Age int `json:"age,omitempty"`
}Name=""和Age=0均不会出现在 JSON 输出中；- 若业务逻辑依赖
age字段存在性做权限校验，则空值被丢弃将绕过校验。
典型风险场景对比
| 场景 | 是否触发 omitempty | 实际输出 JSON 片段 |
|---|---|---|
User{ID:1, Name:"", Age:0} |
是 | {"id":1} |
User{ID:1, Name:"A", Age:25} |
否 | {"id":1,"name":"A","age":25} |
防御性设计建议
- 优先使用指针字段（如
*string,*int）配合omitempty，明确区分“未设置”与“零值”； - 在关键字段上禁用
omitempty，改用默认值预设或业务层校验。
2.3 自定义MarshalJSON/UnmarshalJSON规避时间戳与大整数截断
Go 标准库 time.Time 默认序列化为 RFC3339 字符串，而 int64 时间戳或超 2^53 的大整数（如 MongoDB ObjectId 时间段、Snowflake ID）在 JavaScript 端易被 Number 类型截断。
常见截断场景
- Unix 毫秒时间戳（
1712345678901）→ JSNumber精度仅 53 位 → 末尾数字丢失 - 64 位 Snowflake ID（如
1234567890123456789）→ 解析后变为1234567890123456768
自定义 JSON 行为示例
type Event struct {
ID int64 `json:"id"`
Timestamp int64 `json:"ts"`
CreatedAt time.Time `json:"created_at"`
}
// MarshalJSON 输出字符串化时间戳与ID，避免JS精度丢失
func (e Event) MarshalJSON() ([]byte, error) {
type Alias Event // 防止递归调用
return json.Marshal(struct {
ID string `json:"id"`
Timestamp string `json:"ts"`
CreatedAt string `json:"created_at"`
*Alias
}{
ID: strconv.FormatInt(e.ID, 10),
Timestamp: strconv.FormatInt(e.Timestamp, 10),
CreatedAt: e.CreatedAt.Format(time.RFC3339Nano),
Alias: (*Alias)(&e),
})
}逻辑说明：通过匿名嵌套结构体 +
string字段覆盖原始字段，将int64强制转为字符串；Alias避免MarshalJSON无限递归；RFC3339Nano保证时区与纳秒级可读性。
序列化策略对比
| 方式 | 时间戳精度 | 大整数安全 | 前端兼容性 | 实现复杂度 |
|---|---|---|---|---|
默认 json.Marshal |
✅ | ❌（JS截断） | ⚠️（需BigInt） | 低 |
字符串化 int64 |
✅ | ✅ | ✅（原生String） | 中 |
graph TD
A[Go struct] --> B{MarshalJSON defined?}
B -->|Yes| C[调用自定义逻辑]
B -->|No| D[使用默认反射序列化]
C --> E[转为字符串/ISO8601]
E --> F[JS安全接收]2.4 使用json.RawMessage实现动态结构解析与精度保全策略
在处理异构微服务间 JSON 数据交换时，字段动态性与数值精度（如金融金额、科学计数）常引发解析失真。
为什么需要 json.RawMessage？
- 跳过即时解码，延迟结构绑定
- 避免
float64对int64/大整数的精度截断 - 支持同一字段在不同版本中语义演进（如
data字段可为对象或数组）
典型应用模式
type Event struct {
ID string `json:"id"`
Type string `json:"type"`
Data json.RawMessage `json:"data"` // 延迟解析，保全原始字节
}逻辑分析：
json.RawMessage本质是[]byte别名，Unmarshal仅拷贝原始 JSON 片段（不含解析），后续按Type分支调用json.Unmarshal(data, &v)精准反序列化。参数Data不触发类型转换，彻底规避12345678901234567890→1.2345678901234567e19的 float64 丢失。
精度保全对比表
| 场景 | 使用 float64 |
使用 json.RawMessage |
|---|---|---|
9223372036854775807 |
截断为 9223372036854776000 |
完整保留原始字符串 |
{"amount":"123.456789"} |
强转 float 后精度漂移 | 可交由 decimal 库精确解析 |
graph TD
A[收到JSON字节流] --> B{解析Event结构}
B --> C[RawMessage暂存data字段]
C --> D[根据Type路由到具体Schema]
D --> E[对RawMessage二次Unmarshal]2.5 替代方案对比：encoding/json vs go-json vs simdjson在精度场景下的压测与选型指南
基准测试环境
统一使用 Go 1.22、Intel Xeon Platinum 8360Y、128GB RAM，输入为含 float64 高精度字段（如 1.0000000000000002）的 10KB JSON 文档，重复 10 万次解析。
性能与精度关键指标
| 库名 | 吞吐量 (MB/s) | float64 解析误差 | 内存分配 (KB/op) |
|---|---|---|---|
encoding/json |
42.1 | ✅ 完全保真（IEEE 754） | 12.4 |
go-json |
96.7 | ✅ 保真（基于 strconv.ParseFloat） |
5.8 |
simdjson-go |
138.5 | ⚠️ 默认启用 unsafe_float 时可能舍入（需显式禁用） |
2.1 |
精度敏感代码示例
// 必须禁用 simdjson 的浮点优化以保障精度
dec := simdjson.NewDecoder()
dec.DisableFloatParsingOptimization() // 关键：避免 fast-path 导致的 double-rounding
var v map[string]any
err := dec.Unmarshal(data, &v) // 此时 float64 值严格等价于 encoding/json 输出该配置绕过 SIMD 浮点快速路径，回退至标准 strconv.ParseFloat，确保二进制级精度一致，代价是吞吐下降约 18%。
选型决策树
- 需要极致吞吐 + 可接受微秒级浮点展示差异 →
simdjson-go（默认） - 要求金融/科学计算级精度 + 中等性能 →
go-json - 兼容性优先、调试友好 →
encoding/json
第三章：time.Time时区与序列化错乱根源剖析
3.1 time.Time底层结构、Location字段语义与时区传播机制深度解析
time.Time 是 Go 标准库中不可变的值类型，其底层结构为：
type Time struct {
wall uint64 // 墙钟时间（含 locID 和秒级纳秒偏移）
ext int64 // 扩展字段：秒数（若 wall 不足以表示则用此）
loc *Location // 时区信息指针，nil 表示 UTC
}loc 字段非仅“显示格式控制”，而是参与所有时间计算：Add, Sub, Before 等方法均依据 loc 的 Zone 规则进行夏令时推演与偏移查表。
Location 的语义本质
*Location是时区规则的运行时快照，包含name,zone（历史偏移数组）和tx（转换点索引）- 同一地理位置（如
"Asia/Shanghai"）在不同时刻可能映射不同Zone条目（因政策变更）
时区传播的关键约束
Time的loc不随算术运算丢失：t.Add(24*time.Hour)仍保留原loc- 但
t.In(loc2)显式创建新Time，仅复制wall/ext并重绑定loc2
| 操作 | 是否改变 loc | 是否触发偏移重计算 |
|---|---|---|
t.Add() |
否 | 否（仅数值加法） |
t.In(loc2) |
是（新副本） | 是（查 zone 表） |
t.UTC() / t.Local() |
是（新副本） | 是 |
graph TD
A[原始Time t] -->|t.In(loc2)| B[新Time<br>wall/ext 不变<br>loc ← loc2]
A -->|t.Add(d)| C[新Time<br>loc 保持不变<br>wall/ext 更新]
B --> D[调用Zone() → 查loc2.tx匹配时刻→返回对应Zone]3.2 数据库驱动（如pq、mysql）对time.Time的默认时区转换行为逆向工程
驱动层时区感知入口点
Go 标准库 database/sql 不处理时区，转换逻辑完全由驱动实现。以 pq（PostgreSQL）和 mysql 驱动为例，其 Scan() 方法对 time.Time 类型字段执行隐式时区归一化。
典型行为对比
| 驱动 | 默认时区来源 | time.Time.Location() 结果 |
是否可禁用 |
|---|---|---|---|
github.com/lib/pq |
time.Local（除非设 timezone=UTC） |
本地时区或 UTC |
✅ 通过连接参数 |
github.com/go-sql-driver/mysql |
time.Local（若未设 loc） |
本地时区 | ✅ 通过 loc=Local 或 loc=UTC |
关键代码逆向分析
// pq driver 中 time parsing 片段（简化）
func parseTime(s string, loc *time.Location) (time.Time, error) {
t, err := time.ParseInLocation(time.RFC3339Nano, s, loc)
// loc 来自：config.TZ（显式）→ os.Getenv("TZ") → time.Local
return t, err
}loc 决定解析上下文：若连接串含 timezone=Asia/Shanghai，则 loc 被设为对应 *time.Location；否则回退至进程默认时区，非数据库服务器时区。
时区转换流程（简化）
graph TD
A[DB 返回 timestamp without timezone] --> B{驱动解析逻辑}
B --> C[pq: 使用 config.TZ / time.Local]
B --> D[mysql: 使用 loc 参数 / time.Local]
C --> E[time.Time 带该 Location]
D --> E3.3 JSON+数据库双落盘场景下时区叠加错乱的复现与修复模式
数据同步机制
当业务层序列化 LocalDateTime.now() 为 JSON（无时区信息），同时 JDBC 驱动又按 JVM 默认时区自动转换 TIMESTAMP 写入数据库，导致同一时间被双重时区解释。
复现场景代码
// 错误示范：JSON 序列化 + JDBC 自动转换双重偏移
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(Map.of("ts", LocalDateTime.now()));
// → {"ts":"2024-05-20T14:30:00"}（纯本地时间，无Z/offset）
// 数据库写入（JVM时区为CST，UTC+8）：
PreparedStatement.setTimestamp(1, Timestamp.valueOf("2024-05-20 14:30:00"));
// JDBC 将该字符串按CST解释为 UTC+8 → 实际存入数据库值 = UTC 06:30逻辑分析：LocalDateTime 本身无时区语义，但 setTimestamp 会隐式按 Calendar.getInstance() 时区转为 UTC 存储；JSON 层又丢失上下文，造成“本地时间→CST解释→转UTC→再被前端按浏览器时区渲染”，叠加两次偏移。
修复策略对比
| 方案 | 优点 | 缺点 |
|---|---|---|
统一使用 Instant + ISO-8601（含Z） |
语义明确、跨系统一致 | 需改造全链路类型 |
数据库字段改用 TIMESTAMP WITH TIME ZONE |
存储即带时区元数据 | 依赖数据库支持（如PostgreSQL） |
修复流程
graph TD
A[业务生成Instant.now()] --> B[JSON序列化为ISO-8601字符串<br>e.g. “2024-05-20T06:30:00Z”]
B --> C[JDBC setTimestamp<br>传入Instant.toTimestamp()]
C --> D[数据库存UTC原值]第四章：其他高频生产级数据持久化隐患
4.1 nil指针解引用与零值覆盖：struct字段初始化缺失导致的数据静默污染
静默污染的根源
Go 中未显式初始化的 struct 字段会获得其类型的零值（如 int→0, string→"", *T→nil）。当后续逻辑误用 nil 指针字段，既不 panic 也不报错，却悄然覆盖业务语义。
典型误用示例
type User struct {
ID int
Name string
Meta *Metadata // 未初始化 → nil
}
func (u *User) SetMeta(name string) {
u.Meta.Name = name // panic: nil pointer dereference
}逻辑分析：
u.Meta为nil，直接解引用u.Meta.Name触发运行时 panic。但若代码路径中混入零值写入（如u.Meta = &Metadata{}后再覆盖），则污染真实数据。
防御策略对比
| 方法 | 安全性 | 可维护性 | 是否拦截静默覆盖 |
|---|---|---|---|
| 构造函数强制初始化 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | 是 |
if u.Meta == nil 检查 |
⭐⭐⭐⭐ | ⭐⭐ | 否（需人工补全） |
go vet 静态检查 |
⭐⭐ | ⭐⭐⭐⭐⭐ | 否（不覆盖场景） |
数据同步机制
graph TD
A[New User] --> B{Meta initialized?}
B -->|No| C[Meta = &Metadata{}]
B -->|Yes| D[Use existing Meta]
C --> E[Set fields safely]4.2 SQL NULL与Go零值映射失配：Scan/Value接口实现不当引发的脏读事故
数据同步机制
当 PostgreSQL 的 updated_at 字段为 NULL，而 Go 结构体字段声明为 time.Time（非指针），sql.Scan 会将 NULL 覆盖为 time.Time{}（即 Unix 零时），造成逻辑误判。
典型错误实现
type User struct {
ID int `db:"id"`
Name string `db:"name"`
UpdatedAt time.Time `db:"updated_at"` // ❌ 应为 *time.Time
}time.Time是值类型，无nil状态；Scan遇NULL时调用其Scan()方法，内部静默赋值为零值；- 导致后续业务逻辑（如“仅更新非空时间”）误将脏数据视为有效时间戳。
正确映射方案对比
| SQL 类型 | Go 类型 | NULL 安全性 | 零值语义清晰度 |
|---|---|---|---|
| TIMESTAMP | *time.Time |
✅ | 高（nil = 未知） |
| TIMESTAMP | time.Time |
❌ | 低（零值 = 1970-01-01） |
修复后的 Scan 实现关键路径
graph TD
A[DB 返回 NULL] --> B{Scan 调用 User.UpdatedAt.Scan}
B --> C[time.Time.Scan 接收 nil]
C --> D[静默设为 time.Time{}]
D --> E[业务层误判为合法时间]4.3 Go泛型约束与ORM类型擦除冲突：interface{}透传导致的序列化类型丢失
当ORM库（如GORM）配合Go泛型使用时，interface{}作为泛型参数的“兜底”类型，会触发运行时类型擦除。
类型擦除的典型路径
func Save[T any](data T) error {
// data 被转为 interface{} 后传入底层SQL构建器
return db.Create(&data).Error // ← 此处 T 的具体类型信息已丢失
}逻辑分析：T any 约束过宽，编译器无法在反射或序列化阶段保留原始类型元数据；&data 经 interface{} 中转后，reflect.TypeOf() 返回 interface{} 而非 *User，导致JSON标签、数据库列映射失效。
关键冲突对比
| 场景 | 泛型约束类型 | 序列化时可识别字段 | ORM列推导 |
|---|---|---|---|
Save[User] |
~User |
✅ json:"name" |
✅ |
Save[any] |
any |
❌ 仅 map[string]any |
❌ |
根本解决方向
- 避免
any或interface{}作为泛型边界； - 使用接口约束（如
type Entity interface { TableName() string }）替代类型擦除透传。
4.4 context超时传递断裂与事务回滚失效：持久化链路中上下文生命周期管理疏漏
数据同步机制中的context透传断点
当 HTTP 请求携带 context.WithTimeout 进入服务链路，若在调用数据库驱动前未显式传递至 sql.Tx，则事务超时控制将完全失效：
// ❌ 错误：ctx未传递给BeginTx，超时无法中断事务
tx, err := db.Begin() // ctx被丢弃！
// ✅ 正确：显式透传带超时的ctx
tx, err := db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})BeginTx 的 ctx 参数是唯一能触发底层驱动超时中断的入口；缺失时，即使上层HTTP已超时，事务仍持续占用连接并阻塞提交。
事务回滚失效的典型路径
| 阶段 | 是否感知ctx超时 | 回滚是否触发 |
|---|---|---|
| HTTP handler | 是 | 否（panic前未显式Rollback） |
| DB transaction | 否（ctx未传入） | 否（超时后连接卡死） |
| 连接池回收 | 否 | 延迟数分钟（依赖空闲超时） |
graph TD
A[HTTP Request] --> B[WithTimeout ctx]
B --> C{DB.BeginTx?}
C -- 否 --> D[事务脱离ctx生命周期]
D --> E[超时后goroutine泄漏]
D --> F[Rollback不被调度]根本症结在于：context生命周期未与事务资源绑定，导致超时信号无法穿透持久化层。
第五章：Go数据持久化稳定性建设方法论
数据库连接池的精细化调优
在高并发订单系统中，我们曾观测到 PostgreSQL 连接耗尽导致 503 错误率突增至 12%。通过 sql.DB.SetMaxOpenConns(80)、SetMaxIdleConns(40) 与 SetConnMaxLifetime(30 * time.Minute) 的组合配置，并结合 pgbouncer 在连接层做协议级复用，将平均连接建立延迟从 18ms 降至 2.3ms。关键指标监控需覆盖 sql.DB.Stats().OpenConnections 与 sql.DB.Stats().WaitCount，并设置 Prometheus 告警规则：
- alert: HighDBConnectionWait
expr: rate(go_sql_wait_count_total{job="order-service"}[5m]) > 5
for: 2m分布式事务的降级策略设计
电商履约服务采用 Saga 模式协调库存扣减、物流单创建与支付确认。当物流服务超时（context.DeadlineExceeded）时，自动触发本地补偿事务：先将订单状态置为 PENDING_LOGISTICS_RETRY，再异步投递至 Kafka 主题 saga-compensate-v1，由独立补偿消费者执行 UPDATE inventory SET quantity = quantity + ? WHERE sku_id = ? 回滚库存。补偿流程具备幂等性，依赖 compensation_id（UUIDv4）+ event_version 双字段去重。
读写分离场景下的强一致性保障
用户中心服务使用 MySQL 主从架构，但“修改手机号后立即登录”场景出现从库延迟导致旧号码仍可登录的问题。解决方案是引入 读写分离路由标记：在写操作后生成 read-after-write token（SHA256(user_id:ts:secret)），将其注入 HTTP Header X-Read-Token，从库查询时通过中间件校验该 token 是否在最近 30 秒内被主库写入 read_consistency_log 表（含 token, user_id, created_at 字段），若命中则强制路由至主库。
异常熔断与自动恢复机制
使用 gobreaker 实现对 Redis 缓存层的熔断保护，配置如下：
| 参数 | 值 | 说明 |
|---|---|---|
| Name | redis-cache-breaker |
熔断器标识 |
| MaxRequests | 10 | 半开状态允许的最大请求数 |
| Timeout | 60s | 熔断持续时间 |
| ReadyToTrip | func(counts gobreaker.Counts) bool { return float64(counts.TotalFailures)/float64(counts.Requests) > 0.3 } |
失败率阈值 |
当缓存集群网络分区时，熔断器在 3 个连续错误周期后进入 OPEN 状态，所有 GET user:1001 请求直接返回 cache_unavailable 错误码，并触发 Slack 告警；60 秒后进入 HALF-OPEN，放行 10 个探针请求验证集群连通性。
持久化链路全链路追踪
在 gorm 中注入 OpenTelemetry Span：
db.Callback().Query().Before("gorm:query").Register("otlp:query", func(db *gorm.DB) {
ctx := db.Statement.Context
span := trace.SpanFromContext(ctx)
span.SetAttributes(attribute.String("db.statement", db.Statement.SQL))
span.SetAttributes(attribute.Int("rows.affected", db.RowsAffected))
})结合 Jaeger UI 可定位某次慢查询是否源于 N+1 问题（如 SELECT * FROM orders 后循环执行 SELECT * FROM order_items WHERE order_id = ?），进而推动使用 Preload() 或原生 JOIN 重构。
数据校验与修复自动化
每日凌晨 2:00 触发一致性扫描 Job，对比 MySQL 订单表 orders.status 与 Elasticsearch 中对应文档 status.keyword 字段差异，将不一致记录写入 consistency_violation 表，并启动修复协程批量调用 UPDATE orders SET status = ? WHERE id = ? 同步修正。修复过程记录 repair_log 表，包含 order_id, before_status, after_status, operator（值为 auto-repair）。
故障注入验证方案
在 CI/CD 流水线中集成 Chaos Mesh，对 staging 环境注入以下故障场景：
- 使用
NetworkChaos模拟数据库网络丢包率 30% - 使用
IOChaos对/var/lib/postgresql/data目录注入 500ms I/O 延迟 - 使用
PodChaos随机终止 1 个 PostgreSQL Pod
每次注入后运行 15 分钟稳定性测试套件（含 2000+ 并发订单创建、查询、取消），验证连接池自动重建、重试策略生效及熔断器正确响应。
备份恢复 RPO/RTO 实测报告
对生产集群执行 pg_basebackup -Ft -z -Z9 -D /backup/full_$(date +%Y%m%d) 全量备份，配合 WAL 归档（archive_command = 'gsutil cp %p gs://my-bucket/pg-wal/%f'）。实测 RPO ≤ 3s（WAL 切换间隔），RTO 为 4m12s（含下载 12GB 基础备份 + 应用 2.3GB WAL + 启动验证）。恢复后执行 SELECT pg_is_in_recovery(), pg_last_wal_receive_lsn(), pg_last_wal_replay_lsn() 校验回放位置一致性。
多活单元化数据同步保障
在华东、华北双活架构中，使用 Vitess 的 vttablet 分片路由 + 自研 binlog-syncer 组件监听主库 binlog，过滤 DML 事件后通过 gRPC 推送至异地单元。关键约束：所有跨单元写操作必须携带 x-cell-id: shanghai Header，中间件校验该 Header 与当前单元 ID 一致，否则拒绝执行并返回 403 Forbidden: cross-cell-write-prohibited。
