4. 接口组合：接口嵌套、接口组合模式、常见标准库接口组合示例

在 Go 语言的接口设计中，接口组合（Interface Composition）是一种核心的复用与抽象机制。它允许开发者通过将多个小接口“拼装”成更大的接口，从而构建出灵活、可扩展且职责单一的类型系统。本章将深入剖析接口嵌套的语法、接口组合的设计模式，并结合 Go 标准库中的经典案例，展示如何在实际业务中运用这些原则。

4.1 接口嵌套：语法与语义

Go 语言支持在接口定义中直接嵌入其他接口，这种语法称为接口嵌套（Interface Embedding）。被嵌入的接口的所有方法集合会自动成为新接口的方法集。

// 定义两个小接口
type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

// 通过嵌套组合成新接口
type ReadWriter interface {
    Reader
    Writer
}

上述代码中，ReadWriter 接口通过嵌套 Reader 和 Writer，自动获得了 Read 和 Write 两个方法。这种机制避免了重复声明，同时保持了接口的原子性。

4.2 接口组合模式：从原子到聚合

接口组合模式强调将大型接口拆解为多个原子接口（每个接口只包含 1-2 个紧密相关的方法），再根据业务需求灵活组合。这种模式遵循“小即是美”的哲学，能够显著降低耦合度。

模式名称	核心思想	适用场景
原子接口拆分	每个接口只定义一个行为（如 Closer、Flusher）	需要高度可插拔的组件
聚合接口组合	通过嵌套将多个原子接口组合成业务接口	定义服务契约、中间件链
可选接口断言	调用方通过类型断言检查是否实现了额外接口	优化路径、扩展功能

以下是一个典型的业务层组合示例：

// 原子接口
type Finder interface {
    Find(id string) (Entity, error)
}

type Creator interface {
    Create(entity Entity) error
}

type Deleter interface {
    Delete(id string) error
}

// 聚合接口：仓库服务
type Repository interface {
    Finder
    Creator
    Deleter
}

4.3 常见标准库接口组合示例

Go 标准库是接口组合的最佳教科书。以下列举几个最具代表性的组合模式。

4.3.1 io 包：Reader/Writer/Closer 家族

io 包定义了最基础的原子接口，并通过嵌套构建了丰富的组合接口：

type Reader interface { Read(p []byte) (n int, err error) }
type Writer interface { Write(p []byte) (n int, err error) }
type Closer interface { Close() error }

// 组合接口
type ReadWriter interface { Reader; Writer }
type ReadCloser interface { Reader; Closer }
type WriteCloser interface { Writer; Closer }
type ReadWriteCloser interface { Reader; Writer; Closer }

这种设计使得任何实现了 Read 和 Write 的类型（如 os.File、bytes.Buffer）都能自动满足 ReadWriter 接口，无需额外适配。

4.3.2 net/http 包：Handler 与 Middleware

net/http 包利用接口组合实现了强大的中间件链：

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

// ResponseWriter 本身是一个组合接口
type ResponseWriter interface {
    Header() Header
    Write([]byte) (int, error)
    WriteHeader(statusCode int)
}

中间件通过包装 Handler 接口，可以透明地添加日志、鉴权、限流等功能，而无需修改原始业务逻辑。

4.3.3 sort 包：排序接口的组合

sort 包通过 Interface 接口定义了排序契约，并提供了多种组合辅助：

type Interface interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}

// 通过组合实现逆序
type reverse struct { Interface }

func (r reverse) Less(i, j int) bool {
    return r.Interface.Less(j, i)
}

这种组合模式使得排序行为可以灵活地反转、扩展，而无需重新实现整个接口。

4.4 接口组合的架构图

下图展示了从原子接口到聚合接口，再到具体实现的完整组合链路：

4.5 接口组合与业务契约设计

在业务接口契约设计中，接口组合模式能够带来以下收益：

• 最小依赖原则：调用方只需依赖它真正需要的方法集合，而非整个大接口。
• 可测试性：可以针对原子接口编写轻量级 mock，避免为庞大接口实现无用的桩方法。
• 演进友好：新增行为时，只需定义新的原子接口，并通过组合扩展，不会破坏现有实现。

以下是一个业务场景中的组合示例：

// 订单服务原子接口
type OrderReader interface {
    GetOrder(id string) (*Order, error)
    ListOrders(filter OrderFilter) ([]*Order, error)
}

type OrderWriter interface {
    CreateOrder(order *Order) (string, error)
    UpdateOrder(order *Order) error
}

type OrderCanceller interface {
    CancelOrder(id string) error
}

// 聚合接口：完整订单服务
type OrderService interface {
    OrderReader
    OrderWriter
    OrderCanceller
}

4.6 接口组合的常见陷阱

陷阱	说明	解决方案
方法冲突	两个被嵌套的接口包含同名方法，但签名不同	避免同名方法；或使用匿名嵌入并显式声明
过度拆分	将接口拆得过于细碎，导致组合爆炸	保持每个接口 1-3 个方法，按业务语义分组
循环嵌套	接口 A 嵌套 B，B 又嵌套 A	Go 编译器会检测并报错，设计时注意单向依赖
隐式耦合	组合接口的调用方依赖了未显式声明的方法	始终通过类型断言检查可选接口，而非隐式假设

接口组合是 Go 语言中构建可维护、可测试业务系统的基石。通过合理运用嵌套语法和组合模式，开发者能够设计出既灵活又清晰的接口契约，为后续的迭代与扩展打下坚实基础。