深入理解Go语言接口：以io.ReadCloser为例解析接口嵌入与使用

type Reader interface {
    Read(p []byte) (n int, err error)
}

type ReadCloser interface {
    Reader
    Closer
}

type Response struct {
    // ... 其他字段
    Body io.ReadCloser // The response body.
    // ... 其他字段
}

package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
)

func main() {
    resp, err := http.Get("http://example.com")
    if err != nil {
        fmt.Printf("Error making request: %v\n", err)
        return
    }
    // 确保在函数结束时关闭响应体，释放资源
    defer resp.Body.Close()

    // 正确的读取方式：直接在resp.Body上调用Read方法
    // resp.Body本身就是一个io.Reader
    bodyBytes, err := io.ReadAll(resp.Body) // io.ReadAll 接受一个 io.Reader
    if err != nil {
        fmt.Printf("Error reading response body: %v\n", err)
        return
    }

    fmt.Println("Response Body:")
    fmt.Println(string(bodyBytes))

    // 尝试错误的使用方式 (会导致编译错误)
    // line, _ , err := resp.Body.Reader.ReadLine() // 错误: resp.Body没有Reader字段
    // fmt.Println(line)
}

package main

import (
    "bytes"
    "fmt"
    "io"
)

// MyReadCloser 实现了 io.ReadCloser 接口
type MyReadCloser struct {
    buffer *bytes.Buffer
    closed bool
}

// NewMyReadCloser 创建一个新的 MyReadCloser 实例
func NewMyReadCloser(data string) *MyReadCloser {
    return &MyReadCloser{
        buffer: bytes.NewBufferString(data),
        closed: false,
    }
}

// Read 方法实现了 io.Reader 接口
func (mrc *MyReadCloser) Read(p []byte) (n int, err error) {
    if mrc.closed {
        return 0, fmt.Errorf("read from closed MyReadCloser")
    }
    return mrc.buffer.Read(p)
}

// Close 方法实现了 io.Closer 接口
func (mrc *MyReadCloser) Close() error {
    if mrc.closed {
        return fmt.Errorf("MyReadCloser already closed")
    }
    mrc.closed = true
    fmt.Println("MyReadCloser closed.")
    return nil
}

func main() {
    // 创建一个自定义的 ReadCloser 实例
    myRC := NewMyReadCloser("Hello, Go Interfaces!")

    // 声明一个 io.ReadCloser 类型的变量，并赋值为 myRC
    // 因为 MyReadCloser 实现了 io.ReadCloser 的所有方法
    var rc io.ReadCloser = myRC

    // 现在可以直接在 rc 上调用 Read 和 Close 方法
    data, err := io.ReadAll(rc) // 使用 io.ReadAll 读取数据
    if err != nil {
        fmt.Printf("Error reading: %v\n", err)
        return
    }
    fmt.Printf("Read data: %s\n", string(data))

    err = rc.Close() // 调用 Close 方法
    if err != nil {
        fmt.Printf("Error closing: %v\n", err)
    }

    // 再次尝试读取或关闭，会报错
    _, err = io.ReadAll(rc)
    if err != nil {
        fmt.Printf("Attempt to read after close: %v\n", err)
    }
    err = rc.Close()
    if err != nil {
        fmt.Printf("Attempt to close after close: %v\n", err)
    }
}