📚 课程目录第4章接口嵌入

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

接口嵌入（Interface Embedding）是 Go 语言中构建可复用、可扩展抽象层的关键机制。它允许一个接口类型直接包含（嵌入）其他接口类型的方法集，从而形成新的、更强大的接口契约。这种组合方式避免了重复定义，并鼓励“小接口 + 组合”的设计哲学。

4.1 接口嵌入的语法与语义

在 Go 中，接口嵌入通过在接口定义中直接声明其他接口类型名称来实现。被嵌入接口的所有方法会自动提升到新接口的方法集中。

// 定义两个小接口
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
}

// 等价于显式声明：
// type ReadWriter interface {
//     Read(p []byte) (n int, err error)
//     Write(p []byte) (n int, err error)
// }

设计原则：优先定义只包含 1-2 个方法的小接口，然后通过嵌入组合成更复杂的接口。这符合 Go 的“隐式实现”和“接口隔离原则”（ISP）。

4.2 组合接口的层次结构

接口嵌入支持多层嵌套，形成清晰的层次化抽象。以下是一个典型的 I/O 接口层次结构：

type Closer interface {
    Close() error
}

type Seeker interface {
    Seek(offset int64, whence int) (int64, error)
}

// 三层组合
type ReadCloser interface {
    Reader
    Closer
}

type WriteCloser interface {
    Writer
    Closer
}

type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

type ReadSeeker interface {
    Reader
    Seeker
}

type ReadWriteSeeker interface {
    Reader
    Writer
    Seeker
}

关键点：嵌入的接口不能有同名方法冲突。如果两个被嵌入的接口都定义了相同签名的方法，编译器会报错。如果方法签名不同（参数或返回值不同），同样无法通过编译。

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

Go 标准库大量使用了接口嵌入来构建灵活、可组合的抽象。以下是几个最典型的例子：

标准库包	组合接口	嵌入的接口	典型用途
`io`	`ReadWriter`	`Reader` + `Writer`	双向数据流（如网络连接、管道）
`io`	`ReadCloser`	`Reader` + `Closer`	可关闭的读取源（如文件、HTTP 响应体）
`io`	`ReadWriteCloser`	`Reader` + `Writer` + `Closer`	全双工可关闭连接（如 TCP Socket）
`io`	`ReadSeeker`	`Reader` + `Seeker`	支持随机读取的文件
`io`	`WriteSeeker`	`Writer` + `Seeker`	支持随机写入的文件
`net`	`Conn`	`io.ReadWriteCloser` + 额外方法	网络连接抽象
`http`	`ResponseWriter`	`io.Writer` + 额外方法	HTTP 响应写入

4.4 接口嵌入与结构体嵌入的对比

接口嵌入和结构体嵌入在语法上相似，但语义完全不同：

特性	接口嵌入	结构体嵌入
目标类型	接口	结构体
提升内容	方法集	字段和方法
实现方式	隐式组合，无字段访问	显式组合，可访问嵌入字段
多态性	支持接口多态	支持方法提升和重写
冲突处理	同名方法签名冲突编译错误	同名方法优先使用外层定义

4.5 接口嵌入的架构意义

从软件架构角度看，接口嵌入实现了以下目标：

关注点分离：将读、写、关闭、定位等不同职责拆分为独立的小接口。
按需组合：使用者可以根据实际需要组合出精确的接口契约，避免依赖不需要的方法。
演进友好：新增一个基础接口不会破坏已有实现，只需在组合接口中嵌入即可扩展能力。
测试便利：可以针对小接口编写 mock 实现，组合后的大接口自然获得测试覆盖。

常见陷阱：不要为了“复用”而盲目嵌入大量接口。组合接口应该反映真实的业务抽象，而不是机械地拼凑方法。过大的接口会破坏接口隔离原则，增加实现者的负担。

4.6 实战：构建可组合的日志系统

以下示例展示如何利用接口嵌入构建一个灵活的日志抽象层：

package logger

import "io"

// 基础接口
type LogWriter interface {
    WriteLog(level string, message string) error
}

type Flusher interface {
    Flush() error
}

type Rotator interface {
    Rotate() error
}

// 组合接口
type FlushableLogWriter interface {
    LogWriter
    Flusher
}

type RotatableLogWriter interface {
    LogWriter
    Rotator
}

type FullLogWriter interface {
    LogWriter
    Flusher
    Rotator
}

// 实现：文件日志
type FileLogger struct {
    writer io.WriteCloser
}

func (f *FileLogger) WriteLog(level string, message string) error {
    _, err := f.writer.Write([]byte(level + ": " + message + "\n"))
    return err
}

func (f *FileLogger) Flush() error {
    // 模拟 flush 操作
    return nil
}

func (f *FileLogger) Rotate() error {
    // 模拟日志轮转
    return nil
}

// 使用：只依赖需要的接口
func ProcessWithFlush(logger FlushableLogWriter) {
    logger.WriteLog("INFO", "processing started")
    logger.Flush()
}

func ProcessWithRotation(logger RotatableLogWriter) {
    logger.WriteLog("WARN", "rotation needed")
    logger.Rotate()
}

架构收益：通过接口嵌入，ProcessWithFlush 和 ProcessWithRotation 函数只依赖它们实际需要的方法。未来新增一个只支持 LogWriter 的控制台日志实现，无需修改任何现有代码。

4.7 接口嵌入的局限性

方法冲突：两个嵌入接口不能包含同名但签名不同的方法。
无法覆盖：接口嵌入不支持方法重写，所有提升的方法必须由实现类型完整提供。
循环嵌入：接口不能直接或间接嵌入自身，编译器会检测并报错。
空接口嵌入：嵌入 interface{} 虽然语法允许，但会引入空接口的所有方法（即无方法），通常没有实际意义。

接口嵌入是 Go 语言中实现“组合优于继承”理念的核心语法工具。掌握它，你就能设计出既灵活又稳固的接口契约体系。