Installieren Sie Abhängigkeiten und Umgebungsvariablen

Ersetzen Sie die Werte aus der Datenbankverbindung durch Ihre.

#env file
REDIS_ADDRESS=localhost
REDIS_PORT=6379
REDIS_PASSWORD=123456
REDIS_DB=0

#install on go
go get github.com/redis/go-redis/v9

Manager Redis

Erstellen Sie eine Datei für manage.go. Diese enthält eine Methode, um die Verbindung mit Redis beispielsweise in anderen Modulen und Diensten herzustellen.

package main

import (
    "fmt"
    "github.com/redis/go-redis/v9"
    "os"
    "strconv"
)

const CustomerDb = 0

type RedisManager struct {
    Db     int
    Client *redis.Client
}

func NewRedisClient(customerDb int) (*RedisManager, error) {
    address := os.Getenv("REDIS_ADDRESS")
    if address == "" {
        return nil, fmt.Errorf("REDIS_ADDRESS is not set")
    }
    password := os.Getenv("REDIS_PASSWORD")
    if password == "" {
        return nil, fmt.Errorf("REDIS_PASSWORD is not set")
    }
    port := os.Getenv("REDIS_PORT")
    if port == " " {
        return nil, fmt.Errorf("REDIS_PORT is not set")
    }
    db := os.Getenv("REDIS_DB")
    if db == "" {
        return nil, fmt.Errorf("REDIS_DB is not set")
    }
    redisDb, err := strconv.Atoi(db)
    if err != nil {
        return nil, fmt.Errorf("REDIS_DB is not a number")
    }
    cli := redis.NewClient(&redis.Options{
        Addr:     fmt.Sprintf("%s:%s", address, port),
        Password: password,
        DB:       redisDb,
    })
    return &RedisManager{
        Client: cli,
        Db:     customerDb,
    }, nil
}
func (rd *RedisManager) SetDb(db int) {
    rd.Db = db
}

Erstellen Sie eine Struktur zum Verwalten des Entitäts-(Kunden-)Repositorys

Erstellen Sie eine Struktur zum Verwalten der Redis-Verbindung und rufen Sie alle Methoden für die Interaktion mit der Redis-Entität ab (CRUD-Operationen und Abfragen)
Mit dieser Struktur können wir jedes Mal, wenn wir auf die Daten der Entität (des Kunden) zugreifen müssen, eine Instanz erstellen und sie als Repository-Muster verwenden.

type CustomerRepo struct {
    Cli *RedisManager
    Db  int
}

func NewCustomerRepo() (*CustomerRepo, error) {
    cli, err := NewRedisClient(CustomerDb)
    if err != nil {
        return nil, err
    }
    return &CustomerRepo{
        Cli: cli,
    }, nil
}

Erstellen Sie eine Strukturentität

Fügen Sie in der Entität „Kunden“ die Tags für die Zuordnung mit Brötchenfeldern hinzu.
Die Redis:"-" stellen eine Beziehung zu den Feldern her, um sie auf Redis zu speichern. Wenn Sie eine Datei oder die Struktur nicht speichern möchten, fügen Sie einfach das Tag nicht hinzu.

type Customer struct {
    ID    string `redis:"id"`
    Name  string `redis:"name"`
    Email string `redis:"email"`
    Phone string `redis:"phone"`
    Age   int    `redis:"age"`
}

CRUD-Methoden

Ein Methodenbeispiel zum Speichern, Aktualisieren oder Abrufen von Informationen von der Entität.
Diese Methoden werden von der CustomersRepo-Entität verwendet.
Sie erhalten eine Kundenentität mit den Informationen und geben je nach Vorgang das Ergebnis zurück.

Speichern Sie einen neuen Datensatz

func (c *CustomerRepo) Save(customer *Customer) error {
    return c.Cli.Client.HSet(context.TODO(), customer.ID, customer).Err()
}

Holen Sie sich einen Ausweis

func (c *CustomerRepo) Get(id string) (*Customer, error) {
    customer := &Customer{}
    resMap := c.Cli.Client.HGetAll(context.TODO(), id)
    if resMap.Err() != nil {
        return nil, resMap.Err()
    }
    if len(resMap.Val()) == 0 {
        return nil, nil
    }
    err := resMap.Scan(customer)
    if err != nil {
        return nil, err
    }
    return customer, nil
}

Aktualisieren Sie einen neuen Datensatz

func (c *CustomerRepo) Update(customer *Customer) error {
    return c.Cli.Client.HSet(context.TODO(), customer.ID, customer).Err()
}

Löschen Sie einen neuen Datensatz

func (c *CustomerRepo) Delete(id string) error {
    return c.Cli.Client.Del(context.TODO(), id).Err()
}

Sehen Sie sich das Codebeispiel an

Redis-Beispiel zum Testen