Pembangunan Golang: Tolak data masa nyata berdasarkan WebSockets

Pembangunan Golang: Melaksanakan tolak data masa nyata berdasarkan WebSockets

Abstrak: Artikel ini akan memperkenalkan cara menggunakan Golang untuk membangunkan fungsi tolak data masa nyata berdasarkan WebSockets. Mula-mula, kami akan menerangkan apakah itu WebSockets dan sebab anda perlu menggunakannya untuk menolak data masa nyata. Kami kemudiannya menyediakan beberapa contoh kod Golang yang menunjukkan cara menggunakan perpustakaan Gorilla WebSocket untuk membangunkan pelayan tolak data masa nyata yang ringkas.

Pengenalan:
Dalam pembangunan web, tolakan data masa nyata (Penstriman masa nyata) adalah keperluan yang sangat biasa. Tolakan data masa nyata membolehkan aplikasi menghantar data kepada pelanggan dalam masa nyata, dan membolehkan pelanggan menerima dan memaparkan data ini dalam masa nyata. Model respons permintaan HTTP tradisional bukanlah pilihan terbaik untuk tolak data masa nyata kerana ia memerlukan pelanggan membuat permintaan yang kerap untuk mendapatkan data terkini. WebSockets menyediakan penyelesaian yang lebih cekap dan masa nyata.

Apakah itu WebSockets?
WebSockets ialah teknologi yang disediakan oleh HTML5 untuk komunikasi dua hala masa nyata antara pelanggan dan pelayan. Ia membolehkan pelayan untuk menolak data secara aktif kepada pelanggan tanpa pelanggan membuat permintaan terlebih dahulu. Berbanding dengan model respons permintaan HTTP tradisional, WebSockets mempunyai kelebihan berikut:

1. Sambungan antara pelanggan dan pelayan adalah berterusan, dan tidak perlu kerap membuat dan memutuskan sambungan, menjimatkan overhed rangkaian.
2. Pelayan boleh menolak data secara aktif kepada pelanggan tanpa menunggu permintaan pelanggan.
3. Komunikasi antara pelanggan dan pelayan adalah dupleks penuh, dan data boleh dihantar dan diterima pada masa yang sama.

Golang melaksanakan tolak data masa nyata untuk WebSockets:
Contoh kod berikut akan menunjukkan cara menggunakan Golang untuk membangunkan pelayan tolak data masa nyata yang ringkas. Kami akan menggunakan perpustakaan WebSocket Gorilla untuk melaksanakan fungsi WebSockets.

Pertama sekali, kami perlu memperkenalkan perpustakaan Gorilla WebSocket ke dalam projek:

go get github.com/gorilla/websocket

Berikut ialah contoh kod pelayan tolak data masa nyata Golang yang ringkas:

package main

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

    "github.com/gorilla/websocket"
)

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

// Message 接收和发送的数据结构体
type Message struct {
    Message string `json:"message"`
}

func main() {
    // 创建一个简单的文件服务器，用于向客户端提供Web页面
    fs := http.FileServer(http.Dir("public"))
    http.Handle("/", fs)

    // 注册处理函数
    http.HandleFunc("/ws", handleConnections)

    // 启动消息广播协程
    go handleMessages()

    // 启动服务器
    fmt.Println("Server started on http://localhost:8000")
    err := http.ListenAndServe(":8000", nil)
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

func handleConnections(w http.ResponseWriter, r *http.Request) {
    // 升级HTTP连接为WebSockets
    ws, err := websocket.Upgrade(w, r, nil, 1024, 1024)
    if err != nil {
        log.Fatal(err)
    }

    // 当前连接关闭时，从全局连接池中删除
    defer func() {
        delete(clients, ws)
        ws.Close()
    }()

    // 将新的客户端连接添加到全局连接池中
    clients[ws] = true

    for {
        var msg Message
        // 读取客户端发送的消息
        err := ws.ReadJSON(&msg)
        if err != nil {
            log.Printf("error: %v", err)
            delete(clients, ws)
            break
        }
        // 将收到的消息发送到广播频道
        broadcast <- msg
    }
}

func handleMessages() {
    for {
        // 从广播频道接收消息
        msg := <-broadcast
        // 向所有客户端发送消息
        for client := range clients {
            err := client.WriteJSON(msg)
            if err != nil {
                log.Printf("error: %v", err)
                client.Close()
                delete(clients, client)
            }
        }
    }
}

Dalam contoh kod di atas, kami mula-mula mencipta kod ringkas pelayan fail, menggunakan Untuk menyediakan halaman Web kepada pelanggan. Kemudian, kami mentakrifkan fungsi pemprosesan sambungan WebSocket handleConnections untuk mengendalikan permintaan sambungan pelanggan baharu. Dalam fungsi ini, kami menambah sambungan pelanggan ke kumpulan sambungan global dan gelung untuk membaca mesej yang dihantar oleh pelanggan dan menghantarnya ke saluran siaran. handleConnections，用于处理新的客户端连接请求。在该函数中，我们将客户端连接添加到全局连接池，并循环读取客户端发送的消息，并将其发送到广播频道。

同时，我们还定义了一个消息广播函数handleMessages，用于从广播频道接收消息，并向所有连接的客户端发送消息。

最后，我们通过调用http.HandleFunc

Pada masa yang sama, kami juga mentakrifkan fungsi siaran mesej handleMessages, yang digunakan untuk menerima mesej daripada saluran siaran dan menghantar mesej kepada semua pelanggan yang disambungkan.

Akhir sekali, kami mendaftarkan fungsi pengendali dengan memanggil fungsi http.HandleFunc dan memulakan pelayan.

Kesimpulan:
Artikel ini memperkenalkan cara menggunakan Golang untuk membangunkan fungsi tolak data masa nyata berdasarkan WebSockets. Dengan bantuan perpustakaan Gorilla WebSocket, kami boleh melaksanakan pelayan tolak data masa nyata yang mudah. Dengan menggunakan WebSockets, kami boleh mencapai penghantaran data masa nyata dengan berkesan dan memberikan pengalaman pengguna yang lebih baik.

🎜Lampiran: 🎜Kod sampel lengkap dan sumber berkaitan boleh didapati dalam repositori berikut: [https://github.com/your-github-repository](https://github.com/your-github-repository) . 🎜

Atas ialah kandungan terperinci Pembangunan Golang: Tolak data masa nyata berdasarkan WebSockets. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!