Redis客户端合集

关注

原创最新推荐文章于 2026-03-24 00:23:51 发布 913 阅读 AI 写同款· GEO 优化 ›

Redis 面试题合集给缓存设置过期时间，定期清理缓存并回写，是保证最终一致性的解决方案我们可以对存入缓存的数据设置过期时间，所有的写操作以数据库为准，对缓存操作只是尽最大努力即可。也就是说如果数据库写成功，缓存更新失败，那么只要到达过期时间，则后面的读请求自然会从数据库中读取新值然后回填缓存，达到一致性，切记，要以数据落库DB为准TTL随机数分散降低机率Redis宕机：利用集群提高服务的可用性快速失败、拒绝服务一人一单在单机运行的情况下且synchronized会保证线程任务顺序执行；阅读详情

在 Java 中，常用的 Redis 客户端库有几种，每种库提供不同的功能和特性，适用于不同的应用场景。以下是主要的 Redis 客户端库：

1. Jedis

Jedis 是一个非常流行且易于使用的 Redis 客户端库。它是同步的客户端，通常用于中小型应用，特别是在传统的阻塞式操作中。

特点：
- 简单易用。
- 支持同步操作。
- 支持 Redis 基本数据结构操作。
- 提供了连接池支持。
适用场景：
- 单机应用。
- 简单的 Redis 操作场景。
缺点：
- 高并发情况下可能性能不足。
- 采用同步调用，可能会造成阻塞。
常用方法：
- set: 设置键值
- get: 获取键值
- del: 删除键
- exists: 检查键是否存在
- expire: 设置键的过期时间
- hset: 设置哈希表字段
- hget: 获取哈希表字段的值
- lpush: 向列表头部添加元素
- rpush: 向列表尾部添加元素

import redis.clients.jedis.Jedis;

public class JedisExample {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);

        // 设置键值
        jedis.set("name", "John");

        // 获取键值
        String name = jedis.get("name");
        System.out.println("Name: " + name);

        // 设置哈希表字段
        jedis.hset("user:1000", "username", "john_doe");
        String username = jedis.hget("user:1000", "username");
        System.out.println("Username: " + username);

        // 向列表添加元素
        jedis.lpush("mylist", "item1", "item2", "item3");
        System.out.println("List: " + jedis.lrange("mylist", 0, -1));

        // 检查键是否存在
        boolean exists = jedis.exists("name");
        System.out.println("Exists 'name': " + exists);

        // 设置过期时间（单位秒）
        jedis.expire("name", 10);  // 键将在10秒后过期

        // 删除键
        jedis.del("name");

        jedis.close();  // 关闭连接
    }
}

2. Lettuce

Lettuce 是一个响应式的 Redis 客户端，支持异步、同步和反应式（Reactive）编程，特别适合于需要高并发、非阻塞操作的应用。它基于 Netty 网络框架构建，支持 Redis 的多种操作模式（如集群、主从复制、事务等）。

特点：
- 支持异步和响应式 API。
- 支持连接池和集群模式。
- 基于 Netty 提供非阻塞 IO 操作，适合高并发。
- 提供对 Redis 5.0 特性（如 Streams）的支持。
适用场景：
- 高并发应用。
- 微服务架构和响应式编程（如 Spring WebFlux）。
缺点：
- 相对于 Jedis，使用起来稍微复杂一些。
常用方法：
- set: 设置键值
- get: 获取键值
- del: 删除键
- exists: 检查键是否存在
- hset: 设置哈希表字段
- hget: 获取哈希表字段的值
- lpush: 向列表头部添加元素
- rpush: 向列表尾部添加元素

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

public class LettuceExample {
    public static void main(String[] args) {
        // 创建 Redis 客户端实例
        RedisClient redisClient = RedisClient.create("redis://localhost:6379");
        RedisCommands<String, String> syncCommands = redisClient.connect().sync();

        // 设置键值
        syncCommands.set("name", "John");

        // 获取键值
        String name = syncCommands.get("name");
        System.out.println("Name: " + name);

        // 设置哈希表字段
        syncCommands.hset("user:1000", "username", "john_doe");
        String username = syncCommands.hget("user:1000", "username");
        System.out.println("Username: " + username);

        // 向列表添加元素
        syncCommands.lpush("mylist", "item1", "item2", "item3");
        System.out.println("List: " + syncCommands.lrange("mylist", 0, -1));

        // 检查键是否存在
        boolean exists = syncCommands.exists("name") > 0;
        System.out.println("Exists 'name': " + exists);

        // 删除键
        syncCommands.del("name");

        redisClient.shutdown();  // 关闭连接
    }
}

3. Redisson

Redisson 是一个功能非常强大的 Redis 客户端，提供了更多高级的 Redis 功能，例如分布式锁、分布式集合、计数器、分布式对象、分布式队列等。它还支持 Spring 集成，可以轻松地将 Redis 用作缓存、消息队列等。

特点：
- 提供 Redis 以外的高级功能，如分布式锁、分布式集合、分布式对象等。
- 支持异步、同步和反应式 API。
- 易于与 Spring 集成。
- 支持 Redis 集群、主从复制等。
适用场景：
- 需要高级 Redis 功能的场景（如分布式锁、计数器）。
- Spring 应用。
缺点：
- 较大的库和更复杂的 API，可能不适合简单的应用场景。
常用方法：
- set: 设置键值
- get: 获取键值
- del: 删除键
- getBucket: 获取分布式桶（可以当作普通 Redis 键值对使用）
- getList: 获取分布式列表
- getLock: 获取分布式锁

import org.redisson.api.Redisson;
import org.redisson.api.RBucket;
import org.redisson.api.RList;
import org.redisson.api.RLock;
import org.redisson.config.Config;

public class RedissonExample {
    public static void main(String[] args) {
        // 配置 Redisson 客户端
        Config config = new Config();
        config.useSingleServer().setAddress("redis://localhost:6379");

        // 创建 Redisson 客户端实例
        Redisson redisson = Redisson.create(config);

        // 获取分布式桶
        RBucket<String> bucket = redisson.getBucket("name");
        bucket.set("John");
        System.out.println("Name: " + bucket.get());

        // 获取分布式列表
        RList<String> list = redisson.getList("mylist");
        list.add("item1");
        list.add("item2");
        System.out.println("List: " + list);

        // 获取分布式锁
        RLock lock = redisson.getLock("myLock");
        lock.lock();  // 锁定
        try {
            // 执行需要同步的操作
            System.out.println("Executing critical section...");
        } finally {
            lock.unlock();  // 释放锁
        }

        // 删除键
        bucket.delete();

        redisson.shutdown();  // 关闭连接
    }
}

4. Spring Data Redis

Spring Data Redis 是 Spring 生态中的 Redis 客户端库。它封装了 Redis 的操作，提供了一个高层次的 API，使得 Spring 应用能够更方便地与 Redis 进行交互。它通常与 Spring Boot 集成，可以自动配置 Redis 连接。

特点：
- 与 Spring 框架紧密集成，支持自动配置和依赖注入。
- 提供 RedisTemplate、StringRedisTemplate 等高层 API。
- 支持缓存管理、消息队列等功能。
- 支持 Redis 的所有基本功能和数据结构。
适用场景：
- Spring Boot 应用。
- 使用 Redis 作为缓存或消息队列时。
缺点：
- 需要使用 Spring 生态环境，不能独立使用。
常用方法:
- opsForValue: 处理简单的键值对操作
- opsForList: 处理列表操作
- opsForHash: 处理哈希操作
- opsForSet: 处理集合操作
- opsForZSet: 处理有序集合操作

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class RedisService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    public void saveValue() {
        // 保存简单的键值对
        redisTemplate.opsForValue().set("name", "John");
    }

    public String getValue() {
        // 获取简单的键值对
        return redisTemplate.opsForValue().get("name");
    }

    public void saveList() {
        // 向列表中添加元素
        redisTemplate.opsForList().leftPush("mylist", "item1");
        redisTemplate.opsForList().leftPush("mylist", "item2");
    }

    public void printList() {
        // 获取并打印列表内容
        System.out.println(redisTemplate.opsForList().range("mylist", 0, -1));
    }
}

5. JRedis

JRedis 是一个相对较小且轻量级的 Redis 客户端库，提供了对 Redis 的基本支持。它的特点是简单易用，适合嵌入式或轻量级的应用。

特点：
- 小巧、简单、易用。
- 提供 Redis 的基本操作。
适用场景：
- 小型或嵌入式应用。
缺点：
- 功能相对较少，缺少一些高级特性。
常用方法：
- set: 设置键值
- get: 获取键值
- del: 删除键
- exists: 检查键是否存在
- hset: 设置哈希表字段
- hget: 获取哈希表字段的值

import org.jredis.JRedis;
import org.jredis.ri.alphazero.JRedisClient;

public class JRedisExample {
    public static void main(String[] args) {
        JRedis jredis = new JRedisClient("localhost", 6379);

        // 设置键值
        jredis.set("name", "John");

        // 获取键值
        String name = (String) jredis.get("name");
        System.out.println("Name: " + name);

        // 设置哈希表字段
        jredis.hset("user:1000", "username", "john_doe");
        String username = (String) jredis.hget("user:1000", "username");
        System.out.println("Username: " + username);

        // 删除键
        jredis.del("name");

        // 检查键是否存在
        boolean exists = jredis.exists("name");
        System.out.println("Exists 'name': " + exists);
    }
}

6. Apache Commons Pool

Apache Commons Pool 不是一个 Redis 客户端库本身，而是一个连接池管理工具，适用于管理 Redis 连接的池化。通常与 Redis 客户端库（如 Jedis）结合使用，可以提高高并发情况下的性能，减少每次连接 Redis 时的开销。

特点：
- 通过连接池管理 Redis 连接。
- 适用于需要高并发的场景，避免频繁创建和销毁连接。
适用场景：
- 与 Jedis 等客户端库结合使用时，管理 Redis 连接池。
缺点：
- 需要与其他 Redis 客户端库一起使用。
常用方法：
- setMaxTotal: 设置连接池最大连接数
- setMaxIdle: 设置连接池最大空闲连接数
- setMinIdle: 设置连接池最小空闲连接数
- borrowObject: 从连接池中获取一个 Redis 连接
- returnObject: 将 Redis 连接归还给连接池
- close: 关闭连接池

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.11.1</version>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.0.1</version>
</dependency>

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisConnectionPoolExample {

    public static void main(String[] args) {
        // 配置连接池
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(10);  // 最大连接数
        poolConfig.setMaxIdle(5);    // 最大空闲连接数
        poolConfig.setMinIdle(1);    // 最小空闲连接数
        poolConfig.setTestOnBorrow(true);  // 在借用连接时进行测试

        // 创建 Jedis 连接池
        JedisPool jedisPool = new JedisPool(poolConfig, "localhost", 6379);

        // 从连接池获取 Redis 连接
        try (Jedis jedis = jedisPool.getResource()) {
            // 设置键值
            jedis.set("name", "John");

            // 获取键值
            String name = jedis.get("name");
            System.out.println("Name: " + name);
        }

        // 关闭连接池
        jedisPool.close();
    }
}

7. Apache Ignite Redis

Apache Ignite 是一个内存计算平台，通常用于大数据处理和分布式缓存。Apache Ignite 提供了对 Redis 协议的支持（通过 Ignite Redis 模块），允许你通过 Ignite 提供的 Redis 协议兼容层来操作数据。虽然 Ignite 并不完全是 Redis，但它支持 Redis 的一些常用命令，使得 Redis 客户端能够与 Ignite 一起工作。

Apache Ignite 提供了一种方式，可以将 Redis 用作数据存储引擎或缓存系统的一部分，但它还提供了更多的功能，比如分布式计算、数据存储和事务。

特点：
- 支持 Redis 协议。
- 提供分布式存储和计算能力。
适用场景：
- 分布式缓存和大规模数据存储场景。
缺点：
- 相对较重，更多用于分布式计算，而非单纯的 Redis 替代。
常用方法：
- set: 设置键值
- get: 获取键值
- del: 删除键
- exists: 检查键是否存在
- hset: 设置哈希表字段
- hget: 获取哈希表字段的值
- lpush: 向列表头部添加元素

<dependency>
    <groupId>org.apache.ignite</groupId>
    <artifactId>ignite-redis</artifactId>
    <version>2.9.0</version>
</dependency>

import org.apache.ignite.Ignite;
import org.apache.ignite.IgniteCache;
import org.apache.ignite.IgniteConfiguration;
import org.apache.ignite.cache.CacheMode;
import org.apache.ignite.cache.configuration.CacheConfiguration;
import org.apache.ignite.redis.RedisServer;
import org.apache.ignite.redis.RedisConfiguration;

public class IgniteRedisExample {

    public static void main(String[] args) {
        // 配置 Ignite
        IgniteConfiguration igniteCfg = new IgniteConfiguration();

        // 配置 Redis 服务器
        RedisConfiguration redisCfg = new RedisConfiguration();
        redisCfg.setPort(6379);
        igniteCfg.setRedisConfiguration(redisCfg);

        // 启动 Ignite 实例
        Ignite ignite = Ignition.start(igniteCfg);

        // 使用 Ignite 缓存作为 Redis 操作
        IgniteCache<String, String> cache = ignite.getOrCreateCache("myCache");

        // 使用 Redis 命令设置键值
        cache.put("name", "John");

        // 获取键值
        String name = cache.get("name");
        System.out.println("Name: " + name);

        // 删除键
        cache.remove("name");

        // 关闭 Ignite
        ignite.close();
    }
}
   jedisPool.close();
    }
}

8. Kiwi Redis

Kiwi Redis 是一个支持 Lua 脚本的 Redis 客户端，主要关注脚本化操作和性能优化。

特点：
- 轻量级，支持 Lua 脚本执行。
- 提供 Redis 的基本操作。
适用场景：
- 需要与 Lua 脚本交互的 Redis 应用。
缺点：
- 功能相对较少，社区支持较少。
常用方法:
- set: 设置键值
- get: 获取键值
- del: 删除键
- exists: 检查键是否存在
- eval: 执行 Lua 脚本

import kiwi.redis.Redis;
import kiwi.redis.RedisClient;

public class KiwiRedisExample {
    public static void main(String[] args) {
        // 创建 Kiwi Redis 客户端
        Redis redis = new RedisClient("localhost", 6379);

        // 设置键值
        redis.set("name", "John");

        // 获取键值
        String name = redis.get("name");
        System.out.println("Name: " + name);

        // 执行 Lua 脚本
        String script = "return redis.call('GET', KEYS[1])";
        String result = redis.eval(script, "name");
        System.out.println("Script result: " + result);

        // 删除键
        redis.del("name");

        // 检查键是否存在
        boolean exists = redis.exists("name");
        System.out.println("Exists 'name': " + exists);
    }
}