Golang 中的 io 包详解（二）：组合接口

Golang 中，接口可以通过嵌入多个其他接口组成组合接口。组合接口表示的是子接口的集合，具有所有子接口的方法，可以通过组合多个不同的接口组成一个更强大的抽象。本文主要介绍下 io 包中的组合接口。

io.ReadWriter

// ReadWriter is the interface that groups the basic Read and Write methods.
type ReadWriter interface {
	Reader
	Writer
}

是对Reader和Writer接口的组合，聚合了基本的读写操作。简单示例如下：

package main

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

func main() {
	var buf bytes.Buffer
	rw := io.ReadWriter(&buf)

	// 写入数据
	_, err := rw.Write([]byte("hello world"))
	if err != nil {
		panic(err)
	}

	// 读取数据
	var data = make([]byte, 11)
	_, err = rw.Read(data)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(data))
}

io.ReadCloser

// ReadCloser is the interface that groups the basic Read and Close methods.
type ReadCloser interface {
	Reader
	Closer
}

是对Reader和Closer接口的组合，聚合了基本的读操作和关闭操作。使用 ReadCloser 接口时，一般会通过 NewReader 或其它方式获取一个 io.ReadCloser 对象，然后通过 Read 方法不断读取数据，直到数据读取结束，最后通过 Close 方法释放资源。

io.WriteCloser

// WriteCloser is the interface that groups the basic Write and Close methods.
type WriteCloser interface {
	Writer
	Closer
}

是对Writer和Closer接口的组合，聚合了基本的写操作和关闭操作。使用 WriteCloser 接口时，一般会通过 NewWriter 或其它方式获取一个 io.WriteCloser 对象，然后通过 Write 方法不断写入数据，直到数据写入结束，最后通过 Close 方法释放资源。简单示例如下：

package main

import (
	"bufio"
	"compress/gzip"
	"os"
)

func main() {
	f, err := os.Create("test.gz")
	if err != nil {
		panic(err)
	}
	defer f.Close()

	// 通过 gzip.NewWriter 方法创建一个 io.WriteCloser 对象
	// 用于将数据压缩并写入文件中
	w := gzip.NewWriter(f)
	defer w.Close()

	// 将数据写入到 io.WriteCloser 对象中
	writer := bufio.NewWriter(w)
	_, err = writer.WriteString("hello world")
	if err != nil {
		panic(err)
	}

	writer.Flush()
}

首先通过 os.Create 方法创建一个文件对象 f，然后通过 gzip.NewWriter 方法创建一个 io.WriteCloser 对象 w，该对象将数据写入到 f 中，并对数据进行压缩。接着通过 bufio.NewWriter 方法创建一个 bufio.Writer 对象 writer，该对象将数据写入到 io.WriteCloser 对象中。最后调用 writer.Flush 方法将缓冲区中的数据写入到 io.WriteCloser 对象中，然后释放资源。

io.ReadWriteCloser

// ReadWriteCloser is the interface that groups the basic Read, Write and Close methods.
type ReadWriteCloser interface {
	Reader
	Writer
	Closer
}

是对 Reader、Writer 和 Closer 接口的组合，聚合了基本的读写操作和关闭操作。使用 ReadWriteCloser 接口时，可以通过 Read 方法从数据源读取数据，通过 Write 方法写入数据到数据接收器中，最后通过 Close 方法释放资源。

io.ReadSeeker

// ReadSeeker is the interface that groups the basic Read and Seek methods.
type ReadSeeker interface {
	Reader
	Seeker
}

是对 Reader 和 Seeker 接口的组合，聚合了基本的读取和移位操作。使用 ReadSeeker 接口时，可以通过 Read 方法从数据源读取数据，通过 Seek 方法在数据源中定位读取位置，然后再通过 Read 方法继续读取数据。简单示例：

package main

import (
	"fmt"
	"io"
	"strings"
)

func main() {
	s := strings.NewReader("0123456789")
	rs := io.ReadSeeker(s)

	// 读取前 4 个字节
	var data = make([]byte, 4)
	_, err := rs.Read(data)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data))

	// 定位到第 6 个字节
	offset, err := rs.Seek(2, io.SeekCurrent)
	if err != nil {
		panic(err)
	}
	fmt.Printf("current offset:%d\n", offset)

	// 读取后 5 个字节
	data = make([]byte, 5)
	_, err = rs.Read(data)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data))
}

io.ReadSeekCloser

// ReadSeekCloser is the interface that groups the basic Read, Seek and Close
// methods.
type ReadSeekCloser interface {
	Reader
	Seeker
	Closer
}

是对 Reader、Seeker 和 Closer 接口的组合，聚合了基本的读操作、移位操作和关闭操作。使用 ReadSeekCloser 接口时，可以通过 Read 方法从数据源读取数据，通过 Seek 方法在数据源中定位读取位置，最后通过 Close 方法释放资源。

io.WriteSeeker

// WriteSeeker is the interface that groups the basic Write and Seek methods.
type WriteSeeker interface {
	Writer
	Seeker
}

是对 Writer 和 Seeker 接口的组合，聚合了基本的写操作和移位操作。

io.ReadWriteSeeker

// ReadWriteSeeker is the interface that groups the basic Read, Write and Seek methods.
type ReadWriteSeeker interface {
	Reader
	Writer
	Seeker
}

是对 Reader、Writer 和 Seeker 接口的组合，聚合了基本的读写操作和移位操作。