Go 语言 interface从源码到使用实践指南

// 定义接口
type Writer interface {
   Write([]byte) (int, error)
}
// 某个类型只要实现了 Write 方法，就自动实现了 Writer 接口
type File struct{}
func (f File) Write(b []byte) (int, error) {
   // 具体实现
   return len(b), nil
}

// src/runtime/runtime2.go
type eface struct {
   _type *type  // 指向类型信息
   data  unsafe.Pointer  // 指向数据值
}

// src/runtime/runtime2.go
type iface struct {
   tab  *itab   // 接口表
   data unsafe.Pointer  // 指向数据值
}
// 接口表，存储接口与具体类型的匹配信息
type itab struct {
   inter *interfacetype  // 接口类型信息
   _type *type           // 具体类型信息
   link  *itab
   bad   int32
   inhash int32
   fun   [1]uintptr      // 方法表（函数指针）
}

var w Writer = File{}
// 底层会创建 iface 结构体，tab 指向包含 File 与 Writer 匹配信息的 itab，data 指向 File 实例

// 定义接口
type Reader interface {
   Read(p []byte) (n int, err error)
}
// 实现接口（隐式）
type StringReader struct {
   s string
   pos int
}
func (r *StringReader) Read(p []byte) (n int, err error) {
   if r.pos >= len(r.s) {
       return 0, io.EOF
   }
   n = copy(p, r.s[r.pos:])
   r.pos += n
   return n, nil
}

type ReadWriter interface {
   Reader  // 嵌入 Reader 接口
   Writer  // 嵌入 Writer 接口
}
// 等价于：
// type ReadWriter interface {
//     Read(p []byte) (n int, err error)
//     Write(p []byte) (n int, err error)
// }

var i interface{} = "hello"
// 基本用法
s, ok := i.(string)
if ok {
   fmt.Println("字符串值：", s)
}
// 错误用法（当断言失败时会 panic）
s = i.(int)  // panic: interface conversion: interface {} is string, not int

func printType(i interface{}) {
   switch v := i.(type) {
   case int:
       fmt.Println("int 类型，值为：", v)
   case string:
       fmt.Println("string 类型，值为：", v)
   case bool:
       fmt.Println("bool 类型，值为：", v)
   default:
       fmt.Println("未知类型")
   }
}

// 推荐：小接口
type Reader interface { Read() }
type Writer interface { Write() }
// 不推荐：大而全的接口
type Everything interface {
   Read()
   Write()
   Delete()
   Update()
   // ... 过多方法
}

// 推荐：依赖接口
func SaveData(w Writer, data []byte) error {
   _, err := w.Write(data)
   return err
}
// 不推荐：依赖具体类型
func SaveData(f *File, data []byte) error {  // 只能接收 File 类型
   _, err := f.Write(data)
   return err
}

// 合理使用：通用容器
type Cache struct {
   data map[string]interface{}  // 存储任意类型的值
}
// 不推荐：无必要的空接口
func Add(a, b interface{}) interface{} {  // 丢失类型检查，需在内部做大量类型断言
   // ...
}

// 定义接口
type APIClient interface {
   Get(url string) (string, error)
}
// 真实实现
type HTTPClient struct{}
func (c HTTPClient) Get(url string) (string, error) { /* 真实 HTTP 请求 */ }
// Mock 实现（用于测试）
type MockClient struct {
   mockResponse string
   mockError    error
}
func (m MockClient) Get(url string) (string, error) {
   return m.mockResponse, m.mockError
}
// 业务逻辑（依赖接口）
func FetchData(client APIClient, url string) (string, error) {
   return client.Get(url)
}
// 测试时使用 MockClient，无需真实网络请求

// 不推荐：多层嵌套
type A interface { M1() }
type B interface { A; M2() }
type C interface { B; M3() }
type D interface { C; M4() }

func main() {
   var err error  // err 是 nil 接口（类型和值都是 nil）
   fmt.Println(err == nil)  // true
   var f *os.File = nil  // f 是 nil 指针
   err = f  // 此时 err 的类型是 *os.File，值是 nil
   fmt.Println(err == nil)  // false！（类型非 nil）
}

type Fooer interface { Foo() }
type Bar struct{}
// 值接收者实现接口
func (b Bar) Foo() {}
var b Bar
var pb *Bar = &b
var f Fooer
f = b    // 合法
f = pb   // 合法（指针会自动解引用）
// 指针接收者实现接口
func (b *Bar) Foo() {}
f = b    // 不合法！编译错误
f = pb   // 合法

type I interface { M() }
type T struct{}
var t T
var i I = t  // 编译错误：T 未实现 I.M()

// 不推荐：不必要的接口
type User struct{}
type UserInterface interface {
   GetID() int
}
func (u User) GetID() int { return 1 }
// 直接使用 User 即可，无需额外定义接口

type I interface {
   Do(int) error
}
type T struct{}
// 方法签名不匹配（返回值不同）
func (t T) Do(n int) string {  // 未实现 I 接口
   return "done"
}

// 定义日志接口
type Logger interface {
   Log(message string)
}
// 控制台日志实现
type ConsoleLogger struct{}
func (c ConsoleLogger) Log(message string) {
   fmt.Println("日志：", message)
}
// 文件日志实现
type FileLogger struct {
   filename string
}
func (f FileLogger) Log(message string) {
   // 写入文件...
}
// 业务代码依赖接口
func Process(logger Logger) {
   logger.Log("处理开始")
   // 业务逻辑...
   logger.Log("处理结束")
}
// 使用时可灵活切换实现
func main() {
   Process(ConsoleLogger{})
   Process(FileLogger{filename: "app.log"})
}

// 不推荐：过度使用空接口导致类型不安全
func Calculate(a, b interface{}) interface{} {
   switch a.(type) {
   case int:
       return a.(int) + b.(int)  // 若 b 不是 int 会 panic
   case float64:
       return a.(float64) + b.(float64)
   default:
       return nil
   }
}
// 调用时缺乏类型检查
result := Calculate(10, "20")  // panic！