3 migliori client Redis per gli sviluppatori Go

Redis è un archivio di strutture di dati in memoria, ampiamente utilizzato per la memorizzazione nella cache, l’analisi in tempo reale e l’intermediazione di messaggi. È una scelta popolare per gli sviluppatori grazie alla sua velocità fulminea e al ricco set di funzionalità.

Redis supporta molte strutture di dati tra cui stringhe, hash, elenchi, raccolte e set ordinati. Offre inoltre supporto integrato per la messaggistica di pubblicazione/sottoscrizione, supporto per le transazioni e scripting Lua.

Esistono diversi client Redis popolari per gli sviluppatori Go, ognuno con caratteristiche e funzionalità uniche. I seguenti tre client Redis sono i più popolari tra gli sviluppatori Go.

1. Il pacchetto go-redis

Il pacchetto go-redis è una popolare libreria client Go per il database Redis. Fornisce un’API semplice e facile da usare per l’interazione con Redis e il pacchetto supporta tutti i comandi Redis.

Il pacchetto go-redis è popolare tra gli sviluppatori Go grazie alle sue prestazioni, affidabilità e interfaccia facile da usare. Troverai il pacchetto utile per funzionalità dalla gestione delle sessioni alla memorizzazione nella cache, accodamento dei messaggi e altro ancora.

Esegui questo comando nel terminale della directory del tuo progetto per installare il pacchetto go-redis.

go get github.com/go-redis/redis


Ecco come puoi importare il pacchetto go-redis nel tuo progetto.

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


Creare un’istanza di una nuova connessione a un database Redis con il pacchetto go-redis è facile. Utilizzerai il metodo NewClient del pacchetto redis , che accetta la struttura Options contenente i dettagli di configurazione.

func main() {
  client: = redis.NewClient(&redis.Options{
    Addr: "localhost:6379",
    Password: "", // no password set
  })
}


Nella funzione principale , la variabile client è l’istanza di connessione del client Redis. È possibile inizializzare la struttura Options con i campi Addr e Password che contengono rispettivamente l’indirizzo e la password del database.

Quando crei un’istanza del client Redis, puoi eseguire il ping del database per verificare la tua connessione con il metodo Ping . È possibile utilizzare il metodo Result sul metodo Ping, che restituisce lo stato e un errore.

pong, err: = client.Ping().Result()


if err! = nil {
  fmt.Println(err)
  return
}

Puoi aggiungere una coppia chiave-valore al tuo database con il metodo Set della tua istanza client. L’uso del metodo Err su un’operazione restituisce un errore che puoi gestire.

// Set a key
err = client.Set("key", "value", 0).Err()


if err! = nil {
   fmt.Println(err)
   return
}


È possibile recuperare un valore dal database con la chiave utilizzando il metodo Get dell’istanza del client. L’utilizzo del metodo Result in un’operazione restituisce il risultato dell’operazione e un errore.

// Get a key
val, err: = client.Get("key").Result()


if err! = nil {
  fmt.Println(err)
  return
}

fmt.Println("key", val)


2. Il pacchetto Radix

Il pacchetto Radix è una libreria che fornisce un client per l’archivio della struttura dei dati in memoria di Redis. Il pacchetto Radix astrae il pacchetto Redigo per fornire un’API di facile utilizzo per l’interazione con Redis.

Il pacchetto Radix fornisce supporto per tutti i comandi Redis, inclusi scripting Lua e Pub/Sub, pool di connessioni e riconnessioni automatiche che consentono operazioni efficienti e resilienti con Redis, supporto per cluster Redis inclusi sharding trasparente e failover e un design leggero ed efficiente che consente per bassa latenza e throughput elevato.

Troverai il pacchetto Radix molto utile se stai cercando di aggiungere un rapido supporto Redis ai tuoi progetti Go poiché il pacchetto astrae le complessità sottostanti del protocollo Redis, semplificando la memorizzazione nella cache, la gestione delle sessioni e l’accodamento dei messaggi.

Esegui questo comando per installare la versione tre del pacchetto Radix nella directory di lavoro del progetto.

go get github.com/mediocregopher/radix/v3


Ecco come puoi importare il pacchetto Radix nel tuo programma.

import (
  "fmt"
  "github.com/mediocregopher/radix/v3"
)


Puoi utilizzare il metodo Dial del pacchetto radix per connetterti a un server Redis. Il metodo Dial accetta il tipo di connessione e l’indirizzo del server Redis e restituisce un’istanza di connessione e un errore.

func main() {
  //connect to redis server
  conn, err: = radix.Dial("tcp", "localhost:6379")


  if err! = nil {
    fmt.Println(err)
    return
  }

  defer conn.Close()
}


Nella funzione principale, hai creato un’istanza di connessione Redis con il metodo Dial e chiuso la connessione con il metodo Close e un’istruzione defer .

Puoi eseguire i comandi Redis con il metodo Cmd del pacchetto radix . Il metodo Cmd accetta un’interfaccia, un comando ei valori del comando.

err = conn.Do(radix.Cmd(nil, "SET", "mykey", "myvalue"))


if err! = nil {
  fmt.Println("Error setting key: ", err)
} else {
  fmt.Println("Key set successfully")
}


Il metodo Do racchiude l’operazione e restituisce un errore.

Allo stesso modo, puoi recuperare i valori dal tuo database con il metodo FlatCmd . Il metodo FlatCmd accetta il riferimento a una variabile, il comando e la chiave.

var val string
err = conn.Do(radix.FlatCmd(&val, "GET", "mykey"))


if err! = nil {
  fmt.Println("Error getting key: ", err)
} else {
  fmt.Println("Value of mykey is", val)
}

Quando esegui quel codice, dovresti vedere un output simile a questo:

3. Il pacchetto Redigo

Il pacchetto Redigo è un’altra popolare libreria client Go per Redis. A differenza di Radix e Go-redis , il pacchetto Redigo è un client leggero che fornisce un’interfaccia semplice ed efficiente per l’interazione con Redis.

Uno dei punti di forza di Redigo è la sua performance, nonostante la sua leggerezza. Redigo fornisce un’API simile alla stampa con supporto per tutti i comandi Redis e il pacchetto è comunemente utilizzato per pipelining, pub-sub, pool di connessioni e altre operazioni.

Esegui questo comando da terminale per installare il pacchetto redigo e iniziare.

go get github.com/gomodule/redigo/redis


Ecco come puoi importare il pacchetto redigo nei tuoi file di progetto.

import (
  "fmt"
  "github.com/gomodule/redigo/redis"
)


È possibile utilizzare il metodo Dial del pacchetto redis per connettersi a un’istanza del database Redis. Il metodo Dial accetta un tipo di connessione e un indirizzo e restituisce l’istanza di connessione e un errore.

func main() {
  // Connect to the Redis instance
  conn, err: = redis.Dial("tcp", "localhost:6379")


  if err! = nil {
    fmt.Println(err)
    return
  }

  defer conn.Close()
}


Nella funzione principale , ti sei connesso a un’istanza di database Redis in esecuzione sulla porta 6379 e hai chiuso la connessione con il metodo Close dell’istanza di connessione e un’istruzione di rinvio .

Puoi eseguire operazioni Redis utilizzando il metodo Do della tua istanza di connessione. Il metodo Do restituisce un’interfaccia di output e un errore.

// Set the value "hello"to the key "message"
_, err = conn.Do("SET", "message", "hello")


if err! = nil {
  fmt.Println(err)
  return
}


È possibile recuperare un output di stringa di un’operazione Redis con il metodo String del pacchetto redis . Il metodo String accetta l’istanza dell’operazione e restituisce il valore e un errore.

// Get the value of the key "message"
value, err: = redis.String(conn.Do("GET", "message"))


if err! = nil {
  fmt.Println(err)
  return
}

fmt.Println(value) // Output: "hello"


È possibile utilizzare i database SQL con Go

C’è il supporto per i database e gli archivi di dati più diffusi nell’ecosistema Go. Go fornisce il pacchetto database/sql come parte della libreria standard per lavorare con i database SQL.