如何使用Java连接Redis数据库 Java连接Redis的实现方式

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisExample {

    // 通常生产环境会使用连接池
    private static JedisPool jedisPool;

    static {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(100); // 最大连接数
        poolConfig.setMaxIdle(20);  // 最大空闲连接数
        poolConfig.setMinIdle(5);   // 最小空闲连接数
        poolConfig.setTestOnBorrow(true); // 借用连接时是否测试
        poolConfig.setTestOnReturn(true); // 归还连接时是否测试
        poolConfig.setTestWhileIdle(true); // 空闲时是否测试连接可用性

        // 假设Redis运行在本地，端口6379，无密码
        // 如果有密码，JedisPool jedisPool = new JedisPool(poolConfig, "localhost", 6379, 2000, "your_password");
        jedisPool = new JedisPool(poolConfig, "localhost", 6379);
    }

    public static void main(String[] args) {
        // 从连接池获取一个连接
        try (Jedis jedis = jedisPool.getResource()) {
            // 设置一个键值对
            jedis.set("mykey", "Hello Redis from Jedis!");
            System.out.println("设置键值对：mykey = " + jedis.get("mykey"));

            // 列表操作
            jedis.lpush("mylist", "value1", "value2", "value3");
            System.out.println("列表内容：mylist = " + jedis.lrange("mylist", 0, -1));

            // Hash操作
            jedis.hset("myhash", "field1", "valueA");
            jedis.hset("myhash", "field2", "valueB");
            System.out.println("Hash内容：myhash = " + jedis.hgetAll("myhash"));

        } catch (Exception e) {
            System.err.println("Jedis操作失败：" + e.getMessage());
            e.printStackTrace();
        } finally {
            // 在try-with-resources结构中，连接会自动关闭并返回池中
            // 如果不是try-with-resources，需要手动 jedis.close();
        }

        // 应用关闭时，关闭连接池
        // jedisPool.close();
    }
}

import io.lettuce.core.RedisClient;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.sync.RedisCommands;

public class LettuceExample {
    public static void main(String[] args) {
        // 创建RedisClient实例
        // 如果有密码：RedisClient redisClient = RedisClient.create("redis://password@localhost:6379/0");
        RedisClient redisClient = RedisClient.create("redis://localhost:6379/0");

        // 建立连接
        StatefulRedisConnection<String, String> connection = redisClient.connect();

        // 获取同步命令API
        RedisCommands<String, String> syncCommands = connection.sync();

        try {
            // 设置一个键值对
            syncCommands.set("anotherkey", "Hello Redis from Lettuce!");
            System.out.println("设置键值对：anotherkey = " + syncCommands.get("anotherkey"));

            // 列表操作
            syncCommands.lpush("anotherlist", "item1", "item2");
            System.out.println("列表内容：anotherlist = " + syncCommands.lrange("anotherlist", 0, -1));

        } catch (Exception e) {
            System.err.println("Lettuce操作失败：" + e.getMessage());
            e.printStackTrace();
        } finally {
            // 关闭连接
            connection.close();
            // 关闭RedisClient
            redisClient.shutdown();
        }
    }
}

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisPoolConfigExample {
    public static void main(String[] args) {
        JedisPoolConfig poolConfig = new JedisPoolConfig();

        // 最大连接数：池中“最多”有多少个连接
        // 我通常会根据服务器的CPU核数、Redis的并发能力以及应用自身的并发量来估算这个值。
        poolConfig.setMaxTotal(100);

        // 最大空闲连接数：池中“最多”有多少个空闲连接
        // 太多可能浪费资源，太少可能在高峰期需要频繁创建新连接。
        poolConfig.setMaxIdle(20);

        // 最小空闲连接数：池中“至少”保留多少个空闲连接
        // 保证在低峰期也有足够的连接立即可用，避免冷启动时的连接创建延迟。
        poolConfig.setMinIdle(5);

        // 当连接池耗尽时，是否阻塞等待可用连接。
        // 如果设置为true，会阻塞直到有连接可用或达到maxWaitMillis。
        // 如果设置为false，则会立即抛出异常。我个人倾向于阻塞，但要设置合理的maxWaitMillis。
        poolConfig.setBlockWhenExhausted(true);

        // 当连接池耗尽时，阻塞等待可用连接的最长时间（毫秒）。
        poolConfig.setMaxWaitMillis(2000); // 等待2秒

        // 借用连接时，是否测试连接的可用性。
        // 开启可以保证拿到的连接是健康的，但会有轻微性能开销。
        poolConfig.setTestOnBorrow(true);

        // 归还连接时，是否测试连接的可用性。
        // 开启可以确保归还的连接是健康的，但同样有开销。
        poolConfig.setTestOnReturn(false); // 通常不开启，因为借出时已经测试过

        // 空闲连接检查：空闲连接是否需要周期性地测试可用性。
        // 这是防止连接长时间空闲后被Redis服务器关闭（如timeout）的关键。
        poolConfig.setTestWhileIdle(true);
        // 两次空闲连接测试之间的最小间隔时间（毫秒）。
        poolConfig.setMinEvictableIdleTimeMillis(60000L); // 60秒
        // 空闲连接驱逐线程的运行间隔时间（毫秒）。
        poolConfig.setTimeBetweenEvictionRunsMillis(30000L); // 30秒
        // 每次空闲连接驱逐时，检查的连接数量。
        poolConfig.setNumTestsPerEvictionRun(3);

        // 创建JedisPool实例
        // 假设Redis在localhost:6379，没有密码
        JedisPool jedisPool = new JedisPool(poolConfig, "localhost", 6379);

        // 实际使用时，从池中获取连接
        try (Jedis jedis = jedisPool.getResource()) {
            jedis.set("test_pool_key", "value_from_pool");
            System.out.println("从连接池获取并设置值：" + jedis.get("test_pool_key"));
        } catch (Exception e) {
            System.err.println("连接池操作失败：" + e.getMessage());
        } finally {
            // 应用关闭时，务必关闭连接池
            // jedisPool.close();
        }
    }
}