Golang?WebSocket創(chuàng)建單獨會話詳細實例

更新時間：2023年11月16日 11:11:31 作者：一只會寫程序的貓

這篇文章主要給大家介紹了關于Golang?WebSocket創(chuàng)建單獨會話的相關資料,WebSocket 協(xié)議主要為了解決基于 HTTP/1.x 的 Web 應用無法實現(xiàn)服務端向客戶端主動推送的問題,文中通過代碼介紹的非常詳細,需要的朋友可以參考下

引言

在互聯(lián)網應用程序中，實時通信是一種非常重要的功能。WebSocket 是一種基于 TCP 的協(xié)議，它允許客戶端和服務器之間進行雙向通信。Golang 是一種高性能的編程語言，它提供了對 WebSocket 的原生支持，使得在 Golang 中創(chuàng)建 WebSocket 會話變得非常簡單。本文將介紹如何使用 Golang 創(chuàng)建單獨的 WebSocket 會話，以實現(xiàn)實時通信功能。

WebSocket 簡介

WebSocket 是一種在單個 TCP 連接上進行全雙工通信的協(xié)議。它與傳統(tǒng)的 HTTP 協(xié)議不同，HTTP 是一種無狀態(tài)的協(xié)議，每個請求都需要建立一個新的連接。而 WebSocket 在客戶端和服務器之間建立一條持久的連接，可以實現(xiàn)實時的雙向通信。

WebSocket 協(xié)議的握手是通過 HTTP 請求完成的，握手后，客戶端和服務器之間的連接將保持打開狀態(tài)，可以發(fā)送和接收任意數(shù)據。WebSocket 使用一種類似于事件的機制，當有新消息到達時，服務器可以主動推送給客戶端，而不需要客戶端主動發(fā)送請求。

Golang 中的 WebSocket 支持

Golang 提供了 net/http 包來處理 HTTP 請求和響應，同時也提供了 gorilla/websocket 庫來實現(xiàn) WebSocket 協(xié)議的支持。gorilla/websocket 是一個非常流行的第三方庫，它提供了對 WebSocket 協(xié)議的高級封裝，使得在 Golang 中創(chuàng)建 WebSocket 會話變得更加簡單。

在開始之前，我們首先需要安裝 gorilla/websocket 庫?？梢允褂靡韵旅顏戆惭b：

go get github.com/gorilla/websocket

安裝完成后，我們就可以開始創(chuàng)建 WebSocket 會話了。

創(chuàng)建 WebSocket 服務器

首先，我們需要創(chuàng)建一個 WebSocket 服務器，用于接收來自客戶端的連接請求，并處理 WebSocket 會話。以下是一個簡單的 WebSocket 服務器示例：

package main
import (
    "log"
    "net/http"
    "github.com/gorilla/websocket"
)
// 創(chuàng)建一個 upgrader 對象，用于升級 HTTP 連接為 WebSocket 連接
var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}
func main() {
    http.HandleFunc("/ws", handleWebSocket)
    log.Fatal(http.ListenAndServe(":8080", nil))
}
func handleWebSocket(w http.ResponseWriter, r *http.Request) {
    // 將 HTTP 連接升級為 WebSocket 連接
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("Upgrade failed:", err)
        return
    }
    defer conn.Close()
    // 處理 WebSocket 會話
    for {
        // 讀取客戶端發(fā)送的消息
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            log.Println("Read message failed:", err)
            break
        }
        // 處理客戶端發(fā)送的消息
        log.Printf("Received message: %s", message)
        // 回復客戶端消息
        err = conn.WriteMessage(messageType, message)
        if err != nil {
            log.Println("Write message failed:", err)
            break
        }
    }
}

在上面的示例中，我們首先創(chuàng)建了一個 upgrader 對象，它用于將 HTTP 連接升級為 WebSocket 連接。然后，我們定義了一個 handleWebSocket 函數(shù)，用于處理 WebSocket 會話。在該函數(shù)中，我們首先將 HTTP 連接升級為 WebSocket 連接，然后進入一個無限循環(huán)，不斷讀取客戶端發(fā)送的消息，并給客戶端回復相同的消息。

最后，我們使用 http.HandleFunc 函數(shù)將 /ws 路徑映射到 handleWebSocket 函數(shù)，然后調用 http.ListenAndServe 函數(shù)來啟動 WebSocket 服務器。

創(chuàng)建 WebSocket 客戶端

接下來，我們需要創(chuàng)建一個 WebSocket 客戶端，用于向服務器發(fā)送 WebSocket 請求，并處理服務器推送的消息。以下是一個簡單的 WebSocket 客戶端示例：

package main
import (
    "log"
    "os"
    "os/signal"
    "time"
    "github.com/gorilla/websocket"
)
func main() {
    // 創(chuàng)建一個 dialer 對象，用于建立 WebSocket 連接
    dialer := websocket.Dialer{
        HandshakeTimeout: 10 * time.Second,
    }
    // 建立 WebSocket 連接
    conn, _, err := dialer.Dial("ws://localhost:8080/ws", nil)
    if err != nil {
        log.Fatal("Dial failed:", err)
    }
    defer conn.Close()
    // 啟動一個 goroutine 來接收服務器推送的消息
    go func() {
        for {
            _, message, err := conn.ReadMessage()
            if err != nil {
                log.Println("Read message failed:", err)
                break
            }
            log.Printf("Received message: %s", message)
        }
    }()
    // 向服務器發(fā)送消息
    message := []byte("Hello, WebSocket!")
    err = conn.WriteMessage(websocket.TextMessage, message)
    if err != nil {
        log.Println("Write message failed:", err)
        return
    }
    // 等待用戶按下 Ctrl+C 終止程序
    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, os.Interrupt)
    <-interrupt
}

在上面的示例中，我們首先創(chuàng)建了一個 dialer 對象，它用于建立 WebSocket 連接。然后，我們使用 dialer.Dial 函數(shù)建立 WebSocket 連接，并指定服務器的地址為 ws://localhost:8080/ws。然后，我們使用 conn.WriteMessage 函數(shù)向服務器發(fā)送消息，并使用一個 goroutine 來接收服務器推送的消息。

最后，我們使用 signal.Notify 函數(shù)來注冊一個信號監(jiān)聽器，當用戶按下 Ctrl+C 時，程序會接收到一個中斷信號，然后程序退出。

創(chuàng)建單獨會話

在實際應用中，我們可能需要為每個客戶端創(chuàng)建一個單獨的會話，以便管理和跟蹤客戶端的狀態(tài)。在 Golang 中，可以通過為每個 WebSocket 連接創(chuàng)建一個獨立的 goroutine 來實現(xiàn)這一點。以下是一個示例：

package main
import (
    "log"
    "net/http"
    "github.com/gorilla/websocket"
)
var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}
func main() {
    http.HandleFunc("/ws", handleWebSocket)
    log.Fatal(http.ListenAndServe(":8080", nil))
}
func handleWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("Upgrade failed:", err)
        return
    }
    defer conn.Close()
    // 創(chuàng)建一個獨立的會話
    session := NewSession()
    // 處理會話
    session.Handle(conn)
}
type Session struct {
    conn *websocket.Conn
}
func NewSession() *Session {
    return &Session{}
}
func (s *Session) Handle(conn *websocket.Conn) {
    s.conn = conn
    go s.readLoop()
    go s.writeLoop()
}
func (s *Session) readLoop() {
    for {
        messageType, message, err := s.conn.ReadMessage()
        if err != nil {
            log.Println("Read message failed:", err)
            break
        }
        log.Printf("Received message: %s", message)
    }
}
func (s *Session) writeLoop() {
    for {
        select {
        // 從消息隊列中獲取消息并發(fā)送給客戶端
        case message := <-s.messageQueue:
            err := s.conn.WriteMessage(websocket.TextMessage, message)
            if err != nil {
                log.Println("Write message failed:", err)
            }
        }
    }
}

在上面的示例中，我們首先定義了一個 Session 結構體，它包含一個 WebSocket 連接。然后，我們創(chuàng)建了一個 NewSession 函數(shù)，用于創(chuàng)建一個新的會話對象。會話對象有兩個重要的方法：Handle 方法用