Redis

Redis est une base de données de stockage clé-valeur (Key-Value) open source, écrite en langage C ANSI, conforme au protocole BSD, prenant en charge le réseau, basée sur la mémoire, distribuée et optionnellement persistante. Elle fournit des API dans plusieurs langages. Redis peut être utilisé comme base de données NoSQL, comme cache haute vitesse, et prend également en charge une file d'attente de messages simple.

Cet article explique uniquement comment utiliser le pilote du langage Go pour opérer la base de données Redis, et ne fournira aucune explication sur Redis lui-même.

Documentation officielle : Golang Redis client (uptrace.dev)

Dépôt officiel : go-redis/redis: Type-safe Redis client for Golang (github.com)

Installation

Il existe plusieurs pilotes pour Redis. Cet article utilise github.com/go-redis/redis.

Si vous utilisez la version 6 de Redis

go get github.com/go-redis/redis/v8

Si vous utilisez la version 7 de Redis

go get github.com/go-redis/redis/v9

Démarrage rapide

import (
   "fmt"
   "log"
   "testing"

   "github.com/go-redis/redis"
)

func TestQuickStart(t *testing.T) {
   // Créer un client de connexion Redis
   redisClient := redis.NewClient(&redis.Options{
      Addr:     "192.168.48.134:6379",
      Password: "123456",
      DB:       0, // Utiliser la base de données par défaut
   })

   // Définir une paire clé-valeur, 0 signifie jamais expirer
   redisClient.Set("hello", "world", 0)

   // Lire la valeur
   result, err := redisClient.Get("hello").Result()
   if err == redis.Nil {
      fmt.Println("ket not exist")
   } else if err != nil {
      log.Panic(err)
   }
   fmt.Println(result)
}

Configuration de connexion

type Options struct {
  // Type de réseau tcp ou unix.
  // Par défaut tcp.
  Network string
  // Adresse redis, format host:port
  Addr string

    // Dialer crée une nouvelle connexion réseau et a une priorité plus élevée que Network et Addr
  // Network and Addr options.
  Dialer func() (net.Conn, error)

  // Rappelé lors de la création d'une nouvelle connexion redis
  OnConnect func(*Conn) error

  // Mot de passe redis, peut être vide si le serveur redis n'est pas configuré.
  Password string

  // Base de données redis, numérotée à partir de 0, par défaut 0, pas besoin de configurer
  DB int

  // Nombre maximum de tentatives en cas d'échec d'opération redis, par défaut 0.
  MaxRetries int

  // Intervalle minimum entre les tentatives.
  // Par défaut 8ms ; -1 pour désactiver.
  MinRetryBackoff time.Duration

  // Intervalle maximum entre les tentatives
  // Par défaut 512ms ; -1 pour désactiver.
  MaxRetryBackoff time.Duration

  // Délai d'attente pour les nouvelles connexions redis.
  // Par défaut 5 secondes.
  DialTimeout time.Duration

  // Délai de lecture du socket
  // Par défaut 3 secondes.
  ReadTimeout time.Duration

  // Délai d'écriture du socket
  WriteTimeout time.Duration

  // Nombre maximum de connexions dans le pool de connexions redis.
  // Par défaut, la taille du pool est égale au nombre de CPU * 10
  PoolSize int

  // Nombre minimum de connexions inactives dans le pool de connexions redis.
  MinIdleConns int

  // Durée de vie maximum d'une connexion redis, par défaut les connexions obsolètes ne sont pas fermées.
  MaxConnAge time.Duration

  // Lorsque vous récupérez une connexion du pool, le pool attend maximum ce délai.
  // Par défaut ReadTimeout + 1 seconde.
  PoolTimeout time.Duration

  // Fréquence de fermeture des connexions inactives par le pool redis.
  // Par défaut 5 minutes. -1 pour désactiver cette option
  IdleTimeout time.Duration

  // Fréquence de vérification des connexions inactives
  // Par défaut 1 minute. -1 pour désactiver la vérification des connexions inactives
  IdleCheckFrequency time.Duration

  // Paramètre en lecture seule, si true, sur l'instance actuelle, redis ne peut que mettre en cache les requêtes, pas les mises à jour.
  readOnly bool

    // Configuration TLS
  TLSConfig *tls.Config
}

Établir une connexion

// Créer un client de connexion Redis
redisClient := redis.NewClient(&redis.Options{
    Addr:     "192.168.48.134:6379",
    Password: "123456",
    DB:       0, // Utiliser la base de données par défaut
})

Fermer la connexion

Le pilote maintient un pool de connexions en interne, il n'est pas nécessaire de fermer la connexion après chaque opération.

defer redisClient.Close()

Ce pilote Redis a encapsulé presque toutes les opérations. Les commandes Redis correspondent une à une aux noms de méthodes. Pour utiliser les méthodes correspondantes du pilote, il suffit de savoir comment utiliser les commandes Redis.

Commandes Redis : Manuel des commandes redis

Opérations de base

Supprimer une clé

redisClient.Set("name", "jack", 0)
fmt.Println(redisClient.Del("name").Result())

Durée d'expiration

redisClient.Set("name", "jack", 0)
// Définir la durée d'expiration
redisClient.Expire("name", time.Second*2)
fmt.Println(redisClient.Get("name").Val())
time.Sleep(time.Second * 3)
fmt.Println(redisClient.Get("name").Val())

Annuler la durée d'expiration

redisClient.Set("name", "jack", 2)
// Annuler la durée d'expiration
redisClient.Persist("name")
time.Sleep(time.Second * 2)
fmt.Println(redisClient.Get("name"))

Consulter la durée d'expiration

fmt.Println(redisClient.TTL("name"))
fmt.Println(redisClient.PTTL("name"))

Renommer

redisClient.Rename("name", "newName")

Consulter le type

redisClient.Type("name")

Scanner

fmt.Println(redisClient.Scan(0, "", 4))

Chaînes

Lecture et écriture simples

redisClient.Set("token", "abcefghijklmn", 0)
fmt.Println(redisClient.Get("token").Val())

Lecture et écriture par lots

redisClient.MSet("cookie", "12345", "token", "abcefg")
fmt.Println(redisClient.MGet("cookie", "token").Val())

Incrémenter et décrémenter des nombres

redisClient.Set("age", "1", 0)
// Incrémenter
redisClient.Incr("age")
fmt.Println(redisClient.Get("age").Val())
// Décrémenter
redisClient.Decr("age")
fmt.Println(redisClient.Get("age").Val())

Tables de hachage

Opérations de lecture et écriture

// Définir un seul champ
redisClient.HSet("map", "name", "jack")
// Définir plusieurs champs
redisClient.HMSet("map", map[string]interface{}{"a": "b", "c": "d", "e": "f"})
// Accéder à un seul champ
fmt.Println(redisClient.HGet("map", "a").Val())
// Accéder à plusieurs champs
fmt.Println(redisClient.HMGet("map", "a", "b").Val())
// Obtenir toute la map
fmt.Println(redisClient.HGetAll("map").Val())

Sortie

b
[b <nil>]
map[a:b c:d e:f name:jack]

Supprimer un champ

// Supprimer un champ de la map
redisClient.HDel("map", "a")

Vérifier si un champ existe

// Vérifier si un champ existe
redisClient.HExists("map", "a")

Obtenir toutes les clés

// Obtenir toutes les clés de la map
redisClient.HKeys("map")

Obtenir la longueur de la table de hachage

// Obtenir la longueur de la map
redisClient.HLen("map")

Parcourir les paires clé-valeur de la table de hachage

// Parcourir les paires clé-valeur dans la map
redisClient.HScan("map", 0, "", 1)

Listes

Modifier des éléments

// Ajouter à gauche
redisClient.LPush("list", "a", "b", "c", "d", "e")
// Ajouter à droite
redisClient.RPush("list", "g", "i", "a")
// Insérer une valeur avant la valeur de référence
redisClient.LInsertBefore("list", "a", "aa")
// Insérer une valeur après la valeur de référence
redisClient.LInsertAfter("list", "a", "gg")
// Définir la valeur de l'élément à l'index spécifié
redisClient.LSet("list", 0, "head")

Accéder à la longueur

// Accéder à la longueur de la liste
redisClient.LLen("list")

Accéder aux éléments

// Extraire un élément depuis la gauche
redisClient.LPop("list")
// Extraire un élément depuis la droite
redisClient.RPop("list")
// Accéder à l'élément à l'index spécifié
redisClient.LIndex("list", 1)
// Accéder aux éléments dans la plage spécifiée
redisClient.LRange("list", 0, 1)

Supprimer des éléments

// Supprimer l'élément spécifié
redisClient.LRem("list", 0, "a")
// Supprimer les éléments dans la plage spécifiée
redisClient.LTrim("list", 0, 1)
// Conserver les éléments dans la plage spécifiée
redisClient.LTrim("list", 0, 1)

Ensembles

Ajouter des éléments

// Ajouter des éléments à un ensemble
redisClient.SAdd("set", "a", "b", "c")
redisClient.SAdd("set2", "c", "d", "e")

Accéder aux éléments d'un ensemble

// Obtenir tous les membres d'un ensemble
redisClient.SMembers("set")
// Vérifier si un élément appartient à cet ensemble
redisClient.SIsMember("set", "a")
// Retourner count éléments aléatoires
redisClient.SRandMemberN("set", 1)
// Obtenir le nombre d'éléments d'un ensemble
redisClient.SCard("set")

Opérations sur les ensembles

// Retourner la différence entre les ensembles donnés
redisClient.SDiff("set", "set2")
// Stocker la différence dans l'ensemble résultat, retourner la taille de l'ensemble résultat
redisClient.SDiffStore("store", "set", "se2")
// Retourner l'intersection des ensembles donnés
redisClient.SInter("set", "set2")
// Stocker l'intersection dans l'ensemble résultat, retourner la taille de l'ensemble résultat
redisClient.SInterStore("store", "set", "set2")
// Retourner l'union des ensembles donnés
redisClient.SUnion("set", "set2")
// Stocker l'union dans l'ensemble résultat, retourner la taille de l'ensemble résultat
redisClient.SUnionStore("store", "set", "store")

Supprimer des éléments

// Extraire et supprimer l'élément
redisClient.SPop("set")
// Extraire et supprimer N éléments
redisClient.SPopN("set", 2)

Déplacer un élément

// Déplacer l'élément spécifié de l'ensemble source vers l'ensemble cible
redisClient.SMove("set", "set2", "a")

Supprimer des éléments

// Supprimer les éléments spécifiés
redisClient.SRem("set", "a", "b")

Parcourir

// Parcourir l'ensemble
redisClient.SScan("set", 0, "", 2)

Ensembles ordonnés

Ajouter des éléments

// Ajouter des éléments à un ensemble ordonné
redisClient.ZAdd("ss", redis.Z{
   Score:  1,
   Member: "a",
}, redis.Z{
   Score:  2,
   Member: "b",
})

Classement des éléments

// Retourner le rang de l'élément dans l'ensemble ordonné, classé du plus bas au plus haut
redisClient.ZRank("ss", "1")
// Retourner le rang de l'élément dans l'ensemble ordonné, classé du plus haut au plus bas
redisClient.ZRevRank("ss", "1")

Accéder aux éléments

// Retourner le nombre de membres entre min et max
redisClient.ZCount("ss", "1", "2")

// Retourner le score de l'élément
redisClient.ZScore("ss", "a")

// Retourner les éléments dans la plage spécifiée
redisClient.ZRange("ss", 1, 2)
// Retourner la liste de tous les membres entre min et max
redisClient.ZRangeByScore("ss", redis.ZRangeBy{
   Min:    "1",
   Max:    "2",
   Offset: 0,
   Count:  1,
})

Modifier le score

// Augmenter le score correspondant d'un élément
redisClient.ZIncr("ss", redis.Z{
   Score:  2,
   Member: "b",
})

Supprimer des éléments

// Supprimer l'élément spécifié
redisClient.ZRem("ss", "a")
// Supprimer les éléments dans la plage de rangs spécifiée
redisClient.ZRemRangeByRank("ss", 1, 2)
// Supprimer les éléments dont le score est entre min et max
redisClient.ZRemRangeByScore("ss", "1", "2")

Scripts

// Charger un script, retourner la valeur sha
redisClient.ScriptLoad("return 0")
// Exécuter un script selon la valeur sha
redisClient.EvalSha("sha", []string{}, "")
// Exécuter directement un script
redisClient.Eval("return 0", []string{}, "")
// Vider le cache des scripts
redisClient.ScriptFlush()
// Tuer le script en cours d'exécution
redisClient.ScriptKill()
// Vérifier si le script avec le hash correspondant existe
redisClient.ScriptExists("")

Publication et abonnement

// Envoyer un message sur le canal spécifié
redisClient.Publish("channel", "message")
// S'abonner au canal spécifié
redisClient.Subscribe("channel")
// Voir l'état des abonnements
redisClient.PubSubNumSub("channel")