Go 字节[]信道使用率

我得到了一个REST命令，想在它的主体上计算散列函数。 为此，我使用

io.teereder（request.body，&writerToHash）

读取正文，其中我传递了我自己实现io.Writer的类：

func (self *WriterToHash) Write(p []byte) (n int, err error) {
    n=len(p)
    fmt.println("WriterToHash  len=%v, buff=%v", n, p)  //PRINT 1
    self.BodyChannel <- p
    return n, nil
}

听力部分：

func (wth *WriterToHash) StartListen() {
    wth.OutChannel = make(chan []byte, 1000)
    go func (self *WriterToHash) {
        done := int64(0)
        h := sha1.New()
        for done < MessageSize{
            buff := <- self.BodyChannel

            done += int64(len(buff))
            DPrint(5, "AccamulateSha1 Done=: %v, buff=%v", done, buff)  //PRINT 2

            actually_write, err := h.Write(buff)
            if err != nil ||  actually_write != len(buff) {
                log.Println("Error in sha write:" + err.Error())
                break
            }
        }
        bs := h.Sum(nil)
        self.OutChannel <- bs
    }(wth)
 }

func（带*WriterToHash）StartListen（）{
wth.OutChannel=make（chan[]字节，1000）
go func（自*写程序）{
完成：=int64（0）
h:=sha1.New（）
对于已完成的
写入操作不能修改切片数据，即使是暂时的

无法存储或重用传递给写入方法的切片。如果要在其他地方使用该数据，则需要制作该数据的副本

func (self *WriterToHash) Write(p []byte) (n int, err error) {
    b := make([]byte, len(p))
    copy(b, p)
    fmt.println("WriterToHash  len=%d, buff=%v", len(p), b)
    self.BodyChannel <- b
    return len(p), nil
}

func（self*WriterToHash）写入（p[]字节）（n int，err error）{
b:=make（[]字节，len（p））
副本（b，p）
fmt.println（“写入器的长度=%d，buff=%v”，长度（p），b）
self.BodyChannel谢谢Jim，它成功了。顺便说一句，你可能知道为什么流总是被分成第一个字节+其余字节吗？它似乎不太有效。@Ety:TeeReader准确地写入了从读卡器读取的内容，因此如果从
请求.Body
读取了一个字节，那么一个字节将被写入
writerToHash
。如果如果读写操作将成为一个问题（在您的情况下这无关紧要），您可以使用bufio将它们批处理成更大的操作。
func (self *WriterToHash) Write(p []byte) (n int, err error) {
    b := make([]byte, len(p))
    copy(b, p)
    fmt.println("WriterToHash  len=%d, buff=%v", len(p), b)
    self.BodyChannel <- b
    return len(p), nil
}