Golang io.Reader与io.Writer使用详解

io.Reader和io.Writer是Go语言中处理I/O的核心接口，分别定义了Read(p []byte) (n int, err error)和Write(p []byte) (n int, err error)方法，实现它们的类型可统一进行数据读写操作。通过接口抽象，Go程序能以一致方式处理文件、网络、内存等不同来源的数据。典型应用场景包括使用os.File进行文件复制、利用io.Copy简化读写流程、通过http.Response.Body读取网络数据以及在函数间传递io.Reader实现解耦。借助bufio可提升性能，io.MultiWriter支持多目标写入，io.LimitReader限制读取长度，还可自定义类型实现Reader或Writer接口以满足特殊需求。掌握这些机制有助于编写高效、通用的I/O代码。

在Go语言中，io.Reader 和 io.Writer 是处理数据输入输出的核心接口。它们不关心数据来源或目的地，只关注“读”和“写”的行为，这种抽象让代码更加灵活、可复用。掌握这两个接口的使用，是编写高效、通用Go程序的关键。

理解 io.Reader 与 io.Writer 接口

Go标准库中的 io.Reader 和 io.Writer 定义非常简洁：

io.Reader 的定义是：

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

它从数据源读取数据到字节切片 p 中，返回读取的字节数 n 和可能的错误。当读取到数据末尾时，通常返回 io.EOF。

io.Writer 的定义是：

type Writer interface {
    Write(p []byte) (n int, err error)
}

它将字节切片 p 中的数据写入目标，返回成功写入的字节数和错误。

只要一个类型实现了这两个方法，就可以作为 Reader 或 Writer 使用。比如 *os.File、*bytes.Buffer、http.ResponseWriter 都实现了这些接口。

常见使用场景与实践示例

通过具体例子理解如何在实际开发中使用这两个接口。

1. 从文件读取并写入另一个文件

file, _ := os.Open("input.txt")
defer file.Close()

dest, _ := os.Create("output.txt")
defer dest.Close()

buffer := make([]byte, 1024)
for {
    n, err := file.Read(buffer)
    if n > 0 {
        dest.Write(buffer[:n])
    }
    if err == io.EOF {
        break
    }
    if err != nil {
        log.Fatal(err)
    }
}

这是最基础的读写循环。但更推荐使用 io.Copy 简化操作。

2. 使用 io.Copy 提升效率

file, _ := os.Open("input.txt")
defer file.Close()

dest, _ := os.Create("output.txt")
defer dest.Close()

_, err := io.Copy(dest, file)
if err != nil {
    log.Fatal(err)
}

io.Copy(dst Writer, src Reader) 自动处理缓冲和循环，代码更简洁且性能更好。

3. 处理网络响应体

resp, _ := http.Get("https://example.com/data")
defer resp.Body.Close()

var buf bytes.Buffer
_, err := io.Copy(&buf, resp.Body)
if err != nil {
    log.Fatal(err)
}
fmt.Println(buf.String())

这里 resp.Body 是 io.ReadCloser（实现了 Reader），bytes.Buffer 实现了 Writer，可以直接传给 io.Copy。

4. 在函数间传递 Reader/Writer 实现解耦

func process(r io.Reader) error {
    scanner := bufio.NewScanner(r)
    for scanner.Scan() {
        fmt.Println("Line:", scanner.Text())
    }
    return scanner.Err()
}

这个函数可以接受文件、字符串、网络流等任何实现 io.Reader 的类型：

// 从字符串读
reader := strings.NewReader("line1\nline2")
process(reader)

// 从文件读
file, _ := os.Open("data.txt")
process(file)

组合与转换：增强数据处理能力

Go提供了多种工具来增强 Reader 和 Writer 的能力。

1. 使用 bufio 添加缓冲

直接调用 Read/Write 可能频繁进行系统调用。使用 bufio.Reader 和 bufio.Writer 可减少开销：

w := bufio.NewWriter(destFile)
w.WriteString("hello")
w.WriteString("world")
w.Flush() // 别忘了刷新

2. 多个 Writer 同时写入（io.MultiWriter）

w1 := &bytes.Buffer{}
w2, _ := os.Create("log.txt")
mw := io.MultiWriter(w1, w2)
fmt.Fprintf(mw, "Log message") // 同时写入 buffer 和文件

3. 限制读取长度（io.LimitReader）

limited := io.LimitReader(reader, 100) // 最多读100字节
io.Copy(os.Stdout, limited)

自定义 Reader 和 Writer

你可以创建自己的类型来实现这些接口。例如，一个生成重复字符的 Writer：

type CharWriter struct {
    ch byte
}

func (w *CharWriter) Write(p []byte) (int, error) {
    for i := range p {
        p[i] = w.ch
    }
    return len(p), nil
}

// 使用
writer := &CharWriter{ch: 'A'}
buffer := make([]byte, 5)
writer.Write(buffer)
fmt.Printf("%s\n", buffer) // 输出 AAAAA

或者一个不断返回固定数据的 Reader：

type CycleReader struct {
    data   []byte
    index  int
}

func (r *CycleReader) Read(p []byte) (int, error) {
    for i := range p {
        p[i] = r.data[r.index]
        r.index = (r.index + 1) % len(r.data)
    }
    return len(p), nil
}

基本上就这些。熟练运用 io.Reader 和 io.Writer 能让你写出更通用、更简洁的IO代码。关键是理解它们的抽象意义：不关心数据在哪，只关心能不能读和写。配合 io.Copy、bufio 等工具，大多数IO任务都能优雅解决。