当前位置：首页 > 文章列表 > Golang > Go问答 > 获取请求 VS. WebSocket 哪一个更快？

获取请求 VS. WebSocket 哪一个更快？

来源：stackoverflow 2024-03-31 20:12:35 0浏览收藏

从现在开始，我们要努力学习啦！今天我给大家带来《获取请求 VS. WebSocket 哪一个更快？》，感兴趣的朋友请继续看下去吧！下文中的内容我们主要会涉及到等等知识点，如果在阅读本文过程中有遇到不清楚的地方，欢迎留言呀！我们一起讨论，一起学习！

问题内容

我在 fetch 和 websocket 中发送相同的数据，但是：

http 传输大约需要 29 秒，大约为 200 mb。
websocket 传输大约需要 6 秒，大约为 200 mb。

问题

为什么 websocket 比 http 更快？它与编码或技术或其他什么有关......？

获取

async function postdata(url = '', data) {
        const response = await fetch(url, {
            method: 'post',
            mode: 'no-cors',
            cache: 'no-cache',
            credentials: 'same-origin',
            headers: {
                'content-type': 'application/octet-stream'
            },
            redirect: 'follow',
            referrerpolicy: 'no-referrer',
            body: data
        });
        return response; //.arraybuffer();
    }

    postdata('http://localhost:3800/buffer', arru8)
        .then(data => {
            console.log(data);
        });

arru8 是一个 uint8array，长度为：185578200

websocket

function connect() {
        return new promise(function (resolve, reject) {
            var ws = new websocket('ws://127.0.0.1:8081/echo');
            ws.onopen = function () {
                resolve(ws);
            };
            ws.onerror = function (err) {
                reject(err);
            };
            ws.onclose = function (evt) {
                console.log("close socket", new date().tolocalestring());
            };
            ws.onmessage = function (evt) {
                console.log("response socket: " + "received" /* evt.data */, new date().tolocalestring());
            };
        });
    }

    connect().then(function (ws) {
        // onopen
        ws.binarytype = 'arraybuffer';
        ws.send(arru8);
        ws.close();
    }).catch(function (err) {
        // onerror
        console.log("error: " + evt.data, new date().tolocalestring());
    });

服务器端由go编写

http

func process(w http.responsewriter, r *http.request) {

    if r.url.path != "/buffer" {
        http.error(w, "404 not found.", http.statusnotfound)
        return
    }

    switch r.method {
    case "get":

        fmt.fprintf(w, "get request is received: %s \n", r.url)
    case "post":

        body, err := ioutil.readall(r.body)
        if err != nil {
            http.error(w, err.error(), http.statusinternalservererror)
            return
        }
        log.println("data length received = ", len(body))

        fmt.fprintf(w, "data length = %v \n", len(body))

    default:
        fmt.fprintf(w, "sorry, only get and post methods are supported.")
    }
}

websocket

package main

import (
    "flag"
    "log"
    "net/http"
    "text/template"

    "github.com/gorilla/websocket"
)

var addr = flag.String("addr", "localhost:8081", "http service address")
var upgrader = websocket.Upgrader{} // use default options
func main() {

    log.Println("Launching WebSocket server...", *addr)
    flag.Parse()
    log.SetFlags(log.LstdFlags | log.Lmicroseconds)
    http.HandleFunc("/echo", echo)
    http.HandleFunc("/", home)
    log.Fatal(http.ListenAndServe(*addr, nil))
}

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

    // To fix 403 error temporarily. It's unsafe:
    upgrader.CheckOrigin = func(r *http.Request) bool { return true }

    c, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Print("upgrade:", err)
        return
    }
    defer c.Close()
    for {
        mt, message, err := c.ReadMessage()
        if err != nil {
            log.Println("read:", err)
            break
        }
        log.Println("recv: message type:", mt)
        log.Printf("recv: bytes count: %v", len(message))
        // // // Disable echo and log
        // log.Printf("recv: %s", message)
        // err = c.WriteMessage(mt, message)
        // if err != nil {
        //  log.Println("write:", err)
        //  break
        // }
    }
}

func home(w http.ResponseWriter, r *http.Request) {
    homeTemplate.Execute(w, "ws://"+r.Host+"/echo")
}