快捷導(dǎo)航

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

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

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

引言

在互聯(lián)網(wǎng)應(yīng)用程序中，實時通信是一種非常重要的功能。WebSocket 是一種基于 TCP 的協(xié)議，它允許客戶端和服務(wù)器之間進行雙向通信。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 在客戶端和服務(wù)器之間建立一條持久的連接，可以實現(xiàn)實時的雙向通信。

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

Golang 中的 WebSocket 支持

Golang 提供了 net/http 包來處理 HTTP 請求和響應(yīng)，同時也提供了 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 服務(wù)器

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

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)
        // 回復(fù)客戶端消息
        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ā)送的消息，并給客戶端回復(fù)相同的消息。

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

創(chuàng)建 WebSocket 客戶端

接下來，我們需要創(chuàng)建一個 WebSocket 客戶端，用于向服務(wù)器發(fā)送 WebSocket 請求，并處理服務(wù)器推送的消息。以下是一個簡單的 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 來接收服務(wù)器推送的消息
    go func() {
        for {
            _, message, err := conn.ReadMessage()
            if err != nil {
                log.Println("Read message failed:", err)
                break
            }
            log.Printf("Received message: %s", message)
        }
    }()
    // 向服務(wù)器發(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 連接，并指定服務(wù)器的地址為 ws://localhost:8080/ws。然后，我們使用 conn.WriteMessage 函數(shù)向服務(wù)器發(fā)送消息，并使用一個 goroutine 來接收服務(wù)器推送的消息。

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

創(chuàng)建單獨會話

在實際應(yī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 結(jié)構(gòu)體，它包含一個 WebSocket 連接。然后，我們創(chuàng)建了一個 NewSession 函數(shù)，用于創(chuàng)建一個新的會話對象。會話對象有兩個重要的方法：Handle 方法用