Go依赖注入不等于Wire：Uber Go Style Guide未公开的5条DI设计铁律

第一章：Go依赖注入的本质与认知跃迁

依赖注入在Go中并非语言原生机制，而是一种设计思想的显式落地——它拒绝隐式耦合，要求开发者以结构体字段、构造函数参数或接口组合的方式，将依赖关系“声明出来”，而非在内部自行创建。这种显式性迫使团队直面组件边界与职责划分，是Go“少即是多”哲学在架构层面的延伸。

什么是真正的依赖注入

它不是简单地把一个结构体传给另一个结构体；
它是控制反转（IoC）的具体实践：调用方不再决定依赖如何构建，而是由外部容器（或主函数）统一协调生命周期与组装逻辑；
它天然适配Go的接口即契约特性：只要满足接口定义，实现可自由替换，无需修改使用者代码。

Go中常见的注入模式对比

模式	示例场景	可测试性	生命周期管理
构造函数注入	`NewUserService(repo UserRepo)`	★★★★★	手动可控
字段注入（非推荐）	`svc.Repo = &mockRepo{}`	★★☆☆☆	易被意外覆盖
函数选项模式	`NewServer(WithLogger(l), WithDB(db))`	★★★★☆	灵活可扩展

实现一个最小可行注入示例

// 定义抽象依赖
type Database interface {
    Query(string) error
}

// 具体实现（可被替换）
type PostgreSQL struct{}
func (p PostgreSQL) Query(q string) error { /* ... */ }

// 业务服务 —— 仅声明依赖，不创建
type UserService struct {
    db Database // 依赖通过字段声明
}

// 构造函数强制注入，杜绝 nil panic
func NewUserService(db Database) *UserService {
    return &UserService{db: db}
}

// 主函数作为“容器”，完成组装
func main() {
    db := PostgreSQL{}                    // 创建具体依赖
    svc := NewUserService(db)             // 注入依赖
    _ = svc                               // 使用服务
}

这段代码没有引入任何第三方DI框架，却已具备依赖注入的核心特征：解耦、可测、可替换。认知跃迁的关键在于：注入不是为了炫技，而是为了让“谁负责什么”在代码中一目了然。

第二章：Uber Go Style Guide中隐含的DI设计铁律

2.1 铁律一：构造函数必须显式声明所有依赖（理论：依赖可见性原则；实践：从隐式全局状态迁移至显式参数注入）

为什么隐式依赖是“静默陷阱”？

全局变量、单例引用、静态方法调用看似便捷，实则掩盖了组件的真实协作关系；
测试时无法隔离替换，重构时难以追溯影响范围；
依赖关系只能在运行时暴露，编译期零校验。

显式注入的典型演进路径

// ❌ 反模式：隐式依赖（Date 构造隐含系统时钟）
class ReportGenerator {
  generate() {
    return `Report_${new Date().toISOString()}`;
  }
}

// ✅ 正模式：依赖显式化（时钟抽象为接口）
interface Clock {
  now(): Date;
}
class SystemClock implements Clock {
  now() { return new Date(); }
}
class ReportGenerator {
  constructor(private clock: Clock) {} // ← 依赖可见、可替换
  generate() {
    return `Report_${this.clock.now().toISOString()}`;
  }
}

逻辑分析：ReportGenerator 不再耦合具体时间实现，clock 参数声明即契约。测试时可注入 MockClock，单元测试无需真实时间流逝；扩展时可轻松切换为 NTP 时钟或固定时间快照。

依赖可见性带来的收益对比

维度	隐式依赖	显式构造注入
可测试性	依赖全局状态，难 Mock	接口注入，天然支持 Stub
可读性	调用栈中隐含，需追踪	构造函数签名即依赖图谱
可维护性	修改全局行为影响未知	依赖变更强制更新调用方

graph TD
  A[Client Code] -->|传入实例| B[ReportGenerator]
  B --> C[Clock Interface]
  C --> D[SystemClock]
  C --> E[MockClock]

2.2 铁律二：禁止在构造函数中执行副作用操作（理论：纯构造契约；实践：重构Init()方法为独立Setup阶段）

构造函数应仅负责状态初始化，不触发网络调用、文件读写、事件发布等任何外部交互。

为何必须隔离副作用？

破坏可测试性：无法在单元测试中 mock 构造时的 HTTP 请求
阻碍依赖注入：DI 容器无法控制实例化与资源准备的时机分离
引发隐式失败：构造异常导致对象处于半初始化状态

重构前后对比

场景	违反铁律（构造即加载）	遵守铁律（显式 Setup）
对象生命周期	`new DataService()` 抛出 `IOException`	`var svc = new DataService(); svc.Setup().Wait();`
单元测试	难以绕过构造时 DB 连接	可注入 `IHttpClientFactory` 并验证 Setup 行为

// ❌ 反模式：构造函数中执行副作用
public class ReportGenerator {
    private readonly HttpClient _client;
    public ReportGenerator() {
        _client = new HttpClient();
        // ⚠️ 副作用：同步加载配置（可能失败/阻塞）
        Config = LoadConfigFromRemote().Result; 
    }
    private async Task<Config> LoadConfigFromRemote() => await _client.GetFromJsonAsync<Config>("..."); 
}

逻辑分析：LoadConfigFromRemote().Result 在构造中强制同步等待异步操作，易引发死锁（尤其在 UI/ASP.NET 同步上下文），且 HttpClient 实例未通过 DI 注入，违反可替换性原则。参数 Config 的获取时机与对象创建强耦合，丧失按需加载能力。

graph TD
    A[New ReportGenerator] --> B[分配内存]
    B --> C[调用构造函数]
    C --> D[初始化字段]
    D --> E[发起远程 HTTP 请求]
    E --> F[阻塞线程等待响应]
    F --> G[构造完成？]
    G -->|失败| H[对象不可用]
    G -->|成功| I[对象已部分就绪但状态不可控]

推荐实践：显式 Setup 阶段

将副作用移至 SetupAsync() 方法
构造函数仅接受依赖项（如 IHttpClientFactory）
由调用方决定何时、是否执行 Setup

2.3 铁律三：依赖图必须是DAG且可静态分析（理论：循环依赖的语义不可判定性；实践：用go list + ast遍历验证依赖拓扑）

为什么DAG是硬约束

循环依赖导致构建顺序不可解、初始化死锁、测试隔离失效，且在Go中触发编译错误 import cycle not allowed。更本质的是：依赖关系的可达性判定在存在环时退化为停机问题的变体——语义上不可判定。

静态验证双路径

go list -f '{{.ImportPath}} -> {{join .Imports "\n\t-> "}}' ./... 提取原始依赖边
AST遍历校验跨包符号引用（如 *ast.Ident.Obj.Decl 所属包），捕获隐式依赖

# 生成模块级依赖图（含主模块）
go list -json -deps -f '{{if not .Test}}{"P": "{{.ImportPath}}", "D": [{{range .Deps}}"{{.}}",{{end}}]}{{end}}' . | jq -s 'map(select(.D != null))'

此命令输出JSON格式的依赖节点集合，-deps 递归展开所有直接/间接依赖，-json 保证结构化解析；select(.D != null) 过滤测试包，避免干扰主拓扑。

DAG检测核心逻辑

graph TD
    A[解析 go list 输出] --> B[构建有向图 G = (V, E)]
    B --> C{DFS 检测回边}
    C -->|存在| D[报错：违反铁律三]
    C -->|无| E[通过：拓扑序唯一]

工具	覆盖维度	局限性
`go list`	包级显式导入	忽略反射/插件动态加载
`go/ast`遍历	符号级隐式引用	需完整类型检查上下文

2.4 铁律四：接口定义权归属消费者而非提供者（理论：稳定依赖原则；实践：基于Use Case提取窄接口并内聚于调用方包）

消费者驱动的接口契约

传统RPC中，服务提供方定义宽泛接口（如 UserService 含 create, update, delete, syncAll），导致调用方被迫依赖未使用的方法，违反稳定依赖原则——被依赖者应比依赖者更稳定。

窄接口提取示例

// ✅ 消费者包内定义：仅需同步用户头像
package com.example.order.usecase;
public interface AvatarSyncPort {
    void syncAvatar(Long userId, String avatarUrl);
}

逻辑分析：AvatarSyncPort 由订单服务（消费者）定义，声明最小必要能力；实现类由用户服务提供，但接口生命周期由订单模块管控。参数 userId（业务主键）与 avatarUrl（幂等关键字段）精准匹配用例，无冗余字段。

依赖流向对比

角色	接口定义位置	依赖方向	稳定性影响
提供者中心	`user-service`	消费者 → 提供者	提供者变更即断裂
消费者中心	`order-usecase`	提供者 → 消费者	消费者可自主演进接口

graph TD
    A[订单服务] -->|依赖| B[AvatarSyncPort]
    C[用户服务] -->|实现| B

接口定义权移交后，消费者可按用例拆分接口（如 EmailValidationPort、InventoryCheckPort）
所有端口接口内聚于调用方包，物理隔离保障演进自由度

2.5 铁律五：DI容器生命周期必须与应用生命周期严格对齐（理论：资源泄漏的根因模型；实践：集成runtime.SetFinalizer与defer链式释放）

资源泄漏的根因模型

当 DI 容器生命周期长于其托管对象（如数据库连接、gRPC client）时，runtime.GC() 无法回收强引用闭包中的资源，形成隐式持有链——这是 Go 中最隐蔽的泄漏根源。

defer 链式释放模式

func (c *Container) Close() error {
    var errs []error
    for _, closer := range c.closers {
        if err := closer.Close(); err != nil {
            errs = append(errs, err)
        }
    }
    return errors.Join(errs...)
}

c.closers 是按依赖拓扑逆序注册的 io.Closer 切片，确保子资源先于父资源关闭；errors.Join 统一聚合错误，避免单点失败中断整条释放链。

Finalizer 作为最后防线

触发条件	行为	风险
容器未显式 Close	打印告警 + 强制释放	仅用于调试，不可依赖
GC 回收容器对象	`SetFinalizer(c, finalize)`	不保证调用时机

graph TD
    A[App Start] --> B[New Container]
    B --> C[Register Services]
    C --> D[Inject Dependencies]
    D --> E[App Run]
    E --> F{Graceful Shutdown?}
    F -->|Yes| G[container.Close()]
    F -->|No| H[Finalizer triggers]
    G --> I[Clean Exit]
    H --> J[Log Warning + Force Release]

第三章：Wire之外的轻量级DI实现范式

3.1 基于函数选项模式的手动依赖组装（理论：Option Pattern的类型安全演进；实践：构建可组合、可测试的NewXxxClient()变体）

函数选项模式将配置逻辑从构造函数参数列表中解耦，转为类型安全的函数式组合：

type ClientOption func(*Client)

func WithTimeout(d time.Duration) ClientOption {
    return func(c *Client) { c.timeout = d }
}

func WithLogger(l *zap.Logger) ClientOption {
    return func(c *Client) { c.logger = l }
}

func NewClient(opts ...ClientOption) *Client {
    c := &Client{timeout: 5 * time.Second}
    for _, opt := range opts {
        opt(c)
    }
    return c
}

该实现避免了可选参数爆炸，每个 ClientOption 是独立、无副作用的纯函数，支持任意顺序组合与单元隔离测试。

核心优势对比

特性	传统结构体初始化	函数选项模式
参数可扩展性	需修改函数签名	无需改动 `NewClient`
类型安全性	依赖字段赋值顺序	编译期校验函数签名
测试友好性	需构造完整依赖树	可按需注入单个依赖

graph TD
    A[NewClient] --> B[WithTimeout]
    A --> C[WithLogger]
    A --> D[WithRetryPolicy]
    B --> E[Client实例]
    C --> E
    D --> E

3.2 利用Go 1.18+泛型构建类型安全的依赖注册表（理论：编译期依赖约束；实践：Generic Registry + constraint-based Resolver）

核心设计思想

泛型注册表将 interface{} 替换为可验证的类型参数，使依赖绑定在编译期完成类型检查，杜绝运行时 panic("invalid type")。

泛型注册器实现

type Registrar[T any] struct {
    instances map[reflect.Type]T
}

func NewRegistrar[T any]() *Registrar[T] {
    return &Registrar[T]{instances: make(map[reflect.Type]T)}
}

func (r *Registrar[T]) Register(instance T) {
    r.instances[reflect.TypeOf(instance).Type] = instance
}

逻辑分析：T any 约束保证实例为具体类型；reflect.TypeOf(instance).Type 提取底层类型用于键值映射。注意：此处仅适用于非接口类型实例——若需支持接口，须配合 ~ 或自定义 constraint。

类型约束解析器

type Resolvable[T any] interface {
    ~*T | ~[]T | fmt.Stringer // 示例约束：指针、切片或实现Stringer
}

func Resolve[T Resolvable[T]](reg *Registrar[T], t reflect.Type) (T, error) {
    if inst, ok := reg.instances[t]; ok {
        return inst, nil
    }
    var zero T
    return zero, fmt.Errorf("no instance registered for %v", t)
}

特性	编译期检查	运行时开销	类型推导
`interface{}` 方案	❌	高（type assert）	手动
泛型 `Registrar[T]`	✅	零（无反射）	自动

graph TD
    A[Register\ne.g. dbConn] --> B[Registrar[DBConnection]]
    C[Resolve\ndbConn] --> D[Compiler validates T matches DBConnection]
    B --> D

3.3 基于Build Tag的环境感知依赖切换（理论：编译时多态原理；实践：dev/test/prod三套依赖树的零运行时开销切换）

传统环境切换依赖 @Profile 或配置中心，引入运行时分支与条件判断。Build Tag 方案将环境决策前移至编译期，利用 Go 的 //go:build 指令或 Rust 的 cfg 属性，结合构建系统（如 Bazel 的 select() 或 Gradle 的 variant-aware dependencies）实现静态链接时的依赖树裁剪。

编译期多态的本质

编译器依据标签（如 dev, test, prod）在解析阶段排除不匹配的源文件与依赖声明，生成完全隔离的二进制产物——无 if env == "prod"，无反射、无动态加载。

依赖树对比（Gradle 示例）

环境	数据库驱动	日志后端	配置源
dev	h2:2.2.224	logback	application-dev.yml
test	postgresql:42.6.0	logstash	config-test.yaml
prod	r2dbc-postgresql:1.0.5	datadog-trace	consul

// build.gradle.kts
dependencies {
    "devImplementation"("com.h2database:h2:2.2.224")
    "testImplementation"("org.postgresql:postgresql:42.6.0")
    "prodImplementation"("io.r2dbc:r2dbc-postgresql:1.0.5")
}

此声明由 Gradle 的 java-library 插件配合 variant-aware dependency resolution 解析：仅当前构建变体（如 ./gradlew assembleProd）激活对应 prodImplementation，其余依赖彻底不参与类路径计算与字节码链接，消除任何运行时开销。

构建流程示意

graph TD
    A[执行 ./gradlew build -Penv=prod] --> B{解析 -Penv=prod}
    B --> C[激活 prodImplementation 依赖]
    B --> D[忽略 dev/test 分支代码与依赖]
    C --> E[链接 r2dbc-postgresql + datadog-trace]
    E --> F[产出 prod-only fat jar]

第四章：生产级DI架构的工程化落地

4.1 依赖注入与可观测性的深度整合（理论：Dependency Graph → OpenTelemetry Service Graph；实践：自动注入SpanContext与依赖健康度指标）

传统 DI 容器仅管理对象生命周期，而现代可观测性要求将依赖关系实时映射为服务拓扑。Spring Boot 3.x + Micrometer Tracing 自动将 @Bean 依赖图谱注入 OpenTelemetry 的 ServiceGraph，实现从代码结构到分布式追踪的语义对齐。

数据同步机制

DI 容器在 BeanPostProcessor.postProcessAfterInitialization 阶段拦截所有 Bean 实例，通过反射提取 @Autowired 字段/构造器依赖，并注册为 otel.service.dependency 属性：

@Bean
public TracingDependencyListener dependencyListener(Tracer tracer) {
    return new TracingDependencyListener(tracer); // 注入全局 Tracer
}

此监听器在 Bean 初始化后触发，利用 Span.current() 获取当前 SpanContext，并将被依赖方的服务名、实例 ID、延迟分位数作为 Link 关联至当前 Span，确保依赖调用链可追溯。

健康度指标建模

指标名	类型	标签示例	用途
`dependency.health.score`	Gauge	`service=auth, status=up`	综合响应率、P95延迟、错误率的归一化健康分（0–100）
`dependency.call.rate`	Counter	`target=payment, outcome=success`	每秒调用频次，驱动服务图边权重

graph TD
  A[OrderService] -->|SpanContext<br>propagated| B[PaymentService]
  B -->|health.score=92.3| C[InventoryService]
  C -->|error_rate=0.8%| D[NotificationService]

该整合使服务图不再静态，而是随 DI 实例状态与调用行为动态演进。

4.2 在微服务边界实施依赖契约治理（理论：Bounded Context下的DI契约协议；实践：Protobuf定义依赖接口+生成Go stub与mock）

在领域驱动设计中，Bounded Context 明确划分了各微服务的语义边界，而依赖注入（DI）契约需严格对齐上下文边界——即接口定义必须由消费方主导、提供方实现并承诺兼容性，避免“反向耦合”。

Protobuf 定义强类型契约

// user_service/v1/user_contract.proto
syntax = "proto3";
package users.v1;

message GetUserRequest { string user_id = 1; }
message GetUserResponse { string name = 1; int32 age = 2; }

service UserService {
  rpc Get(GetUserRequest) returns (GetUserResponse);
}

该定义强制约定字段名、类型、序号及服务端点，规避 JSON Schema 的运行时松散校验风险；package users.v1 确保 Go 生成的包路径与领域上下文一致。

生成与集成

protoc --go_out=. --go-grpc_out=. user_contract.proto

生成 user_contract.pb.go（stub）与 user_contract_grpc.pb.go（client/server 接口），支持 gomock 自动生成 mock 实现，使消费者可在 provider 未就绪时完成集成测试。

契约要素	保障目标
`.proto` 文件版本化	语义演进可追溯
`go-grpc` stub	编译期接口一致性校验
`gomock` mock	单元测试解耦 provider

graph TD
  A[Consumer Code] -->|调用| B[UserServiceClient]
  B --> C[Generated gRPC Stub]
  C --> D[Wire Protocol: HTTP/2 + Protobuf]
  D --> E[Provider Service]

4.3 构建可审计的依赖变更追踪系统（理论：依赖漂移风险模型；实践：git hook + go mod graph diff + 自动PR注释）

依赖漂移风险模型核心维度

依赖漂移并非偶然，而是由语义版本偏离度、间接依赖爆炸半径与维护者活跃衰减率三者耦合驱动。高风险变更常表现为：v1.2.0 → v1.9.0（跳过6个补丁/小版本）、引入≥3层嵌套新模块、或主仓库近90天零提交。

自动化追踪流水线

# pre-commit hook: 捕获变更快照
git diff --name-only HEAD~1 -- go.mod | grep -q "go.mod" && \
  go mod graph > .git/refs/depgraph-$(git rev-parse --short HEAD).txt

该脚本在每次提交前生成依赖图快照，文件名绑定 commit hash，确保不可篡改溯源；仅当 go.mod 变更时触发，避免冗余开销。

差分与告警机制

风险等级	判定条件	响应动作
中	新增 ≥5 个间接依赖	PR 描述自动追加⚠️标签
高	主要依赖版本跨度 ≥2 小版本	阻断合并，需安全委员会审批

graph TD
  A[git push] --> B{go.mod changed?}
  B -->|Yes| C[run go mod graph diff]
  C --> D[计算依赖拓扑差异]
  D --> E[匹配风险模型阈值]
  E -->|High| F[Reject + Notify]
  E -->|Medium| G[Auto-comment PR]

4.4 面向Serverless场景的无状态DI优化（理论：冷启动与依赖初始化成本博弈；实践：lazy-init wrapper + sync.OncePool缓存策略）

在函数即服务（FaaS）环境中，每次冷启动都需重建依赖图，导致延迟激增。核心矛盾在于：早初始化保障运行时性能但拖慢启动，懒加载降低冷启动开销却增加首次调用延迟。

懒初始化封装器设计

type LazyDB struct {
    init sync.Once
    db   *sql.DB
}

func (l *LazyDB) Get() (*sql.DB, error) {
    l.init.Do(func() {
        l.db, _ = sql.Open("postgres", os.Getenv("DB_URL"))
    })
    return l.db, nil
}

sync.Once确保单例安全初始化；Get()仅在首次调用时触发连接池构建，避免冷启动期冗余资源分配。

sync.OncePool 缓存策略对比

策略	冷启动耗时	首次调用延迟	实例复用率
全局预初始化	高	低	100%
单次 lazy-init	低	中	~85%
sync.OncePool	低	低	>95%

依赖生命周期协同流程

graph TD
    A[函数实例创建] --> B{是否复用?}
    B -- 是 --> C[复用已缓存依赖]
    B -- 否 --> D[执行lazy-init]
    D --> E[注册到OncePool]
    E --> F[后续调用直接获取]

第五章：从DI思维到Go工程哲学的升维

依赖注入不是目的，而是解耦的副产品

在 Go 社区早期，许多开发者将 DI 等同于“用 Wire 或 Dig 注册构造函数”，却忽略了其本质：控制权让渡。某电商订单服务重构案例中，团队最初用 wire.NewSet(order.NewService, order.NewRepository, cache.NewRedisClient) 强制绑定 Redis 实现，导致测试时无法注入内存缓存模拟器。后来改写为接受 cache.Cache 接口并由调用方传入，构造函数签名从 func(*redis.Client) *Service 升级为 func(cache.Cache) *Service——此时 DI 已隐式内化为函数参数契约，不再依赖框架。

Go 的接口即契约，而非抽象基类

对比 Java Spring 的 @Service 注解与 Go 的 type UserRepository interface { Save(context.Context, *User) error }，前者需容器管理生命周期，后者仅要求满足方法集。某 SaaS 平台用户中心模块采用此范式后，本地开发可注入 memdb.UserRepo{}，灰度环境切换为 dynamodb.UserRepo{}，而无需修改任何业务逻辑代码。接口定义位于 internal/domain/user/repo.go，实现分散在 internal/infra/redis/ 与 internal/infra/dynamo/，目录结构天然体现关注点分离：

层级	目录路径	职责
Domain	`internal/domain/user/`	用户核心模型与仓储接口
Infra	`internal/infra/redis/`	Redis 实现细节（含连接池、序列化）
App	`internal/app/user/service.go`	业务流程编排，仅依赖 domain 接口

构造函数即文档，显式声明依赖关系

// ✅ 清晰表达依赖：需要配置、日志、数据库连接、消息队列客户端
func NewOrderService(
    cfg config.OrderConfig,
    logger *zap.Logger,
    db *sql.DB,
    publisher message.Publisher,
) *OrderService {
    return &OrderService{
        cfg:      cfg,
        logger:   logger,
        db:       db,
        publisher: publisher,
    }
}

// ❌ 隐藏依赖：全局变量或 init() 初始化，难以单元测试
var globalDB *sql.DB // 测试时无法替换

工程哲学落地：从“能跑”到“可演进”

某支付网关项目经历三次迭代：V1 使用 init() 加载配置与 DB 连接；V2 引入 Wire 生成 DI 图；V3 彻底移除 DI 框架，所有依赖通过 main.go 中的 NewApp() 函数逐层传递。最终 cmd/payment-gateway/main.go 不足 80 行，却清晰呈现了启动顺序与依赖拓扑：

graph TD
    A[main] --> B[NewApp]
    B --> C[NewConfig]
    B --> D[NewLogger]
    B --> E[NewDatabase]
    B --> F[NewKafkaProducer]
    C --> D
    E --> F
    B --> G[NewHTTPServer]
    G --> H[NewOrderHandler]
    H --> I[NewOrderService]
    I --> E
    I --> F

错误处理即流程分支，拒绝 panic 传染

在订单创建链路中，service.Create(ctx, req) 不返回 error 而是返回 *domain.OrderResult，其中包含 Err 字段与结构化错误码（如 ErrInsufficientBalance = "balance_insufficient"）。HTTP handler 根据该字段选择返回 400 Bad Request 或 500 Internal Server Error，避免底层 database/sql 的 sql.ErrNoRows 向上泄露。这种设计使可观测性系统能直接聚合业务错误码，而非解析模糊的 error.Error() 字符串。

模块边界即文件系统边界，`go.mod` 是契约声明

internal/checkout/ 模块的 go.mod 明确声明 require github.com/myorg/payment v1.2.0，但禁止其内部 import internal/payment/ —— 因为 checkout 仅应依赖 payment 的 public API（即 github.com/myorg/payment 导出的接口与 DTO）。CI 流水线通过 go list -deps ./... | grep internal/payment 检测越界引用，失败则阻断合并。

依赖倒置不靠注解，而靠包导入方向

当 internal/app/order 需要通知用户，它不 import internal/infra/email，而是定义 type Notifier interface { Send(ctx context.Context, to string, tpl string, data map[string]interface{}) error }，并在 internal/infra/email 中实现该接口。go list -f '{{.ImportPath}} -> {{join .Imports "\n"}}' ./internal/app/order 输出中绝不会出现 internal/infra/email，证明依赖方向严格向上收敛。