Comment résoudre le problème de la conversion du type de données lors de l'utilisation du flux de Redis pour implémenter les files d'attente de messages dans le langage GO?

GO Redis Stream Message Fitre: Résoudre intelligemment le problème de conversion du type de données

Lors de la création de files d'attente de messages à l'aide de GO et Redis Stream, vous rencontrez souvent des problèmes de conversion de type de données. Cet article explorera ce problème en profondeur et fournira des solutions efficaces.

Description du problème

Supposons que vous créez un système de file d'attente de messages basé sur Redis Stream. Vous pouvez rencontrer les situations suivantes:

1. Écrivez des données: vous écrivez des données sur Redis Stream où user_id est un type entier ( int ).

    // Exemple d'écriture de données client.xadd (CTX, & redis.xaddargs {
       Stream: "mystream",
       VALEURS: Map [String] Interface {} {
           "user_id": 123,
           "Message": "Bonjour, monde!",
       },
   })

2. Lire les données: cependant, lorsque vous lisez des données, le champ user_id devient un type de chaîne ( string ).

    // Exemple de lecture des entrées de données, err: = client.xread (ctx, & redis.xreadargs {
       Streams: [] String {"MyStream", "0"},
   })
   Si err! = Nil {
       panique (euh)
   }
   pour _, msg: = entrées de plage [0] .Messages {
       fmt.printf ("user_id type:% t, valeur:% v \ n", msg.values ​​["user_id"], msg.values ​​["user_id"])
   }

Il en résulte un décalage de type et nécessite un traitement supplémentaire. Pourquoi cela se produit-il? Avons-nous besoin de convertir manuellement le type à chaque fois que nous le lisons?

Analyse des causes profondes et solutions

Redis sous-jacent les données de stockage existe généralement sous forme de chaîne, même si vous écrivez un type numérique. Redis Stream ne fait pas exception.

Pour résoudre ce problème, les stratégies suivantes sont recommandées:

1. Structure sérialisation et désérialisation: avant d'écrire sur redis, sérialisez la structure des données en une chaîne JSON; désérialisez-le à la structure Go lors de la lecture.

    // Définir le type de structure de message Struct {
       UserId int `json:" user_id "`
       Chaîne de message `json:" message "`
   }
   
   // Écriture de données msg: = message {utilisateur: 123, message: "Bonjour, monde!"}
   données, err: = json.marshal (msg)
   Si err! = Nil {
       panique (euh)
   }
   client.xadd (ctx, & redis.xaddargs {
       Stream: "mystream",
       VALEURS: Map [String] Interface {} {
           "données": chaîne (données),
       },
   })
   
   // Lire les entrées de données, err: = client.xRead (ctx, & redis.xreadargs {
       Streams: [] String {"MyStream", "0"},
   })
   Si err! = Nil {
       panique (euh)
   }
   pour _, msg: = entrées de plage [0] .Messages {
       Message var reçusmsg
       json.unmarshal ([] byte (msg.values ​​["data"]. (String)), & reçusmsg)
       fmt.printf ("user_id:% d, message:% s \ n", reçusmsg.userid, reçus.
   }

   En sérialisant et en désérialisant, assurez-vous que les types de données sont cohérents entre les programmes Redis et GO, en évitant les tracas de la conversion de type.

L'utilisation de cette méthode peut éviter efficacement les problèmes de conversion du type de données et améliorer la lisibilité et la maintenabilité du code. N'oubliez pas de toujours gérer les erreurs potentielles telles que les erreurs de codec JSON.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!