Bagaimana untuk memulakan dan menutup sambungan Websocket di Golang

Websocket ialah protokol rangkaian yang membolehkan komunikasi dua hala masa nyata antara pelanggan dan pelayan. Ia boleh mencapai penghantaran data yang cekap dan kesan interaksi kependaman rendah pada masa yang sama tanpa menggunakan tinjauan HTTP. Golang ialah sumber terbuka, bahasa pengaturcaraan berprestasi tinggi dengan prestasi serentak yang sangat baik dan kualiti kod yang sangat baik. Dalam komunikasi Websocket, Golang juga mempunyai kaedah pelaksanaan yang sangat baik. Artikel ini akan memperkenalkan cara untuk memulakan dan menutup sambungan Websocket di Golang.

Pelaksanaan Websocket di Golang

Untuk melaksanakan Websocket di Golang, anda perlu melakukan langkah berikut:

1. Import pakej yang sepadan

Dalam bahasa Go, melaksanakan Websocket memerlukan sokongan pakej WebSocket dan Http. Kodnya adalah seperti berikut:

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

Antaranya, github.com/gorilla/websocket ialah pakej WebSocket yang sangat baik yang menyokong pelbagai protokol. Ia mengandungi beberapa struktur dan fungsi berkaitan WebSocket, yang boleh kami gunakan untuk melaksanakan sambungan WebSocket dengan cepat.

2. Tentukan fungsi pemprosesan sambungan WebSocket

Dalam fungsi yang mengendalikan sambungan WebSocket, kita perlu menyelesaikan tugas berikut:

a

Untuk permintaan HTTP, jika ia perlu ditingkatkan kepada sambungan WebSocket, kami perlu memprosesnya dan mengembalikan permintaan naik taraf yang berkaitan. Kodnya adalah seperti berikut:

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

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    // 升级为WebSocket连接
    ws, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    
    // 实现WebSocket通信
    ...
}

Dalam kod ini, kami menggunakan struktur Penaik Taraf, iaitu fungsi dalam perpustakaan gorila/soket web untuk melaksanakan peningkatan WebSocket.

Peningkatan termasuk saiz penimbal baca dan tulis serta fungsi CheckOrigin. CheckOrigin digunakan untuk menyemak sama ada permintaan itu datang daripada sumber yang sah. Jika kaedah ini mengembalikan palsu, permintaan naik taraf akan ditolak. Memandangkan kami tidak perlu menyemak kesahihan dalam contoh ini, CheckOrigin kami sentiasa mengembalikan benar.

Selepas memanggil kaedah Upgrader.Upgrade, kita akan mendapat objek WebSocket ws. Pada objek ini, kita boleh memanggil kaedah seperti ReadMessage dan WriteMessage untuk melengkapkan komunikasi WebSocket berikutnya.

b. Baca mesej WebSocket

Selepas mendapat sambungan WebSocket, kami perlu terus membaca mesej yang dihantar oleh pelanggan. Untuk membaca mesej WebSocket, anda boleh menggunakan kaedah ReadMessage. Kodnya adalah seperti berikut:

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    ...
    
    for {
        // 读取消息
        _, message, err := ws.ReadMessage()
        if err != nil {
            log.Println(err)
            break
        }
        
        // 处理消息
        ...
    }
}

Dalam kod ini, kami menggunakan gelung for untuk terus membaca mesej daripada WebSocket. Jika bacaan gagal, sambungan WebSocket telah ditutup dan kami keluar dari gelung.

c. Hantar mesej WebSocket

Selepas memproses mesej yang dihantar oleh pelanggan, kami mungkin perlu menghantar beberapa hasil pemprosesan kepada pelanggan. Untuk menghantar mesej WebSocket, anda boleh menggunakan kaedah WriteMessage. Kodnya adalah seperti berikut:

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    ...
    
    for {
        ...
        
        // 发送消息
        err = ws.WriteMessage(websocket.TextMessage, []byte(reply))
        if err != nil {
            log.Println(err)
            break
        }
    }
}

Dalam kod ini, kami menghantar mesej kepada pelanggan melalui kaedah WriteMessage. Parameter pertama kaedah ini ialah jenis mesej, yang boleh kita tentukan sebagai TextMessage atau BinaryMessage parameter kedua ialah tatasusunan bait yang mengandungi data yang akan dihantar.

3. Mulakan perkhidmatan WebSocket

Selepas melengkapkan langkah di atas, kami boleh memulakan perkhidmatan WebSocket. Kodnya adalah seperti berikut:

func main() {
    http.HandleFunc("/ws", websocketHandler)
    log.Println("Server started at http://127.0.0.1:8080")
    http.ListenAndServe(":8080", nil)
}

Dalam kod ini, kami memanggil fungsi http.HandleFunc untuk memetakan laluan "/ws" ke fungsi pemprosesan WebSocket kami websocketHandler. Akhir sekali, kami memanggil http.ListenAndServe untuk memulakan perkhidmatan.

Tutup sambungan WebSocket

Selepas menggunakan WebSocket, kita perlu menutup sambungan secara manual. Untuk menutup sambungan WebSocket seperti biasa, anda perlu memberi perhatian kepada perkara berikut:

a Bahagian pelayan ditutup secara aktif

Apabila bahagian pelayan perlu menutup sambungan WebSocket, ia boleh memanggil. kaedah WebSocket.Close. Kodnya adalah seperti berikut:

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    defer ws.Close() // 关闭WebSocket连接
    
    for {
        ...
    }
}

Dalam kod ini, kami menggunakan penyata tangguh untuk menutup sambungan WebSocket secara automatik pada penghujung fungsi websocket.

b. Pelanggan menutup secara aktif

Apabila pelanggan perlu menutup sambungan WebSocket, ia boleh menghantar mesej Tutup kepada pelayan. Pelayan akan menerima mesej Tutup dan menutup sambungan WebSocket secara aktif selepas menerima mesej.

Kami boleh menambah cawangan untuk mengendalikan mesej Tutup dalam fungsi soket web sebelah pelayan. Kodnya adalah seperti berikut:

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    ...
    
    for {
        // 读取消息
        messageType, message, err := ws.ReadMessage()
        if err != nil {
            log.Println(err)
            break
        }
        
        // 处理消息
        switch messageType {
        case websocket.CloseMessage:
            // 收到关闭消息，关闭连接
            return
        case websocket.TextMessage:
            // 收到文本消息，处理消息
            ...
        case websocket.BinaryMessage:
            ...
        }
    }
    
    // 关闭WebSocket连接
    ws.Close()
}

Dalam kod ini, kami menambah cawangan pemprosesan dengan jenis mesej CloseMessage. Selepas menerima mesej Tutup, kami segera keluar dari fungsi websocket dan menutup sambungan WebSocket.

c. Penutupan tidak normal

Apabila keabnormalan berlaku dalam sambungan WebSocket, sambungan perlu ditutup tepat pada masanya. Contohnya, apabila rangkaian diputuskan, sambungan antara klien dan pelayan tamat masa, dsb., sambungan WebSocket perlu ditutup.

Kita boleh menangkap pengecualian dalam fungsi websocket dan menutup sambungan WebSocket apabila pengecualian ditangkap. Kodnya adalah seperti berikut:

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    defer ws.Close() // 当函数退出时关掉WebSocket连接
    
    for {
        _, message, err := ws.ReadMessage()
        if err != nil {
            if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) {
                log.Printf("error: %v", err)
            }
            break
        }
        
        // 处理消息
        ...
    }
}

Dalam kod ini, kami menutup sambungan WebSocket secara manual melalui pernyataan penangguhan sebelum fungsi websocket kembali. Dalam operasi ReadMessage, kami menambah keupayaan untuk menangkap ralat pengecualian dan melaksanakan output log.

Ringkasan

Di Golang, sambungan Websocket boleh dicapai melalui perpustakaan gorila/websocket. Kita boleh menggunakan struktur Penaik Taraf dalam fungsi pemprosesan komunikasi WebSocket untuk menaik taraf protokol HTTP kepada WebSocket. Apabila menyambung ke WebSocket, kita perlu melaksanakan beberapa operasi membaca dan menghantar mesej WebSocket.

Untuk memastikan penutupan biasa sambungan WebSocket, kita perlu memberi perhatian kepada perkara berikut:

1. Pelayan mesti menutup sambungan WebSocket secara manual selepas menyelesaikan operasi;
2. Apabila pelanggan menerima mesej Tutup, pelayan harus segera menutup sambungan WebSocket; Sambungan WebSocket berlaku Apabila pengecualian berlaku, sambungan perlu ditutup dengan segera selepas menangkap pengecualian.

Atas ialah kandungan terperinci Bagaimana untuk memulakan dan menutup sambungan Websocket di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!