go io 包的使用（TeeReader, MultiReader, MultiWriter, Pipe）

最新推荐文章于 2024-08-06 10:31:49 发布
最新推荐文章于 2024-08-06 10:31:49 发布
阅读量1.7k 收藏 2
点赞数
文章标签： go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DisMisPres/article/details/119650714
版权

背景

今天在做文件的上传，在文件上传结束后，需对比上传文件和本地文件的哈希值是否一致。
对上传客户端来说，可以提前单独计算好文件的哈希值，然后在上传成功后，与服务端返回的哈希值进行对比。但显然，这并不是一个理想的方案，边上传边计算，这样是比较合理的。
我这里一开始使用的是 io 包的 Pipe() 方法来做的，之前一直都没怎么用过，比较冷门，顺带着就看了下源码实现，再带着就看了下 io 包的其他方法的使用，最后引申出了本篇。

TeeReader

func TeeReader(r Reader, w Writer) Reader {
	return &teeReader{r, w}
}

边读边写，函数返回的 reader 会在从接收参数 r 中读取内容的同时，将内容写入 w。

源码
type teeReader struct {
	r Reader
	w Writer
}

func (t *teeReader) Read(p []byte) (n int, err error) {
	n, err = t.r.Read(p)
	if n > 0 {
		if n, err := t.w.Write(p[:n]); err != nil {
			return n, err
		}
	}
	return
}
简单示例

可以简化代码，如：计算文件哈希 (这里使用不一定合理，仅打个比方)

func TeeGetFileMD5(path string) (string, error) {
	file, err := os.Open(path)
	if err != nil {
		return "", err
	}
	h := md5.New()
	tr := io.TeeReader(file, h)
	_, err = io.ReadAll(tr) // 优化
	if err != nil {
		return "", err
	}
	return fmt.Sprintf("%x", h.Sum(nil)), nil
}

MultiReader

func MultiReader(readers ...Reader) Reader {
	r := make([]Reader, len(readers))
	copy(r, readers)
	return &multiReader{r}
}

顺序读取所有的 reader，直到出错或者所有的 reader 都读取完成后返回 EOF。

源码
type multiReader struct {
	readers []Reader
}

func (mr *multiReader) Read(p []byte) (n int, err error) {
	for len(mr.readers) > 0 {
		// Optimization to flatten nested multiReaders (Issue 13558).
		if len(mr.readers) == 1 { // 适配multiReader的嵌套
			if r, ok := mr.readers[0].(*multiReader); ok {
				mr.readers = r.readers
				continue
			}
		}
		n, err = mr.readers[0].Read(p)
		if err == EOF { // 读完一个，从数组剔除，换下一个
			// Use eofReader instead of nil to avoid nil panic
			// after performing flatten (Issue 18232).
			mr.readers[0] = eofReader{} // permit earlier GC
			mr.readers = mr.readers[1:]
		}
		if n > 0 || err != EOF {
			if err == EOF && len(mr.readers) > 0 { // 是EOF，读到最后一个再返回EOF
				// Don't return EOF yet. More readers remain.
				err = nil
			}
			return 
		}
	}
	return 0, EOF
}
简单示例
func tMultiReader() {
	r1 := bytes.NewReader([]byte("ABC"))
	r2 := bytes.NewReader([]byte("DEF"))
	reader := io.MultiReader(r1, r2)
	var buf = make([]byte, 1)
	for {
		n, err := reader.Read(buf)
		if err != nil {
			if err == io.EOF {
				return 
			}
			fmt.Println(err)
			return
		}
		fmt.Println(string(buf[:n])) // ABCDEF
	}
}

MultiWriter

func MultiWriter(writers ...Writer) Writer {
	allWriters := make([]Writer, 0, len(writers))
	for _, w := range writers {
		if mw, ok := w.(*multiWriter); ok {
			allWriters = append(allWriters, mw.writers...)
		} else {
			allWriters = append(allWriters, w)
		}
	}
	return &multiWriter{allWriters}
}

写一即多，函数返回的 writer 进行写操作时，会对所有的入参 writer 都进行写操作（copy）。当有多个输出点的时候，直接使用它会简化不少代码。

源码
type multiWriter struct {
	writers []Writer
}

func (t *multiWriter) Write(p []byte) (n int, err error) {
	for _, w := range t.writers {
		n, err = w.Write(p)
		if err != nil {
			return
		}
		if n != len(p) {
			err = ErrShortWrite
			return
		}
	}
	return len(p), nil
}
简单示例
func tMultiWriter() {
	var buf []byte
	w1 := bytes.NewBuffer(buf)
	w2 := bytes.NewBuffer(buf)
	writer := io.MultiWriter(w1, w2)
	_, err := writer.Write([]byte("123"))
	if err != nil {
		fmt.Println(err)
		return
	}

	w1Res, err := ioutil.ReadAll(w1)
	fmt.Println(string(w1Res), err) // 123 <nil>
	w2Res, err := ioutil.ReadAll(w2)
	fmt.Println(string(w2Res), err) // 123 <nil>
}

Pipe

func Pipe() (*PipeReader, *PipeWriter) {
	p := &pipe{
		wrCh: make(chan []byte),
		rdCh: make(chan int),
		done: make(chan struct{}),
	}
	return &PipeReader{p}, &PipeWriter{p}
}
type pipe struct {
	wrMu sync.Mutex // Serializes Write operations
	wrCh chan []byte
	rdCh chan int

	once sync.Once // Protects closing done
	done chan struct{}
	rerr onceError
	werr onceError
}

函数返回的 PipeReader 和 PipeWriter 均有 Close 和 CloseWithError 方法，用于停止读写（done）。

  • wrCh 写入的数据
  • rdCh 读了多少了
  • once 只close一次done
  • done 结束标志
  • rerr 读错
  • werr 写错
源码
func (p *pipe) Write(b []byte) (n int, err error) {
	select {
	case <-p.done:
		return 0, p.writeCloseError()
	default:
		p.wrMu.Lock()
		defer p.wrMu.Unlock()
	}

	for once := true; once || len(b) > 0; once = false {
		select {
		case p.wrCh <- b:
			nw := <-p.rdCh
			b = b[nw:]
			n += nw
		case <-p.done:
			return n, p.writeCloseError()
		}
	}
	return n, nil
}

func (p *pipe) Read(b []byte) (n int, err error) {
	select {
	case <-p.done:
		return 0, p.readCloseError()
	default:
	}

	select {
	case bw := <-p.wrCh:
		nr := copy(b, bw)
		p.rdCh <- nr
		return nr, nil
	case <-p.done:
		return 0, p.readCloseError()
	}
}

Read 和 Write 方法的开头都有如下一段代码。由于 channel 的 case 选择是随机的，需要确保没有结束再进行 Read 或 Write 操作。

	select {
	case <-p.done:
		return 0, p.writeCloseError()
	default:
		p.wrMu.Lock()
		defer p.wrMu.Unlock()
	}
简单示例
func tPipe() {
	r, w := io.Pipe()
	go func  () {
		for i := 0; i < 3 ; i++ {
			fmt.Println("write now!")
			n, err := w.Write([]byte("hello"))
			if err != nil {
				fmt.Println("write err:", err.Error())
			} else {
				fmt.Println("write end n:", n)
			}
		}
		w.Close()
	}()
	//time.Sleep(time.Second)
	b := make([]byte, 100)
	for {
		n, err := r.Read(b)
		if err != nil {
			if err != io.EOF {
				fmt.Println("read err:", err.Error())
			}
			break
		} else {
			fmt.Println("read:", string(b[:n]))
		}
	}
}
// write now!
// read: hello
// write end n: 5
// write now!
// read: hello
// write end n: 5
// write now!
// read: hello
// write end n: 5

TeeReader 和 MultiWriter 的结合使用

例子：复制文件，并计算文件的哈希值

func copyFileWithHash() {
	f, dstF, hashW, err := getTestRW()
	if err != nil {
		fmt.Println(err)
		return
	}

	now := time.Now()
	defer func() {
		fmt.Println("耗时：", time.Now().Sub(now))
	}()

	multiW := io.MultiWriter(dstF, hashW)

	teeR := io.TeeReader(f, multiW)


	buf := make([]byte, 512)
	for {
		_, err := teeR.Read(buf)
		if err == io.EOF {
			break
		}
		utils.CheckErr(err)
	}

	fmt.Printf("文件sha256：%x\n",  hashW.Sum(nil))
	// 文件大小： 1840640
	// 文件sha256：b61ec80071fc414c44ff1a05f323679f9fc3e7caa2a68363019663fc16677568
	// 耗时： 15.881ms
}

func getTestRW() (f, dstF *os.File, shaW hash.Hash, err error) {
	f, err = os.Open(`E:\test\html报告-1628662433.tar`)
	if err != nil {
		return
	}
	fInfo, err := f.Stat()
	if err != nil {
		return
	}
	fmt.Println("文件大小：", fInfo.Size())

	dstF, err = os.Create(`E:\test\1.tar`)
	if err != nil {
		return
	}

	shaW = sha256.New()
	return
}

总结

io 包的一些方法还是挺好用的，实现都并不是很复杂，感兴趣的可以看下各个方法的具体实现。本篇抛砖引玉，只是做了简单的介绍，实际开发过程中，不使用这些方法也是能够完全达成目的的，可能就是稍微繁琐点。

  • TeeReader 的一心二用（边读编写）
  • MultiReader 的先来后到（顺序读取）
  • MultiWriter 的同甘共苦（写一即多）
  • Pipe 的绝不先做（写->读->写->读->…）
Grassto
关注
go语言io reader_【已解决】go语言中如何使用io的MultiWriter
weixin_35551323的博客
01-17 730
【背景】折腾：期间，需要去搞懂：如果新建和设置MultiWriter。【折腾过程】1.参考：去看看：2.然后去试试代码：var filenameOnly stringfilenameOnly = GetCurFilename()fmt.Println("filenameOnly=", filenameOnly)var logFilename string = filenameOnly + ".l...
go语言io reader_Go语言中异步拆分io.Reader
weixin_42298164的博客
01-17 467
在Go语言中处理任何stream数据时，我已经深陷io.Reader和io.Writer的灵活性中不能自拔。同时我在有一点上又或多或少的受了些折磨，挑战我的reader interface在你看来可能会觉得很简单：那就是怎么样拆分读操作。我甚至不知道使用“拆分(split)”这个词是否正确，我就是想通过io.Reader多次读取接收到的东西，有时候可能还需要并行操作。但是由于readers不一定会...
syncreader:SyncReader 创建一个读取器，将其读取同步到所有提供的读取器，类似于 io.MultiWriter
07-13
同步阅读器 SyncReader 创建一个读取器，它的读取与第一个读取器同步，类似于io.MultiWriter 。 查看。 蜜蜂 New(readers ...io.Reader) First reader是source reader ，其他读者阅读与第一个读者同步。 如果first readera读者返回EOF ，其他读者也会返回。 用法 正在读取文件。 import "github.com/go-libs/syncreader" import "github.com/go-libs/progress" filename := "syncreader_test.go" f , err := os . Open ( filename ) defer f . Close () if err != nil { log . Fatalln ( err ) } fs , err :=
golang下载、上传文件MD5高效计算方法，利用io.TeeReader函数特性 实时计算文件md5签名
最新发布
08-06 434
在go语言的开发中，当我们在操作下载或者上传文件对象时， 我们可以利用golang内置的io包中的 TeeReader函数特性，高效实时计算文件的md5值。 方法如下......
multiWriter.go
weixin_30659829的博客
08-29 103
package blog4goimport ( "errors" "fmt")var ( // ErrFilePathNotFound 文件路径找不到 ErrFilePathNotFound = errors.New("File Path must be defined") // ErrInvalidLevel 非法日志级别 ErrInvalidLevel = errors.New("Inval...
go io
harryhare的专栏
05-20 294
https://studygolang.com/articles/2073
Go语言学习笔记—golang标准库io包
qq_39280718的博客
07-10 2422
io包中提供I/O原始操作的一系列接口。它主要包装了一些已有的实现，如 os 包中的那些，并将这些抽象成为实用性的功能和一些其他相关的接口。
parallelwriter:io.MultiWriter但具有更多goroutine
05-21
在Go语言中，`io.MultiWriter`是一个非常有用的工具，它允许我们将多个写入器组合成一个，使得每次调用`Write`方法时，数据会被同时写入到所有注册的写入器。然而，`io.MultiWriter`并不支持并行写入，这意味着如果...
golang log4go的日志输出优化详解
09-20
在Go语言中，标准库已经提供了基本的日志功能支持，通过`import "log"`即可使用。然而，在复杂的应用场景下，开发者可能需要更高级别的日志管理功能，如分类输出、远程输出等。虽然有诸如logrus这样的强大日志库可供...
Go 语言标准库
04-09
Go语言的I/O操作不仅限于简单的读写，还包括了一些高级特性，比如`io.Copy`可以用来复制数据，`io.MultiReader`和`io.MultiWriter`可以合并多个读写操作为一个，提供更加灵活的I/O操作方式。 Go语言标准库中的I/O...
Golang学习 - io 包
weixin_30545285的博客
08-23 82
------------------------------------------------------------ 　　先说一下接口，Go 语言中的接口很简单，在 Go 语言的 io 包中有这样一个函数： func ReadFull(r Reader, buf []byte) (n int, err error) 　　这个函数可以把对象 r 中的数据读出来，然后存入一个缓冲...
go语言io reader_Golang io.TeeReader()用法及代码示例
weixin_33216825的博客
01-17 986
在Go语言中，io软件包为I /O原语提供基本接口。它的主要工作是封装此类原始之王的正在进行的实现。 Go语言中的TeeReader()函数用于返回“Reader”，该“Reader”从声明的“r”读取，然后将其写入声明的“w”。然后，将通过声明的“r”执行的所有读取与对声明的“w”的等效写入进行比较。此方法不需要任何内部缓冲，并且读取完成后即可完成写入。而且，此功能在io包下定义。在这里，您需要...
Collector的使用和MultiReader的使用
ningbohezhijun的专栏
11-12 1621
Lucene版本用的是3.5.0，虽然版本比较老，但是Zoie支持这个版本。
Golang Writer同时写入多个目的地
CHEENE
10-17 514
dest := io.MultiWriter(os.Stdout, file) io.Copy(dest, r.Body) if err := r.Body.Close();err != nil { }
go语言io reader_Go 语言显示下载文件进度/分段读取 io.TeeReader()
weixin_35867608的博客
01-17 698
在 Go 语言下载文件 http.Get() 和 io.Copy() 章节我们讲解了如何使用 Go 实现一个下载器，可以实现下载任何大小的任意文件。一般情况下，这个下载器已经足够使用了，但是，在下载文件时，我们往往想知道当前进度是多少。这时候，直接使用 io.Copy() 就无能为了。实现下载文件进度的方法其实很简单，就是实现分段读取响应流。因为响应是一个流 ( stream ) ，就像水管里的水...
golang io.TeeReader函数使用，实现一个实时下载进度条
gitxuzan
09-21 663
golang io.TeeReader函数使用，实现一个实时下载进度条。
go语言内置io包中TreeReader函数的理解和使用示例
05-27 608
在go语言的内置io包中的这个 TreeReader函数，函数原型func TeeReader(r Reader, w Writer) Reader 从函数原型中看是给他一个Reader, 和一个Writer 然后他给你返回一个Reader, 本文中我们把这个返回的Reader叫做 treeReader， 他是一个很特别的reader,。 他的作用就是将你输入的 r 和w建立一个对应关系，当你在读取这个treeReader的时候，他会将读取到的数据同时写入到w中。同时在他的内部没
Go语言中异步拆分io.Reader
酱油蔡的酱油坛
08-26 7782
在Go语言中处理任何stream数据时，我已经深陷io.Reader和io.Writer的灵活性中不能自拔。同时我在有一点上又或多或少的受了些折磨，挑战我的reader interface在你看来可能会觉得很简单：那就是怎么样拆分读操作。我甚至不知道使用“拆分（split）”这个词是否正确，我就是想通过io.Reader多次读取接收到的东西，有时候可能还需要并行操作。
zapcore.NewTee{}的使用
04-01
`zapcore.NewTee()` 方法可以用于创建一个 `io.Writer`，可以同时将日志消息写入多个目标，例如文件和标准输出流。 使用方法如下： ```go // 创建一个文件输出器 fileWriter, _ := os.Create("log.txt") // 创建一个输出到标准输出流的输出器 consoleWriter := zapcore.AddSync(os.Stdout) // 使用 NewTee() 方法创建一个同时输出到文件和标准输出流的输出器 multiWriter := zapcore.NewTee(fileWriter, consoleWriter) // 创建一个新的 Logger 实例，使用 multiWriter 输出器 logger := zap.New(zapcore.NewCore( // 设置日志级别和输出格式 zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()), multiWriter, zap.NewAtomicLevelAt(zap.DebugLevel), )) // 输出日志 logger.Info("info message") ``` 在上面的例子中，我们使用 `zapcore.NewTee()` 方法将日志消息同时输出到文件和标准输出流。我们首先创建了一个向文件写入日志的 `fileWriter`，然后创建了一个向标准输出流写入日志的 `consoleWriter`。接着使用 `NewTee()` 方法将这两个输出器合并为一个 `multiWriter`。最后，我们使用 `multiWriter` 作为 `zap.New()` 方法的参数创建了一个新的 Logger 实例，从而实现了将日志同时输出到文件和标准输出流的效果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值