发布于 2023-03-16 10:36:31

从 io.Reader 中读数据

原文地址 colobu.com

Go 的标准库提供了多个从 io.Reader 中读取数据的方法 (io、ioutil)，本文通过从 net.Conn 中读取数据为例，演示各种方法已经应用场景。

Go 的标准库提供了多个从 io.Reader 中读取数据的方法 (io、ioutil)，本文通过从 net.Conn中读取数据为例，演示各种方法已经应用场景。

使用 TCP 连接访问某个网站，采用HTTP 1.0的协议，让 TCP 连接保持短连接，读取完 response 之后连接会关闭，这样就模拟了io.EOF的错误：

conn, err := net.Dial("tcp", "rpcx.site:80")

if err != nil {
    fmt.Println("dial error:", err)
    return
}

defer conn.Close()

io.Reader.Read

io.Reader接口定义了Read(p []byte) (n int, err error)方法，我们可以使用它从 Reader 中读取一批数据。

一次最多读取len(p)长度的数据
读取遭遇到 error(io.EOF 或者其它错误), 会返回已读取的数据的字节数和 error
即使读取字节数 <len(p), 也不会更改 p 的大小 (显然的，因为正常它也没办法更改)
当输入流结束时，调用它可能返回 err == EOF 或者 err == nil，并且n >=0, 但是下一次调用肯定返回 n=0, err=io.EOF

常常使用这个方法从输入流中批量读取数据，直到输入流读取到头，但是需要注意的时候，我们应该总是先处理读取到的 n 个字节，然后再处理 error。

如果你要实现io.Reader接口，在实现Read方法时，不建议你返回0,nil, 除非输入的len(p)==0, 因为这容易造成困惑，一般用0,io.EOF 来表示输入流已经读取到头。

下面是演示这个方法的例子：

package main

import (

	"fmt"

	"io"

	"net"

	"strings"

)

func main() {

	conn, err := net.Dial("tcp", "rpcx.site:80")

	if err != nil {

		fmt.Println("dial error:", err)
		return
	}

	defer conn.Close()

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

	var sb strings.Builder

	buf := make([]byte, 256)

	for {

		n, err := conn.Read(buf)

		if err != nil {
			if err != io.EOF {
				fmt.Println("read error:", err)
			}
			break
		}

		sb.Write(buf[:n])
	}

	fmt.Println("response:", sb.String())

	fmt.Println("total response size:", sb.Len())

}

io.Copy

func Copy(dst Writer, src Reader) (written int64, err error)可以从 src 复制数据到 dst(Go 实现的方法一般把目的地址参数放在源参数的前面)，直到：

EOF
其它 error

它返回读取的字节数以及遇到的第一个错误

注意成功的读取完输入流后 err 并不是io.EOF, 而是nil。
它内部是调用CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error)实现的，
CopyBuffer会有可能使用一个指定的buf来复制数据, 如果 buf 的长度为 0, 它会 panic。

在两种特例的情况下 buf 并不会被使用, 而是使用接口的方法进行复制：

src 实现了WriterTo接口
dst 实现了ReadFrom接口

package main

import (

	"fmt"

	"io"

	"net"

	"strings"

)

func main() {

	conn, err := net.Dial("tcp", "rpcx.site:80")

	if err != nil {
		fmt.Println("dial error:", err)
		return
	}

	defer conn.Close()

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

	var sb strings.Builder

	_, err = io.Copy(&sb, conn)

	if err != nil {
		fmt.Println("read error:", err)
	}

	fmt.Println("response:", sb.String())

	fmt.Println("total response size:", sb.Len())

}

ioutil.ReadAll

ReadAll(r io.Reader) ([]byte, error)提供了一个从输入流中读取全部数据的方法，它读取输入流直到出现错误（error）或者读到头（EOF）。

成功的读取到头不会返回 io.EOF, 而是返回数据和 nil。

我们经常用它来读取可信的 http.Response.Body。

package main

import (

	"fmt"

	"io"

	"io/ioutil"

	"net"

)

func main() {

	conn, err := net.Dial("tcp", "rpcx.site:80")

	if err != nil {
		fmt.Println("dial error:", err)
		return
	}

	defer conn.Close()

	fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")
	data, err := ioutil.ReadAll(conn)

	if err != nil {

		if err != io.EOF {
			fmt.Println("read error:", err)
		}
		panic(err)
	}

	fmt.Println("response:", string(data)) 

	fmt.Println("total response size:", len(data))

}

io.ReadFull

ReadFull(r Reader, buf []byte) (n int, err error)从输入流中读取正好 len(buf) 字节的数据。

读取到 0 字节，并且遇到 EOF, 返回 EOF
读取到 0<n<len(buf) 字节，并且遇到 EOF, 返回 ErrUnexpectedEOF
读取到 n==len(buf), 即使遇到 error 也返回 err=nil
返回 err != nil 则肯定 n<len(buf)

package main

import (

	"fmt"

	"io"

	"net"

	"strings"

)

func main() {

	conn, err := net.Dial("tcp", "rpcx.site:80")

	if err != nil {
		fmt.Println("dial error:", err)
		return
	}

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

	var sb strings.Builder

	buf := make([]byte, 256)

	for {
		n, err := io.ReadFull(conn, buf)
		if err != nil {
			if err != io.EOF && err != io.ErrUnexpectedEOF {
				fmt.Println("read error:", err)
			}
			break
		}
		sb.Write(buf[:n])
	}

	fmt.Println("response:", sb.String())

	fmt.Println("total response size:", sb.Len())

}

io.ReadAtLeast

ReadAtLeast(r Reader, buf []byte, min int) (n int, err error)从输入流中读取至少 min 个字节到 buf 中，直到把 buf 读取满或者遇到 error，包括 EOF。

如果 n < min, 肯定返回错误
没有数据可读返回 n=0 和 EOF
n < min, 并且遇到 EOF, 返回 n 和 ErrUnexpectedEOF
如果参数 min>len(buf), 返回 0,ErrShortBuffer
如果读取了至少 min 个字节，即使遇到错误也会返回 err=nil

package main

import (

	"fmt"

	"io"

	"net"

	"strings"

)

func main() {

	conn, err := net.Dial("tcp", "rpcx.site:80")

	if err != nil {
		fmt.Println("dial error:", err)
		return
	}

	defer conn.Close()

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

	var sb strings.Builder

	buf := make([]byte, 256)

	for {
		n, err := io.ReadAtLeast(conn, buf, 256)
		if err != nil {
			if err != io.EOF && err != io.ErrUnexpectedEOF {
				fmt.Println("read error:", err)
			}
			break
		}

		sb.Write(buf[:n])
	}

	fmt.Println("response:", sb.String())

	fmt.Println("total response size:", sb.Len())

}

io.LimitReader

LimitReader(r Reader, n int64) Reader返回一个内容长度受限的 Reader，当从这个 Reader 中读取了 n 个字节一会就会遇到 EOF。

设想一下如果没有这个保护措施，别让告诉你发送一个图片，结果发送给你一个 3G 的葫芦娃的视频，有可能会使你的内存飙升。

它就是提供了一个保护的功能，其它和普通的 Reader 没有两样。

package main

import (

	"fmt"

	"io"

	"net"

	"strings"

)

func main() {

	conn, err := net.Dial("tcp", "rpcx.site:80")

	if err != nil {
		fmt.Println("dial error:", err)
		return
	}

	defer conn.Close()

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

	var sb strings.Builder

	buf := make([]byte, 256)

	rr := io.LimitReader(conn, 102400)

	for {
		n, err := io.ReadAtLeast(rr, buf, 256)
		if err != nil {
			if err != io.EOF && err != io.ErrUnexpectedEOF {
				fmt.Println("read error:", err)
			}
			break
		}

		sb.Write(buf[:n])
	}

	fmt.Println("response:", sb.String())

	fmt.Println("total response size:", sb.Len())

}

参考资料

[Newer

在 Linux 中查询 CPU 的核数
](https://colobu.com/2019/02/22/how-to-find-cpu-cores-in-linux/)[Older

Go Reflect 性能
](https://colobu.com/2019/01/29/go-reflect-performance/)

技术

浏览 (269)