Spring Data Redis proporciona RedisTemplate como una interfaz central para ejecutar comandos en Redis. Este artículo explora los métodos esenciales para los tipos de datos principales.

Estructuras de Datos en Redis

• Cadenas (String)
• Hash
• Listas (List)
• Conjuntos (Set)
• Conjuntos Ordenados (Sorted Set)

Interfaz de RedisTemplate

Operaciones con Cadenas

Almacenar un valor con su clave:

redisOps.opsForValue().asignar(clave, valor);

Definir un valor con tiempo de expiración:

redisOps.opsForValue().asignar(clave, valor, duracion, unidad);

Verificar la existencia de una clave:

redisOps.existeClave(clave);

Recuperar el valor asociado a una clave:

redisOps.opsForValue().obtener(clave);

Eliminar una clave individual:

redisOps.eliminar(clave);

Eliminar múltiples claves en lote:

redisOps.eliminarConjunto(claves);

Serializar una clave a bytes:

redisOps.volcar(clave);

Establecer tiempo de vida para una clave:

public Boolean configurarExpiracion(String clave, long tiempo, TimeUnit unidad) {
    return redisOps.expirar(clave, tiempo, unidad);
}
public Boolean configurarExpiracionEnFecha(String clave, Date fecha) {
    return redisOps.expirarEnFecha(clave, fecha);
}

Buscar claves que coincidan con un patrón:

public Set<string> buscarClaves(String patron) {
    return redisOps.claves(patron);
}</string>

Cambiar el nombre de una clave:

public void renombrarClave(String claveAnterior, String nuevaClave) {
    redisOps.renombrar(claveAnterior, nuevaClave);
}

Obtener el tipo de dato de una clave:

public DataType tipoDeClave(String clave) {
    return redisOps.tipo(clave);
}

Renombrar solo si la clave antigua no existe:

public Boolean renombrarSiAusente(String claveAnterior, String nuevaClave) {
    return redisOps.renombrarSiAusente(claveAnterior, nuevaClave);
}

Seleccionar una clave aleatoria:

redisOps.claveAleatoria();

Consultar el tiempo restante de expiración:

public Long obtenerExpiracion(String clave) {
    return redisOps.obtenerExpiracion(clave);
}

Consultar el tiempo restante con unidad específica:

public Long obtenerExpiracionConUnidad(String clave, TimeUnit unidad) {
    return redisOps.obtenerExpiracion(clave, unidad);
}

Hacer persistente una clave:

public Boolean hacerPersistente(String clave) {
    return redisOps.persistir(clave);
}

Mover una clave a otra base de datos:

public Boolean moverABaseDatos(String clave, int indice) {
    return redisOps.mover(clave, indice);
}

Extraer subcadenas de un valor:

public String obtenerSubcadena(String clave, long inicio, long fin) {
    return redisOps.opsForValue().obtener(clave, inicio, fin);
}

Reemplazar un valor y retornar el anterior:

public String obtenerYReemplazar(String clave, String nuevoValor) {
    return redisOps.opsForValue().obtenerYReemplazar(clave, nuevoValor);
}

Obtener múltiples valores en una sola operación:

public List<string> obtenerMultiples(Collection<string> claves) {
    return redisOps.opsForValue().obtenerMultiples(claves);
}</string></string>

Agregar contenido al final de un valor existente:

redisOps.opsForValue().agregar(clave, valorAdicional);

Incrementar un valor numérico:

public Double incrementarDecimal(String clave, double delta) {
    return redisOps.opsForValue().incrementar(clave, delta);
}

Incrementar o decrementar un valor entero:

public Long incrementarEntero(String clave, long delta) {
    return redisOps.opsForValue().incrementar(clave, delta);
}

Establecer múltiples pares clave-valor si no existen:

Map<string string=""> mapaValores = new HashMap<>();
mapaValores.put("llave1", "dato1");
mapaValores.put("llave2", "dato2");
redisOps.opsForValue().establecerMultiplesSiAusentes(mapaValores);</string>

Almacenar un mapa de valores:

Map<string string=""> mapaDatos = new HashMap<>();
mapaDatos.put("campoA", "valorX");
mapaDatos.put("campoB", "valorY");
redisOps.opsForValue().establecerMultiples(mapaDatos);</string>

Calcular la longitud de una cadena:

redisOps.opsForValue().longitud(clave);

Sobrescribir parte de un valor desde un desplazamiento:

redisOps.opsForValue().establecerConDesplazamiento(clave, nuevoValor, desplazamiento);

Asignar un valor solo si la clave no existe:

redisOps.opsForValue().establecerSiAusente(clave, valor);

Configurar bit en una posición específica:

redisOps.opsForValue().configurarBit(clave, posicion, estadoBit);

Leer el valor de un bit en una posición:

redisOps.opsForValue().obtenerBit(clave, posicion);

Operaciones con Hash

Consultar un campo específico de un hash:

redisOps.opsForHash().obtener(claveHash, campo);

Recuperar todos los pares campo-valor:

public Map<object object=""> obtenerTodoHash(String claveHash) {
    return redisOps.opsForHash().entradas(claveHash);
}</object>

Insetrar un nuevo par campo-valor:

redisOps.opsForHash().insertar(claveHash, campo, valor);

Cargar un mapa completo en un hash:

public void cargarMapaEnHash(String claveHash, Map<string string=""> mapa) {
    redisOps.opsForHash().insertarTodos(claveHash, mapa);
}</string>

Insertar un campo solo si no existe previamente:

public Boolean insertarSiAusente(String claveHash, String campo, String valor) {
    return redisOps.opsForHash().insertarSiAusente(claveHash, campo, valor);
}

Eliminar campos de un hash:

public Long eliminarCamposHash(String claveHash, Object... campos) {
    return redisOps.opsForHash().eliminar(claveHash, campos);
}

Comprobar la existencia de un campo:

public boolean existeCampoHash(String claveHash, String campo) {
    return redisOps.opsForHash().tieneClave(claveHash, campo);
}

Incrementar un valor numérico en un campo:

public Long incrementarHashEntero(String claveHash, Object campo, long incremento) {
    return redisOps.opsForHash().incrementar(claveHash, campo, incremento);
}
public Double incrementarHashDecimal(String claveHash, Object campo, double delta) {
    return redisOps.opsForHash().incrementar(claveHash, campo, delta);
}

Listar todos los campos de un hash:

redisOps.opsForHash().campos(claveHash);

Contar el número de campos:

redisOps.opsForHash().tamaño(claveHash);

Obtener todos los valores de un hash:

public List<object> valoresHash(String claveHash) {
    return redisOps.opsForHash().valores(claveHash);
}</object>

Escanear campos con opciones específicas:

public Cursor<entry object="">> escanearHash(String claveHash, ScanOptions opciones) {
    return redisOps.opsForHash().escanear(claveHash, opciones);
}</entry>

Operaciones con Listas

Acceder a un elemento por índice:

redisOps.opsForList().indice(claveLista, posicion);

Obtener un rango de elementos:

redisOps.opsForList().rango(claveLista, inicio, fin);

Insertar al inicio de la lista:

redisOps.opsForList().insertarIzquierda(claveLista, elemento);

Agregar múltiples elementos al inicio:

redisOps.opsForList().insertarMultiplesIzquierda(claveLista, elementos);

Insertar solo si la lista existe:

redisOps.opsForList().insertarIzquierdaSiPresente(claveLista, elemento);

Insertar antes de un elemento pivote:

redisOps.opsForList().insertarIzquierdaAntes(claveLista, pivote, nuevoElemento);

Insertar al final de la lista:

redisOps.opsForList().insertarDerecha(claveLista, elemento);
redisOps.opsForList().insertarMultiplesDerecha(claveLista, elementos);

Insertar después de un elemento pivote:

redisOps.opsForList().insertarDerechaDespues(claveLista, pivote, nuevoElemento);

Actualizar un elemento por índice:

redisOps.opsForList().establecer(claveLista, indice, nuevoValor);

Extraer el primer elemento (con o sin bloqueo):

redisOps.opsForList().extraerIzquierda(claveLista);
redisOps.opsForList().extraerIzquierda(claveLista, tiempoEspera, unidad);

Extraer el último elemento:

redisOps.opsForList().extraerDerecha(claveLista);
redisOps.opsForList().extraerDerecha(claveLista, tiempoEspera, unidad);

Transferir elementos entre listas:

redisOps.opsForList().extraerDerechaEInsertarIzquierda(origen, destino);
redisOps.opsForList().extraerDerechaEInsertarIzquierda(origen, destino, tiempoEspera, unidad);

Eliminar elementos por valor:

redisOps.opsForList().eliminar(claveLista, cantidad, valor);

Recortar una lista a un rango específico:

redisOps.opsForList().recortar(claveLista, inicio, fin);

Obtener el tamaño de una lista:

redisOps.opsForList().tamaño(claveLista);

Operaciones con Conjuntos

Añadir elementos a un conjunto:

redisOps.opsForSet().agregar(claveConjunto, elementos);

Eliminar elementos de un conjunto:

redisOps.opsForSet().eliminar(claveConjunto, elementos);

Extraer un elemento aleatorio:

redisOps.opsForSet().extraerAleatorio(claveConjunto);

Contar los elementos del conjunto:

redisOps.opsForSet().tamaño(claveConjunto);

Verificar si un elemento pertenece al conjunto:

redisOps.opsForSet().esMiembro(claveConjunto, elemento);

Calcular la intersección con otro conjunto:

redisOps.opsForSet().interseccion(claveConjunto, otraClave);

Intersección con múltiples conjuntos:

redisOps.opsForSet().interseccion(claveConjunto, otrasClaves);

Almacenar la intersección en un nuevo conjunto:

redisOps.opsForSet().interseccionYAlmacenar(claveConjunto, otraClave, destino);
redisOps.opsForSet().interseccionYAlmacenar(claveConjunto, otrasClaves, destino);

Obtener la unión de conjuntos:

redisOps.opsForSet().union(claveConjunto, otrasClaves);

Almacenar la unión en un conjunto destino:

redisOps.opsForSet().unionYAlmacenar(claveConjunto, otraClave, destino);

Calcular la diferencia entre conjuntos:

redisOps.opsForSet().diferencia(claveConjunto, otrasClaves);

Almacenar la diferencia:

redisOps.opsForSet().diferenciaYAlmacenar(claveConjunto, otraClave, destino);

Seleccionar un miembro aleatorio:

redisOps.opsForSet().miembroAleatorio(claveConjunto);

Listar todos los miembros:

redisOps.opsForSet().miembros(claveConjunto);

Obtener múltiples miembros aleatorios:

redisOps.opsForSet().miembrosAleatorios(claveConjunto, cantidad);

Miembros aleatorios únicos:

redisOps.opsForSet().miembrosAleatoriosDistintos(claveConjunto, cantidad);

Iterar sobre el conjunto:

redisOps.opsForSet().escanear(claveConjunto, opciones);

Operaciones con Conjuntos Ordenados

Añadir elementos con puntuación:

redisOps.opsForZSet().agregar(claveZSet, elemento, puntuacion);

Eliminar elementos:

redisOps.opsForZSet().eliminar(claveZSet, elementos);

Obtener elementos en orden ascendente:

redisOps.opsForZSet().rango(claveZSet, inicio, fin);

Obtener elementos en orden descendente:

redisOps.opsForZSet().rangoInverso(claveZSet, inicio, fin);

Incrementar la puntuación de un elemento:

redisOps.opsForZSet().incrementarPuntuacion(claveZSet, elemento, delta);

Consultar el rango de un elemento:

redisOps.opsForZSet().rango(claveZSet, elemento);

Rango inverso de un elemento:

redisOps.opsForZSet().rangoInverso(claveZSet, elemento);

Obtener elementos con puntuaciones en un rango:

redisOps.opsForZSet().rangoInversoConPuntuaciones(claveZSet, inicio, fin);

Filtrar por rango de puntuación ascendente:

redisOps.opsForZSet().rangoPorPuntuacion(claveZSet, min, max);
redisOps.opsForZSet().rangoPorPuntuacionConPuntuaciones(claveZSet, min, max);

Filtrar por rango de puntuación descendente:

redisOps.opsForZSet().rangoInversoPorPuntuacion(claveZSet, min, max, inicio, fin);

Contar elementos por rango de puntuación:

redisOps.opsForZSet().contar(claveZSet, min, max);

Obtener el tamaño del conjunto:

redisOps.opsForZSet().tamaño(claveZSet);
redisOps.opsForZSet().tarjeta(claveZSet);

Consultar la puntuación de un elemento:

redisOps.opsForZSet().puntuacion(claveZSet, elemento);

Eliminar por rango de índices:

redisOps.opsForZSet().eliminarRango(claveZSet, inicio, fin);

Eliminar por rango de puntuación:

redisOps.opsForZSet().eliminarRangoPorPuntuacion(claveZSet, min, max);

Almacenar la unión de conjuntos ordenados:

redisOps.opsForZSet().unionYAlmacenar(claveZSet, otraClave, destino);

Almacenar la intersección:

redisOps.opsForZSet().interseccionYAlmacenar(claveZSet, otraClave, destino);

Recorrer el conjunto ordenado:

Cursor<typedtuple>> iterador = opsForZSet.escanear("miZSet", ScanOptions.NONE);
while (iterador.hasNext()) {
    ZSetOperations.TypedTuple<object> item = iterador.next();
    System.out.println(item.getValor() + ":" + item.getPuntuacion());
}</object></typedtuple>