【Go业务开发黄金法则】：从CRUD到百万级订单系统，我用12个生产级模块讲透

第一章：Go语言能写业务吗？——从质疑到生产级落地的真相

当“Go只适合写中间件、不适合写业务逻辑”的声音仍在某些技术群中回响时，PayPal、Twitch、Uber、腾讯微服务中台、字节跳动推荐后台早已将Go作为核心业务语言。这不是权宜之计，而是基于工程效率、可维护性与长周期演进的理性选择。

为什么业务系统需要确定性而非语法糖

Go的显式错误处理（if err != nil）、无隐式继承、强制依赖管理（go.mod）和极简反射模型，让业务逻辑边界清晰、协作成本降低。对比动态语言中常见的运行时panic或类型漂移，Go在编译期即捕获90%以上的接口不一致与空指针风险——这对订单创建、资金扣减、库存预占等关键链路至关重要。

一个真实业务模块的快速落地示例

以下是一个电商履约服务中“发货单生成”的最小可行实现：

// pkg/fulfillment/generator.go
func GenerateShipment(ctx context.Context, orderID string) (*Shipment, error) {
    // 1. 查询订单（带超时控制）
    order, err := orderRepo.Get(ctx, orderID)
    if err != nil {
        return nil, fmt.Errorf("failed to get order %s: %w", orderID, err)
    }

    // 2. 校验业务规则（如已支付、未发货）
    if !order.IsPaid || order.Status == "shipped" {
        return nil, errors.New("invalid order state for shipment")
    }

    // 3. 生成唯一运单号并持久化（事务内完成）
    shipment := &Shipment{
        ID:       "SHIP-" + xid.New().String(),
        OrderID:  orderID,
        Status:   "pending",
        Created:  time.Now(),
    }
    if err := shipmentRepo.Create(ctx, shipment); err != nil {
        return nil, fmt.Errorf("failed to create shipment: %w", err)
    }
    return shipment, nil
}

该函数具备完整可观测性（可注入log/slog上下文）、可测试性（依赖接口抽象）、可监控性（天然适配OpenTelemetry），且无需额外框架即可嵌入gRPC或HTTP Handler。

主流业务场景的Go支撑能力

场景	典型实践	关键工具链
高并发API网关	基于net/http+gorilla/mux限流熔断	go-playground/validator
实时消息驱动业务	Kafka消费者 + Saga事务协调	segmentio/kafka-go, asynq
多租户SaaS后台	中间件路由+DB Schema隔离	pgx/v5 + sqlc代码生成
含复杂工作流的系统	Temporal集成状态机	temporalio/sdk-go

Go不是银弹，但它用克制的设计，把业务开发者从框架魔咒中解放出来——专注领域建模，而非调试依赖注入容器。

第二章：高并发订单系统的核心模块设计

2.1 基于context与中间件的请求生命周期治理

Go 的 net/http 请求处理天然依托 context.Context 实现跨中间件的超时、取消与数据透传，是生命周期治理的核心载体。

中间件链式编排模型

典型洋葱模型：请求进入 → 中间件A → B → Handler → B退出 → A退出 → 响应返回

func AuthMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 从 context 提取 token 并校验
        ctx := r.Context()
        token := r.Header.Get("Authorization")
        if !isValidToken(token) {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        // 注入用户ID到 context，供下游使用
        newCtx := context.WithValue(ctx, "userID", extractUserID(token))
        r = r.WithContext(newCtx) // 关键：传递增强后的 context
        next.ServeHTTP(w, r)
    })
}

逻辑分析：该中间件在 r.WithContext() 中将认证后的 userID 注入 context，后续 handler 可通过 r.Context().Value("userID") 安全获取；context.WithValue 仅适用于传递请求级元数据（不可存大对象或函数），且需配合类型断言使用。

生命周期关键阶段对照表

阶段	触发时机	context 行为
初始化	Server.ListenAndServe	`context.Background()` 创建
中间件进入	每层中间件调用前	`WithValue` / `WithTimeout` 扩展
超时/取消	客户端断连或 deadline 到	`ctx.Done()` 通道关闭，自动传播
Handler 执行	最内层业务逻辑	读取 `ctx.Value()` 或监听 `ctx.Err()`

graph TD
    A[HTTP Request] --> B[Middleware 1]
    B --> C[Middleware 2]
    C --> D[Handler]
    D --> C
    C --> B
    B --> E[HTTP Response]

2.2 幂等性保障：分布式ID+数据库唯一约束+Redis令牌桶实践

在高并发场景下，重复请求可能导致订单重复创建、库存超扣等严重问题。单一手段难以兼顾性能与可靠性，需分层协同防御。

三重防护机制设计

分布式ID（Snowflake）：全局唯一、时序递增，作为业务主键基础
数据库唯一索引：对 order_id 或 (user_id, biz_type, biz_id) 建唯一约束
Redis令牌桶预检：拦截明显重复请求（如5秒内相同操作ID）

核心校验代码示例

def create_order(user_id: str, order_id: str) -> bool:
    # Redis令牌桶：key=uid:order:{user_id}, ttl=300s，最大1次/桶
    key = f"uid:order:{user_id}"
    if redis.eval(SCRIPT_TOKEN_BUCKET, 1, key, order_id, 300) == 0:
        raise ValueError("Request rejected by rate limiter")

    # 数据库插入（依赖唯一约束兜底）
    try:
        db.execute("INSERT INTO orders (id, user_id, created_at) VALUES (?, ?, ?)", 
                   [order_id, user_id, datetime.now()])
        return True
    except IntegrityError as e:  # 触发唯一索引冲突
        return False  # 幂等返回成功

逻辑分析：SCRIPT_TOKEN_BUCKET 是 Lua 脚本实现的原子令牌桶；order_id 作为 token 防止同一操作重复提交；300 为桶过期时间（秒）。数据库层兜底确保最终一致性。

各层防护能力对比

层级	响应延迟	可靠性	适用场景
Redis令牌桶		中	快速拦截高频重复请求
数据库唯一约束	~20ms	高	最终一致性保障
分布式ID生成		极高	消除ID冲突，支撑前两层

graph TD
    A[客户端请求] --> B{Redis令牌桶检查}
    B -- 通过 --> C[DB唯一约束插入]
    B -- 拒绝 --> D[返回429]
    C -- 成功 --> E[返回201]
    C -- 冲突 --> F[返回200幂等]

2.3 状态机驱动的订单生命周期建模与go:embed静态策略表集成

订单状态流转需强一致性与可审计性。我们采用有限状态机（FSM）建模，将 Created → Paid → Shipped → Delivered → Completed 定义为合法跃迁路径。

状态跃迁规则表

from	to	allowed	reason
Created	Paid	true	支付成功回调触发
Paid	Shipped	true	仓库出库完成
Shipped	Delivered	false	需经签收确认事件

内嵌策略表加载

// embed策略表：orders_fsm.yaml 于 assets/ 目录下
var fsmPolicy embed.FS

func init() {
    fsmBytes, _ := fsmPolicy.ReadFile("assets/orders_fsm.yaml") // ✅ 编译期固化
    yaml.Unmarshal(fsmBytes, &fsmRules)                         // 规则热加载零运行时IO
}

该方式规避了配置中心依赖，提升启动速度与部署确定性；fsmBytes 在二进制中直接映射，无文件系统调用开销。

状态校验流程

graph TD
    A[OrderEvent] --> B{Valid Transition?}
    B -->|Yes| C[Apply State Change]
    B -->|No| D[Reject & Log Violation]
    C --> E[Fire Domain Event]

核心优势：编译期策略固化 + 运行时零反射校验 + 事件驱动终态收敛。

2.4 异步化演进：从channel协程池到自研轻量级任务队列（无Redis依赖）

早期采用 chan Task + worker goroutine 池处理异步任务，但存在阻塞风险与动态扩缩容困难。

核心瓶颈

channel 容量固定，突发流量易触发背压或 panic
无优先级、延迟执行、失败重试等语义支持
依赖外部中间件（如 Redis）增加部署复杂度

自研轻量队列设计要点

内存型双端队列（list.List）+ 时间轮调度器（延迟任务）
任务元信息结构体含 ID, Priority, RetryCount, NextExecuteAt
无锁环形缓冲区实现高吞吐写入（CAS + 原子计数器）

type Task struct {
    ID            string    `json:"id"`
    Payload       []byte    `json:"payload"`
    Priority      int       `json:"priority"` // 0=low, 10=high
    Delay         time.Duration `json:"delay"`  // 首次延迟执行时间
    MaxRetries    int       `json:"max_retries"`
    RetryInterval time.Duration `json:"retry_interval"`
}

// 任务提交接口（线程安全）
func (q *TaskQueue) Submit(t *Task) error {
    q.mu.Lock()
    defer q.mu.Unlock()
    if q.len >= q.capacity {
        return ErrQueueFull
    }
    q.tasks.PushBack(t)
    q.len++
    return nil
}

Submit 使用互斥锁保障写入一致性；q.len 为原子计数器优化读多写少场景；PushBack 支持 O(1) 入队。延迟任务由独立 goroutine 轮询时间轮触发。

性能对比（10K QPS 场景）

方案	P99 延迟	内存占用	依赖组件
Channel 协程池	128ms	42MB	无
自研任务队列	23ms	58MB	无

graph TD
    A[HTTP Request] --> B{路由分发}
    B --> C[同步主流程]
    B --> D[异步任务提交]
    D --> E[内存队列入队]
    E --> F[Worker Pool 拉取]
    F --> G[执行/重试/回调]

2.5 数据一致性攻坚：Saga模式在库存扣减与支付回调中的Go原生实现

Saga模式通过一连串本地事务与补偿操作保障跨服务最终一致性。在电商场景中，订单创建需原子性协调「扣减库存」与「发起支付」，任一失败须回滚前置动作。

核心状态机设计

Saga采用Pending → Confirmed → Compensated三态流转，每个步骤绑定正向函数与逆向补偿函数。

Go原生实现关键结构

type SagaStep struct {
    Do      func() error     // 如：decreaseInventory(orderID)
    Undo    func() error     // 如：restoreInventory(orderID)
    Timeout time.Duration    // 防悬挂：默认30s
}

Do执行本地事务并持久化步骤状态；Undo幂等恢复资源；Timeout触发自动补偿调度器。

典型执行流程

graph TD
    A[开始Saga] --> B[执行扣库存]
    B --> C{成功？}
    C -->|是| D[调用支付网关]
    C -->|否| E[立即补偿]
    D --> F{支付回调到达？}
    F -->|是| G[标记Saga完成]
    F -->|超时| H[触发补偿：还原库存]

补偿策略对比

策略	优点	缺点
Chained（链式）	实现简单，状态轻量	单点故障导致整链中断
Best-effort（尽力）	高可用，支持重试	需额外幂等与对账机制

Saga不追求强一致，而以可预测的失败边界换取分布式系统的弹性与可观测性。

第三章：可扩展业务架构的Go范式重构

3.1 领域分层：DDD四层架构在Go中的接口契约与依赖注入实践

DDD四层架构（展现层、应用层、领域层、基础设施层）在Go中需通过接口即契约实现松耦合。领域层定义核心接口，应用层仅依赖其抽象，基础设施层负责具体实现。

接口契约示例

// domain/user.go —— 领域层声明仓储契约
type UserRepository interface {
    Save(ctx context.Context, u *User) error
    FindByID(ctx context.Context, id string) (*User, error)
}

该接口定义了领域规则不可妥协的操作语义；context.Context 支持超时与取消，*User 为领域实体指针，确保不变性约束在实现层被尊重。

依赖注入实践

使用构造函数注入，避免全局容器：

// application/user_service.go
type UserService struct {
    repo UserRepository // 仅依赖接口，无具体实现
}

func NewUserService(repo UserRepository) *UserService {
    return &UserService{repo: repo}
}

层级	职责	Go 实现关键
领域层	业务规则与实体	`interface{}` + 值类型
应用层	用例编排与事务边界	构造函数注入依赖
基础设施层	外部服务适配（DB/HTTP）	实现 `UserRepository`

graph TD
    A[展现层 HTTP Handler] --> B[应用层 UserService]
    B --> C[领域层 UserRepository Interface]
    D[基础设施层 GORMRepo] --> C

3.2 插件化能力：基于go:generate与interface{}动态注册的促销引擎

促销规则需高频迭代，硬编码导致编译耦合。我们采用 go:generate 自动生成注册桩，配合 interface{} 实现运行时插件发现。

注册机制设计

//go:generate go run gen_register.go
type Promotion interface {
    Apply(ctx context.Context, order *Order) error
}

gen_register.go 扫描 ./plugins/**/*_plugin.go，生成 register_gen.go，自动调用 init() 注册实现到全局 map。

插件动态加载表

插件名	触发条件	优先级	加载方式
`CouponPlugin`	`order.total > 100`	10	静态编译
`FlashSalePlugin`	`time.Now().In(loc).Hour() == 20`	20	`init()` 注册

执行流程

graph TD
    A[LoadPlugins] --> B[Scan plugin/*.go]
    B --> C[Generate register_gen.go]
    C --> D[Build-time init registration]
    D --> E[Runtime by name lookup]

核心优势：零反射、无 unsafe，类型安全且启动即就绪。

3.3 多租户隔离：Schema级与Context级双模路由在SaaS订单系统的落地

为兼顾数据强隔离与资源弹性，系统采用 Schema级（硬隔离） + Context级（软路由）双模策略：核心租户（如金融客户）独占 PostgreSQL Schema；长尾租户（日均订单 tenant_id 上下文动态注入过滤条件。

路由决策逻辑

def resolve_tenant_strategy(tenant_id: str) -> str:
    # 查询租户元数据表获取隔离等级
    meta = db.execute("SELECT isolation_level FROM tenant_meta WHERE id = %s", [tenant_id])
    return "SCHEMA" if meta["isolation_level"] == "HARD" else "CONTEXT"

该函数实时查库判定路由模式，避免硬编码；isolation_level 字段支持运行时热切换，保障灰度发布能力。

双模执行对比

维度	Schema级	Context级
数据隔离性	✅ 物理隔离，零越权风险	⚠️ 依赖SQL注入防护与ORM层拦截
扩展成本	高（建库/授予权限）	极低（无DDL开销）
查询性能	原生索引，毫秒级	需强制添加 `WHERE tenant_id=?`

请求处理流程

graph TD
    A[HTTP请求] --> B{解析tenant_id}
    B --> C[查tenant_meta]
    C --> D{isolation_level == HARD?}
    D -->|是| E[路由至专属schema]
    D -->|否| F[注入tenant_id上下文]
    F --> G[执行共享schema查询]

第四章：百万级订单系统的稳定性工程体系

4.1 全链路可观测性：OpenTelemetry+Prometheus+Grafana的Go SDK深度定制

为实现Go服务在微服务架构下的统一观测，需深度定制OpenTelemetry SDK，使其原生兼容Prometheus指标导出与Grafana可视化语义。

数据同步机制

OpenTelemetry的PrometheusExporter默认采用拉模式，但存在采样延迟。我们通过WithRegisterer(reg)绑定自定义prometheus.Registry，并启用metric.WithTemporalitySelector()适配直方图累积语义。

// 自定义SDK初始化：注入低开销指标管道
exp, _ := prometheus.NewExporter(prometheus.NewExporterOptions{
    Namespace: "myapp",
    Registerer: reg, // 复用主应用Registry，避免冲突
    Temporality: metric.CumulativeTemporality, // 适配Prometheus抓取周期
})

该配置确保Histogram指标以_sum/_count/_bucket形式暴露，与Grafana的Prometheus数据源无缝对接。

关键组件协同关系

组件	职责	Go SDK定制点
OpenTelemetry SDK	统一采集追踪/日志/指标	注入`propagators.TraceContext{}`支持W3C透传
Prometheus Exporter	指标序列化与暴露	重写`scrapeHandler`添加租户标签注入
Grafana Dashboard	可视化编排	预置`$__rate_interval`变量适配动态抓取间隔

graph TD
    A[Go App] -->|OTLP Trace| B(OpenTelemetry Collector)
    A -->|Prometheus Metrics| C[Prometheus Server]
    C --> D[Grafana: myapp-dashboard.json]
    B -->|Metrics| C

4.2 流量治理：基于x/net/netutil限流器与自适应熔断器的组合策略

在高并发场景下，单一限流或熔断易导致保护失衡。我们采用 x/net/netutil.LimitListener 实现连接级粗粒度限流，再叠加自研的 AdaptiveCircuitBreaker 实现请求级细粒度熔断。

核心协同逻辑

// 初始化限流监听器（限制并发连接数）
listener, _ := netutil.LimitListener(baseListener, 1000)

// 包装为带熔断的HTTP handler
http.Handle("/", circuitBreaker.WrapHandler(http.HandlerFunc(handleRequest)))

LimitListener 在 accept 阶段阻塞新连接，避免资源耗尽；AdaptiveCircuitBreaker 基于最近10秒错误率与延迟P95动态切换 OPEN/HALF-OPEN/CLOSED 状态。

熔断器状态决策依据

指标	阈值	触发动作
错误率	≥60%	强制跳转 OPEN
P95延迟	>800ms	降权半开探测概率
连续成功请求数	≥5	允许状态恢复

graph TD
    A[请求到达] --> B{连接数 < 1000?}
    B -->|否| C[拒绝连接]
    B -->|是| D[接受连接]
    D --> E{熔断器状态}
    E -->|CLOSED| F[转发请求]
    E -->|OPEN| G[立即返回503]
    E -->|HALF-OPEN| H[按权重放行探测]

4.3 故障演练：Chaos Mesh在K8s集群中对Go微服务的精准注入实践

场景定义：聚焦订单服务HTTP延迟注入

使用 NetworkChaos 类型模拟上游依赖（如支付网关）超时，仅影响 order-service 的 /v1/pay 路径：

apiVersion: chaos-mesh.org/v1alpha1
kind: NetworkChaos
metadata:
  name: order-pay-delay
spec:
  action: delay
  mode: one
  selector:
    namespaces: ["prod"]
    labelSelectors:
      app.kubernetes.io/name: "order-service"
  delay:
    latency: "2s"
    correlation: "0.0"
  duration: "30s"
  scheduler:
    cron: "@every 5m"

逻辑分析：labelSelectors 精准锚定Pod；delay.latency 强制引入2秒网络延迟；scheduler.cron 实现周期性扰动，避免单次故障掩盖重试逻辑缺陷。

注入效果验证维度

指标	预期变化	观测工具
HTTP 5xx率	↑ 15–20%（熔断前）	Prometheus + Grafana
P99响应时间	从320ms → 2.3s	OpenTelemetry链路追踪
CircuitBreaker状态	从CLOSED → OPEN（触发阈值）	应用日志 + /actuator/health

自愈行为验证流程

graph TD
  A[注入延迟] --> B{熔断器是否触发？}
  B -->|是| C[降级返回mock支付结果]
  B -->|否| D[持续重试直至超时]
  C --> E[监控告警收敛]
  D --> F[引发级联超时]

4.4 热更新演进：基于plugin包与HTTP handler热替换的零停机配置下发

传统配置重载需重启服务，而现代微服务要求秒级生效。核心突破在于将配置驱动逻辑封装为可动态加载的 Go plugin，并通过 HTTP handler 实现运行时替换。

插件化配置处理器

// config_plugin.go —— 编译为 .so 文件
func LoadHandler() http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 从插件内嵌配置生成响应
        w.Header().Set("X-Config-Rev", "v2.3.1")
        json.NewEncoder(w).Encode(map[string]string{"timeout": "30s"})
    })
}

该函数导出为符号 LoadHandler，主程序通过 plugin.Open() 加载并调用，避免进程重启；http.Handler 接口保证与标准路由兼容。

热替换流程

graph TD
    A[新配置提交] --> B[构建 plugin.so]
    B --> C[原子替换 ./plugins/latest.so]
    C --> D[触发 reload goroutine]
    D --> E[安全卸载旧 handler]
    E --> F[加载新 plugin.LoadHandler]

关键参数说明

参数	作用	示例
`plugin.Open(path)`	加载动态库	`"./plugins/v2.3.1.so"`
`sym.Method("LoadHandler")`	获取导出函数	返回 `http.Handler` 实例
`http.ServeMux.Handle()`	原子注册新 handler	配合 `sync.RWMutex` 保护

第五章：写给业务开发者的Go终局思考

为什么你的微服务上线三个月后开始吃内存

某电商中台团队用 Go 编写的订单履约服务，在压测阶段表现优异（QPS 12,000，P99 sync.Pool 被误用于缓存用户会话上下文——该对象含 *sql.Tx 引用，导致事务未显式提交/回滚，连接长期被池持有。修复方案不是加 GC 频率，而是重构为 context.Context 传递生命周期，并用 defer tx.Rollback() + tx.Commit() 显式控制。真实生产日志片段如下：

// ❌ 危险：sync.Pool 存储含资源引用的对象
var sessionPool = sync.Pool{
    New: func() interface{} {
        return &Session{DB: db} // db 是全局 *sql.DB，但 Session 又持有了未关闭的 *sql.Tx
    },
}

// ✅ 正确：按请求生命周期管理，不复用跨请求状态
func handleFulfill(ctx context.Context, req *FulfillReq) error {
    tx, err := db.BeginTx(ctx, nil)
    if err != nil { return err }
    defer func() {
        if r := recover(); r != nil { tx.Rollback() }
    }()
    // ... 业务逻辑
    return tx.Commit()
}

并发模型不是银弹：goroutine 泄漏的隐蔽现场

金融风控服务曾因 time.AfterFunc 创建的 goroutine 无法取消，导致每秒累积 3–5 个泄漏协程。根源在于该函数内部启动 goroutine 后未暴露 stop channel。改用 time.NewTimer 并显式 Stop() 后，72 小时内 goroutine 数稳定在 1,200±30（此前峰值达 18,600）。对比数据如下：

方案	启动开销	可取消性	72h goroutine 增量	内存增长
`time.AfterFunc(d, f)`	极低	❌ 不可取消	+12,400	+1.8GB
`timer := time.NewTimer(d); go func(){ <-timer.C; f() }()`	中等	✅ `timer.Stop()`	+0	+12MB

错误处理必须绑定业务语义

支付回调服务曾将 io.EOF 和 http.ErrServerClosed 统一返回 500 Internal Error，导致对账系统误判交易失败而重复发起支付。最终采用错误分类中间件：

func classifyError(err error) (code int, logLevel log.Level) {
    switch {
    case errors.Is(err, io.EOF), errors.Is(err, http.ErrServerClosed):
        return 0, log.Debug // 不记录 error 级别日志，不触发告警
    case errors.Is(err, ErrInsufficientBalance):
        return 402, log.Info // 业务错误，需记录但不告警
    default:
        return 500, log.Error // 真实异常
    }
}

日志不是调试工具，而是可观测性契约

某物流轨迹服务日志中混用 fmt.Printf、log.Println 和 zap.Sugar()，导致结构化日志字段缺失 trace_id 和 order_no。改造后强制所有日志调用必须携带 Fields：

// 全局日志封装
func Log(ctx context.Context, msg string, fields ...interface{}) {
    traceID := getTraceID(ctx)
    orderNo := getOrderNo(ctx)
    logger.With(
        zap.String("trace_id", traceID),
        zap.String("order_no", orderNo),
    ).Info(msg, fields...)
}

模块边界比接口更重要

一个用户中心服务曾定义 UserRepo 接口供所有模块依赖，但实际实现中 CacheUserRepo 和 DBUserRepo 共享同一 Redis 连接池，导致缓存击穿时 DB 层也雪崩。解耦方案是拆分为 UserReader（只读）和 UserWriter（强一致性写），并通过 wire 注入不同连接池实例。

// wire.go 片段
func InitializeUserModule() (*UserModule, error) {
    cachePool := redis.NewClient(&redis.Options{Addr: "cache:6379"})
    dbPool := sql.Open("mysql", "prod-db:3306")
    return &UserModule{
        Reader: NewCachedUserReader(cachePool, dbPool),
        Writer: NewTransactionalUserWriter(dbPool),
    }, nil
}

性能优化永远从 pprof 开始，而非直觉

某推荐服务响应延迟突增，开发直觉认为是算法复杂度问题，但 pprof cpu 显示 68% 时间消耗在 json.Unmarshal 的反射路径上。替换为 easyjson 生成的解析器后，P99 从 210ms 降至 33ms，GC 次数下降 92%。关键指标对比：

指标	`encoding/json`	`easyjson`	改进幅度
P99 延迟	210ms	33ms	↓ 84%
GC Pause Avg	12.7ms	0.9ms	↓ 93%
内存分配/请求	1.2MB	142KB	↓ 88%

依赖注入不是炫技，而是测试可替代性的基础设施

所有外部依赖（短信网关、风控 SDK、消息队列）均通过 interface 定义，并在 main.go 中统一注入。单元测试时可直接传入 mock 实现，例如：

type SMSSender interface {
    Send(phone, content string) error
}

func TestOrderConfirmed_NotifiesUser(t *testing.T) {
    mockSender := &mockSMSSender{sent: make(map[string]string)}
    handler := NewOrderHandler(mockSender)
    handler.OnOrderConfirmed("13800138000", "ORD-2024-7781")
    assert.Equal(t, "订单已确认，请注意查收", mockSender.sent["13800138000"])
}