Cara menggunakan bahasa Go untuk membangunkan sistem penghantaran data masa nyata berdasarkan Websocket-Golang-php.cn

Cara menggunakan bahasa Go untuk membangunkan sistem penghantaran data masa nyata berdasarkan Websocket

WBOY

Lepaskan： 2023-12-18 18:39:46

asal

657 orang telah melayarinya

Cara menggunakan bahasa Go untuk membangunkan sistem penghantaran data masa nyata berdasarkan Websocket

Cara menggunakan bahasa Go untuk membangunkan sistem penghantaran data masa nyata berdasarkan Websocket, contoh kod khusus diperlukan

Websocket ialah protokol dupleks penuh, yang boleh mencapai penghantaran data masa nyata tanpa menyegarkan halaman. Dalam aplikasi web moden, pemindahan data masa nyata adalah bahagian yang penting. Artikel ini akan memperkenalkan cara menggunakan bahasa Go untuk membangunkan sistem penghantaran data masa nyata berdasarkan Websocket, termasuk cara melaksanakan kod sisi pelayan dan sisi klien serta memberikan contoh kod khusus.

Buat pelayan WebSocket

Untuk mencipta sistem penghantaran data masa nyata berdasarkan Websocket, anda perlu mencipta pelayan Websocket terlebih dahulu. Dalam Go, anda boleh menggunakan perpustakaan gorila/soket web untuk mencipta pelayan Websocket.

Berikut ialah contoh kod untuk pelayan Websocket mudah:

package main

import (
    "fmt"
    "net/http"

    "github.com/gorilla/websocket"
)

// 定义升级器
var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func serveWs(w http.ResponseWriter, r *http.Request) {
    // 升级请求为Websocket
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 读取Websocket消息
    for {
        messageType, p, err := conn.ReadMessage()
        if err != nil {
            fmt.Println(err)
            return
        }

        // 处理消息
        fmt.Println(string(p))

        // 回复消息
        err = conn.WriteMessage(messageType, p)
        if err != nil {
            fmt.Println(err)
            return
        }
    }
}

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

Salin selepas log masuk

Dalam contoh ini, kami mula-mula mentakrifkan peningkatan (penaik taraf), yang digunakan untuk menaik taraf sambungan HTTP kepada sambungan Websocket. Kemudian, kami mentakrifkan fungsi serveW yang menerima penulis respons HTTP (w) dan permintaan HTTP (r) dan meningkatkan sambungan HTTP kepada sambungan Websocket.

Dalam fungsi serveWs, kami mula-mula menaik taraf sambungan HTTP kepada sambungan Websocket. Kami kemudian menggunakan gelung untuk membaca mesej Websocket. Sebaik sahaja kami telah membaca mesej itu, kami memprosesnya dan menghantar semula mesej yang sama kepada pelanggan.

Akhir sekali, dalam fungsi utama, kami mengaitkan fungsi serveWs dengan laluan /ws dan memulakan pelayan HTTP pada port 8080.

Cipta Pelanggan Websocket

Sebelum membuat klien Websocket, kita perlu membuat halaman HTML yang akan berkomunikasi dengan pelayan melalui Websocket. Berikut ialah contoh kod untuk halaman HTML asas:

<!DOCTYPE html>
<html>
<head>
    <title>Websocket Example</title>
</head>
<body>

    <textarea id="message"></textarea>
    <button onclick="send()">Send</button>

    <script>
    // 创建Websocket对象
    var ws = new WebSocket("ws://localhost:8080/ws");

    // 接收来自服务器的消息
    ws.onmessage = function(event) {
        console.log(event.data);
    };

    // 发送消息到服务器
    function send() {
        var input = document.getElementById("message");
        ws.send(input.value);
        input.value = "";
    }
    </script>

</body>
</html>

Salin selepas log masuk

Dalam contoh ini, kami mencipta kawasan teks (mesej) dan butang (hantar). Apabila pengguna mengklik butang hantar, kami menghantar teks yang dimasukkan ke pelayan melalui Websocket.

Dalam JavaScript, kami menggunakan objek WebSocket untuk mencipta klien Websocket. Dalam contoh kami, klien Websocket akan menyambung ke laluan /ws dan apabila ia menerima mesej daripada pelayan, ia akan mengeluarkannya ke konsol.

Jalankan Pelayan dan Pelanggan Websocket

Untuk menjalankan Pelayan dan Pelanggan Websocket, ikut langkah berikut:

Dalam terminal, gunakan baris arahan untuk menukar kepada direktori yang mengandungi kod pelayan sampel.
Masukkan arahan berikut untuk memulakan pelayan:

go run main.go

Salin selepas log masuk

Dalam pelayar anda, buka URL berikut untuk memuatkan contoh halaman HTML:

http://localhost:8080/

Salin selepas log masuk

Masukkan beberapa teks dalam kawasan teks dan klik butang Hantar. Anda sepatutnya melihat mesej dihantar dan dikembalikan daripada pelayan, dan output dalam konsol penyemak imbas.
Penghantaran data masa nyata

Kini, kami telah berjaya mencipta pelayan dan pelanggan Websocket yang ringkas, tetapi ini hanyalah permulaan. Untuk mencapai penghantaran data masa nyata, kita perlu mengubah suai kod bahagian pelayan dan sisi klien dan menggunakan goroutine pada bahagian pelayan untuk mengendalikan berbilang sambungan Websocket.

Berikut ialah contoh kod yang melaksanakan penghantaran data masa nyata:

package main

import (
    "fmt"
    "net/http"
    "time"

    "github.com/gorilla/websocket"
)

// 定义升级器
var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

// 定义客户端
type Client struct {
    conn *websocket.Conn
    send chan []byte
}

// 处理客户端消息
func (c *Client) read() {
    defer func() {
        c.conn.Close()
    }()
    for {
        messageType, p, err := c.conn.ReadMessage()
        if err != nil {
            fmt.Println(err)
            return
        }
        // 处理消息
        fmt.Printf("Received: %s
", p)
    }
}

// 发送消息到客户端
func (c *Client) write() {
    defer func() {
        c.conn.Close()
    }()
    for {
        select {
        case message, ok := <-c.send:
            if !ok {
                c.conn.WriteMessage(websocket.CloseMessage, []byte{})
                return
            }
            writer, err := c.conn.NextWriter(websocket.TextMessage)
            if err != nil {
                return
            }
            writer.Write(message)
            if err := writer.Close(); err != nil {
                return
            }
        }
    }
}

// 定义Hub
type Hub struct {
    clients map[*Client]bool
    broadcast chan []byte
    register chan *Client
    unregister chan *Client
}

// 创建Hub
func newHub() *Hub {
    return &Hub{
        clients:    make(map[*Client]bool),
        broadcast:  make(chan []byte),
        register:   make(chan *Client),
        unregister: make(chan *Client),
    }
}

// 运行Hub
func (h *Hub) run() {
    for {
        select {
        case client := <-h.register:
            h.clients[client] = true
            fmt.Println("Client registered")
        case client := <-h.unregister:
            if _, ok := h.clients[client]; ok {
                delete(h.clients, client)
                close(client.send)
                fmt.Println("Client unregistered")
            }
        case message := <-h.broadcast:
            for client := range h.clients {
                select {
                case client.send <- message:
                    fmt.Printf("Sent: %s
", message)
                default:
                    close(client.send)
                    delete(h.clients, client)
                }
            }
        }
    }
}

func serveWs(hub *Hub, w http.ResponseWriter, r *http.Request) {
    // 升级请求为Websocket
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 创建客户端
    client := &Client{
        conn: conn,
        send: make(chan []byte),
    }

    // 注册客户端
    hub.register <- client

    // 读取Websocket消息
    go client.read()

    // 发送Websocket消息
    go client.write()
}

func main() {
    // 创建Hub
    hub := newHub()

    // 运行Hub
    go hub.run()

    // 定期广播消息
    go func() {
        for {
            hub.broadcast <- []byte(fmt.Sprintf("Server Time: %s", time.Now().Format("2006-01-02 15:04:05")))
            time.Sleep(1 * time.Second)
        }
    }()

    // 启动HTTP服务器
    http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
        serveWs(hub, w, r)
    })
    http.Handle("/", http.FileServer(http.Dir(".")))
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        panic(err)
    }
}

Salin selepas log masuk

Dalam contoh ini, kami mentakrifkan Hab yang mengurus berbilang pelanggan Websocket. Setiap pelanggan mempunyai goroutine baca (terima) dan goroutine tulis (hantar), yang mengendalikan mesej yang dibaca daripada pelanggan dan mesej yang dihantar kepada pelanggan masing-masing.

Selain memproses mesej pelanggan, Hub juga mengandungi saluran penyiaran untuk penyiaran mesej kepada semua pelanggan. Dalam contoh kami, Hab menyiarkan tarikh dan masa semasa secara berkala.

Kesimpulan

Melalui contoh kod dalam artikel ini, kami mempelajari cara menggunakan bahasa Go untuk mencipta sistem penghantaran data masa nyata berdasarkan Websocket. Kami mempelajari cara menggunakan perpustakaan gorila/websocket untuk mencipta pelayan dan klien Websocket, dan melaksanakan cara mengendalikan input klien, cara menghantar mesej kepada klien, dan melaksanakan Hab yang mengurus berbilang klien Websocket, dan melaksanakan Logik menyiarkan mesej.

Atas ialah kandungan terperinci Cara menggunakan bahasa Go untuk membangunkan sistem penghantaran data masa nyata berdasarkan Websocket. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!