Rumah > Artikel > pembangunan bahagian belakang > 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
- WBOYasal
- 2023-12-18 18:39:46665semak imbas
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)
}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>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
- Dalam pelayar anda, buka URL berikut untuk memuatkan contoh halaman HTML:
http://localhost:8080/
- 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)
}
}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!