Comment résoudre le problème de conversion de type user_id lors de l'utilisation du flux redis pour implémenter les files d'attente de messages dans le langage Go?

GO Redis Stream Message Fitre: Résolu intelligemment le problème de conversion de type user_id

Lors de la création de files d'attente de messages à l'aide de GO et de Redis Stream, les problèmes de conversion des types entiers tels que user_id affligent souvent les développeurs. Cet article explorera ce problème en profondeur et fournira des solutions efficaces.

Supposons que votre application ait besoin d'écrire des données contenant user_id (type entier) dans Redis Stream. Vous pouvez rencontrer les problèmes suivants:

Description de la question:

Après avoir écrit directement sur Redis Stream, user_id devient un type de chaîne lors de la lecture. Par exemple:

Écrire: xadd mystream * user_id 123

Lire: xread block 0 streams mystream $ ( user_id est la chaîne "123")

Analyse des causes:

Redis est une chaîne dans le stockage sous-jacent de toutes les données. Même si vous écrivez un entier, Redis le convertira en un stockage de chaîne. Par conséquent, ce que vous obtenez naturellement lors de la lecture, c'est le type de chaîne.

Solution: sérialisation et désérialisation

Pour maintenir l'intégrité du type de données, nous devons sérialiser avant d'écrire sur Redis et désérialiser après la lecture. Il est recommandé d'utiliser JSON pour la sérialisation et la désérialisation.

Voici un exemple de code qui montre comment résoudre ce problème à l'aide de JSON:

 package principal

importer (
    "Encodage / JSON"
    "FMT"
    "github.com/go-redis/redis/v8"
)

Tapez le message Struct {
    UserId int `json:" user_id "`
    // ... Autres champs
}

func main () {
    Client: = redis.newclient (& redis.options {
        Addr: "localhost: 6379",
    })

    // Message de données d'écriture: = message {userId: 123}
    JSONDATA, ERR: = JSON.MARSHAL (Message)
    Si err! = Nil {
        panique (euh)
    }

    err = client.xadd (& redis.xaddargs {
        Stream: "mystream",
        VALEURS: Map [String] Interface {} {
            "Données": JSONDATA, // Stocker les données JSON en valeur},
    }).Se tromper()
    Si err! = Nil {
        panique (euh)
    }

    // Lire Data Stream, err: = client.xread (& redis.xreadargs {
        Streams: [] String {"MyStream", "0"},
        Bloc: 0,
    }).Résultat()
    Si err! = Nil {
        panique (euh)
    }

    pour _, message: = range stream [0] .Messages {
        Message Var ReçuSage
        JSON.UNMARSHAL ([] BYTE (Message.Values ​​["Data"]. (String)), & ReçuMessage) // Desérialize JSON Data FMT.Printf ("ID utilisateur reçu:% D \ N", ReçuSage.Userid)
    }
}

Ce code sérialise d'abord la structure Message en une chaîne JSON, puis stocke la chaîne JSON dans un flux redis. Lors de la lecture, désérialisez la chaîne JSON à la structure Message , restaurant ainsi le type entier de user_id . Cela garantit la cohérence du type des données pendant le stockage et la lecture dans Redis. J'espère que cet exemple peut vous aider à résoudre efficacement le problème de conversion de type dans la file d'attente de messages GO Redis Stream.

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!