在golang中如何实现 WebSocket 的双向通信

在golang中如何实现 WebSocket 的双向通信 ?

原创磊丰 Go语言圈 2023-12-21 08:30 发表于广东听全文

Go语言圈

Go语言开发者的学习好助手，分享Go语言知识,技术技巧，学习与交流Go语言开发经验，互动才有助于技术的提升，每天5分钟，助你GO语言技术快乐成长

137篇原创内容

公众号

学习与交流：Go语言技术微信群

商务合作加微信：LetsFeng

现在就开始你的Go语言学习之旅吧！人生苦短，let’s Go.

Goland 全家桶激活码，免费获取了，赶紧下手

https://web.52shizhan.cn

在Go语言中实现WebSocket的双向通信通常需要使用第三方库，其中 gorilla/websocket 是一个非常流行和广泛使用的库。

以下是实现WebSocket双向通信的步骤和简单示例代码：

1 安装 gorilla/websocket 库：

go get github.com/gorilla/websocket

2 编写WebSocket服务器：

package main

import (
"fmt"
"net/http"
"github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
    // 允许所有来源的WebSocket连接
    return true
},
}

func handleConnection(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
    fmt.Println(err)
    return
}
defer conn.Close()

fmt.Println("Client connected")

for {
    // 读取客户端消息
    messageType, p, err := conn.ReadMessage()
    if err != nil {
        fmt.Println(err)
        return
    }

    // 处理消息
    fmt.Printf("Received message: %s\n", p)

    // 发送消息给客户端
    err = conn.WriteMessage(messageType, p)
    if err != nil {
        fmt.Println(err)
        return
    }
}
}

func main() {
http.HandleFunc("/ws", handleConnection)

// 启动WebSocket服务器
fmt.Println("WebSocket server listening on :8080")
err := http.ListenAndServe(":8080", nil)
if err != nil {
    fmt.Println(err)
}
}

在上述代码中，我们使用 gorilla/websocket 的 Upgrader 来升级HTTP连接为WebSocket连接。在 handleConnection 函数中，我们处理了连接的升级、读取客户端消息以及向客户端发送消息。

3 编写WebSocket客户端：

package main

import (
"fmt"
"log"
"os"
"os/signal"
"time"

"github.com/gorilla/websocket"
)

func main() {
interrupt := make(chan os.Signal, 1)
signal.Notify(interrupt, os.Interrupt)

u := "ws://localhost:8080/ws"
log.Printf("connecting to %s", u)

c, _, err := websocket.DefaultDialer.Dial(u, nil)
if err != nil {
    log.Fatal("dial:", err)
}
defer c.Close()

done := make(chan struct{})

go func() {
    defer close(done)
    for {
        _, message, err := c.ReadMessage()
        if err != nil {
            log.Println("read:", err)
            return
        }
        log.Printf("recv: %s", message)
    }
}()

ticker := time.NewTicker(time.Second)
defer ticker.Stop()

for {
    select {
    case <-done:
        return
    case t := <-ticker.C:
        err := c.WriteMessage(websocket.TextMessage, []byte(t.String()))
        if err != nil {
            log.Println("write:", err)
            return
        }
    case <-interrupt:
        log.Println("interrupt")

        // 关闭连接
        err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
        if err != nil {
            log.Println("write close:", err)
            return
        }
        select {
        case <-done:
        case <-time.After(time.Second):
        }
        return
    }
}
}