使用 Golang 实现 WebSockets：现代应用程序的实时通信

在本文中，我们将深入探讨 WebSockets，重点是如何在 Golang 中实现 WebSockets 以构建实时应用程序。我们将介绍从设置基本的 WebSocket 服务器到处理多个连接、广播消息、确保安全以及与客户端创建端到端工作系统的所有内容。

什么是 WebSockets，它们为什么重要？

WebSockets 通过单个长期连接提供全双工通信通道，允许服务器实时向客户端发送数据，而无需等待客户端的请求。这与传统 HTTP 形成了鲜明对比，在传统 HTTP 中，客户端必须发起每个请求，从而导致实时通信效率低下。

WebSockets 与 HTTP 及其他协议

HTTP：在传统的 HTTP 请求-响应循环中，客户端发送请求，服务器做出响应。这种模式对于实时更新来说效率很低，因为它需要持续轮询或长时间轮询，而这两种方式都是资源密集型的。

WebSockets：WebSockets 在客户端和服务器之间建立持久连接，允许任何一方随时发送信息。这减少了延迟，提高了效率。

服务器发送事件（SSE）：SSE 是另一种实时更新协议，服务器通过 HTTP 连接向客户端推送更新。不过，SSE 是单向的（服务器到客户端），不如 WebSockets 灵活。

在 Golang 中设置基本 WebSocket 服务器

让我们先在 Golang 中设置一个基本的 WebSocket 服务器。我们将使用流行的 gorilla/websocket 软件包，它为使用 WebSockets 提供了一种简单而有效的方法。

步骤 1：安装 Gorilla WebSocket 软件包

首先需要安装 gorilla/websocket 软件包：

go get github.com/gorilla/websocket

步骤 2：创建 WebSocket 服务器

创建一个简单的 WebSocket 服务器，它可以监听传入连接并回传收到的任何信息。

package main

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

//  Upgrader 用于将 HTTP 连接升级为 WebSocket 连接。
var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool {
       return true
    },
}

func wsHandler(w http.ResponseWriter, r *http.Request) {
    // 将 HTTP 连接升级为 WebSocket 连接
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
       fmt.Println("Error upgrading:", err)
       return
    }
    defer conn.Close()
    // 监听传入消息
    for {
       // 从客户端读取消息
       _, message, err := conn.ReadMessage()
       if err != nil {
          fmt.Println("Error reading message:", err)
          break
       }
       fmt.Printf("Received: %s\\n", message)
       // 将消息回传给客户端
       if err := conn.WriteMessage(websocket.TextMessage, message); err != nil {
          fmt.Println("Error writing message:", err)
          break
       }
    }
}

func main() {
    http.HandleFunc("/ws", wsHandler)
    fmt.Println("WebSocket server started on :8080")
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
       fmt.Println("Error starting server:", err)
    }
}

步骤3：运行服务器

使用以下命令运行服务器:

go run main.go

现在，您的 WebSocket 服务器已在 http://localhost:8080/ws 上运行。您可以使用 WebSocket 客户端与之连接，发送消息并查看回显。

创建 WebSocket 客户端

现在我们已经启动并运行了 WebSocket 服务器，开始创建一个简单的 HTML 和 JavaScript 客户端来连接 Golang WebSocket 服务器。

步骤 1：创建 HTML 客户端

创建一个包含以下内容的 index.html 文件：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>WebSocket Client</title>
</head>
<body>
<h1>WebSocket Client</h1>
<div>
    <input type="text" id="messageInput" placeholder="Enter your message">
    <button onclick="sendMessage()">Send</button>
</div>
<div id="messages"></div>

<script>
    let ws;

    function connect() {
        ws = new WebSocket("ws://localhost:8080/ws");

        ws.onopen = function() {
            console.log("Connected to WebSocket server");
        };

        ws.onmessage = function(event) {
            let messageDisplay = document.getElementById("messages");
            messageDisplay.innerHTML += `<p>${event.data}</p>`;
        };

        ws.onclose = function() {
            console.log("WebSocket connection closed, retrying...");
            setTimeout(connect, 1000); // Reconnect after 1 second
        };

        ws.onerror = function(error) {
            console.error("WebSocket error:", error);
        };
    }

    function sendMessage() {
        let input = document.getElementById("messageInput");
        let message = input.value;
        ws.send(message);
        input.value = "";
    }

    connect();
</script>
</body>
</html>

步骤 2：运行客户端

在浏览器中打开 index.html。它会自动连接到运行在 ws://localhost:8080/ws 上的 WebSocket 服务器。

步骤 3 ：测试连接

在输入框中键入一条消息，然后单击 “发送 ”按钮。消息将被发送到服务器，然后服务器将回传消息，消息将显示在页面的 “消息 ”部分。

同时处理 WebSocket 连接

在构建实时应用程序时，通常会有多个客户端同时连接到 WebSocket 服务器。有效处理这些连接对性能和可扩展性至关重要。

使用 Goroutines 进行并发处理

Golang 的轻量级并发模型由 Goroutines 提供支持，可以轻松同时处理多个 WebSocket 连接。

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

    go handleConnection(conn)
}

func handleConnection(conn *websocket.Conn) {
    for {
       _, message, err := conn.ReadMessage()
       if err != nil {
          fmt.Println("Error reading message:", err)
          break
       }
       fmt.Printf("Received: %s\n", message)

       if err := conn.WriteMessage(websocket.TextMessage, message); err != nil {
          fmt.Println("Error writing message:", err)
          break
       }
    }
}

在本例中，每个新的 WebSocket 连接都在一个单独的 Goroutine 中处理。这样，多个客户端就能同时与服务器交互，而不会相互阻塞。

向多个客户端广播消息

向多个连接的客户端广播消息是聊天室或实时通知等实时应用程序的常见要求。让我们扩展 WebSocket 服务器以支持广播。

实现广播系统

我们将使用一个映射来存储所有活动的 WebSocket 连接，并使用一个通道来向所有已连接的客户端分发消息。

package main

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

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool {
       return true
    },
}

var clients = make(map[*websocket.Conn]bool) // 已连接的客户端
var broadcast = make(chan []byte)            // 广播频道
var mutex = &sync.Mutex{}                    // 保护客户端 map 

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

    mutex.Lock()
    clients[conn] = true
    mutex.Unlock()

    for {
       _, message, err := conn.ReadMessage()
       if err != nil {
          mutex.Lock()
          delete(clients, conn)
          mutex.Unlock()
          break
       }
       broadcast <- message
    }
}

func handleMessages() {
    for {
       // 从广播频道获取下一条消息
       message := <-broadcast

       // 将消息发送给所有连接的客户端
       mutex.Lock()
       for client := range clients {
          err := client.WriteMessage(websocket.TextMessage, message)
          if err != nil {
             client.Close()
             delete(clients, client)
          }
       }
       mutex.Unlock()
    }
}

func main() {
    http.HandleFunc("/ws", wsHandler)
    go handleMessages()
    fmt.Println("WebSocket server started on :8080")
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
       fmt.Println("Error starting server:", err)
    }
}

测试广播

在此实现中，任何客户端向服务器发送消息时，都会将消息广播给所有连接的客户端。您可以通过打开多个 index.html 客户端实例并从每个实例发送信息来测试这一点。

确保 WebSocket 通信的安全性

安全是任何 WebSocket 实现的一个重要方面。以下是一些确保 WebSocket 通信安全的最佳实践。

防范跨站 WebSocket 劫持（CSWSH）

CSWSH 是一个安全漏洞，攻击者可以劫持来自其他来源的 WebSocket 连接。为防止这种情况，请在 WebSocket 服务器中验证来源标头：

var upgrader = websocket.Upgrader{ 
    CheckOrigin：func （r *http.Request）  bool { 
       origin := r.Header.Get（"Origin"）
       return origin == "<http://yourdomain.com>"
     }, 
}

使用安全 WebSockets (wss://)

对于生产应用程序，应始终使用 wss:// 而不是 ws://，以使用 SSL/TLS 加密通信通道。这样可以防止中间人攻击，确保客户端和服务器之间交换的数据是安全的。