Jedis,Lettuce,Redisson——你想用哪一款Redis客户端？

主流Redis客户端介绍

1. Jedis

• 优点:
  • 简单直观，学习成本低
  • API与Redis命令的风格非常相似
  • 轻量级，依赖少
• 缺点:
  • 使用阻塞的I/O，且其方法调用都是同步的
  • 线程不安全，需要使用连接池来保证线程安全
  • 无法开箱即用地支持Redis Cluster

2. Lettuce

• 优点:
  • 基于Netty的异步驱动
  • 支持异步操作
  • 线程安全
  • 支持Redis Cluster
  • Spring Boot 2.x默认的Redis客户端
• 缺点:
  • 相对较重，依赖较多
  • 学习曲线相对较陡

3. Redisson

• 优点:
  • 提供了很多分布式相关操作服务
  • 提供了分布式锁等高级功能
  • 异步响应式API
  • 支持Redis Cluster
• 缺点:
  • 体量较大
  • 上手难度较高

依赖配置

1. Jedis依赖

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

2. Lettuce依赖

<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>6.2.1.RELEASE</version>
</dependency>

3. Redisson依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.17.1</version>
</dependency>

代码示例

下面我们分别用这三个客户端实现常见的Redis操作。

1. Jedis示例

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

public class JedisDemo {
    private static JedisPool jedisPool;
    
    static {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(20);
        config.setMaxIdle(10);
        config.setMinIdle(5);
        jedisPool = new JedisPool(config, "localhost", 6379);
    }
    
    public static void main(String[] args) {
        // String操作
        try (Jedis jedis = jedisPool.getResource()) {
            // String类型操作
            jedis.set("name", "jedis");
            System.out.println(jedis.get("name"));
            
            // List类型操作
            jedis.lpush("list", "1", "2", "3");
            System.out.println(jedis.lrange("list", 0, -1));
            
            // Hash类型操作
            jedis.hset("hash", "name", "jedis");
            jedis.hset("hash", "age", "10");
            System.out.println(jedis.hgetAll("hash"));
            
            // Set类型操作
            jedis.sadd("set", "a", "b", "c");
            System.out.println(jedis.smembers("set"));
            
            // ZSet类型操作
            jedis.zadd("zset", 1, "one");
            jedis.zadd("zset", 2, "two");
            System.out.println(jedis.zrange("zset", 0, -1));
        }
    }
}

2. Lettuce示例

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

public class LettuceDemo {
    public static void main(String[] args) {
        RedisClient redisClient = RedisClient.create("redis://localhost:6379");
        StatefulRedisConnection<String, String> connection = redisClient.connect();
        RedisCommands<String, String> syncCommands = connection.sync();
        
        try {
            // String类型操作
            syncCommands.set("name", "lettuce");
            System.out.println(syncCommands.get("name"));
            
            // List类型操作
            syncCommands.lpush("list", "1", "2", "3");
            System.out.println(syncCommands.lrange("list", 0, -1));
            
            // Hash类型操作
            syncCommands.hset("hash", "name", "lettuce");
            syncCommands.hset("hash", "age", "10");
            System.out.println(syncCommands.hgetall("hash"));
            
            // Set类型操作
            syncCommands.sadd("set", "a", "b", "c");
            System.out.println(syncCommands.smembers("set"));
            
            // ZSet类型操作
            syncCommands.zadd("zset", 1, "one");
            syncCommands.zadd("zset", 2, "two");
            System.out.println(syncCommands.zrange("zset", 0, -1));
        } finally {
            connection.close();
            redisClient.shutdown();
        }
    }
}

3. Redisson示例

import org.redisson.Redisson;
import org.redisson.api.RList;
import org.redisson.api.RMap;
import org.redisson.api.RSet;
import org.redisson.api.RSortedSet;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

public class RedissonDemo {
    public static void main(String[] args) {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://localhost:6379");
        RedissonClient redisson = Redisson.create(config);
        
        try {
            // String类型操作
            redisson.getBucket("name").set("redisson");
            System.out.println(redisson.getBucket("name").get());
            
            // List类型操作
            RList<String> list = redisson.getList("list");
            list.add("1");
            list.add("2");
            list.add("3");
            System.out.println(list.readAll());
            
            // Hash类型操作
            RMap<String, String> map = redisson.getMap("hash");
            map.put("name", "redisson");
            map.put("age", "10");
            System.out.println(map.readAllMap());
            
            // Set类型操作
            RSet<String> set = redisson.getSet("set");
            set.add("a");
            set.add("b");
            set.add("c");
            System.out.println(set.readAll());
            
            // SortedSet类型操作
            RSortedSet<String> sortedSet = redisson.getSortedSet("sortedSet");
            sortedSet.add("one");
            sortedSet.add("two");
            System.out.println(sortedSet.readAll());
        } finally {
            redisson.shutdown();
        }
    }
}

选择建议

1. 如果是简单的Redis操作，并且是单机Redis，可以选择Jedis
2. 如果需要异步操作和更好的性能，建议使用Lettuce
3. 如果需要分布式功能（如分布式锁、限流等），建议选择Redisson

一般来说：

• 小型项目：Jedis
• 中型项目：Lettuce
• 大型分布式项目：Redisson

需要注意的是，如果使用Spring Boot，建议直接使用spring-boot-starter-data-redis，它从Spring Boot 2.x开始默认使用Lettuce作为客户端。

要集成到Spring Boot中，只需要添加以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>