Java DB Redis 相关

简介

Java DB 内置了许多与 Redis 相关的类，这些类可以简化 Redis 操作并提高开发效率。

使用示例

示例 1：设置和获取字符串值

public class StringValueExample {

    public static void main(String[] args) {
        // 获取 RedisCache 实例
        RedisCache redisCache = Redis.use();

        // 设置键值对
        redisCache.set("myKey", "myValue");

        // 获取值
        String value = redisCache.get("myKey");
        System.out.println("The value of 'myKey' is: " + value);

        // 设置带有过期时间的键值对
        redisCache.setex("expiringKey", 60, "expiringValue"); // 60秒后过期

        // 获取值
        String expiringValue = redisCache.get("expiringKey");
        System.out.println("The value of 'expiringKey' is: " + expiringValue);
    }
}

示例 2：操作整数值

public class IntegerValueExample {

    public static void main(String[] args) {
        // 获取 RedisCache 实例
        RedisCache redisCache = Redis.use();

        // 设置整数值
        redisCache.setInt("intKey", 100);

        // 获取整数值
        Integer intValue = redisCache.getInt("intKey");
        System.out.println("The value of 'intKey' is: " + intValue);

        // 增加整数值
        redisCache.incrBy("intKey", 50);
        intValue = redisCache.getInt("intKey");
        System.out.println("The value of 'intKey' after increment is: " + intValue);

        // 减少整数值
        redisCache.decrBy("intKey", 30);
        intValue = redisCache.getInt("intKey");
        System.out.println("The value of 'intKey' after decrement is: " + intValue);
    }
}

示例 3：操作哈希表

public class HashValueExample {

    public static void main(String[] args) {
        // 获取 RedisCache 实例
        RedisCache redisCache = Redis.use();

        // 设置哈希表字段
        redisCache.hset("user:1001", "name", "John Doe");
        redisCache.hset("user:1001", "age", 30);

        // 获取哈希表字段的值
        String name = redisCache.hget("user:1001", "name");
        Integer age = redisCache.hget("user:1001", "age");

        System.out.println("User 1001 Name: " + name);
        System.out.println("User 1001 Age: " + age);

        // 获取整个哈希表
        Map<String, Object> user = redisCache.hgetAll("user:1001");
        System.out.println("User 1001 Details: " + user);
    }
}

示例 4：操作列表

public class ListValueExample {

    public static void main(String[] args) {
        // 获取 RedisCache 实例
        RedisCache redisCache = Redis.use();

        // 将元素压入列表头部
        redisCache.lpush("myList", "element1", "element2", "element3");

        // 从列表尾部弹出元素
        String element = redisCache.rpop("myList");
        System.out.println("Popped element from myList: " + element);

        // 获取列表中的所有元素
        List<String> elements = redisCache.lrange("myList", 0, -1);
        System.out.println("All elements in myList: " + elements);
    }
}

示例 5：检查键是否存在

public class KeyExistenceExample {

    public static void main(String[] args) {
        // 获取 RedisCache 实例
        RedisCache redisCache = Redis.use();

        // 设置一个键值对
        redisCache.set("someKey", "someValue");

        // 检查键是否存在
        boolean exists = redisCache.hasKey("someKey");
        System.out.println("Does 'someKey' exist? " + exists);

        // 删除键
        redisCache.del("someKey");

        // 再次检查键是否存在
        exists = redisCache.hasKey("someKey");
        System.out.println("Does 'someKey' exist after deletion? " + exists);
    }
}

示例 6：发布和订阅消息

public class PubSubExample {

    public static void main(String[] args) {
        // 获取 RedisCache 实例
        RedisCache redisCache = Redis.use();

        // 订阅一个频道
        new Thread(() -> {
            redisCache.subscribe(new JedisPubSub() {
                @Override
                public void onMessage(String channel, String message) {
                    System.out.println("Received message: " + message + " from channel: " + channel);
                }
            }, "myChannel");
        }).start();

        // 发布消息到频道
        redisCache.publish("myChannel", "Hello, Redis!");
    }
}

示例 7：使用 Redis 脚本执行操作

public class ScriptExecutionExample {

    public static void main(String[] args) {
        // 获取 RedisCache 实例
        RedisCache redisCache = Redis.use();

        // Lua 脚本示例：获取一个键的值并设置一个新值
        String script = "local value = redis.call('get', KEYS[1]); " +
                        "redis.call('set', KEYS[2], ARGV[1]); " +
                        "return value;";

        // 执行 Lua 脚本
        Object result = redisCache.eval(script, 2, "key1", "key2", "newValue");
        System.out.println("Result of script execution: " + result);
    }
}

示例 8：使用扫描命令查找匹配的键

public class ScanKeysExample {

    public static void main(String[] args) {
        // 获取 RedisCache 实例
        RedisCache redisCache = Redis.use();

        // 扫描匹配的键
        redisCache.scan(0, "user:*", 10, keys -> {
            System.out.println("Found keys: " + keys);
            return true; // 返回 true 继续扫描，返回 false 停止扫描
        });
    }
}

示例 9：获取随机元素（集合操作）

public class SetOperationsExample {

    public static void main(String[] args) {
        // 获取 RedisCache 实例
        RedisCache redisCache = Redis.use();

        // 添加元素到集合
        redisCache.sadd("mySet", "element1", "element2", "element3");

        // 获取集合中的随机元素
        String randomElement = redisCache.srandmember("mySet");
        System.out.println("Random element from mySet: " + randomElement);

        // 获取集合中的所有元素
        Set<String> elements = redisCache.smembers("mySet");
        System.out.println("All elements in mySet: " + elements);
    }
}

示例 10：为键设置过期时间

public class ExpireKeyExample {

    public static void main(String[] args) {
        // 获取 RedisCache 实例
        RedisCache redisCache = Redis.use();

        // 设置键值对
        redisCache.set("tempKey", "tempValue");

        // 设置键的过期时间为 30 秒
        redisCache.expire("tempKey", 30);

        // 检查剩余时间
        Long ttl = redisCache.ttl("tempKey");
        System.out.println("TTL of 'tempKey': " + ttl + " seconds");
    }
}

示例 11 ：使用 RedisCache.lock 进行分布式锁

public class DistributedLockExample {

    public static void main(String[] args) {
        // 获取 RedisCache 实例
        RedisCache redisCache = Redis.use();

        // 定义锁的名称
        String lockName = "distributed_lock";

        // 锁的超时时间，单位：秒
        int lockExpireTime = 120; // 锁的过期时间为 120 秒

        // 获取锁的等待时间，单位：秒
        int lockTimeout = 5; // 如果在 5 秒内没有获取到锁，则放弃

        // 尝试获取锁
        String lockId = redisCache.lock(lockName, lockExpireTime, lockTimeout);

        if (lockId != null) {
            try {
                // 成功获取到锁，执行需要保护的业务逻辑
                System.out.println("成功获取锁，正在执行业务逻辑...");

                // 业务逻辑代码
                performBusinessLogic();

            } finally {
                // 释放锁
                redisCache.unlock(lockName, lockId);
                System.out.println("锁已释放。");
            }
        } else {
            // 未能获取到锁
            System.out.println("未能获取锁，可能另一个进程持有该锁。");
        }
    }

    private static void performBusinessLogic() {
        // 模拟业务逻辑的执行
        try {
            Thread.sleep(3000); // 假设业务逻辑需要 3 秒钟才能执行完毕
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("业务逻辑执行成功。");
    }
}

代码说明

  1. 获取 RedisCache 实例：

    • 通过 Redis.use() 获取 RedisCache 实例。

  2. 定义锁相关参数：

    • lockName: 锁的名称，通常与业务逻辑相关联。
    • lockExpireTime: 锁的过期时间，设置为 120 秒。
    • lockTimeout: 尝试获取锁的超时时间，设置为 5 秒。

  3. 尝试获取分布式锁：

    • 调用 redisCache.lock(lockName, lockExpireTime, lockTimeout) 尝试获取锁。
    • 如果成功获取到锁，返回 lockId；否则返回 null。

  4. 执行业务逻辑：

    • 在成功获取锁后，执行需要保护的业务逻辑。

  5. 释放锁：

    • 在业务逻辑执行完毕后，调用 redisCache.unlock(lockName, lockId) 释放锁。

注意事项

  • 分布式锁通常用于确保在分布式环境下，多个进程不会同时执行同一段代码，从而避免资源竞争导致的数据不一致问题。
  • 在高并发场景下，设置合理的锁过期时间和获取锁的超时时间非常重要。

示例 12 ：使用 RedisCache 的 withLock 方法进行分布式锁

以下是一个使用 RedisCache 的 withLock 方法进行分布式锁的示例。withLock 方法会自动处理锁的获取和释放逻辑，用户只需专注于需要加锁的业务逻辑。

public class DistributedLockWithLockMethodExample {

    public static void main(String[] args) {
        // 获取 RedisCache 实例
        RedisCache redisCache = Redis.use();

        // 定义锁的名称
        String lockName = "distributed_lock_with_withLock";

        // 锁的超时时间，单位：秒
        int lockExpireTime = 120; // 锁的过期时间为 120 秒

        // 获取锁的等待时间，单位：秒
        int lockTimeout = 5; // 如果在 5 秒内没有获取到锁，则放弃

        // 使用 withLock 方法执行加锁的业务逻辑
        boolean success = redisCache.withLock(lockName, lockExpireTime, lockTimeout, () -> {
            // 业务逻辑代码，这段代码在获取锁后执行
            System.out.println("成功获取锁，正在执行业务逻辑...");
            performBusinessLogic();
        });

        if (success) {
            System.out.println("业务逻辑执行完毕，锁已释放。");
        } else {
            System.out.println("未能获取锁，可能另一个进程持有该锁。");
        }
    }

    private static void performBusinessLogic() {
        // 模拟业务逻辑的执行
        try {
            Thread.sleep(3000); // 假设业务逻辑需要 3 秒钟才能执行完毕
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("业务逻辑执行成功。");
    }
}

代码说明

  1. 获取 RedisCache 实例：

    • 通过 Redis.use() 获取 RedisCache 实例。

  2. 定义锁相关参数：

    • lockName: 锁的名称，用于标识此锁。
    • lockExpireTime: 锁的过期时间，设置为 120 秒。
    • lockTimeout: 尝试获取锁的超时时间，设置为 5 秒。

  3. 使用 withLock 方法加锁执行业务逻辑：

    • 调用 redisCache.withLock(lockName, lockExpireTime, lockTimeout, () -> { ... })，并在 Lambda 表达式中编写需要保护的业务逻辑。
    • 如果成功获取锁并执行业务逻辑，则返回 true；否则返回 false。

  4. 锁的自动释放：

    • withLock 方法会在业务逻辑执行完毕后自动释放锁，因此不需要手动调用 unlock。

使用 withLock 方法的优点

  • 简洁易用：withLock 方法封装了锁的获取、业务逻辑的执行和锁的释放，简化了代码。
  • 自动释放锁：即使在业务逻辑抛出异常的情况下，withLock 方法也能确保锁被正确释放，避免死锁问题。

相关类

以下是对 Redis 相关的文档说明：

Redis 类

Redis 类是一个 Redis 工具类，提供了一组静态方法来简化 Redis 缓存的使用。该类允许添加、使用和管理多个 Redis 缓存实例，同时支持基于 Lambda 表达式的 Jedis 操作封装。通过该类，用户可以方便地操作 Redis 缓存，并执行常见的缓存操作。

公共方法

  • void addCache(RedisCache cache)

    • 向 Redis 类中添加一个新的 Redis 缓存实例。
    • 参数：
      • cache: 要添加的 RedisCache 实例，不能为 null。
    • 异常：如果缓存实例为 null 或缓存名称已经存在，则抛出 IllegalArgumentException。

  • RedisCache removeCache(String cacheName)

    • 从 Redis 类中移除指定名称的 Redis 缓存实例。
    • 返回值：被移除的 RedisCache 实例。如果指定名称的缓存不存在，则返回 null。

  • void setMainCache(String cacheName)

    • 设置主缓存 mainCache，如果未设置主缓存，则第一个被初始化的缓存实例将成为主缓存。
    • 参数：
      • cacheName: 要设置为主缓存的缓存名称，不能为 null 或空白。
    • 异常：如果缓存名称为空或缓存实例不存在，则抛出 IllegalArgumentException。

  • RedisCache use()

    • 获取主缓存 mainCache 实例。
    • 返回值：当前的主缓存实例 RedisCache。

  • RedisCache use(String cacheName)

    • 获取指定名称的 Redis 缓存实例。
    • 返回值：对应名称的 RedisCache 实例。如果指定名称的缓存不存在，则返回 null。

  • <R> R call(Function<Jedis, R> jedis)

    • 使用 Lambda 表达式操作 Jedis 实例，优先使用此方法来简化 Jedis API 的调用。
    • 返回值类型：R，即 Lambda 表达式的返回值。

  • <R> R call(String cacheName, Function<Jedis, R> jedis)

    • 使用 Lambda 表达式操作指定缓存实例的 Jedis 对象。
    • 返回值类型：R，即 Lambda 表达式的返回值。

  • <T> T callback(ICallback<T> callback)

    • 使用指定的回调函数操作主缓存实例的 Jedis 对象。
    • 返回值类型：T，即回调函数的返回值。

  • <T> T callback(String cacheName, ICallback<T> callback)

    • 使用指定的回调函数操作指定缓存实例的 Jedis 对象。
    • 返回值类型：T，即回调函数的返回值。

  • <R> R getBean(String key, Class<R> type)

    • 从 Redis 中获取对象，并反序列化为指定类型。
    • 返回值：反序列化后的对象。

  • String setBean(String key, long seconds, Object input)

    • 将对象序列化后存储在 Redis 中，并设置过期时间。
    • 返回值：Redis 的响应字符串。

  • String setBean(String key, Object input)

    • 将对象序列化后存储在 Redis 中。
    • 返回值：Redis 的响应字符串。

  • String setStr(String key, String input)

    • 将字符串值存储在 Redis 中。
    • 返回值：Redis 的响应字符串。

  • <R> String setStr(String key, long seconds, String input)

    • 将字符串值存储在 Redis 中，并设置过期时间。
    • 返回值：Redis 的响应字符串。

  • String getStr(String key)

    • 获取存储在 Redis 中的字符串值。
    • 返回值：字符串值。

  • String setInt(String key, int value)

    • 将整数值存储在 Redis 中。
    • 返回值：Redis 的响应字符串。

  • String setInt(String key, long seconds, int value)

    • 将整数值存储在 Redis 中，并设置过期时间。
    • 返回值：Redis 的响应字符串。

  • Integer getInt(String key)

    • 获取存储在 Redis 中的整数值。
    • 返回值：整数值。

  • String setLong(String key, long value)

    • 将长整数值存储在 Redis 中。
    • 返回值：Redis 的响应字符串。

  • String setLong(String key, long seconds, long value)

    • 将长整数值存储在 Redis 中，并设置过期时间。
    • 返回值：Redis 的响应字符串。

  • Long getLong(String key)

    • 获取存储在 Redis 中的长整数值。
    • 返回值：长整数值。

  • boolean hasKey(String key)

    • 检查给定的键是否存在于 Redis 中。
    • 返回值：true 表示键存在，false 表示键不存在。

RedisCache 类

RedisCache 类提供了对 Redis 操作的封装，涵盖了键值存储、哈希、列表、有序集合等常见 Redis 操作，并提供了丰富的 API，支持常见的缓存和分布式锁功能。该类基于 Jedis 库进行操作，支持序列化键和值。

构造函数

  • RedisCache(String name, JedisPool jedisPool, ISerializer serializer, IKeyNamingPolicy keyNamingPolicy)
    • 构造一个 Cache 实例。
    • name: 缓存名称。
    • jedisPool: Jedis 连接池实例，用于获取 Jedis 对象。
    • serializer: 用于键值序列化的实现。
    • keyNamingPolicy: 键命名策略，用于生成 Redis 键名。

公共方法

  • <R> R call(Function<Jedis, R> jedis)

    • 提供了一个 Lambda 风格的 API，允许用户通过 Lambda 表达式操作 Jedis 实例。
    • 返回值类型：R，即 Lambda 表达式的返回值。

  • String set(Object key, Object value)

    • 将指定的键值对存储在 Redis 中。如果键已经存在，则覆盖旧值。
    • 返回值：Redis 的响应字符串。

  • Long setnx(Object key, Object value)

    • 仅在键不存在时，将键值对存储在 Redis 中。
    • 返回值：1 表示成功设置键值对，0 表示键已经存在。

  • String setex(Object key, long seconds, Object value)

    • 将键值对存储在 Redis 中，并设置键的过期时间（秒为单位）。
    • 返回值：Redis 的响应字符串。

  • String psetex(Object key, long milliseconds, Object value)

    • 将键值对存储在 Redis 中，并设置键的过期时间（毫秒为单位）。
    • 返回值：Redis 的响应字符串。

  • <T> T get(Object key)

    • 获取指定键的值。如果键不存在，则返回 nil。
    • 返回值类型：T，即键对应的值。

  • Long del(Object key)

    • 删除指定的键。
    • 返回值：被删除的键的数量。

  • Long del(Object... keys)

    • 删除多个键。
    • 返回值：被删除的键的数量。

  • Set<String> keys(String pattern)

    • 查找所有符合给定模式的键。
    • 返回值：符合模式的键集合。

  • String mset(Object... keysValues)

    • 同时设置多个键值对。
    • 返回值：Redis 的响应字符串。

  • Long msetnx(Object... keysValues)

    • 当且仅当所有给定键都不存在时，设置多个键值对。
    • 返回值：1 表示成功设置所有键值对，0 表示至少有一个键已经存在。

  • List mget(Object... keys)

    • 获取多个键的值。如果某个键不存在，则返回 nil。
    • 返回值：一个列表，包含每个键对应的值。

  • Long decr(Object key)

    • 将指定键的值减一。如果键不存在，则初始化为 0 后再减一。
    • 返回值：键的新值。

  • Long decrBy(Object key, long longValue)

    • 将指定键的值减去指定的数值。如果键不存在，则初始化为 0 后再进行减法操作。
    • 返回值：键的新值。

  • Long incr(Object key)

    • 将指定键的值加一。如果键不存在，则初始化为 0 后再加一。
    • 返回值：键的新值。

  • Long getCounter(Object key)

    • 获取记数器的值（即键的数值形式）。
    • 返回值：键的数值，如果键不存在则返回 null。

  • Long incrBy(Object key, long longValue)

    • 将指定键的值加上指定的数值。如果键不存在，则初始化为 0 后再进行加法操作。
    • 返回值：键的新值。

  • boolean exists(Object key)

    • 检查给定的键是否存在。
    • 返回值：true 表示键存在，false 表示键不存在。

  • boolean hasKey(Object key)

    • 检查给定的键是否存在。此方法与 exists 方法功能相同。
    • 返回值：true 表示键存在，false 表示键不存在。

  • String randomKey()

    • 随机返回当前数据库中的一个键。
    • 返回值：一个随机键。

  • String rename(Object oldkey, Object newkey)

    • 将键改名为 newkey，如果新键已经存在，则覆盖。
    • 返回值：Redis 的响应字符串。

  • Long renamenx(Object oldkey, Object newkey)

    • 当且仅当 newkey 不存在时，将键改名为 newkey。
    • 返回值：1 表示重命名成功，0 表示新键已经存在。

  • Long move(Object key, int dbIndex)

    • 将键移动到指定的数据库中。
    • 返回值：1 表示成功，0 表示失败。

  • String migrate(String host, int port, Object key, int destinationDb, int timeout)

    • 将键从当前实例迁移到目标实例的指定数据库中。
    • 返回值：Redis 的响应字符串。

  • String select(int databaseIndex)

    • 切换到指定的数据库。
    • 返回值：Redis 的响应字符串。

  • Long expire(Object key, long seconds)

    • 为指定键设置生存时间（秒为单位）。
    • 返回值：1 表示设置成功，0 表示键不存在或设置失败。

  • Long expireAt(Object key, long unixTime)

    • 为指定键设置过期时间，时间参数为 UNIX 时间戳（秒为单位）。
    • 返回值：1 表示设置成功，0 表示键不存在或设置失败。

  • Long pexpire(Object key, long milliseconds)

    • 为指定键设置生存时间（毫秒为单位）。
    • 返回值：1 表示设置成功，0 表示键不存在或设置失败。

  • Long pexpireAt(Object key, long millisecondsTimestamp)

    • 为指定键设置过期时间，时间参数为 UNIX 时间戳（毫秒为单位）。
    • 返回值：1 表示设置成功，0 表示键不存在或设置失败。

  • <T> T getSet(Object key, Object value)

    • 设置键的新值，并返回键的旧值。
    • 返回值：键的旧值。

  • Long persist(Object key)

    • 移除键的生存时间，使其变为永久存在。
    • 返回值：1 表示设置成功，0 表示键不存在或键没有设置生存时间。

  • String type(Object key)

    • 返回键存储的值的类型（如 string、list、set 等）。
    • 返回值：键的类型。

  • Long ttl(Object key)

    • 返回键的剩余生存时间（秒为单位）。
    • 返回值：剩余生存时间，如果键不存在或没有设置生存时间，则返回 -1。

  • Long pttl(Object key)

    • 返回键的剩余生存时间（毫秒为单位）。
    • 返回值：剩余生存时间，如果键不存在或没有设置生存时间，则返回 -1。

  • Long objectRefcount(Object key)

    • 返回键的对象引用计数。
    • 返回值：对象的引用计数。

  • Long objectIdletime(Object key)

    • 返回键的对象空闲时间。
    • 返回值：对象的空闲时间（秒为单位）。

  • Long hset(Object key, Object field, Object value)

    • 设置哈希表中指定字段的值。
    • 返回值：1 表示新字段被插入，0 表示字段已存在且值被更新。

  • Long hsetRawString(String key, String field, String value)

    • 设置哈希表中指定字段的值，使用字符串作为输入。
    • 返回值：1 表示新字段被插入，0 表示字段已存在且值被更新。

  • String hgetRawString(String key, String field)

    • 获取哈希表中指定字段的值，返回字符串形式。
    • 返回值：字段的值，如果字段不存在则返回 null。

  • String hmset(Object key, Map<Object, Object> hash)

    • 设置哈希表中多个字段的值。
    • 返回值：Redis 的响应字符串。

  • <T> T hget(Object key, Object field)

    • 获取哈希表中指定字段的值

。

  • 返回值类型：T，即字段对应的值。

  • String hmsetRawString(String key, Map<String, String> hash)

    • 设置哈希表中多个字段的值，使用字符串作为输入。
    • 返回值：Redis 的响应字符串。

  • String hmgetRawString(String key, String field)

    • 获取哈希表中指定字段的值，返回字符串形式。
    • 返回值：字段的值，如果字段不存在则返回 null。

  • List<String> hmget(String key, String... fields)

    • 获取哈希表中多个字段的值。
    • 返回值：字段值的列表，如果字段不存在则对应位置为 null。

  • Long hdel(Object key, Object... fields)

    • 删除哈希表中指定字段。
    • 返回值：被删除字段的数量。

  • boolean hexists(Object key, Object field)

    • 检查哈希表中指定字段是否存在。
    • 返回值：true 表示字段存在，false 表示字段不存在。

  • Map hgetAll(Object key)

    • 获取哈希表中所有字段和值。
    • 返回值：包含所有字段和值的映射。

  • List hvals(Object key)

    • 获取哈希表中所有字段的值。
    • 返回值：字段值的列表。

  • Set<Object> hkeys(Object key)

    • 获取哈希表中所有字段的键。
    • 返回值：字段的键集合。

  • Set<String> hkeysRawString(String key)

    • 获取哈希表中所有字段的键，返回字符串形式。
    • 返回值：字段的键集合。

  • Long hlen(Object key)

    • 获取哈希表中的字段数量。
    • 返回值：字段的数量。

  • Long hincrBy(Object key, Object field, long value)

    • 为哈希表中指定字段的值加上增量。
    • 返回值：字段的新值。

  • Long hgetCounter(Object key, Object field)

    • 获取哈希表内记数器的值。
    • 返回值：字段的数值，如果字段不存在则返回 null。

  • Double hincrByFloat(Object key, Object field, double value)

    • 为哈希表中指定字段的值加上浮点数增量。
    • 返回值：字段的新值。

  • Double hgetFloatCounter(Object key, Object field)

    • 获取哈希表内浮点数记数器的值。
    • 返回值：字段的浮点数值，如果字段不存在则返回 null。

  • <T> T lindex(Object key, long index)

    • 获取列表中指定下标的元素。
    • 返回值类型：T，即元素对应的值。

  • Long llen(Object key)

    • 获取列表的长度。
    • 返回值：列表的长度。

  • <T> T lpop(Object key)

    • 移除并返回列表的头元素。
    • 返回值类型：T，即头元素的值。

  • Long lpush(Object key, Object... values)

    • 将一个或多个值插入列表的表头。
    • 返回值：列表的长度。

  • Long lpushx(Object key, Object... values)

    • 将值插入到列表的表头，当且仅当列表存在。
    • 返回值：列表的长度。

  • String lset(Object key, long index, Object value)

    • 将列表中指定下标的元素值设置为新的值。
    • 返回值：Redis 的响应字符串。

  • Long lrem(Object key, long count, Object value)

    • 从列表中移除与指定值相等的元素。
    • 返回值：被移除的元素数量。

  • List lrange(Object key, long start, long end)

    • 获取列表中指定区间内的元素。
    • 返回值：元素列表。

  • String ltrim(Object key, long start, long end)

    • 对列表进行修剪，只保留指定区间内的元素。
    • 返回值：Redis 的响应字符串。

  • <T> T rpop(Object key)

    • 移除并返回列表的尾元素。
    • 返回值类型：T，即尾元素的值。

  • <T> T rpoplpush(Object srcKey, Object dstKey)

    • 移除源列表的尾元素，并将该元素插入目标列表的头部。
    • 返回值类型：T，即被移动的元素值。

  • Long rpush(Object key, Object... values)

    • 将一个或多个值插入列表的表尾。
    • 返回值：列表的长度。

  • Long rpushx(Object key, Object... values)

    • 将值插入到列表的表尾，当且仅当列表存在。
    • 返回值：列表的长度。

  • List blpop(int timeout, Object... keys)

    • 从列表中弹出头元素，如果列表为空则阻塞指定时间。
    • 返回值：包含键和值的列表。

  • List brpop(int timeout, Object... keys)

    • 从列表中弹出尾元素，如果列表为空则阻塞指定时间。
    • 返回值：包含键和值的列表。

  • String ping()

    • 向 Redis 服务器发送一个 PING，测试连接是否正常。
    • 返回值：服务器返回的响应字符串 PONG。

  • Long sadd(Object key, Object... members)

    • 将一个或多个成员加入集合中。
    • 返回值：添加到集合中的新成员数量。

  • Long scard(Object key)

    • 获取集合中元素的数量。
    • 返回值：集合的基数。

  • <T> T spop(Object key)

    • 移除并返回集合中的一个随机元素。
    • 返回值类型：T，即随机元素的值。

  • Set smembers(Object key)

    • 返回集合中的所有成员。
    • 返回值：集合的成员列表。

  • boolean sismember(Object key, Object member)

    • 检查元素是否是集合的成员。
    • 返回值：true 表示元素存在，false 表示元素不存在。

  • Set sinter(Object... keys)

    • 返回多个集合的交集。
    • 返回值：交集集合。

  • <T> T srandmember(Object key)

    • 返回集合中的一个随机元素。
    • 返回值类型：T，即随机元素的值。

  • List srandmember(Object key, int count)

    • 返回集合中的多个随机元素。
    • 返回值：随机元素的列表。

  • Long srem(Object key, Object... members)

    • 从集合中移除指定的成员。
    • 返回值：被移除的成员数量。

  • Set sunion(Object... keys)

    • 返回多个集合的并集。
    • 返回值：并集集合。

  • Set sdiff(Object... keys)

    • 返回多个集合的差集。
    • 返回值：差集集合。

  • Long zadd(Object key, double score, Object member)

    • 将成员及其分数加入有序集合中。
    • 返回值：成功添加到集合中的新成员数量。

  • Long zadd(Object key, Map<Object, Double> scoreMembers)

    • 将多个成员及其分数加入有序集合中。
    • 返回值：成功添加到集合中的新成员数量。

  • Long zcard(Object key)

    • 获取有序集合的基数（成员数量）。
    • 返回值：有序集合的基数。

  • Long zcount(Object key, double min, double max)

    • 返回有序集合中，分数在指定范围内的成员数量。
    • 返回值：成员数量。

  • Double zincrby(Object key, double score, Object member)

    • 为有序集合中指定成员的分数加上增量。
    • 返回值：成员的新分数。

  • Set zrange(Object key, long start, long end)

    • 返回有序集合中指定区间内的成员，按分数递增排序。
    • 返回值：成员的集合。

  • Set zrevrange(Object key, long start, long end)

    • 返回有序集合中指定区间内的成员，按分数递减排序。
    • 返回值：成员的集合。

  • Set zrangeByScore(Object key, double min, double max)

    • 返回有序集合中，分数在指定范围内的成员。
    • 返回值：成员的集合。

  • Long zrank(Object key, Object member)

    • 返回有序集合中指定成员的排名，按分数递增排序。
    • 返回值：成员的排名。

  • Long zrevrank(Object key, Object member)

    • 返回有序集合中指定成员的排名，按

分数递减排序。

  • 返回值：成员的排名。

  • Long zrem(Object key, Object... members)

    • 移除有序集合中指定的成员。
    • 返回值：被移除的成员数量。

  • Double zscore(Object key, Object member)

    • 返回有序集合中指定成员的分数。
    • 返回值：成员的分数。

  • String flushDB()

    • 删除当前数据库中的所有数据。
    • 返回值：Redis 的响应字符串。

  • String flushAll()

    • 删除所有数据库中的所有数据。
    • 返回值：Redis 的响应字符串。

  • void subscribe(JedisPubSub jedisPubSub, String... channels)

    • 订阅指定的频道，阻塞等待频道消息。
    • 无返回值。

  • JedisPubSub subscribeThread(JedisPubSub jedisPubSub, String... channels)

    • 在一个新线程中订阅指定的频道，阻塞等待频道消息。
    • 返回值：JedisPubSub 对象。

  • void psubscribe(JedisPubSub jedisPubSub, String... patterns)

    • 订阅与给定模式匹配的所有频道，阻塞等待频道消息。
    • 无返回值。

  • JedisPubSub psubscribeThread(JedisPubSub jedisPubSub, String... patterns)

    • 在一个新线程中订阅与给定模式匹配的所有频道，阻塞等待频道消息。
    • 返回值：JedisPubSub 对象。

  • Long publish(String channel, String message)

    • 向指定的频道发布消息。
    • 返回值：接收到消息的订阅者数量。

  • Object eval(String script, int keyCount, String... params)

    • 执行 Lua 脚本。
    • 返回值：脚本的返回结果。

  • Object eval(String script, List<String> keys, List<String> args)

    • 执行 Lua 脚本，传入键列表和参数列表。
    • 返回值：脚本的返回结果。

  • Object eval(String script)

    • 执行 Lua 脚本，不传入任何键和参数。
    • 返回值：脚本的返回结果。

  • Object evalsha(String sha1)

    • 执行缓存的 Lua 脚本。
    • 返回值：脚本的返回结果。

  • Object evalsha(String sha1, List<String> keys, List<String> args)

    • 执行缓存的 Lua 脚本，传入键列表和参数列表。
    • 返回值：脚本的返回结果。

  • Object evalsha(String sha1, int keyCount, String... params)

    • 执行缓存的 Lua 脚本，传入键的数量和参数。
    • 返回值：脚本的返回结果。

  • Boolean scriptExists(String sha1)

    • 检查缓存的脚本是否存在。
    • 返回值：true 表示脚本存在，false 表示脚本不存在。

  • List<Boolean> scriptExists(String... sha1)

    • 检查多个缓存的脚本是否存在。
    • 返回值：包含每个脚本是否存在的布尔值列表。

  • String scriptLoad(String script)

    • 将脚本缓存到服务器中。
    • 返回值：缓存脚本的 SHA1 校验和。

  • String lock(String name, int secondsToExpire, int secondsToTimeout)

    • 获取分布式锁。
    • 返回值：成功获取锁时返回锁标识，失败返回 null。

  • void unlock(String name, String lockId)

    • 释放分布式锁。
    • 无返回值。

  • boolean withLock(String name, int secondsToExpire, int secondsToTimeout, F00 fun)

    • 在获取分布式锁后执行指定的操作。
    • 返回值：true 表示成功获取锁并执行操作，false 表示未能获取锁。

  • List<Object> tx(String watchKeys, F10<Transaction> tx)

    • 执行 Redis 事务。
    • 返回值：事务执行结果列表。

  • List<Object> tx(F10<Transaction> tx)

    • 执行 Redis 事务。
    • 返回值：事务执行结果列表。

  • void scan(Integer cursor, String pattern, Integer count, F11<List<String>, Boolean> keyList)

    • 执行 Redis SCAN 命令，遍历符合给定模式的键。
    • 无返回值。

  • void scan(Integer cursor, String pattern, F11<List<String>, Boolean> keyList)

    • 执行 Redis SCAN 命令，遍历符合给定模式的键。
    • 无返回值。

  • void scan(Integer cursor, F11<List<String>, Boolean> keyList)

    • 执行 Redis SCAN 命令，遍历键。
    • 无返回值。

  • <R> R getBean(String key, Class<R> type)

    • 获取存储在 Redis 中的对象，并将其反序列化为指定类型。
    • 返回值：反序列化后的对象。

  • String setBean(String key, long seconds, Object input)

    • 将对象序列化后存储在 Redis 中，并设置过期时间。
    • 返回值：Redis 的响应字符串。

  • String setBean(String key, Object input)

    • 将对象序列化后存储在 Redis 中。
    • 返回值：Redis 的响应字符串。

  • String setStr(String key, String input)

    • 将字符串值存储在 Redis 中。
    • 返回值：Redis 的响应字符串。

  • String set(String key, long seconds, String input)

    • 将字符串值存储在 Redis 中，并设置过期时间。
    • 返回值：Redis 的响应字符串。

  • String getStr(String key)

    • 获取存储在 Redis 中的字符串值。
    • 返回值：字符串值。

  • String setInt(String key, int value)

    • 将整数值存储在 Redis 中。
    • 返回值：Redis 的响应字符串。

  • String setInt(String key, long seconds, int value)

    • 将整数值存储在 Redis 中，并设置过期时间。
    • 返回值：Redis 的响应字符串。

  • Integer getInt(String key)

    • 获取存储在 Redis 中的整数值。
    • 返回值：整数值。

  • String setLong(String key, long value)

    • 将长整数值存储在 Redis 中。
    • 返回值：Redis 的响应字符串。

  • String setLong(String key, long seconds, long value)

    • 将长整数值存储在 Redis 中，并设置过期时间。
    • 返回值：Redis 的响应字符串。

  • Long getLong(String key)

    • 获取存储在 Redis 中的长整数值。
    • 返回值：长整数值。

  • Boolean setIfAbsent(Object key, Object value)

    • 设置键值对，仅当键不存在时执行此操作。
    • 返回值：true 表示成功设置键值对，false 表示键已经存在。

  • Boolean setIfAbsent(Object key, Object value, long timeout)

    • 设置键值对，并设置过期时间，仅当键不存在时执行此操作。
    • 返回值：true 表示成功设置键值对，false 表示键已经存在。

  • Boolean setIfPresent(Object key, Object value)

    • 设置键值对，仅当键存在时执行此操作。
    • 返回值：true 表示成功设置键值对，false 表示键不存在。

  • Boolean setIfPresent(Object key, Object value, long timeout, TimeUnit unit)

    • 设置键值对，并设置过期时间，仅当键存在时执行此操作。
    • 返回值：true 表示成功设置键值对，false 表示键不存在。