Redis

Redis es una base de datos de almacenamiento clave-valor (Key-Value) de código abierto escrita en lenguaje ANSI C, que sigue el protocolo BSD, soporta red, puede basarse en memoria, es distribuida y opcionalmente persistente. También proporciona API para múltiples lenguajes. Redis puede usarse como una base de datos NoSQL, como almacenamiento de caché de alta velocidad y también soporta colas de mensajes simples.

Este artículo solo explica cómo usar el controlador de Go para operar la base de datos Redis, sin hacer ninguna explicación sobre Redis en sí.

Documentación oficial: Golang Redis client (uptrace.dev)

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

Instalación

Hay muchos controladores para Redis. Este artículo usa github.com/go-redis/redis.

Si tu versión de Redis es 6:

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

Si tu versión de Redis es 7:

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

Inicio rápido

import (
   "fmt"
   "log"
   "testing"

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

func TestQuickStart(t *testing.T) {
   // Crear cliente de conexión Redis
   redisClient := redis.NewClient(&redis.Options{
      Addr:     "192.168.48.134:6379",
      Password: "123456",
      DB:       0, // Usar DB por defecto
   })

   // Establecer par clave-valor, 0 significa nunca expira
   redisClient.Set("hello", "world", 0)

   // Leer valor
   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)
}

Configuración de conexión

type Options struct {
  // Tipo de red tcp o unix.
  // Por defecto es tcp.
  Network string
  // Dirección redis, formato host:port
  Addr string

    // Dialer crea una nueva conexión de red y tiene prioridad sobre las opciones Network y Addr
  // Network and Addr options.
  Dialer func() (net.Conn, error)

  // Esta función se llama al crear una nueva conexión redis
  OnConnect func(*Conn) error

  // Contraseña redis, puede estar vacía si el servidor redis no tiene configuración.
  Password string

  // Base de datos redis, índice comenzando desde 0, por defecto es 0, no es necesario configurar
  DB int

  // Número máximo de reintentos fallidos de operación redis, por defecto 0.
  MaxRetries int

  // Intervalo mínimo de reintento.
  // Por defecto es 8ms ; -1 significa desactivado.
  MinRetryBackoff time.Duration

  // Intervalo máximo de reintento
  // Por defecto es 512ms; -1 significa desactivado.
  MaxRetryBackoff time.Duration

  // Tiempo de espera de nueva conexión redis.
  // Por defecto es 5 segundos.
  DialTimeout time.Duration

  // Tiempo de espera de lectura del socket
  // Por defecto 3 segundos.
  ReadTimeout time.Duration

  // Tiempo de espera de escritura del socket
  WriteTimeout time.Duration

  // Número máximo de conexiones en el pool de conexiones redis.
  // El tamaño del pool por defecto es cpu * 10
  PoolSize int

  // Número mínimo de conexiones inactivas en el pool de conexiones redis.
  MinIdleConns int

  // Tiempo máximo de vida de la conexión redis, por defecto no cierra conexiones obsoletas.
  MaxConnAge time.Duration

  // Después de obtener una conexión del pool de conexiones redis, cuánto tiempo esperará el pool a que esta conexión sea devuelta.
  // Por defecto espera ReadTimeout + 1 segundo.
  PoolTimeout time.Duration

  // Cada cuánto tiempo se cierra una conexión inactiva en el pool de conexiones redis.
  // Por defecto es 5 minutos. -1 significa desactivar esta opción
  IdleTimeout time.Duration

  // Cada cuánto tiempo se detectan conexiones inactivas
  // Por defecto es 1 minuto. -1 significa desactivar la detección de conexiones inactivas
  IdleCheckFrequency time.Duration

  // Configuración de solo lectura, si es true, en la instancia del nodo actual, redis solo puede consultar caché y no actualizar.
  readOnly bool

    // Configuración TLS
  TLSConfig *tls.Config
}

Establecer conexión

// Crear cliente de conexión Redis
redisClient := redis.NewClient(&redis.Options{
    Addr:     "192.168.48.134:6379",
    Password: "123456",
    DB:       0, // Usar DB por defecto
})

Cerrar conexión

El controlador mantiene un pool de conexiones internamente, no es necesario cerrar la conexión después de cada operación.

defer redisClient.Close()

Este controlador de Redis ha encapsulado casi todas las operaciones. Los comandos de Redis se corresponden uno a uno con los nombres de los métodos. Básicamente, si sabes cómo usar los comandos de Redis, sabrás usar los métodos correspondientes del controlador.

Comandos de Redis: redis 命令手册

Operaciones básicas

Eliminar clave

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

Tiempo de expiración

redisClient.Set("name", "jack", 0)
// Establecer tiempo de expiración
redisClient.Expire("name", time.Second*2)
fmt.Println(redisClient.Get("name").Val())
time.Sleep(time.Second * 3)
fmt.Println(redisClient.Get("name").Val())

Cancelar tiempo de expiración

redisClient.Set("name", "jack", 2)
// Cancelar tiempo de expiración
redisClient.Persist("name")
time.Sleep(time.Second * 2)
fmt.Println(redisClient.Get("name"))

Consultar tiempo de expiración

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

Renombrar

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

Consultar tipo

redisClient.Type("name")

Escanear

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

Cadenas

Almacenamiento y recuperación simple

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

Almacenamiento y recuperación por lotes

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

Incremento y decremento numérico

redisClient.Set("age", "1", 0)
// Autoincremento
redisClient.Incr("age")
fmt.Println(redisClient.Get("age").Val())
// Autodecremento
redisClient.Decr("age")
fmt.Println(redisClient.Get("age").Val())

Tablas hash

Operaciones de lectura y escritura

// Establecer uno
redisClient.HSet("map", "name", "jack")
// Establecer por lotes
redisClient.HMSet("map", map[string]interface{}{"a": "b", "c": "d", "e": "f"})
// Acceder a uno
fmt.Println(redisClient.HGet("map", "a").Val())
// Acceder por lotes
fmt.Println(redisClient.HMGet("map", "a", "b").Val())
// Obtener todo el map
fmt.Println(redisClient.HGetAll("map").Val())

Salida

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

Eliminar clave

// Eliminar un campo del map
redisClient.HDel("map", "a")

Verificar si existe la clave

// Verificar si existe el campo
redisClient.HExists("map", "a")

Obtener todas las claves

// Obtener todas las claves del map
redisClient.HKeys("map")

Obtener longitud de la tabla hash

// Obtener longitud del map
redisClient.HLen("map")

Iterar pares clave-valor de la tabla hash

// Iterar pares clave-valor en el map
redisClient.HScan("map", 0, "", 1)

Listas

Modificar elementos

// Añadir a la izquierda
redisClient.LPush("list", "a", "b", "c", "d", "e")
// Añadir a la derecha
redisClient.RPush("list", "g", "i", "a")
// Insertar valor antes del valor de referencia
redisClient.LInsertBefore("list", "a", "aa")
// Insertar valor después del valor de referencia
redisClient.LInsertAfter("list", "a", "gg")
// Establecer valor del elemento en índice especificado
redisClient.LSet("list", 0, "head")

Acceder longitud

// Acceder longitud de la lista
redisClient.LLen("list")

Acceder elementos

// Pop elemento desde la izquierda
redisClient.LPop("list")
// Pop elemento desde la derecha
redisClient.RPop("list")
// Acceder elemento en índice especificado
redisClient.LIndex("list", 1)
// Acceder elementos en rango especificado
redisClient.LRange("list", 0, 1)

Eliminar elementos

// Eliminar elemento especificado
redisClient.LRem("list", 0, "a")
// Eliminar elementos en rango especificado
redisClient.LTrim("list", 0, 1)
// Conservar elementos en rango especificado
redisClient.LTrim("list", 0, 1)

Conjuntos

Añadir elementos

// Añadir elementos a un conjunto
redisClient.SAdd("set", "a", "b", "c")
redisClient.SAdd("set2", "c", "d", "e")

Acceder elementos del conjunto

// Obtener todos los miembros del conjunto
redisClient.SMembers("set")
// Verificar si un elemento pertenece al conjunto
redisClient.SIsMember("set", "a")
// Devolver count elementos aleatorios
redisClient.SRandMemberN("set", 1)
// Obtener número de elementos del conjunto
redisClient.SCard("set")

Operaciones de conjuntos

// Devolver diferencia de conjuntos dados
redisClient.SDiff("set", "set2")
// Guardar diferencia de conjuntos dados en conjunto resultado, devolver longitud del resultado
redisClient.SDiffStore("store", "set", "se2")
// Devolver intersección de conjuntos dados
redisClient.SInter("set", "set2")
// Guardar intersección de conjuntos dados en conjunto resultado, devolver longitud del resultado
redisClient.SInterStore("store", "set", "set2")
// Devolver unión de conjuntos dados
redisClient.SUnion("set", "set2")
// Guardar unión de conjuntos dados en conjunto resultado, devolver longitud del resultado
redisClient.SUnionStore("store", "set", "store")

Eliminar elementos

// Pop y eliminar elemento
redisClient.SPop("set")
// Pop y eliminar N elementos
redisClient.SPopN("set", 2)

Mover elementos

// Mover elemento especificado desde conjunto origen a conjunto destino
redisClient.SMove("set", "set2", "a")

Eliminar elementos

// Eliminar elemento especificado
redisClient.SRem("set", "a", "b")

Iterar

// Iterar conjunto
redisClient.SScan("set", 0, "", 2)

Conjuntos ordenados

Añadir elementos

// Añadir elementos a conjunto ordenado
redisClient.ZAdd("ss", redis.Z{
   Score:  1,
   Member: "a",
}, redis.Z{
   Score:  2,
   Member: "b",
})

Ranking de elementos

// Devolver ranking del elemento en conjunto ordenado, orden ascendente
redisClient.ZRank("ss", "1")
// Devolver ranking del elemento en conjunto ordenado, orden descendente
redisClient.ZRevRank("ss", "1")

Acceder elementos

// Devolver número de miembros entre min y max
redisClient.ZCount("ss", "1", "2")

// Devolver peso del elemento
redisClient.ZScore("ss", "a")

// Devolver elementos en intervalo especificado
redisClient.ZRange("ss", 1, 2)
// Devolver lista de todos los miembros entre min y max
redisClient.ZRangeByScore("ss", redis.ZRangeBy{
   Min:    "1",
   Max:    "2",
   Offset: 0,
   Count:  1,
})

Modificar peso

// Incrementar peso correspondiente a un elemento
redisClient.ZIncr("ss", redis.Z{
   Score:  2,
   Member: "b",
})

Eliminar elementos

// Eliminar elemento especificado
redisClient.ZRem("ss", "a")
// Eliminar elementos en intervalo de ranking especificado
redisClient.ZRemRangeByRank("ss", 1, 2)
// Eliminar elementos con peso entre min y max
redisClient.ZRemRangeByScore("ss", "1", "2")

Scripts

// Cargar script, devolver valor sha
redisClient.ScriptLoad("return 0")
// Ejecutar script según valor sha
redisClient.EvalSha("sha", []string{}, "")
// Ejecutar script directamente
redisClient.Eval("return 0", []string{}, "")
// Limpiar caché de scripts
redisClient.ScriptFlush()
// Matar script en ejecución actual
redisClient.ScriptKill()
// Verificar si existe script correspondiente al hash
redisClient.ScriptExists("")

Publicar/Suscribir

// Enviar mensaje a canal especificado
redisClient.Publish("channel", "message")
// Suscribirse a canal especificado
redisClient.Subscribe("channel")
// Verificar estado de suscripción
redisClient.PubSubNumSub("channel")