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("业务逻辑执行成功。");
    }
}

代码说明

获取 RedisCache 实例：
- 通过 Redis.use() 获取 RedisCache 实例。
定义锁相关参数：
- lockName: 锁的名称，通常与业务逻辑相关联。
- lockExpireTime: 锁的过期时间，设置为 120 秒。
- lockTimeout: 尝试获取锁的超时时间，设置为 5 秒。
尝试获取分布式锁：
- 调用 redisCache.lock(lockName, lockExpireTime, lockTimeout) 尝试获取锁。
- 如果成功获取到锁，返回 lockId；否则返回 null。
执行业务逻辑：
- 在成功获取锁后，执行需要保护的业务逻辑。
释放锁：
- 在业务逻辑执行完毕后，调用 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("业务逻辑执行成功。");
    }
}

代码说明

获取 RedisCache 实例：
- 通过 Redis.use() 获取 RedisCache 实例。
定义锁相关参数：
- lockName: 锁的名称，用于标识此锁。
- lockExpireTime: 锁的过期时间，设置为 120 秒。
- lockTimeout: 尝试获取锁的超时时间，设置为 5 秒。
使用 withLock 方法加锁执行业务逻辑：
- 调用 redisCache.withLock(lockName, lockExpireTime, lockTimeout, () -> { ... })，并在 Lambda 表达式中编写需要保护的业务逻辑。
- 如果成功获取锁并执行业务逻辑，则返回 true；否则返回 false。
锁的自动释放：
- 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 表示键不存在。

Java DB Redis 相关

Java DB Redis 相关

简介

使用示例

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

示例 2：操作整数值

示例 3：操作哈希表

示例 4：操作列表

示例 5：检查键是否存在

示例 6：发布和订阅消息

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

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

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

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

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

代码说明

注意事项

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

代码说明

使用 `withLock` 方法的优点

相关类

`Redis` 类

公共方法

`RedisCache` 类

构造函数

公共方法

李通

引用和评论

tio-boot 整合hotswap-classloader 实现热加载

在Java程序中监听mysql的binlog

Activiti7实战笔记

Just for fun——迅速写完快速排序

Java自定义注解实现简单的权限认证

Spring 实现 3 种异步流式接口，干掉接口超时烦恼

Bitmap 和布隆过滤器傻傻分不清？你这不应该啊

Java DB Redis 相关

Java DB Redis 相关

简介

使用示例

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

示例 2：操作整数值

示例 3：操作哈希表

示例 4：操作列表

示例 5：检查键是否存在

示例 6：发布和订阅消息

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

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

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

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

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

代码说明

注意事项

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

代码说明

使用 withLock 方法的优点

相关类

Redis 类

公共方法

RedisCache 类

构造函数

公共方法

李通

引用和评论

tio-boot 整合hotswap-classloader 实现热加载

在Java程序中监听mysql的binlog

Activiti7实战笔记

Just for fun——迅速写完快速排序

Java自定义注解实现简单的权限认证

Spring 实现 3 种异步流式接口，干掉接口超时烦恼

Bitmap 和 布隆过滤器傻傻分不清？你这不应该啊

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

使用 `withLock` 方法的优点

`Redis` 类

`RedisCache` 类

Bitmap 和布隆过滤器傻傻分不清？你这不应该啊