Menggunakan WebSocket untuk komunikasi masa nyata dalam Beego

Dalam era Internet hari ini, komunikasi masa nyata telah menjadi fungsi yang sangat diperlukan dalam banyak senario aplikasi. Daripada sembang dalam talian, permainan masa nyata kepada sistem pengawasan, komunikasi masa nyata semakin meningkat. Cara paling biasa untuk mencapai komunikasi masa nyata ialah menggunakan protokol WebSocket.

Protokol WebSocket ialah protokol komunikasi rangkaian baharu dalam spesifikasi HTML5 Ia boleh menyediakan saluran komunikasi dupleks penuh pada sambungan TCP. Fungsi komunikasi masa nyata boleh dicapai dengan mudah menggunakan protokol WebSocket, dan Beego, sebagai rangka kerja Web yang pantas dan cekap, secara semula jadi menyokong protokol WebSocket.

Artikel ini akan memperkenalkan proses penggunaan WebSocket untuk mencapai komunikasi masa nyata dalam Beego. Mula-mula, kita perlu memasang rangka kerja Beego:

go get github.com/astaxie/beego

Selepas pemasangan selesai, kita boleh mula menggunakan rangka kerja Beego. Sebelum menggunakan Beego untuk melaksanakan WebSocket, kita perlu terlebih dahulu memahami protokol WebSocket. Protokol WebSocket mempunyai tiga fasa: jabat tangan, pemindahan data dan penutupan.

Semasa fasa jabat tangan, pelanggan menghantar permintaan HTTP kepada pelayan, meminta peningkatan kepada protokol WebSocket. Selepas menerima permintaan, pelayan mengembalikan respons 101 Switching Protocols Pada masa ini, sambungan WebSocket telah diwujudkan. Semasa fasa pemindahan data, pelanggan dan pelayan boleh memindahkan data antara satu sama lain. Semasa fasa penutupan, pelanggan atau pelayan boleh menghantar bingkai penutupan untuk menutup sambungan WebSocket.

Dalam Beego, kita boleh melaksanakan tiga peringkat WebSocket dengan melaksanakan fungsi WebSocket beego.Controller.

Pertama, kita perlu mencipta pengawal WebSocket:

package controllers

import (
    "github.com/astaxie/beego"
    "github.com/gorilla/websocket"
)

type WebSocketController struct {
    beego.Controller
}

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

func (this *WebSocketController) Get() {
    conn, err := upgrader.Upgrade(this.Ctx.ResponseWriter, this.Ctx.Request, nil)
    if err != nil {
        beego.Error("WebSocket协议升级失败：", err)
        return
    }
    // 处理连接
}

Dalam kod di atas, kami mencipta Penaik taraf melalui pakej gorila/soket web dan memanggil Penaik Taraf dalam protokol peningkatan Kaedah Kaedah Dapatkan . Pada ketika ini, sambungan WebSocket telah berjaya diwujudkan. Seterusnya, kita perlu mengendalikan sambungan WebSocket.

Untuk pemprosesan sambungan WebSocket, kita boleh menggunakan goroutine. Setiap kali terdapat sambungan baharu, kami membuka goroutine baharu untuk mengendalikan sambungan:

func (this *WebSocketController) Get() {
    conn, err := upgrader.Upgrade(this.Ctx.ResponseWriter, this.Ctx.Request, nil)
    if err != nil {
        beego.Error("WebSocket协议升级失败：", err)
        return
    }
    go this.handleConnection(conn)
}

func (this *WebSocketController) handleConnection(conn *websocket.Conn) {
    defer conn.Close()
    // 处理连接
}

Dalam kaedah memproses sambungan, kami boleh menggunakan gelung for untuk terus membaca data daripada klien:

func (this *WebSocketController) handleConnection(conn *websocket.Conn) {
    defer conn.Close()
    for {
        _, msg, err := conn.ReadMessage()
        if err != nil {
            beego.Error("读取消息失败：", err)
            return
        }
        // 处理消息
    }
}

Dalam kaedah pemprosesan mesej, kami boleh melakukan pemprosesan yang sepadan berdasarkan data yang dihantar oleh pelanggan, dan menghantar hasil pemprosesan kembali kepada pelanggan:

func (this *WebSocketController) handleConnection(conn *websocket.Conn) {
    defer conn.Close()
    for {
        _, msg, err := conn.ReadMessage()
        if err != nil {
            beego.Error("读取消息失败：", err)
            return
        }
        // 处理消息
        reply := "收到消息：" + string(msg)
        err = conn.WriteMessage(websocket.TextMessage, []byte(reply))
        if err != nil {
            beego.Error("发送消息失败：", err)
            return
        }
    }
}

Kod di atas melaksanakan gema WebSocket yang mudah pelayan secara langsung mengembalikan data seperti selepas menerima data daripada klien. Dalam aplikasi praktikal, kami boleh melakukan pemprosesan data yang sepadan seperti yang diperlukan dan menolak hasil pemprosesan kepada pelanggan dalam masa nyata.

Akhir sekali, kami perlu mendaftarkan pengawal WebSocket dalam laluan:

beego.Router("/websocket", &controllers.WebSocketController{})

Pada ketika ini, kami telah menyelesaikan proses menggunakan WebSocket untuk mencapai komunikasi masa nyata dalam rangka kerja Beego. Perlu diingatkan bahawa Beego menggunakan pakej gorila/websocket untuk melaksanakan fungsi WebSocket, jadi pakej ini perlu diimport ke dalam projek.

Ringkasnya, Beego ialah rangka kerja Web yang berkuasa dan mudah digunakan yang boleh melaksanakan fungsi komunikasi masa nyata dengan mudah apabila digabungkan dengan protokol WebSocket. Apabila menggunakan WebSocket untuk melaksanakan komunikasi masa nyata, kita perlu memberi perhatian kepada tiga fasa protokol dan menggunakan goroutine untuk pemprosesan.

Atas ialah kandungan terperinci Menggunakan WebSocket untuk komunikasi masa nyata dalam Beego. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!