Warum gibt mein Redis-Cache nur Teildaten zurück?

Bei der Verwendung von Redis-Cache kann es zu einem häufigen Problem kommen: Warum gibt mein Redis-Cache nur einen Teil der Daten zurück? Dieses Problem kann mehrere Ursachen haben, darunter falsche Cache-Einstellungen, Cache-Schlüsselnamenskonflikte, Cache-Ablauf usw. Bevor wir dieses Problem lösen, müssen wir den Code und die Konfiguration sorgfältig prüfen, um sicherzustellen, dass der Cache ordnungsgemäß funktioniert. In diesem Artikel werden die möglichen Ursachen für Sie analysiert und Lösungen bereitgestellt, die Ihnen bei der Lösung dieses Problems helfen und sicherstellen, dass der Redis-Cache vollständige Daten zurückgibt.

Frageninhalt

Diese Funktion überprüft die Implementierung von Postgres und Redis-Cache Wenn ich eine Get-Anfrage mache, gibt das erste Ergebnis alle Daten zurück, aber wenn ich das nächste Ergebnis mache, fehlen einige Felder der Daten

func (usr *UserImplementation) GetAllUsers(ctx context.Context) ([]models.User, error) {

    cachedUsers, err := databaseapi.Redis_CacheDB_Api()
    if err != nil {
        return nil, fmt.Errorf("error connecting to Redis cache: %v", err)
    }

    // pipe := cachedUsers.TxPipeline()

    cachedData, err := cachedUsers.Get(ctx, "users").Result()
    if err != nil && err != redis.Nil {
        return nil, fmt.Errorf("error retrieving cached data: %v", err)
    }

    if cachedData != "" {
        // Data found in the cache, return the cached data
        var cachedUsers []models.User
        err := json.Unmarshal([]byte(cachedData), &cachedUsers)
        if err != nil {
            return nil, fmt.Errorf("error unmarshaling cached data: %v", err)
        }
        return cachedUsers, nil
    }

    users, err := usr.pg.Postgres_DB_Api().DB.GetAllUsers(ctx)
    if err != nil {
        return nil, fmt.Errorf("error: %v", err.Error())
    }

    cacheData, err := json.Marshal(users)
    if err != nil {
        return nil, fmt.Errorf("error marshaling data for caching: %v", err)
    }

    expiration := time.Hour

    err = cachedUsers.Set(ctx, "users", string(cacheData), expiration).Err()
    if err != nil {
        return nil, fmt.Errorf("error caching data: %v", err)
    }

    return models.DatabaseUsersToUsers(users), nil

}

Das ist meine Benutzerstruktur: Typ user struct { id uuid.uuid json:"id" Namenszeichenfolge json:"first_name" Nachnamenszeichenfolge json:"last_name" Andere Namenszeichenfolgen json:"other_name" Benutzernamenzeichenfolge json:"user_name" Passwortzeichenfolge json:"密码" E-Mail-Zeichenfolge json:"email" Profilbildzeichenfolge json:"profile_image" Statuszeichenfolge json:"status" isadmin bool json:"is_admin" Rollenzeichenfolge json:"角色" Geschlechtszeichenfolge json:"性别" Telefonnummernzeichenfolge json:"phone_number" zur Zeit erstellt json:"created_at" zur richtigen Zeit aktualisiert json:"updated_at" }

Workaround

Ich habe ein kleines Beispiel zusammengestellt, um Ihnen zu helfen. Als Prämisse habe ich Ihr Beispiel vereinfacht, um zu verdeutlichen, worauf es hier ankommt. Da einige Teile des Programms noch nicht geteilt wurden, muss ich einige Vermutungen anstellen. Wenn dieses Beispiel nicht funktioniert, teilen Sie mir bitte mit, was fehlt, und ich werde meine Antwort aktualisieren. Beginnen wir mit meinem Befehl, Postgres/Redis lokal mit Docker auszuführen.

Einstellungen

Der Befehl, den ich verwendet habe, ist:

1. docker run -d -p 54322:5432 -e postgres_password=postgres postgres
2. docker run -d --name redis-stack -p 6379:6379 -p 8001:8001 redis/redis-stack:latest

Jetzt wechseln wir zum Code.

Programm

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "time"

    "github.com/redis/go-redis/v9"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

type user struct {
    ID        int    `json:"id"`
    FirstName string `json:"first_name"`
    LastName  string `json:"last_name"`
}

func main() {
    // 1. instantiate clients
    dsn := "host=localhost port=54322 user=postgres password=postgres"
    db, err := gorm.Open(postgres.Open(dsn))
    if err != nil {
        panic(err)
    }
    redisClient := redis.NewClient(&redis.Options{
        Addr:     ":6379",
        Password: "",
        DB:       0,
    })

    // 2. automigrate objects & seed dummy data
    db.AutoMigrate(&user{})
    db.Create(&user{ID: 1, FirstName: "John", LastName: "Doe"})
    db.Create(&user{ID: 2, FirstName: "Suzy", LastName: "White"})

    // 3. attempt to retrieve from cache
    var users []user
    cachedUsers, err := redisClient.Get(context.Background(), "users").Result()
    if err != nil && err != redis.Nil {
        panic(fmt.Errorf("err retrieving cached data: %v", err))
    }
    if cachedUsers != "" {
        if err := json.Unmarshal([]byte(cachedUsers), &users); err != nil {
            panic(fmt.Errorf("err while unmarshaling data: %v", err))
        }
        fmt.Println("users taken from Redis")
        for _, v := range users {
            fmt.Println(v)
        }
        return
    }

    // 4. retrieve from the DB
    if err := db.Model(&user{}).Find(&users).Error; err != nil {
        panic(fmt.Errorf("err while retrieving from DB: %v", err))
    }

    // 5. set the key within the cache
    rawUsers, err := json.Marshal(users)
    if err != nil {
        panic(fmt.Errorf("err while marshaling users: %v", err))
    }
    if err := redisClient.Set(context.Background(), "users", rawUsers, time.Minute*15).Err(); err != nil {
        panic(fmt.Errorf("err while setting key in cache: %v", err))
    }
    fmt.Println("users taken from DB")
    for _, v := range users {
        fmt.Println(v)
    }
}

Schauen wir uns die einzelnen Abschnitte genauer an (unterteilt durch nummerierte Kommentare):

1. Zur Client-Initialisierung gibt es nicht viel zu sagen. Wir haben den Client so initialisiert, dass er auf die lokale Instanz verweist
2. Dann richten wir die Datenbank mit einigen Dummy-Daten ein
3. Wir versuchen, Daten von der Redis-Instanz abzurufen. Werden sie gefunden, drucken wir sie aus und beenden das Programm
4. Wenn die Daten nicht im Cache gefunden werden, dann holen wir sie aus der Datenbank
5. Wenn wir schließlich Daten aus der Datenbank erhalten, können wir davon ausgehen, dass wir sie auch in den Cache legen sollten

In beiden Fällen verwenden wir dieselben Felder, um dieselbe Datenmenge zu erhalten. Wenn Sie also bei diesem Beispiel bleiben und es an Ihr Modell und Ihren Projekttyp anpassen (mein Projekt war kein Webprojekt), sollte alles in Ordnung sein. Wenn Sie weiterhin Probleme haben, lassen Sie es mich bitte wissen. Danke!

Das obige ist der detaillierte Inhalt vonWarum gibt mein Redis-Cache nur Teildaten zurück?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!