Go编程技巧--io.Reader/Writer

Go原生的pkg中有一些核心的interface，其中io.Reader/Writer是比较常用的接口。很多原生的结构都围绕这个系列的接口展开，在实际的开发过程中，你会发现通过这个接口可以在多种不同的io类型之间进行过渡和转化。本文结合实际场景来总结一番。

总览

围绕io.Reader/Writer，有几个常用的实现：

• net.Conn, os.Stdin, os.File: 网络、标准输入输出、文件的流读取
• strings.Reader: 把字符串抽象成Reader
• bytes.Reader: 把[]byte抽象成Reader
• bytes.Buffer: 把[]byte抽象成Reader和Writer
• bufio.Reader/Writer: 抽象成带缓冲的流读取（比如按行读写）

这些实现对于初学者来说其实比较难去记忆，在遇到实际问题的时候更是一脸蒙圈，不知如何是好。下面用实际的场景来举例

什么是 io.Reader

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

• Reader 接口仅有一个 Read 方法，所以只要实现了Read(p []byte) (n int, err
  error)方法的类型，我们就认为其类型就是 Reader。
• Read 方法会把读取的数据复制到 p 中 ，一次只能读取最高不超过 len(p) 的数据，并不保证一定会读满整个 p，读取的数据量返回到
  n，并在读完的时候返回 io.EOF 到 err。
• Read 方法可以从不同来源读取数据，这个来源可能是文件、网络传输的数据或者普通的字符串，io.Reader
  接口不关心数据从哪里来，只要实现了 Read 方法，就能从来源处读数据。

标准库中的 io.Reader

在 go 标准库中，是有一些实现 io.Reader 接口的类型，这些也是 io.Reader 读数据的不同来源，下面列举下：

读文件时，通过 os.Open 打开一个文件，os.Open 会返回一个 Reader

var r io.Reader
var err error
r, err = os.Open("file.txt")

一个普通的字符串可通过 strings.NewReader 初始化一个 Reader

var r io.Reader
r = strings.NewReader("Read will return these bytes")

在网络传输中，http.Request 的 body 类型也是一个 Reader

var r io.Reader
req := http.Request{}
r = req.Body

bytes.Buffer 也是一个 Reader

var r io.Reader
var buf bytes.Buffer
r = &buf

如何使用 io.Reader

通过编写如下程序，使用 File.Read 的方法进行读取。

package main

import (
	"io"
	"log"
	"os"
)

func main() {
	file, err := os.Open("./book.txt")
	if err != nil {
		panic(err)
	}
	defer file.Close()
	bytesRead := make([]byte, 4)
	for {
		n, err := file.Read(bytesRead)
		// 读到文件的结尾，err 是 io.EOF
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatalf("error reading from book.txt: %v", err)
			break
		}
		if n > 0 {
			log.Printf("We read \"%s\" into bytesRead (%d bytes)",
				string(bytesRead[:n]), n)
		}
	}
}

结果

2022/07/10 12:04:22 We read "this" into bytesRead (4 bytes)
2022/07/10 12:04:22 We read " is " into bytesRead (4 bytes)
2022/07/10 12:04:22 We read "a bo" into bytesRead (4 bytes)
2022/07/10 12:04:22 We read "ok.
" into bytesRead (4 bytes)

上面已说过 io.reader 接口的本质是从不同的源读取数据，而这里的来源是文件，程序中的 file 变量是实现了 Read 方法的 Reader 类型，所以可以调用 Read 方法从文件中读数据，然后 copy 到 bytesRead 中。
可能不少小伙伴对最后 string(bytesRead[:n]) 的 re-slice 有些疑惑，这里如果不 re-slice下，打印的结果是不对的；因为 bytesRead 会保存上一次调用的读取的结果，感兴趣的小伙伴可以实践下～

版本一在日常的开发中我们基本不用，因为太繁琐，我们可以使用的 io.ReadAll 方法简化代码，感兴趣的小伙伴可以看下 io.ReadAll 源码，本质是把版本一的for循环封装了下。

package main

import (
   "io"
   "log"
   "os"
)

func main() {
   file, err := os.Open("./book.txt")
   if err != nil {
      panic(err)
   }
   defer file.Close()
   bytesRead, err := io.ReadAll(file)
   if err != nil {
      log.Fatalf("error reading from book.txt: %v", err)
   }
   log.Printf("We read "%s" into bytesRead (%d bytes)",
      string(bytesRead), len(bytesRead))
}

结果

2022/07/10 12:42:41 We read "this is a book.
" into bytesRead (16 bytes)

使用 os.ReadFile 在上一次基础上再次封装下，把 os.Open 也封装在内，这个方法是最常用的，因为足够简单。

package main

import (
   "log"
   "os"
)

func main() {
   bytesRead, err := os.ReadFile("./book.txt")
   if err != nil {
      return
   }
   log.Printf("We read "%s" into bytesRead (%d bytes)",
      string(bytesRead), len(bytesRead))
}

从字符串中初始化 io.Reader

从字符串(源)中读数据，然后 copy 到 buf 中。

package main

import (
    "io"
    "log"
    "strings"
)

func main() {
    s := strings.NewReader("this is a book.")
    buf := make([]byte, 5)
    for {
        n, err := s.Read(buf)
        if err == io.EOF {
            break
        }
        if err != nil {
            log.Fatalf("error reading from book.txt: %v", err)
            break
        }

        if n > 0 {
            log.Printf("We read \"%s\" into bytesRead (%d bytes)",
                string(buf[:n]), len(buf))
        }
    }
}

结果

2022/07/10 13:03:32 We read "this " into bytesRead (5 bytes)
2022/07/10 13:03:32 We read "is a " into bytesRead (5 bytes)
2022/07/10 13:03:32 We read "book." into bytesRead (5 bytes)

其实本质和读文件类似，也可以使用 os.ReadAll(s) 简化下程序，这里不再赘述。

另一个使用比较广泛是反序列化一些json数据，比如我们有个json数据，想反序列化到结构体中，通过如下代码可以操作成功。

package main

import (
   "encoding/json"
   "log"
   "strings"
)

type Student struct {
   Name string `json:"name"`
   Sex  string `json:"sex"`
}

func main() {
   jsonData := `
            {
                "name":"zhangsan",
                "sex":"boy"
            }`

   rdr := strings.NewReader(jsonData)

   var s Student
   if err := json.NewDecoder(rdr).Decode(&s); err != nil {
      log.Fatalf("error deserializing JSON: %v", err)
      return
   }

   log.Printf("Hi! I'm a %s! \n", s.Name)
}

json.NewDecoder 接收 io.reader 类型的数据，rdr 是 io.reader 类型，可以从 rdr 读数据。
读到数据后，通过 json.Decoder.Decode 方法解码 json 数据，也就是反序列化一个结构体

网络传输中获取一个 reader

package main

import (
    "fmt"
    "io"
    "log"
    "net"
)

func main() {
    conn, err := net.Dial("tcp", "baidu.com:80")
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")

    buf := make([]byte, 200)
    for {
        n, err := conn.Read(buf)
        if err == io.EOF {
            break
        }
        if err != nil {
            log.Fatalf("error reading from conn: %v", err)
            break
        }
        if n > 0 {
            log.Printf("We read "%s" into bytesRead (%d bytes)",
                string(buf[:n]), n)
        }
    }
}

运行以上程序，输出为:

2022/07/10 13:24:57 We read "HTTP/1.1 200 OK
Date: Sun, 10 Jul 2022 05:24:57 GMT
Server: Apache
Last-Modified: Tue, 12 Jan 2010 13:48:00 GMT
ETag: "51-47cf7e6ee8400"
Accept-Ranges: bytes
Content-Length: 81
Cache-Control: m" into bytesRead (200 bytes)
2022/07/10 13:24:57 We read "ax-age=86400
Expires: Mon, 11 Jul 2022 05:24:57 GMT
Connection: Close
Content-Type: text/html

<html>
<meta http-equiv="refresh" content="0;url=http://www.baidu.com/">
</html>
" into bytesRead (181 bytes)

本质和读文件类似，也可以使用 io.ReadAll(conn) 简化下程序，简化后清爽了许多。

package main

import (
   "fmt"
   "io"
   "log"
   "net"
)

func main() {
   conn, err := net.Dial("tcp", "baidu.com:80")
   if err != nil {
      panic(err)
   }
   defer conn.Close()

   fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")

   data, _ := io.ReadAll(conn)
   log.Printf("Hi! I'm a %s! \n", string(data))
}

如上所见，io.Reader 是一个很方便用的接口，这也是为什么在 go 代码中，随处可见 io.Readers，所以这是一个你真的需要掌握的知识点~