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

在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
    }
}
}

在客户端代码中，我们使用 gorilla/websocket 的 DefaultDialer 来建立与WebSocket服务器的连接。然后，我们启动两个goroutine，一个用于接收服务器发来的消息，另一个用于定期向服务器发送消息。

4. 运行程序：

• 运行WebSocket服务器：

  go run server.go
  

• 在另一个终端窗口中运行WebSocket客户端：

  go run client.go
  

通过这个简单的示例，你可以看到WebSocket服务器和客户端之间的双向通信。你可以

根据实际需求扩展和修改这个基础的实现。