Bagaimana untuk menyelesaikan masalah penukaran jenis data apabila menggunakan aliran Redis untuk melaksanakan beratur mesej dalam bahasa Go?

Pergi Redis Stream Message Queue: Cleverly menyelesaikan masalah penukaran jenis data

Apabila membina beratur mesej menggunakan aliran Go dan Redis, anda sering menghadapi masalah penukaran jenis data. Artikel ini akan meneroka isu ini secara mendalam dan menyediakan penyelesaian yang berkesan.

Penerangan Masalah

Katakan anda membina sistem giliran mesej berdasarkan aliran redis. Anda mungkin menghadapi situasi berikut:

1. Tulis data: Anda menulis data ke aliran redis di mana medan user_id adalah jenis integer ( int ).

    // Contoh penulisan data client.xadd (ctx, & redis.xaddargs {
       Stream: "Mystream",
       Nilai: peta [string] antara muka {} {
           "user_id": 123,
           "Mesej": "Hello, dunia!",
       },
   })

2. Baca data: Walau bagaimanapun, apabila anda membaca data, medan user_id menjadi jenis rentetan ( string ).

    // Contoh penyertaan data membaca, err: = client.xread (ctx, & redis.xreadargs {
       Streams: [] String {"Mystream", "0"},
   })
   jika err! = nil {
       panik (err)
   }
   untuk _, msg: = penyertaan pelbagai [0] .messages {
       fmt.printf ("Jenis user_id: %t, nilai: %v \ n", msg.values ​​["user_id"], msg.values ​​["user_id"])
   }

Ini mengakibatkan ketidakcocokan jenis dan memerlukan pemprosesan tambahan. Mengapa ini berlaku? Adakah kita perlu menukar jenis secara manual setiap kali kita membacanya?

Analisis dan Penyelesaian Sebab Akar

Data penyimpanan yang mendasari Redis biasanya wujud dalam bentuk rentetan, walaupun anda menulis jenis angka. Redis Stream tidak terkecuali.

Untuk menyelesaikan masalah ini, strategi berikut disyorkan:

1. Struktur Serialization dan Deserialization: Sebelum menulis kepada Redis, bersiri struktur data ke dalam rentetan JSON; Deserialize kembali ke struktur pergi ketika membaca.

    // Tentukan Struktur Struktur Mesej Struktur Mesej {
       Userid int `json:" user_id "`
       Mesej String `JSON:" Mesej "`
   }
   
   // tulis data msg: = mesej {userid: 123, mesej: "hello, dunia!"}
   data, err: = json.marshal (msg)
   jika err! = nil {
       panik (err)
   }
   client.xadd (ctx, & redis.xaddargs {
       Stream: "Mystream",
       Nilai: peta [string] antara muka {} {
           "data": rentetan (data),
       },
   })
   
   // Baca entri data, err: = client.xread (ctx, & redis.xreadargs {
       Streams: [] String {"Mystream", "0"},
   })
   jika err! = nil {
       panik (err)
   }
   untuk _, msg: = penyertaan pelbagai [0] .messages {
       mesej var yang diterima
       json.unmarshal ([] byte (msg.values ​​["data"]. (String)), & diterimaMSG)
       fmt.printf ("user_id: %d, mesej: %s \ n", acceptenmsg.userid, acceptenmsg.message)
   }

   Dengan bersiri dan deserializing, pastikan jenis data konsisten antara program REDIS dan GO, mengelakkan kerumitan penukaran jenis.

Menggunakan kaedah ini dengan berkesan boleh mengelakkan masalah penukaran jenis data dan meningkatkan kebolehbacaan dan mengekalkan kod. Ingatlah untuk sentiasa mengendalikan kesilapan yang berpotensi seperti kesilapan codec JSON.

Atas ialah kandungan terperinci Bagaimana untuk menyelesaikan masalah penukaran jenis data apabila menggunakan aliran Redis untuk melaksanakan beratur mesej dalam bahasa Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!