从 io.Reader 中读数据

目录 [−]

1. io.Reader.Read
2. io.Copy
3. ioutil.ReadAll
4. io.ReadFull
5. io.ReadAtLeast
6. io.LimitReader
7. 参考资料

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()

	// 发送请求, http 1.0 协议
	fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")

	// 读取response
	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并不会被使用,而是使用接口的方法进行复制：

1. src实现了WriterTo接口
2. 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()

	// 发送请求, http 1.0 协议
	fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")

	// 读取response
	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()

	// 发送请求, http 1.0 协议
	fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")

	// 读取response
	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()

	// 发送请求, http 1.0 协议
	fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")

	// 读取response
	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()

	// 发送请求, http 1.0 协议
	fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")

	// 读取response
	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()

	// 发送请求, http 1.0 协议
	fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")

	// 读取response
	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())
}

参考资料

• https://github.com/golang/go/issues/20477
• https://stackoverflow.com/questions/24339660/read-whole-data-with-golang-net-conn-read
• https://stackoverflow.com/questions/29221872/golang-read-bytes-from-net-tcpconn