跳到主要内容

接口隔离原则(ISP)

1. 概述​

接口隔离原则(Interface Segregation Principle, ISP) 是SOLID原则中的第四个原则，由Robert C. Martin提出。其核心思想是：

客户端不应该被迫依赖它们不使用的接口。换句话说，多个特定的小接口比一个通用的大接口更好。

在Go语言中，这一原则尤为重要，因为Go的接口是隐式实现的，且鼓励小而专注的设计。

2. 核心概念​

  • 小而专注：接口应该只包含客户端真正需要的方法
  • 避免"胖接口"：不要让接口承担过多职责
  • 按需实现：客户端应该只依赖它们实际使用的接口

3. Go语言中的ISP实现方式​

3.1 违反ISP的例子​

// 一个"胖接口"包含太多方法
type Animal interface {
    Eat()
    Sleep()
    Fly()   // 不是所有动物都会飞
    Swim()  // 不是所有动物都会游泳
    Bark()  // 不是所有动物都会叫
}

// 实现这个接口很困难
type Dog struct{}

func (d Dog) Eat()   { fmt.Println("Dog eating") }
func (d Dog) Sleep() { fmt.Println("Dog sleeping") }
func (d Dog) Bark()  { fmt.Println("Dog barking") }
func (d Dog) Fly()   {} // 狗不会飞，但被迫实现
func (d Dog) Swim()  {} // 有些狗会游泳，有些不会

问题：Dog被迫实现它不需要的方法(Fly)

3.2 遵循ISP的改进方案​

// 拆分为多个小接口
type Eater interface {
    Eat()
}

type Sleeper interface {
    Sleep()
}

type Flyer interface {
    Fly()
}

type Swimmer interface {
    Swim()
}

type Barker interface {
    Bark()
}

// Dog只需要实现相关接口
type Dog struct{}

func (d Dog) Eat()   { fmt.Println("Dog eating") }
func (d Dog) Sleep() { fmt.Println("Dog sleeping") }
func (d Dog) Bark()  { fmt.Println("Dog barking") }

// 可以按需组合
type AquaticDog struct {
    Dog
}

func (a AquaticDog) Swim() { fmt.Println("Dog swimming") }

4. Go语言中实践ISP的技巧​

4.1 使用接口组合​

type Animal interface {
    Eater
    Sleeper
}

type Bird interface {
    Animal
    Flyer
}

type Fish interface {
    Animal
    Swimmer
}

4.2 客户端特定接口​

// 在需要的地方定义接口
func Feed(e Eater) {
    e.Eat()
}

func PutToSleep(s Sleeper) {
    s.Sleep()
}

4.3 避免接口污染​

// 不好的设计
type FileHandler interface {
    Open()
    Close()
    Read()
    Write()
    Delete()
    Archive() // 不是所有处理器都需要归档
}

// 好的设计
type FileOperator interface {
    Open()
    Close()
}

type FileReader interface {
    FileOperator
    Read()
}

type FileWriter interface {
    FileOperator
    Write()
}

type FileManager interface {
    FileReader
    FileWriter
    Delete()
}

5. 实际应用案例​

5.1 数据库访问层​

type Reader interface {
    Get(id string) (Item, error)
    List() ([]Item, error)
}

type Writer interface {
    Create(item Item) error
    Update(item Item) error
    Delete(id string) error
}

// 只读客户端
func NewReadOnlyClient(r Reader) *ReadOnlyClient {
    return &ReadOnlyClient{reader: r}
}

// 读写客户端
func NewReadWriteClient(rw interface {
    Reader
    Writer
}) *ReadWriteClient {
    return &ReadWriteClient{readerWriter: rw}
}

5.2 HTTP中间件​

type RequestLogger interface {
    LogRequest(r *http.Request)
}

type ResponseLogger interface {
    LogResponse(w http.ResponseWriter)
}

// 只需要请求日志的中间件
func WithRequestLogging(l RequestLogger) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            l.LogRequest(r)
            next.ServeHTTP(w, r)
        })
    }
}

6. 违反ISP的后果​

  1. 不必要的实现负担：类型被迫实现它们不需要的方法
  2. 脆弱的代码：接口变更会影响太多客户端
  3. 难以测试：需要模拟不相关的方法
  4. 低内聚性：接口包含不相关的方法

7. 总结​

  • ISP鼓励小而专注的接口设计
  • 客户端不应该被迫依赖它们不使用的方法
  • Go语言的隐式接口机制天然支持ISP
  • 使用接口组合构建更复杂的抽象
  • 按需定义接口，而不是预先创建大接口

好的接口设计应该像Unix工具一样 - 每个工具只做一件事，但做得很好。