Bagaimana untuk menggunakan WebSocket dalam Go?

Dalam beberapa tahun kebelakangan ini, teknologi WebSocket telah menjadi bahagian yang amat diperlukan dalam pembangunan Web. WebSocket ialah protokol untuk komunikasi dupleks penuh melalui sambungan TCP tunggal, yang menjadikan komunikasi antara klien dan pelayan lebih lancar dan lebih cekap. Hari ini, banyak aplikasi web moden menggunakan teknologi WebSocket, seperti sembang masa nyata, permainan dalam talian dan visualisasi data masa nyata.

Sebagai bahasa pengaturcaraan moden, bahasa Go secara semula jadi menyediakan sokongan yang baik untuk teknologi WebSocket. Dalam artikel ini, kami akan mendalami cara menggunakan teknologi WebSocket dalam Go.

Pelaksanaan WebSocket dalam bahasa Go

Protokol WebSocket ialah protokol yang dinaik taraf daripada HTTP, jadi menggunakan WebSocket dalam bahasa Go juga memerlukan menggabungkannya dengan protokol HTTP. Bahasa Go mempunyai pakej net/http terbina dalam, yang menyediakan pelbagai fungsi berkaitan HTTP. Jika kita ingin menggunakan WebSocket dalam Go, hanya import perpustakaan net/http dan github.com/gorilla/websocket.

Seterusnya, mari kita lihat cara menggunakan pustaka github.com/gorilla/websocket untuk melaksanakan WebSocket.

Mencipta pelayan WebSocket

Dalam bahasa Go, cara untuk mencipta pelayan WebSocket agak mudah. Mari lihat terus pada kod berikut, yang menunjukkan cara membuat pelayan HTTP dan menunggu sambungan WebSocket pelanggan:

package main

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

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func main() {
    http.HandleFunc("/ws", handleWebSocket)
    http.ListenAndServe(":8080", nil)
}

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

    for {
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            return
        }
        log.Printf("Received message: %s
", message)

        err = conn.WriteMessage(messageType, message)
        if err != nil {
            log.Println(err)
            return
        }
        log.Printf("Sent message: %s
", message)
    }
}

Dalam kod di atas, kami mula-mula mencipta objek websocket.Upgrader, yang bertanggungjawab untuk memindahkan sambungan HTTP yang masuk dinaik taraf kepada sambungan WebSocket. Kemudian, kami mencipta fungsi handleWebSocket yang akan dipanggil apabila pelanggan menyambung. Fungsi ini mula-mula akan menaik taraf sambungan HTTP masuk kepada sambungan WebSocket, kemudian masukkan gelung, terus menerima maklumat daripada klien, dan menghantar semula maklumat yang diterima kepada klien. Antaranya, conn.ReadMessage() dan conn.WriteMessage() digunakan untuk membaca dan menulis maklumat masing-masing.

Akhir sekali, kami mengikat fungsi handleWebSocket ke laluan /ws dan memulakan pelayan HTTP supaya pelanggan boleh menyambung ke pelayan WebSocket. Jika semuanya berjalan lancar, apabila kita memulakan kod di atas, anda akan melihat output yang serupa dengan yang berikut:

2021/10/13 15:20:06 http: Server started at http://127.0.0.1:8080

Ini bermakna anda telah berjaya mencipta pelayan WebSocket, dan pelanggan boleh menyambung kepadanya melalui ws://localhost:8080/ws pelayan alamat.

Mencipta klien WebSocket

Sama seperti mencipta pelayan WebSocket, kami juga boleh mencipta klien WebSocket dengan mudah dalam bahasa Go. Mari lihat kod berikut, yang menerangkan cara membuat klien yang mewujudkan sambungan dengan pelayan WebSocket:

package main

import (
    "fmt"
    "log"
    "net/url"
    "os"
    "os/signal"
    "syscall"
    "github.com/gorilla/websocket"
)

func main() {
    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, os.Interrupt, syscall.SIGTERM)

    u := url.URL{Scheme: "ws", Host: "localhost:8080", Path: "/ws"}
    log.Printf("Connecting to %s", u.String())

    conn, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
    if err != nil {
        log.Fatal("dial:", err)
    }
    defer conn.Close()

    done := make(chan struct{})
    go func() {
        defer close(done)
        for {
            messageType, message, err := conn.ReadMessage()
            if err != nil {
                log.Println("read:", err)
                return
            }
            log.Printf("Received message: %s
", message)
            if err := conn.WriteMessage(messageType, message); err != nil {
                log.Println("write:", err)
                return
            }
            log.Printf("Sent message: %s
", message)
        }
    }()

    for {
        select {
        case <-done:
            return
        case <-interrupt:
            log.Println("interrupt")

            if err := conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, "")); err != nil {
                log.Println("write close:", err)
                return
            }
            select {
            case <-done:
            case <-time.After(time.Second):
            }
            return
        }
    }
}

Dalam kod di atas, kami menggunakan kaedah websocket.Dial untuk mewujudkan sambungan dengan pelayan WebSocket . Selepas sambungan diwujudkan, kami memasuki gelung tak terhingga, sentiasa menghantar dan menerima maklumat daripada pelayan WebSocket. Antaranya, conn.ReadMessage() dan conn.WriteMessage() digunakan untuk membaca dan menulis maklumat.

Perlu diperhatikan bahawa dalam kod di atas, kami menggunakan channels untuk menunggu operasi selesai. Jika isyarat interrupt diterima, kami akan menghantar mesej websocket.CloseMessage kepada pelayan untuk menutup sambungan WebSocket.

Kesimpulan

Dalam artikel ini, kami mempelajari cara melaksanakan WebSocket dalam bahasa Go menggunakan pustaka github.com/gorilla/websocket. Menggunakan teknologi WebSocket boleh menambah lebih banyak dinamik dan interaksi pada aplikasi web kami, menjadikan aplikasi lebih moden dan mesra pengguna.

Jika anda mempunyai sebarang soalan atau komen tentang teknologi WebSocket dan cara menggunakannya dalam bahasa Go, sila tinggalkan mesej di bawah untuk berkongsi pendapat anda dengan kami.

Atas ialah kandungan terperinci Bagaimana untuk menggunakan WebSocket dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!