从 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 中读取数据的方法 (ioioutil),本文通过从 net.Conn中读取数据为例,演示各种方法已经应用场景。

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

1
2
3
4
5
6
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 来表示输入流已经读取到头。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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没有两样。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
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())
}

参考资料