Amalan pembangunan Websocket bahasa Go: cara mengendalikan pengecualian dan sambungan rapat

Amalan Pembangunan Soket Web Bahasa Go: Cara Mengendalikan Penutupan Sambungan Tidak Normal

Pengenalan:
Dalam pembangunan Web, protokol Websocket boleh digunakan untuk mencapai komunikasi dua hala, yang biasanya digunakan dalam penghantaran data masa nyata, aplikasi sembang dan senario lain. Walau bagaimanapun, apabila menggunakan Websocket, adalah mudah untuk menghadapi gangguan sambungan yang tidak dijangka, seperti turun naik rangkaian, penutupan pelanggan yang tidak normal, dsb. Cara mengendalikan penutupan sambungan tidak normal dengan betul dalam kes ini dan memastikan kestabilan dan kebolehpercayaan aplikasi telah menjadi isu yang perlu diberi tumpuan semasa pembangunan. Artikel ini akan menggabungkan kod sampel dan mengambil bahasa Go sebagai contoh untuk memperkenalkan cara mengendalikan pengecualian dan sambungan rapat.

1 Buat pelayan Websocket:
Pertama, kita perlu mencipta pelayan Websocket yang mudah. Berikut ialah kod sampel asas:

package main

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

// 定义Websocket读写的缓冲区大小
const bufferSize = 1024

// Websocket处理函数
func wsHandler(w http.ResponseWriter, r *http.Request) {
    // 升级HTTP连接为Websocket连接
    conn, err := websocket.Upgrade(w, r, nil, bufferSize, bufferSize)
    if err != nil {
        fmt.Println("Failed to upgrade the connection to websocket: ", err)
        return
    }

    for {
        // 读取客户端发送的消息
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            fmt.Println("Failed to read message from client: ", err)
            break
        }

        // 处理接收到的消息
        handleMessage(conn, messageType, message)
    }

    // 关闭连接
    defer conn.Close()
}

// 处理接收到的消息
func handleMessage(conn *websocket.Conn, messageType int, message []byte) {
    // 处理消息的逻辑
    fmt.Println("Received message: ", string(message))
}

2. Mengendalikan penutupan sambungan yang tidak normal:
Apabila pelanggan menutup secara tidak normal, pelayan perlu dapat mengesan dengan betul bahawa sambungan telah ditutup dan mengendalikannya dengan sewajarnya. Berikut ialah contoh kod tentang cara mengendalikan sambungan tertutup tidak normal:

// Websocket处理函数
func wsHandler(w http.ResponseWriter, r *http.Request) {
    // 升级HTTP连接为Websocket连接
    conn, err := websocket.Upgrade(w, r, nil, bufferSize, bufferSize)
    if err != nil {
        fmt.Println("Failed to upgrade the connection to websocket: ", err)
        return
    }

    // 异常关闭连接处理协程
    go handleCloseConnection(conn)

    for {
        // 读取客户端发送的消息
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            // 检测到连接异常关闭的错误
            if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
                fmt.Println("Connection closed unexpectedly: ", err)
                break
            }
            // 其他错误处理
            fmt.Println("Failed to read message from client: ", err)
            break
        }

        // 处理接收到的消息
        handleMessage(conn, messageType, message)
    }

    // 关闭连接
    conn.Close()
}

// 异常关闭连接处理协程
func handleCloseConnection(conn *websocket.Conn) {
    // 读取关闭消息，表示客户端主动关闭连接
    _, _, err := conn.ReadMessage()
    if err != nil {
        fmt.Println("Failed to read close message from client: ", err)
    }

    // 处理连接关闭后的逻辑
    fmt.Println("Connection closed by client")
}

Dalam kod contoh di atas, kami menentukan sama ada sambungan ditutup secara tidak normal dengan memanggil fungsi IsUnexpectedCloseError. Jika ia ditutup secara tidak normal, maklumat ralat yang sepadan akan direkodkan, gelung akan melompat keluar, dan sambungan akan ditutup. Selain itu, kami juga menambah fungsi coroutine bernama handleCloseConnection untuk mengendalikan logik selepas sambungan ditutup. IsUnexpectedCloseError函数来判断连接是否异常关闭。如果是异常关闭的情况，则记录相应的错误信息，并跳出循环，关闭连接。另外，我们还添加了一个名为handleCloseConnection的协程函数，用于处理连接关闭后的逻辑。

结论：
在开发Websocket应用时，处理异常关闭连接是非常重要的一环。通过使用IsUnexpectedCloseError

Kesimpulan:

Apabila membangunkan aplikasi Websocket, pengendalian pengecualian dan menutup sambungan adalah langkah yang sangat penting. Dengan menggunakan fungsi IsUnexpectedCloseError dan pemprosesan coroutine, kami boleh mengesan dan mengendalikan penutupan sambungan yang tidak normal, mengelakkan ranap aplikasi disebabkan oleh pengecualian sambungan. Dalam aplikasi sebenar, pengembangan yang sepadan boleh dilakukan mengikut keperluan khusus, seperti log rakaman, menghantar pemberitahuan, dsb., untuk meningkatkan kebolehpercayaan dan kebolehselenggaraan aplikasi.

Rujukan:
• [Gorilla WebSocket](https://github.com/gorilla/websocket)
• [Go Standard Library Documentation](https://golang.org/pkg/net/http/)

[Panduan Pembangunan Protokol WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket_API/Writing_WebSocket_servers)🎜🎜

Atas ialah kandungan terperinci Amalan pembangunan Websocket bahasa Go: cara mengendalikan pengecualian dan sambungan rapat. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!