接口组合：Go 的设计哲学
在学习 Go 的过程中，你可能会发现一个有趣的现象：Go 标准库中的接口都非常小。io.Reader 只有一个方法，io.Writer 也只有一个方法，fmt.Stringer 同样只有一个方法。
这并非巧合，而是 Go 语言的核心设计哲学：小接口，大组合。
为什么接口要小？
在 Java 或 C# 等语言中，我们习惯定义大而全的接口，比如一个 UserService 接口可能包含十几个方法。但在 Go 中，这种做法被认为是反模式。
让我们看看 Go 标准库是怎么做的：
// 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
}
看到了吗？Go 没有定义一个包含所有方法的大接口，而是定义了多个小接口，然后通过组合来创建更复杂的接口。
接口组合的优势
1. 灵活性
小接口让你的代码更加灵活。假设你有一个函数需要写入数据：
// 不好的设计：要求太多
func SaveData(w *os.File, data []byte) error {
_, err := w.Write(data)
return err
}
// 好的设计：只要求必要的接口
func SaveData(w io.Writer, data []byte) error {
_, err := w.Write(data)
return err
}
第二种设计可以接受任何实现了 io.Writer 的类型：文件、网络连接、内存缓冲区、HTTP 响应等。而第一种设计只能接受文件。
2. 可测试性
小接口让单元测试变得简单：
// 定义业务逻辑需要的接口
type UserRepository interface {
FindByID(id int) (*User, error)
Save(user *User) error
}
// 业务逻辑只依赖接口
type UserService struct {
repo UserRepository
}
func (s *UserService) GetUser(id int) (*User, error) {
return s.repo.FindByID(id)
}
// 测试时可以轻松创建 mock
type MockUserRepository struct {
users map[int]*User
}
func (m *MockUserRepository) FindByID(id int) (*User, error) {
user, ok := m.users[id]
if !ok {
return nil, errors.New("user not found")
}
return user, nil
}
func (m *MockUserRepository) Save(user *User) error {
m.users[user.ID] = user
return nil
}
func TestUserService(t *testing.T) {
mockRepo := &MockUserRepository{
users: map[int]*User{
1: {ID: 1, Name: "Alice"},
},
}
service := &UserService{repo: mockRepo}
user, err := service.GetUser(1)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if user.Name != "Alice" {
t.Errorf("expected Alice, got %s", user.Name)
}
}
如果接口包含几十个方法，创建 mock 就会变得非常繁琐。
3. 符合接口隔离原则
接口隔离原则（ISP）指出：客户端不应该依赖它不需要的接口。
// 不好的设计：一个大接口
type Worker interface {
Work()
Eat()
Sleep()
}
// 机器人只能工作，不需要吃饭和睡觉
type Robot struct{}
func (r *Robot) Work() {
fmt.Println("Robot is working")
}
// 被迫实现不需要的方法
func (r *Robot) Eat() {
panic("robots don't eat")
}
func (r *Robot) Sleep() {
panic("robots don't sleep")
}
// 好的设计：多个小接口
type Workable interface {
Work()
}
type Feedable interface {
Eat()
}
type Sleepable interface {
Sleep()
}
// 人类实现所有接口
type Human struct{}
func (h *Human) Work() { fmt.Println("Human is working") }
func (h *Human) Eat() { fmt.Println("Human is eating") }
func (h *Human) Sleep() { fmt.Println("Human is sleeping") }
// 机器人只实现需要的接口
type Robot struct{}
func (r *Robot) Work() { fmt.Println("Robot is working") }
// 函数只依赖需要的接口
func StartWork(w Workable) {
w.Work()
}
func main() {
human := &Human{}
robot := &Robot{}
StartWork(human) // 可以
StartWork(robot) // 也可以
}
实战：构建一个灵活的日志系统
让我们用接口组合来构建一个灵活的日志系统：
package main
import (
"fmt"
"io"
"os"
"time"
)
// 基础接口
type Logger interface {
Log(level string, message string)
}
// 扩展接口
type LevelLogger interface {
Logger
Debug(message string)
Info(message string)
Warn(message string)
Error(message string)
}
// 带上下文的日志接口
type ContextLogger interface {
LevelLogger
WithField(key string, value interface{}) ContextLogger
}
// 基础日志实现
type BasicLogger struct {
output io.Writer
}
func NewBasicLogger(w io.Writer) *BasicLogger {
return &BasicLogger{output: w}
}
func (l *BasicLogger) Log(level string, message string) {
timestamp := time.Now().Format("2006-01-02 15:04:05")
fmt.Fprintf(l.output, "[%s] %s: %s\n", timestamp, level, message)
}
func (l *BasicLogger) Debug(message string) { l.Log("DEBUG", message) }
func (l *BasicLogger) Info(message string) { l.Log("INFO", message) }
func (l *BasicLogger) Warn(message string) { l.Log("WARN", message) }
func (l *BasicLogger) Error(message string) { l.Log("ERROR", message) }
// 带上下文的日志实现
type ContextLoggerImpl struct {
*BasicLogger
fields map[string]interface{}
}
func NewContextLogger(w io.Writer) *ContextLoggerImpl {
return &ContextLoggerImpl{
BasicLogger: NewBasicLogger(w),
fields: make(map[string]interface{}),
}
}
func (l *ContextLoggerImpl) Log(level string, message string) {
timestamp := time.Now().Format("2006-01-02 15:04:05")
fmt.Fprintf(l.output, "[%s] %s: %s %v\n", timestamp, level, message, l.fields)
}
func (l *ContextLoggerImpl) WithField(key string, value interface{}) ContextLogger {
newFields := make(map[string]interface{})
for k, v := range l.fields {
newFields[k] = v
}
newFields[key] = value
return &ContextLoggerImpl{
BasicLogger: l.BasicLogger,
fields: newFields,
}
}
// 使用示例
func processOrder(logger ContextLogger, orderID int) {
// 添加上下文
orderLogger := logger.WithField("order_id", orderID)
orderLogger.Info("Processing order")
// 模拟处理逻辑
if orderID == 999 {
orderLogger.Error("Invalid order")
return
}
orderLogger.Info("Order processed successfully")
}
func main() {
// 使用基础日志
basicLogger := NewBasicLogger(os.Stdout)
basicLogger.Info("Application started")
// 使用上下文日志
contextLogger := NewContextLogger(os.Stdout)
processOrder(contextLogger, 123)
processOrder(contextLogger, 999)
}
接口组合的最佳实践
1. 接受接口，返回结构体
// 好：接受接口，返回具体类型
func NewUserService(repo UserRepository) *UserService {
return &UserService{repo: repo}
}
// 不好：接受和返回都是接口
func NewUserService(repo UserRepository) UserService {
return &UserService{repo: repo}
}
返回具体类型让调用者可以使用结构体的所有方法，而不仅仅是接口定义的方法。
2. 在使用的地方定义接口
// 在 consumer 包中定义接口
package consumer
type DataFetcher interface {
Fetch(id string) ([]byte, error)
}
type Consumer struct {
fetcher DataFetcher
}
func (c *Consumer) Process(id string) error {
data, err := c.fetcher.Fetch(id)
if err != nil {
return err
}
// 处理数据
return nil
}
// 在 provider 包中实现接口
package provider
type HTTPFetcher struct{}
func (f *HTTPFetcher) Fetch(id string) ([]byte, error) {
// HTTP 请求逻辑
return nil, nil
}
这样做的好处是，即使 provider 包的接口发生变化，只要满足 consumer 包定义的小接口，代码仍然可以工作。
3. 避免创建不需要的接口
// 不好：只有一个实现，却创建了接口
type Calculator interface {
Add(a, b int) int
}
type SimpleCalculator struct{}
func (c *SimpleCalculator) Add(a, b int) int {
return a + b
}
// 好：直接使用具体类型
type Calculator struct{}
func (c *Calculator) Add(a, b int) int {
return a + b
}
// 只有在需要多态或测试时才创建接口
记住：不要预测需求，而是在需要时重构。
总结
Go 的接口组合体现了 Unix 哲学：做一件事，做好它。通过定义小接口并组合它们，我们可以构建出灵活、可测试、易维护的系统。
关键要点：
- 接口应该小而专注，最好只有一个方法
- 通过组合小接口来创建更复杂的接口
- 接受接口，返回结构体
- 在使用接口的地方定义接口
- 不要为了接口而接口
下次当你想要定义一个大接口时，停下来想一想：它能不能拆分成几个小接口？你会发现，答案几乎总是"能"。
继续阅读
探索更多技术文章
浏览归档，发现更多关于系统设计、工具链和工程实践的内容。