Conexión y Operaciones con Redis en Java

1. Dependencias necesarias para Jedis

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.1.0</version>
</dependency>

2. Operaciones básicas con Jedis

2.1. Verificación de conexión

public class VerificacionRedis {
    public static void main(String[] args) {
        // Crear conexión
        Jedis redisConn = new Jedis("servidor_redis", puerto);
        // Establecer contraseña si existe
        redisConn.auth("contraseña_segura");
        // Realizar ping
        String respuestaPing = redisConn.ping();
        // Imprimir respuesta
        System.out.println(respuestaPing);
        redisConn.close();
    }
}

2.2. Operaciones comunes

public class OperacionesRedis {
    public static void main(String[] args) {  
        // Crear conexión  
        Jedis redisConn = new Jedis("192.168.1.100", 6379);  
        // Establecer contraseña si existe  
        redisConn.auth("contraseña_segura");  
        
        // Operaciones con claves
        Set<String> todasLasClaves = redisConn.keys("*");  
        for (Iterator<String> iterador = todasLasClaves.iterator(); iterador.hasNext();) {  
            String clave = (String) iterador.next();  
            System.out.println(clave);  
        }  
        System.out.println("existeClave====>" + redisConn.exists("clave2"));  
        System.out.println("tiempoVida====>" + redisConn.ttl("clave1"));  
        
        // Operaciones con Strings
        redisConn.set("clave4", "valor_redis");  
        System.out.println("----------------------------------------");  
        redisConn.mset("str1", "valor1", "str2", "valor2", "str3", "valor3");  
        System.out.println(redisConn.mget("str1", "str2", "str3"));  
        
        // Operaciones con Lists
        System.out.println("----------------------------------------");  
        List<String> lista = redisConn.lrange("miLista", 0, -1);  
        for (String elemento : lista) {  
            System.out.println(elemento);  
        }  
        
        // Operaciones con Sets
        redisConn.sadd("ordenes", "orden001");  
        redisConn.sadd("ordenes", "orden002");  
        redisConn.sadd("ordenes", "orden003");  
        Set<String> conjunto = redisConn.smembers("ordenes");  
        for (Iterator<String> iterador = conjunto.iterator(); iterador.hasNext();) {  
            String elemento = (String) iterador.next();  
            System.out.println(elemento);  
        }  
        redisConn.srem("ordenes", "orden002");  
        System.out.println(redisConn.smembers("ordenes").size());  
        
        // Operaciones con Hashes
        redisConn.hset("hash1", "usuario", "juan");  
        System.out.println(redisConn.hget("hash1", "usuario"));  
        Map<String, String> datos = new HashMap<String, String>();  
        datos.put("telefono", "123456789");  
        datos.put("direccion", "calle principal");  
        datos.put("email", "usuario@ejemplo.com");  
        redisConn.hmset("hash2", datos);  
        List<String> resultados = redisConn.hmget("hash2", "telefono", "email");  
        for (String elemento : resultados) {  
            System.out.println(elemento);  
        }  
        
        // Operaciones con Sorted Sets
        redisConn.zadd("zset01", 60d, "valor1");  
        redisConn.zadd("zset01", 70d, "valor2");  
        redisConn.zadd("zset01", 80d, "valor3");  
        redisConn.zadd("zset01", 90d, "valor4");  
        
        Set<String> conjuntoOrdenado = redisConn.zrange("zset01", 0, -1);  
        for (Iterator<String> iterador = conjuntoOrdenado.iterator(); iterador.hasNext();) {  
            String elemento = (String) iterador.next();  
            System.out.println(elemento);  
        }  
        redisConn.close();  
    }  
}

2.3. Transacciones

public class TransaccionesRedis {
    public static void main(String[] args) {  
        // Crear conexión  
        Jedis redisConn = new Jedis("192.168.1.100", 6379);  
        // Establecer contraseña si existe  
        redisConn.auth("contraseña_segura");  
        
        // Monitorear clave, si se modifica se aborta la transacción
        Transaction transaccion = redisConn.multi();  
        Response<String> respuesta = transaccion.get("numeroSerie");  
        transaccion.set("numeroSerie", "nuevo002");  
        respuesta = transaccion.get("numeroSerie");  
        transaccion.lpush("lista3", "elementoA");  
        transaccion.lpush("lista3", "elementoB");  
        transaccion.lpush("lista3", "elementoC");  
        
        transaccion.exec();  
        System.out.println("numeroSerie\*\*\*\*\*\*\*\*\*\*\*"+respuesta.get());  
        redisConn.close();
    }
}

2.4. Bloqueo con transaccciones

public class BloqueoRedis {
    public boolean metodoTransaccional() {  
        // Crear conexión  
        Jedis redisConn = new Jedis("192.168.1.100", 6379);  
        // Establecer contraseña si existe  
        redisConn.auth("contraseña_segura");  
        int saldoActual;  
        int deuda;  
        int montoADeducir = 10;

        redisConn.watch("saldo");  
        saldoActual = Integer.parseInt(redisConn.get("saldo"));  
        if (saldoActual < montoADeducir) {  
            redisConn.unwatch();  
            System.out.println("Saldo insuficiente");  
            redisConn.close();  
            return false;  
        } else {  
            System.out.println("Procesando transacción");  
            Transaction transaccion = redisConn.multi();  
            transaccion.decrBy("saldo", montoADeducir);  
            transaccion.incrBy("deuda", montoADeducir);  
            transaccion.exec();  
            saldoActual = Integer.parseInt(redisConn.get("saldo"));  
            deuda = Integer.parseInt(redisConn.get("deuda"));  
            System.out.println("Saldo actual: " + saldoActual);  
            System.out.println("Deuda actual: " + deuda);  
            redisConn.close();  
            return true;  
        }  
    }

    public static void main(String[] args) {  
        BloqueoRedis prueba = new BloqueoRedis();  
        boolean resultado = prueba.metodoTransaccional();  
        System.out.println("Resultado principal: " + resultado);  
    }
}

2.5. Replicación maestro-esclavo

public class ReplicacionRedis {
   public static void main(String[] args) throws InterruptedException {
       // Crear conexiones
       Jedis maestro = new Jedis("192.168.1.100", 6379);
       Jedis esclavo = new Jedis("192.168.1.100", 6380);

       esclavo.slaveof("127.0.0.1", 6379);

       maestro.set("claveMaestra", "valorMaestro");

       Thread.sleep(500);
       System.out.println(esclavo.get("claveMaestra"));
       maestro.close();
       esclavo.close();
   }
}

2.6. Conexión a clúster

Para conectarse a un clúster Redis, se utiliza el objeto JedisCluster. Aquí un ejemplo básico:

public class ConexionClusterRedis {
    public static void main(String[] args) {
        Set<HostAndPort> nodosCluster = new HashSet<HostAndPort>();
        nodosCluster.add(new HostAndPort("192.168.1.100", 7000));
        nodosCluster.add(new HostAndPort("192.168.1.100", 7001));
        nodosCluster.add(new HostAndPort("192.168.1.100", 7002));
        
        JedisCluster jedisCluster = new JedisCluster(nodosCluster);
        
        try {
            jedisCluster.set("clusterKey", "clusterValue");
            System.out.println(jedisCluster.get("clusterKey"));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (jedisCluster != null) {
                jedisCluster.close();
            }
        }
    }
}

3. Uso de JedisPool

3.1. Ventajas de JedisPool

• Obtener instancias Jedis desde el pool
• Devolver instancias Jedis al pool cuando se terminan de usar
• Gestionar errores y devolver instancias problemáticas al pool

3.2. Implementación de JedisPool

public class GestorJedisPool {
   private static volatile JedisPool jedisPool = null;

   private GestorJedisPool() {
   }

   public static JedisPool obtenerInstanciaPool() {
       if (null == jedisPool) {
           synchronized (GestorJedisPool.class) {
               if (null == jedisPool) {
                   JedisPoolConfig configPool = new JedisPoolConfig();
                   configPool.setMaxTotal(1000);
                   configPool.setMaxIdle(32);
                   configPool.setMaxWaitMillis(100 * 1000);
                   configPool.setTestOnBorrow(true);

                   jedisPool = new JedisPool(configPool, "192.168.1.100", 6379);
               }
           }
       }
       return jedisPool;
   }

   public static void liberarRecurso(JedisPool pool, Jedis jedis) {
       if (null != jedis) {
           try {
               jedis.close();
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   }
}

3.3. Ejemplo de uso

public class EjemploJedisPool {
   public static void main(String[] args) {
       JedisPool poolRedis = GestorJedisPool.obtenerInstanciaPool();
       Jedis jedis = null;

       try {
           jedis = poolRedis.getResource();
           jedis.set("clavePool", "valorPool");
           System.out.println(jedis.get("clavePool"));
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           GestorJedisPool.liberarRecurso(poolRedis, jedis);
       }
   }
}

4. Configuración de JedisPool

Los parámetros de configuración de JedisPool se establecen principalmente a través de JedisPoolConfig:

• maxTotal/maxActive: Número máximo de instancias Jedis que puede asignar el pool
• maxIdle: Número máximo de instancias inactivas en el pool
• whenExhaustedAction: Acción a tomar cuando no hay instancias disopnibles
• maxWait: Tiempo máximo de espera al obtener una instancia
• testOnBorrow: Verificar disponibilidad al obtener una instancia
• testOnReturn: Verificar disponibilidad al devolver una instancia
• testWhileIdle: Verificar instancias inactivas periódicamente

Configuración por defecto de JedisPoolConfig:

• testWhileIdle=true
• minEvictableIdleTimeMills=60000
• timeBetweenEvictionRunsMillis=30000
• numTestsPerEvictionRun=-1