Installer les dépendances et la variable d'environnement

Remplacez les valeurs de la connexion à la base de données par les vôtres.

#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

Gestionnaire Redis

Créez un fichier pour manager.go. Celui-ci contiendra une méthode pour obtenir la connexion avec redis par exemple dans d'autres modules et services.

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
}

Créer une structure pour gérer le référentiel d'entité (client)

Créez une structure pour gérer la connexion Redis et obtenez toutes les méthodes pour interagir avec l'entité Redis (opérations et requêtes CRUD)
Avec cette structure, chaque fois que nous avons besoin d'accéder aux données de l'entité (client), nous pouvons les instancier et commencer à les utiliser comme modèle de référentiel.

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
}

Créer une entité Struct

Sur l'entité Clients, ajoutez les balises pour les champs mappés avec des chignons.
Le redis:"-" fait la relation avec les champs à sauvegarder sur redis. Si vous voulez qu'un fichier ou la structure soit sauvegardée, n'ajoutez simplement pas la balise.

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

Méthodes CRUD

Un exemple de méthode pour stocker, mettre à jour ou obtenir des informations de l'entité.
Ces méthodes sont utilisées à partir de l'entité CustomersRepo.
Ils ont reçu une entité cliente avec les informations et, en fonction de l'opération, renvoient le résultat.

Enregistrer un nouvel enregistrement

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

Obtenez un dossier d'identification

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
}

Mettre à jour un nouvel enregistrement

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

Supprimer un nouvel enregistrement

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

Revoir l'exemple de code

Exemple Redis pour le tester