golang Petua pengaturcaraan WebSocket: mengendalikan sambungan serentak

Golang ialah bahasa pengaturcaraan yang berkuasa, dan penggunaannya dalam pengaturcaraan WebSocket semakin dihargai oleh pembangun. WebSocket ialah protokol berasaskan TCP yang membenarkan komunikasi dua hala antara klien dan pelayan. Dalam artikel ini, kami akan memperkenalkan cara menggunakan Golang untuk menulis pelayan WebSocket yang cekap yang mengendalikan berbilang sambungan serentak pada masa yang sama. Sebelum memperkenalkan teknik, mari kita pelajari dahulu apa itu WebSocket.

Pengenalan kepada WebSocket

WebSocket ialah protokol komunikasi dupleks penuh yang membolehkan sambungan berterusan diwujudkan antara pelanggan dan pelayan, membolehkan komunikasi dua hala masa nyata. Tidak seperti HTTP, sambungan WebSocket adalah dua arah, dan pelayan boleh secara proaktif menghantar mesej kepada pelanggan tanpa menunggu pelanggan meminta.

Dalam sambungan WebSocket, sebaik sahaja klien memulakan permintaan sambungan, pelayan boleh menggunakan sambungan TCP yang telah ditetapkan untuk menghantar data kepada klien. Pelanggan dan pelayan boleh mendengar dan memproses mesej dalam cara seperti peristiwa Apabila peristiwa dicetuskan, kedua-dua pelanggan dan pelayan boleh menerima data yang dihantar oleh pihak lain.

Petua Pengaturcaraan WebSocket Golang

Sekarang mari kita kaji cara menggunakan Golang untuk menulis pelayan WebSocket yang cekap yang mengendalikan berbilang sambungan serentak pada masa yang sama. Berikut ialah beberapa petua tentang pengaturcaraan Golang WebSocket:

1. Sambungan Serentak

Semasa menulis pelayan WebSocket, kita perlu mempertimbangkan sambungan serentak. Kita perlu memastikan bahawa pelayan boleh mengendalikan berbilang pelanggan yang mewujudkan sambungan secara serentak sambil mengekalkan kebebasan setiap sambungan. Untuk mencapai matlamat ini, kita boleh menggunakan goroutine dan saluran dalam bahasa Go.

Berikut ialah contoh mudah yang menunjukkan cara menggunakan goroutin dan saluran untuk mengendalikan berbilang sambungan serentak:

package main

import (
    "fmt"
    "log"
    "net/http"
)

var clients = make(map[*websocket.Conn]bool) // connected clients
var broadcast = make(chan []byte)           // broadcast channel

// Configure the upgrader
var upgrader = websocket.Upgrader{}

func main() {
    // Create a simple file server
    fs := http.FileServer(http.Dir("public"))
    http.Handle("/", fs)

    // Configure websocket route
    http.HandleFunc("/ws", handleConnections)

    // Start listening for incoming chat messages
    go handleMessages()

    // Start the server on localhost:8000
    log.Println("http server started on :8000")
    err := http.ListenAndServe(":8000", nil)
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

func handleConnections(w http.ResponseWriter, r *http.Request) {
    // Upgrade initial GET request to a websocket
    ws, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Fatal(err)
    }

    // Make sure we close the connection when the function returns
    defer ws.Close()

    // Register our new client
    clients[ws] = true

    for {
        // Read in a new message
        _, msg, err := ws.ReadMessage()
        if err != nil {
            log.Printf("error: %v", err)
            delete(clients, ws)
            break
        }

        // Send the newly received message to the broadcast channel
        broadcast <- msg
    }
}

func handleMessages() {
    for {
        // Grab the next message from the broadcast channel
        msg := <-broadcast

        // Send it out to every client that is currently connected
        for client := range clients {
            err := client.WriteMessage(websocket.TextMessage, msg)
            if err != nil {
                log.Printf("error: %v", err)
                client.Close()
                delete(clients, client)
            }
        }
    }
}

2. Paket degupan jantung

Memandangkan sambungan WebSocket ialah sambungan berterusan, ia mungkin terganggu atas pelbagai sebab, seperti rangkaian Kegagalan atau pelayar dimulakan semula. Untuk mengelakkan perkara ini daripada berlaku, kami harus menghantar paket degupan jantung kepada pelanggan sekali-sekala untuk memastikan sambungan kekal aktif.

Berikut ialah contoh mudah yang menunjukkan cara menggunakan goroutine dan pemasa untuk melaksanakan paket degupan jantung:

package main

import (
    "github.com/gorilla/websocket"
    "time"
)

// Configure the upgrader
var upgrader = websocket.Upgrader{}

func handleConnection(ws *websocket.Conn) {
    // Set the read deadline for the connection
    ws.SetReadDeadline(time.Now().Add(5 * time.Second))

    for {
        // Read a message from the client
        _, _, err := ws.ReadMessage()
        if err != nil {
            if websocket.IsCloseError(err, websocket.CloseAbnormalClosure) ||
                websocket.IsCloseError(err, websocket.CloseGoingAway) {
                // The client has closed the connection
                return
            } else if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                // A timeout has occurred, send a ping message to the client
                ping(ws)
            } else {
                // Some other error has occurred
                log.Println(err)
                return
            }
        }
    }
}

// Send a PING message to the client
func ping(ws *websocket.Conn) {
    if err := ws.WriteMessage(websocket.PingMessage, []byte{}); err != nil {
        log.Println(err)
        ws.Close()
    }
}

// Start the server on localhost:8000
func main() {
    http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
        ws, err := upgrader.Upgrade(w, r, nil)
        if err != nil {
            log.Println(err)
            return
        }

        // Handle the connection using a goroutine
        go handleConnection(ws)
    })

    http.ListenAndServe(":8000", nil)
}

3. Pemutus sambungan

Akhir sekali, kita perlu mempertimbangkan pemutusan sambungan WebSocket. Apabila melaksanakan pelayan WebSocket, kita perlu mengambil kira kitaran hayat sambungan supaya sanitasi yang betul berlaku apabila data dipindahkan antara klien dan pelayan.

Berikut ialah contoh mudah yang menunjukkan cara menggunakan pernyataan goroutine dan pilih untuk mencapai pemutusan sambungan WebSocket:

package main

import (
    "github.com/gorilla/websocket"
)

var clients = make(map[*websocket.Conn]bool)
var broadcast = make(chan Message)
var unregister = make(chan *websocket.Conn)

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

    go handleMessages()

    http.ListenAndServe(":8000", nil)
}

type Message struct {
    Type int    `json:"type"`
    Body string `json:"body"`
}

func handleConnections(w http.ResponseWriter, r *http.Request) {
    upgrader := websocket.Upgrader{}
    ws, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    defer ws.Close()

    clients[ws] = true

    for {
        var msg Message
        err := ws.ReadJSON(&msg)
        if err != nil {
            if websocket.IsCloseError(err, websocket.CloseGoingAway) {
                unregister <- ws
                break
            }
            log.Printf("error: %v", err)
            continue
        }
        broadcast <- msg
    }
}

func handleMessages() {
    for {
        select {
        case msg := <-broadcast:
            for client := range clients {
                err := client.WriteJSON(msg)
                if err != nil {
                    log.Printf("error: %v", err)
                    unregister <- client
                    break
                }
            }
        case client := <-unregister:
            delete(clients, client)
        }
    }
}

Ringkasan

Dalam artikel ini, kami memperkenalkan beberapa petua tentang pengaturcaraan Golang WebSocket. Kami mempelajari cara menggunakan goroutin dan saluran untuk mengendalikan sambungan serentak, cara menghantar paket degupan jantung untuk memastikan sambungan kekal sah dan cara melakukan operasi pembersihan yang sesuai apabila sambungan diputuskan. Kami berharap petua ini membantu anda dalam menulis pelayan WebSocket yang cekap.

Atas ialah kandungan terperinci golang Petua pengaturcaraan WebSocket: mengendalikan sambungan serentak. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!