Go Academy · 课时

接口组合与最佳实践

Q: 「接口组合与最佳实践」这节课中我会学到什么？

小型接口与依赖倒置 你通过在浏览器中直接运行的动手代码来练习 Go Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

小型接口与依赖倒置

接口组合与最佳实践 是 CoddyKit 上的免费 Go Academy 课时。这是第 4 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Go Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Go Academy 课程共包含 4 节课。

接口组合

Go 接口可以嵌入其他接口，以组合出更大的接口：

package main
import "io"

// io.ReadWriter composes Reader and Writer
type ReadWriter interface {
    io.Reader
    io.Writer
}

// Your own composition:
type Processor interface {
    io.Reader
    Process() error
    io.Closer
}

func main() { _ = (*Processor)(nil) }

小接口原则

最强大的 Go 接口通常只有一个或两个方法。这样可以最大限度地增加能够满足这些接口的类型数量：

io.Reader — 1 个方法
io.Writer — 1 个方法
error — 1 个方法
fmt.Stringer — 1 个方法

大型接口更难模拟和测试。

依赖倒置

在函数参数中接收接口，而不是具体类型。这样可以将代码与特定实现解耦：

package main
import "fmt"

type Store interface {
    Get(key string) (string, bool)
    Set(key, val string)
}

func cache(s Store, key, value string) {
    if _, ok := s.Get(key); !ok {
        s.Set(key, value)
    }
}

type MapStore struct{ m map[string]string }
func (ms *MapStore) Get(k string) (string, bool) { v, ok := ms.m[k]; return v, ok }
func (ms *MapStore) Set(k, v string) { ms.m[k] = v }

func main() {
    s := &MapStore{m: map[string]string{}}
    cache(s, "x", "hello")
    v, _ := s.Get("x")
    fmt.Println(v)
}

接口隔离

将大型接口拆分为更小、更专注的接口。调用方只依赖自己使用的方法：

package main

// Bad: large interface forces all methods
type BigStorage interface {
    Read(key string) string
    Write(key, val string)
    Delete(key string)
    List() []string
    Backup() error
}

// Good: small, focused interfaces
type Reader interface{ Read(key string) string }
type Writer interface{ Write(key, val string) }
type Lister interface{ List() []string }

func readAll(r Reader) {} // only needs Read

func main() { _ = readAll }

返回具体类型

构造函数应返回具体类型，而不是接口。调用方始终可以将具体类型赋值给接口变量：

package main

type Logger interface{ Log(string) }
type ConsoleLogger struct{}
func (c *ConsoleLogger) Log(s string) {}

// Good: return concrete *ConsoleLogger
func NewConsoleLogger() *ConsoleLogger { return &ConsoleLogger{} }

// Avoid: return Logger (hides the concrete type)
// func NewConsoleLogger() Logger { return &ConsoleLogger{} }

func main() { _ = NewConsoleLogger() }

接口泛滥

不要为了“以防万一”而为每种类型都创建接口。仅在以下情况下创建接口：

现在或很快就会有多个实现
需要在测试中模拟该依赖
正在构建库，并希望将调用方解耦

嵌入接口进行扩展

嵌入一个接口，以默认实现的方式添加可选方法：

package main
import "fmt"

type Handler interface{ Handle(msg string) }
type NamedHandler interface {
    Handler
    Name() string
}

func dispatch(h Handler) {
    if nh, ok := h.(NamedHandler); ok {
        fmt.Printf("[%s] ", nh.Name())
    }
    h.Handle("event")
}

type MyHandler struct{}
func (m MyHandler) Handle(msg string)  { fmt.Println(msg) }
func (m MyHandler) Name() string       { return "my" }

func main() { dispatch(MyHandler{}) }

使用接口进行模拟

将依赖定义为接口；在测试中注入模拟对象：

package main
import "fmt"

type Clock interface{ Now() int64 }

type MockClock struct{ T int64 }
func (m MockClock) Now() int64 { return m.T }

func isExpired(c Clock, expiresAt int64) bool {
    return c.Now() > expiresAt
}

func main() {
    mc := MockClock{T: 1000}
    fmt.Println(isExpired(mc, 500))  // true
    fmt.Println(isExpired(mc, 1500)) // false
}

接口嵌入与结构体嵌入的复用差异

使用接口嵌入来组合 API，使用结构体嵌入来复用代码。它们的用途不同，不应混淆。

在编译时检测接口实现

使用空白标识符编译时检查，以验证类型满足某个接口：

package main

type Doer interface{ Do() }
type MyType struct{}
func (m *MyType) Do() {}

// Compile-time check — no runtime cost
var _ Doer = (*MyType)(nil)

func main() {}

快速检查

在 Go 中，什么时候应该定义新接口？

回顾：接口最佳实践

要点：

保持接口小巧 — 一个或两个方法
从更小的接口组合出接口
接收接口，返回具体类型
为了可测试性和多个实现而创建接口
使用空白赋值进行编译时检查

练习题

设计一个 Notifier 接口，其中包含 Notify(msg string) error。为 EmailNotifier 和 SMSNotifier 实现该接口。编写一个向 []Notifier 发送通知的 broadcast 函数。

常见问题解答

「接口组合与最佳实践」课时是免费的吗？

是的 — 「接口组合与最佳实践」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Go Academy 课程的其余内容，请升级到 CoddyKit PRO。 Go Academy 课程共包含 4 节课。

「接口组合与最佳实践」这节课中我会学到什么？

小型接口与依赖倒置你通过在浏览器中直接运行的动手代码来练习 Go Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Go Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Go Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 4 节课，共 4 节。

「接口组合与最佳实践」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Go Academy 课中编写并运行代码吗？

能。每节 Go Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Go Academy