Cara membangunkan fungsi sembang masa nyata menggunakan bahasa Go dan Redis

Cara membangunkan fungsi sembang masa nyata menggunakan bahasa Go dan Redis

Dalam era Internet hari ini, fungsi sembang telah menjadi keperluan asas untuk kebanyakan aplikasi. Untuk melaksanakan fungsi sembang masa nyata, kami boleh menggunakan bahasa Go dan Redis sebagai sokongan teknikal latar belakang. Bahasa Go ialah bahasa pengaturcaraan yang cekap dan ringkas, manakala Redis ialah sistem penyimpanan data dalam memori sumber terbuka, terutamanya sesuai untuk mengendalikan sejumlah besar permintaan serentak.

Dalam artikel ini, kami akan memperkenalkan langkah demi langkah cara membangunkan fungsi sembang masa nyata menggunakan bahasa Go dan Redis, dan memberikan contoh kod terperinci.

1. Persediaan
   Sebelum kita mula, kita perlu memastikan bahawa bahasa Go dan Redis telah dipasang dengan betul. Anda boleh memuat turunnya dari tapak web rasmi dan ikut arahan untuk memasangnya.
2. Buat Projek Go
   Buka Terminal dan buat folder projek Go baharu. Cipta fail bernama main.go dalam folder dan mulakan projek menggunakan arahan berikut:

go mod init chatapp

Ini akan membuat fail go.mod secara automatik dan memulakan modul Go bernama chatapp.

3. Import perpustakaan yang diperlukan
   Dalam fail main.go, kita perlu mengimport perpustakaan yang diperlukan. Berikut ialah perpustakaan yang perlu kami import:

package main

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

Antaranya, perpustakaan github.com/gorilla/websocket digunakan untuk mengendalikan sambungan WebSocket, dan perpustakaan github.com/gomodule/redigo/redis digunakan untuk berkomunikasi dengan Redis.

4. Sediakan sambungan WebSocket
   Tambah kandungan berikut dalam kod untuk menyediakan sambungan WebSocket:

var upgrader = websocket.Upgrader{
   ReadBufferSize:  1024,
   WriteBufferSize: 1024,
   CheckOrigin: func(r *http.Request) bool {
       return true
   },
}

Peningkatan di sini mentakrifkan saiz penimbal baca dan tulis WebSocket dan menetapkan kaedah CheckOrigin untuk menyemak sumber sambungan. Kami menetapkannya dalam contoh untuk sentiasa kembali benar.

5. Mengendalikan sambungan WebSocket
   Dalam fungsi utama, tambahkan yang berikut untuk mengendalikan sambungan WebSocket:

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, p, err := conn.ReadMessage()
       if err != nil {
           log.Println(err)
           return
       }

       // 处理聊天消息
       handleMessage(conn, messageType, p)
   }
}

Dalam kod ini, kami mula-mula menaik taraf sambungan HTTP kepada sambungan WebSocket. Kami kemudiannya terus membaca mesej melalui gelung dan mengendalikan logik berdasarkan jenis mesej.

6. Mengendalikan Mesej Sembang
   Tambahkan kod berikut untuk memproses mesej sembang:

func handleMessage(conn *websocket.Conn, messageType int, message []byte) {
   // 处理接收到的消息
   // ...

   // 处理发送的消息
   // ...
}

Di sini, kita boleh melaksanakan logik yang sepadan berdasarkan jenis mesej yang berbeza. Contohnya, apabila mesej daripada pengguna diterima, mesej itu boleh disimpan dalam Redis dan dihantar kepada pengguna dalam talian yang lain.

7. Komunikasi dua hala
   Untuk mencapai komunikasi dua hala, kita perlu menggunakan Redis untuk menyimpan dan menolak mesej. Kod berikut menunjukkan cara berkomunikasi dengan Redis:

func pubsub(conn redis.Conn) {
   // 订阅频道
   // ...

   // 接收消息
   for {
       switch v := pubSub.Receive().(type) {
       case redis.Message:
           // 处理接收到的消息
           // ...
       case redis.Subscription:
           // 处理新的订阅消息
           // ...
       case error:
           log.Println(v)
           return
       }
   }
}

func main() {
   // 创建Redis连接
   conn, err := redis.Dial("tcp", "localhost:6379")
   if err != nil {
       log.Fatal(err)
   }
   defer conn.Close()

   // 创建订阅
   pubSub := redis.PubSubConn{Conn: conn}
   go pubsub(conn)

   // 启动服务器
   http.HandleFunc("/ws", handleWebSocket)
   http.ListenAndServe(":8080", nil)
}

Dalam kod ini, kami mula-mula membuat sambungan Redis dan mencipta objek langganan. Kemudian, kami memanggil fungsi pubsub dalam goroutine lain untuk menerima mesej yang dilanggan dalam masa nyata. Akhir sekali, kami mencipta pelayan HTTP mendengar pada port 8080.

8. Uji aplikasi
   Jalankan arahan berikut untuk memulakan aplikasi:

go run main.go

Anda kemudian boleh menggunakan alat klien WebSocket seperti Posman atau wscat untuk ujian. Tetapkan alamat sambungan kepada ws://localhost:8080/ws dan cuba hantar dan terima mesej.

Ringkasan
Dengan menggunakan bahasa Go dan Redis, kami boleh melaksanakan fungsi sembang masa nyata dengan cepat. Keselarasan tinggi dan kesederhanaan bahasa Go menjadikan proses pembangunan lebih cekap, manakala prestasi membaca dan menulis pantas Redis dapat memenuhi keperluan sembang masa nyata. Saya harap contoh kod yang disediakan dalam artikel ini dapat membantu anda mula membangunkan fungsi sembang masa nyata dengan cepat.

Atas ialah kandungan terperinci Cara membangunkan fungsi sembang masa nyata menggunakan bahasa Go dan Redis. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!