How to solve the user_id type conversion problem when using Redis Stream to implement message queues in Go language?

Go Redis Stream message queue: cleverly solves the user_id type conversion problem

When building message queues using Go and Redis Stream, conversion problems of integer types such as user_id often plague developers. This article will explore this issue in depth and provide effective solutions.

Suppose your application needs to write data containing user_id (integer type) to Redis Stream. You may encounter the following problems:

Question description:

After writing directly to Redis Stream, user_id becomes a string type when read. For example:

Write: xadd mystream * user_id 123

Read: xread block 0 streams mystream $ ( user_id read is the string "123")

Cause analysis:

Redis is a string in the underlying storage of all data. Even if you write an integer, Redis will convert it to a string storage. Therefore, what you naturally get when reading is the string type.

Solution: Serialization and deserialization

To maintain the integrity of the data type, we need to serialize before writing to Redis and deserialize after reading. It is recommended to use JSON for serialization and deserialization.

Here is a sample code that demonstrates how to solve this problem using JSON:

 package main

import (
    "encoding/json"
    "fmt"
    "github.com/go-redis/redis/v8"
)

type Message struct {
    UserID int `json:"user_id"`
    // ... other fields
}

func main() {
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // Write data message := Message{UserID: 123}
    jsonData, err := json.Marshal(message)
    if err != nil {
        panic(err)
    }

    err = client.XAdd(&redis.XAddArgs{
        Stream: "mystream",
        Values: map[string]interface{}{
            "data": jsonData, // Store JSON data as value},
    }).Err()
    if err != nil {
        panic(err)
    }

    // Read data stream, err := client.XRead(&redis.XReadArgs{
        Streams: []string{"mystream", "0"},
        Block: 0,
    }).Result()
    if err != nil {
        panic(err)
    }

    for _, message := range stream[0].Messages {
        var receivedMessage Message
        json.Unmarshal([]byte(message.Values["data"].(string)), &receivedMessage) // Deserialize JSON data fmt.Printf("Received User ID: %d\n", receivedMessage.UserID)
    }
}

This code first serializes the Message structure into a JSON string, and then stores the JSON string into a Redis Stream. When reading, deserialize the JSON string back to the Message structure, thereby restoring the integer type of user_id . This ensures type consistency of data during storage and reading in Redis. Hope this example can help you effectively solve the type conversion problem in the Go Redis Stream message queue.

The above is the detailed content of How to solve the user_id type conversion problem when using Redis Stream to implement message queues in Go language?. For more information, please follow other related articles on the PHP Chinese website!