Redis

Redis è un database di archiviazione chiave-valore (Key-Value) open source scritto in linguaggio ANSI C, che rispetta il protocollo BSD, supporta la rete, può essere basato su memoria, distribuito, con persistenza opzionale. Fornisce API in diversi linguaggi. Redis può essere utilizzato sia come database NoSQL che come archivio di cache ad alta velocità, e supporta anche semplici code di messaggi.

Questo articolo spiega solo come utilizzare il driver Go per operare il database Redis, senza trattare Redis stesso.

Documentazione ufficiale: Golang Redis client (uptrace.dev)

Repository ufficiale: go-redis/redis: Type-safe Redis client for Golang (github.com)

Installazione

Esistono molti driver per Redis. Questo articolo utilizza github.com/go-redis/redis.

Se la versione di Redis che utilizzi è la 6

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

Se la versione di Redis che utilizzi è la 7

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

Avvio rapido

import (
   "fmt"
   "log"
   "testing"

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

func TestQuickStart(t *testing.T) {
   // Crea client di connessione Redis
   redisClient := redis.NewClient(&redis.Options{
      Addr:     "192.168.48.134:6379",
      Password: "123456",
      DB:       0, // Utilizza DB predefinito
   })

   // Imposta coppia chiave-valore, 0 significa mai in scadenza
   redisClient.Set("hello", "world", 0)

   // Leggi valore
   result, err := redisClient.Get("hello").Result()
   if err == redis.Nil {
      fmt.Println("ket non esiste")
   } else if err != nil {
      log.Panic(err)
   }
   fmt.Println(result)
}

Configurazione connessione

type Options struct {
  // Tipo di rete tcp o unix.
  // Predefinito è tcp.
  Network string
  // Indirizzo redis, formato host:port
  Addr string

    // Dialer crea una nuova connessione di rete e ha priorità superiore alle opzioni Network e Addr
  // Network and Addr options.
  Dialer func() (net.Conn, error)

  // Questa funzione viene richiamata quando viene creata una nuova connessione redis
  OnConnect func(*Conn) error

  // Password redis, può essere vuota se il server redis non è configurato con password.
  Password string

  // Database redis, numerazione da 0, predefinito è 0, può non essere impostato
  DB int

  // Numero massimo di tentativi di retry per operazioni redis fallite, predefinito 0.
  MaxRetries int

  // Intervallo minimo di tempo per i retry.
  // Predefinito è 8ms ; -1 indica disattivato.
  MinRetryBackoff time.Duration

  // Intervallo massimo di tempo per i retry
  // Predefinito è 512ms; -1 indica disattivato.
  MaxRetryBackoff time.Duration

  // Timeout per nuove connessioni redis.
  // Predefinito è 5 secondi.
  DialTimeout time.Duration

  // Timeout lettura socket
  // Predefinito 3 secondi.
  ReadTimeout time.Duration

  // Timeout scrittura socket
  WriteTimeout time.Duration

  // Numero massimo di connessioni nel pool di connessioni redis.
  // La dimensione predefinita del pool è uguale al numero di cpu * 10
  PoolSize int

  // Numero minimo di connessioni inattive nel pool di connessioni redis.
  MinIdleConns int

  // Tempo massimo di vita di una connessione redis, predefinito non chiude connessioni obsolete.
  MaxConnAge time.Duration

  // Dopo aver ottenuto una connessione dal pool di connessioni redis, quanto tempo attende al massimo il pool per questa connessione presa.
  // Predefinito è ReadTimeout + 1 secondo.
  PoolTimeout time.Duration

  // Dopo quanto tempo il pool di connessioni redis chiude una connessione inattiva.
  // Predefinito è 5 minuti. -1 indica disattivato questa opzione
  IdleTimeout time.Duration

  // Ogni quanto tempo verificare le connessioni inattive
  // Predefinito è 1 minuto. -1 indica disattivato il rilevamento connessioni inattive
  IdleCheckFrequency time.Duration

  // Impostazione sola lettura, se impostato su true, sull'istanza del nodo corrente, redis può solo eseguire query sulla cache non aggiornamenti.
  readOnly bool

    // Configurazione TLS
  TLSConfig *tls.Config
}

Stabilire connessione

// Crea client di connessione Redis
redisClient := redis.NewClient(&redis.Options{
    Addr:     "192.168.48.134:6379",
    Password: "123456",
    DB:       0, // Utilizza DB predefinito
})

Chiudere connessione

Il driver mantiene internamente un pool di connessioni, non è necessario chiudere la connessione dopo ogni operazione.

defer redisClient.Close()

Questo driver Redis ha incapsulato quasi tutte le operazioni, i comandi Redis corrispondono uno a uno ai nomi dei metodi. Fondamentalmente, se sai come utilizzare i comandi Redis, saprai anche utilizzare i metodi corrispondenti del driver.

Comandi Redis: Manuale comandi redis

Operazioni di base

Eliminare chiave

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

Tempo di scadenza

redisClient.Set("name", "jack", 0)
// Imposta tempo di scadenza
redisClient.Expire("name", time.Second*2)
fmt.Println(redisClient.Get("name").Val())
time.Sleep(time.Second * 3)
fmt.Println(redisClient.Get("name").Val())

Annullare tempo di scadenza

redisClient.Set("name", "jack", 2)
// Annulla tempo di scadenza
redisClient.Persist("name")
time.Sleep(time.Second * 2)
fmt.Println(redisClient.Get("name"))

Interrogare tempo di scadenza

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

Rinominare

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

Interrogare tipo

redisClient.Type("name")

Scansione

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

Stringhe

Salvataggio e recupero semplice

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

Salvataggio e recupero batch

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

Incremento e decremento numerico

redisClient.Set("age", "1", 0)
// Incremento automatico
redisClient.Incr("age")
fmt.Println(redisClient.Get("age").Val())
// Decremento automatico
redisClient.Decr("age")
fmt.Println(redisClient.Get("age").Val())

Tabelle hash

Operazioni di lettura e scrittura

// Impostazione singola
redisClient.HSet("map", "name", "jack")
// Impostazione batch
redisClient.HMSet("map", map[string]interface{}{"a": "b", "c": "d", "e": "f"})
// Accesso singolo
fmt.Println(redisClient.HGet("map", "a").Val())
// Accesso batch
fmt.Println(redisClient.HMGet("map", "a", "b").Val())
// Ottieni l'intera map
fmt.Println(redisClient.HGetAll("map").Val())

Output

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

Eliminare chiave

// Elimina un campo dalla map
redisClient.HDel("map", "a")

Verificare se una chiave esiste

// Verifica se un campo esiste
redisClient.HExists("map", "a")

Ottenere tutte le chiavi

// Ottieni tutte le chiavi della map
redisClient.HKeys("map")

Ottenere la lunghezza della tabella hash

// Ottieni la lunghezza della map
redisClient.HLen("map")

Iterare coppie chiave-valore della tabella hash

// Itera coppie chiave-valore nella map
redisClient.HScan("map", 0, "", 1)

Liste

Modificare elementi

// Aggiunta a sinistra
redisClient.LPush("list", "a", "b", "c", "d", "e")
// Aggiunta a destra
redisClient.RPush("list", "g", "i", "a")
// Inserisce valore prima del valore di riferimento
redisClient.LInsertBefore("list", "a", "aa")
// Inserisce valore dopo il valore di riferimento
redisClient.LInsertAfter("list", "a", "gg")
// Imposta il valore dell'elemento all'indice specificato
redisClient.LSet("list", 0, "head")

Accedere alla lunghezza

// Accedi alla lunghezza della lista
redisClient.LLen("list")

Accedere agli elementi

// Estrai elemento da sinistra
redisClient.LPop("list")
// Estrai elemento da destra
redisClient.RPop("list")
// Accedi all'elemento all'indice specificato
redisClient.LIndex("list", 1)
// Accedi agli elementi nell'intervallo specificato
redisClient.LRange("list", 0, 1)

Eliminare elementi

// Elimina elemento specificato
redisClient.LRem("list", 0, "a")
// Elimina elementi nell'intervallo specificato
redisClient.LTrim("list", 0, 1)
// Mantiene elementi nell'intervallo specificato
redisClient.LTrim("list", 0, 1)

Insiemi

Aggiungere elementi

// Aggiunge elementi a un insieme
redisClient.SAdd("set", "a", "b", "c")
redisClient.SAdd("set2", "c", "d", "e")

Accedere agli elementi dell'insieme

// Ottieni tutti i membri dell'insieme
redisClient.SMembers("set")
// Verifica se un elemento appartiene a questo insieme
redisClient.SIsMember("set", "a")
// Restituisce count elementi casuali
redisClient.SRandMemberN("set", 1)
// Ottieni il numero di elementi di un insieme
redisClient.SCard("set")

Operazioni sugli insiemi

// Restituisce la differenza tra gli insiemi dati
redisClient.SDiff("set", "set2")
// Salva la differenza tra gli insiemi dati nel risultato, restituisce la lunghezza del risultato
redisClient.SDiffStore("store", "set", "se2")
// Restituisce l'intersezione tra gli insiemi dati
redisClient.SInter("set", "set2")
// Salva l'intersezione tra gli insiemi dati nel risultato, restituisce la lunghezza del risultato
redisClient.SInterStore("store", "set", "set2")
// Restituisce l'unione tra gli insiemi dati
redisClient.SUnion("set", "set2")
// Salva l'unione tra gli insiemi dati nel risultato, restituisce la lunghezza del risultato
redisClient.SUnionStore("store", "set", "store")

Eliminare elementi

// Estrai ed elimina l'elemento
redisClient.SPop("set")
// Estrai ed elimina N elementi
redisClient.SPopN("set", 2)

Spostare elementi

// Sposta l'elemento specificato dall'insieme di origine all'insieme di destinazione
redisClient.SMove("set", "set2", "a")

Eliminare elementi

// Elimina elementi specificati
redisClient.SRem("set", "a", "b")

Iterare

// Itera l'insieme
redisClient.SScan("set", 0, "", 2)

Insiemi ordinati

Aggiungere elementi

// Aggiunge elementi a un insieme ordinato
redisClient.ZAdd("ss", redis.Z{
   Score:  1,
   Member: "a",
}, redis.Z{
   Score:  2,
   Member: "b",
})

Classifica elementi

// Restituisce la classifica dell'elemento nell'insieme ordinato, ordinamento dal basso all'alto
redisClient.ZRank("ss", "1")
// Restituisce la classifica dell'elemento nell'insieme ordinato, ordinamento dall'alto al basso
redisClient.ZRevRank("ss", "1")

Accedere agli elementi

// Restituisce il numero di membri tra min e max
redisClient.ZCount("ss", "1", "2")

// Restituisce il peso dell'elemento
redisClient.ZScore("ss", "a")

// Restituisce gli elementi nell'intervallo specificato
redisClient.ZRange("ss", 1, 2)
// Restituisce tutti i membri tra min e max
redisClient.ZRangeByScore("ss", redis.ZRangeBy{
   Min:    "1",
   Max:    "2",
   Offset: 0,
   Count:  1,
})

Modificare il peso

// Aumenta il peso corrispondente per un elemento
redisClient.ZIncr("ss", redis.Z{
   Score:  2,
   Member: "b",
})

Eliminare elementi

// Elimina elemento specificato
redisClient.ZRem("ss", "a")
// Elimina elementi nell'intervallo di classifica specificato
redisClient.ZRemRangeByRank("ss", 1, 2)
// Elimina elementi con peso nell'intervallo tra min e max
redisClient.ZRemRangeByScore("ss", "1", "2")

Script

// Carica script, restituisce valore sha
redisClient.ScriptLoad("return 0")
// Esegue script in base al valore sha
redisClient.EvalSha("sha", []string{}, "")
// Esegue script direttamente
redisClient.Eval("return 0", []string{}, "")
// Pulisce cache script
redisClient.ScriptFlush()
// Termina script attualmente in esecuzione
redisClient.ScriptKill()
// Verifica se esiste lo script per il valore hash corrispondente
redisClient.ScriptExists("")

Pubblicazione e sottoscrizione

// Invia messaggio al canale specificato
redisClient.Publish("channel", "message")
// Sottoscrivi canale specificato
redisClient.Subscribe("channel")
// Verifica stato sottoscrizione
redisClient.PubSubNumSub("channel")