Interface 内部机制

Go 的 interface 是隐式实现的，没有 implements 关键字。理解其底层，能帮你写出更优雅的 Go 代码。

Interface 的两种内部表示

iface — 带方法的接口

// runtime/iface.go
type iface struct {
    tab  *itab          // 接口类型 + 具体类型信息
    data unsafe.Pointer // 指向具体数据的指针
}

type itab struct {
    inter *interfacetype // 接口类型描述
    _type *_type         // 具体类型描述
    hash  uint32         // 类型哈希，用于类型断言
    _     [4]byte
    fun   [1]uintptr     // 方法表（虚函数表）
}

eface — 空接口 interface{}

// runtime/iface.go
type eface struct {
    _type *_type         // 具体类型
    data  unsafe.Pointer // 数据指针
}

// 可视化理解
var r io.Reader = os.Stdin

// r 在内存中：
// ┌──────────────┬──────────────┐
// │  tab (itab)  │  data (ptr)  │
// │  *os.File    │  → os.Stdin  │
// │  io.Reader   │              │
// └──────────────┴──────────────┘

隐式实现

type Animal interface {
    Sound() string
    Name() string
}

// Dog 没有声明 "implements Animal"
// 只要实现了所有方法，就自动满足接口
type Dog struct{ name string }

func (d Dog) Sound() string { return "Woof" }
func (d Dog) Name() string  { return d.name }

type Cat struct{ name string }

func (c Cat) Sound() string { return "Meow" }
func (c Cat) Name() string  { return c.name }

func makeSound(a Animal) {
    fmt.Printf("%s says %s\n", a.Name(), a.Sound())
}

func main() {
    makeSound(Dog{name: "Rex"})
    makeSound(Cat{name: "Whiskers"})
}

接口组合

// 小接口组合成大接口（Go 的推荐风格）
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 ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

// io 包就是这样设计的
// os.File 实现了 ReadWriteCloser

类型断言与类型开关

var i interface{} = "hello"

// 类型断言
s, ok := i.(string)
if ok {
    fmt.Println(s)  // hello
}

// 不安全断言（类型不匹配会 panic）
s = i.(string)  // OK
n := i.(int)    // panic: interface conversion

// 类型开关
func describe(i interface{}) string {
    switch v := i.(type) {
    case int:
        return fmt.Sprintf("int: %d", v)
    case string:
        return fmt.Sprintf("string: %q", v)
    case bool:
        return fmt.Sprintf("bool: %v", v)
    case []int:
        return fmt.Sprintf("[]int len=%d", len(v))
    case nil:
        return "nil"
    default:
        return fmt.Sprintf("unknown: %T", v)
    }
}

接口与 nil 的陷阱

// 经典陷阱：接口不等于 nil
func getError() error {
    var p *MyError = nil  // 具体类型的 nil 指针
    return p              // 包装成 interface，不是 nil！
}

func main() {
    err := getError()
    if err != nil {  // true！即使 p 是 nil
        fmt.Println("有错误:", err)  // 会执行
    }
}

// 原因：interface 有两个字段（type, value）
// type = *MyError, value = nil
// 只有 type 和 value 都是 nil，interface 才是 nil

// 正确做法
func getErrorFixed() error {
    var p *MyError = nil
    if p == nil {
        return nil  // 直接返回 nil interface
    }
    return p
}

接口的性能

// 接口调用有额外开销：
// 1. 间接调用（通过 itab.fun 函数表）
// 2. 数据可能需要堆分配（逃逸）

// 基准测试对比
func BenchmarkDirect(b *testing.B) {
    d := Dog{name: "Rex"}
    for i := 0; i < b.N; i++ {
        _ = d.Sound()  // 直接调用，编译器可内联
    }
}

func BenchmarkInterface(b *testing.B) {
    var a Animal = Dog{name: "Rex"}
    for i := 0; i < b.N; i++ {
        _ = a.Sound()  // 接口调用，无法内联
    }
}
// 接口调用通常慢 2-5 倍，但绝对值很小（纳秒级）
// 大多数场景下接口的设计收益远大于性能损失

实用接口设计模式

接受接口，返回具体类型

// 好的设计：参数用接口（灵活），返回值用具体类型（明确）
func NewBufferedReader(r io.Reader) *bufio.Reader {
    return bufio.NewReader(r)
}

// 调用方可以传入任何实现了 io.Reader 的类型
r1 := NewBufferedReader(os.Stdin)
r2 := NewBufferedReader(strings.NewReader("hello"))
r3 := NewBufferedReader(bytes.NewBuffer(data))

小接口原则

// 不好：大而全的接口，难以实现和测试
type UserService interface {
    Create(user User) error
    Update(user User) error
    Delete(id int) error
    GetByID(id int) (User, error)
    List(page, size int) ([]User, error)
    Search(query string) ([]User, error)
    // ... 更多方法
}

// 好：按职责拆分小接口
type UserCreator interface {
    Create(user User) error
}

type UserReader interface {
    GetByID(id int) (User, error)
    List(page, size int) ([]User, error)
}

// 函数只依赖它需要的接口
func sendWelcomeEmail(creator UserCreator, user User) error {
    if err := creator.Create(user); err != nil {
        return err
    }
    return sendEmail(user.Email, "欢迎！")
}

Stringer 接口

// 实现 fmt.Stringer 接口，自定义打印格式
type Point struct{ X, Y float64 }

func (p Point) String() string {
    return fmt.Sprintf("(%.2f, %.2f)", p.X, p.Y)
}

p := Point{3.14, 2.71}
fmt.Println(p)        // (3.14, 2.71)
fmt.Printf("%v\n", p) // (3.14, 2.71)

error 接口

// error 就是一个接口
type error interface {
    Error() string
}

// 自定义错误类型
type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("验证失败: %s - %s", e.Field, e.Message)
}

// 使用 errors.As 提取具体错误类型
func process(data map[string]string) error {
    if data["name"] == "" {
        return &ValidationError{Field: "name", Message: "不能为空"}
    }
    return nil
}

err := process(map[string]string{})
var ve *ValidationError
if errors.As(err, &ve) {
    fmt.Println("字段:", ve.Field)
}

接口设计哲学

Go 的接口是鸭子类型（duck typing）的静态版本。设计接口时遵循：

1. 接口越小越好（io.Reader 只有一个方法）
2. 在使用方定义接口，而不是在实现方
3. 不要提前抽象，等到需要多态时再提取接口