Go如何根据我声明缓冲区的位置设置不同的内容类型

最近发现不少小伙伴都对Golang很感兴趣，所以今天继续给大家介绍Golang相关的知识，本文《Go如何根据我声明缓冲区的位置设置不同的内容类型》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

我尝试播放视频，但无法解释以下行为。 我从 go 的 net/http 服务器、两个不同的处理程序获得不同的响应标头，唯一的区别在于我声明缓冲区的位置。

在下面的代码中有两个处理程序，唯一的区别是一个处理程序在本地声明缓冲区。在该版本中，流式传输工作正常，chrome 流式传输视频，我看到它得到了 transfer-encoding: chunked 和 content-type: video/mp4 的响应。

在缓冲区作为输入参数的第二个版本中，chrome 不会流式传输视频，并且标头也不同。

package main

import (
    "bytes"
    "io"
    "log"
    "net/http"
    "os"
)

func main() {
    file := "/Users/someUser/Documents/Zoom/Ronen/zoom_0.mp4"

    f, err := os.Open(file)
    defer f.Close()

    if err != nil {
        log.Fatalln(err)
    }
    http.ListenAndServe(":9008", GetVidHandler(f))
}

//This implementation works, buff is declared locally.
//I get header of content-type video/mp4
func GetVidHandler(f *os.File) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        offset := int64(0)
        var buff [4096]byte
        for {
            n, _ := f.ReadAt(buff[:], offset)
            offset += int64(n)
            re := bytes.NewReader(buff[:])
            io.Copy(w, re)
        }
    }
}

//This implementation doesn't stream, buff is input param
//I get header of content-type octet-stream
func GetVidHandler(f *os.File, buff [4096]byte) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        offset := int64(0)
        for {
            n, _ := f.ReadAt(buff[:], offset)
            offset += int64(n)
            re := bytes.NewReader(buff[:])
            io.Copy(w, re)
        }
    }
}

解决方案

感谢您的评论，但修复它们仍然不会改变行为。 例如以下代码得到
写入 tcp 127.0.0.1:9008->127.0.0.1:60443: 写入：管道损坏

package main

import (
    "bytes"
    "io"
    "log"
    "net/http"
    "os"
)

type Viewer struct {
    ch   chan []byte
    buff [3][4096]byte
}

func main() {
    file := "/Users/someUSer/Documents/Zoom/Ronen/zoom_0.mp4"

    f, err := os.Open(file)
    defer f.Close()

    if err != nil {
        log.Fatalln(err)
    }

    m := make(map[int]*Viewer)
    start := make(chan struct{})

    go func() {

        offset := int64(0)
        <-start
        log.Println("Starting...")
        i := 0
        for {
            var b [4096]byte
            n, err := f.ReadAt(b[:], offset)
            if err != nil {
                log.Println(err)
                return
            }

            offset += int64(n)
            for _, v := range m {
                copy(v.buff[i%3][:], b[:n])
                v.ch <- v.buff[i%3][:n]
            }
            i++
        }

    }()

    http.ListenAndServe(":9008", GetVidHandler(m, start))

}

func GetVidHandler(m map[int]*Viewer, start chan struct{}) http.HandlerFunc {

    i := 0

    return func(w http.ResponseWriter, r *http.Request) {

        current := i
        v := &Viewer{ch: make(chan []byte)}
        m[current] = v
        i++
        select {
        case start <- struct{}{}:
        default:

        }
        cn, ok := w.(http.CloseNotifier)
        if !ok {
            http.NotFound(w, r)
            return
        }
        // flusher, ok := w.(http.Flusher)
        // if !ok {
        //  http.NotFound(w, r)
        //  return
        // }

        // Send the initial headers saying we're gonna stream the response.
        // w.Header().Set("Transfer-Encoding", "chunked")
        // w.Header().Set("Content-Type", "video/mp4")
        // w.WriteHeader(http.StatusOK)
        // // flusher.Flush()

        // b := <-v.ch
        // log.Println(current, "-Writing ", len(b), " Bytes")
        // log.Printf("%d - WRITE - First 100 bytes %v\n", current, b[:100])
        // w.Write(b[:len(b)])

        // flusher.Flush()
        for {
            select {
            case <-cn.CloseNotify():
                log.Println("Client stopped listening")
                return
            default:
                b := <-v.ch
                re := bytes.NewReader(b[:])
                _, err := io.Copy(w, re)
                if err != nil {
                    log.Println(err)

                }
            }
        }

    }

}

//Works
// func GetVidHandler(f *os.File) http.HandlerFunc {

//  return func(w http.ResponseWriter, r *http.Request) {
//      offset := int64(0)
//      var buff [4096]byte
//      for {
//          n, _ := f.ReadAt(buff[:], offset)
//          log.Printf("WRITE - First 100 bytes %v\n", buff[:100])

//          offset += int64(n)
//          re := bytes.NewReader(buff[:])
//          io.Copy(w, re)
//      }
//  }

// }

好了，本文到此结束，带大家了解了《Go如何根据我声明缓冲区的位置设置不同的内容类型》，希望本文对你有所帮助！关注编程网公众号，给大家分享更多Golang知识！