Redis客户端基础使用——Jedis、Lettuce、Redisson_lettuce/get

在我们实际开发过程中，官方推荐了以下三种客户端供我们使用：

Jedis

Jedis 是我们最熟悉和最常用的客户端。轻量，简洁，便于集成和改造。

简单使用

• 引入依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.6.1</version>
</dependency>
1
2
3
4
5

• 测试代码

public static void main(String[] args) {
    Jedis jedis = new Jedis("127.0.0.1", 6379);
    jedis.set("chen", "2673");
    System.out.println(jedis.get("chen"));
    jedis.close();
}
1
2
3
4
5
6

• 一般来说，我们不会使用单个 Jedis 连接，而是会使用连接池，Jedis 提供了连接池的功能。

public static void main(String[] args) {
    JedisPool pool = new JedisPool("127.0.0.1", 6379);
    Jedis jedis = pool.getResource();
    jedis.set("chen", "2673");
    System.out.println(jedis.get("chen"));
    jedis.close();
}
1
2
3
4
5
6
7

Lettuce

Lettuce 是一个 Redis 的 Java 驱动包，大家常用的 spring-boot-starter-data-redis 中默认就采用的 Lettuce。Lettuce 是一个高性能基于 Java 编写的 Redis 驱动框架，底层集成了 Project Reactor 提供天然的反应式编程，通信框架集成了 Netty 使用了非阻塞 IO，5.x 版本之后融合了 JDK1.8 的异步编程特性，在保证高性能的同时提供了十分丰富易用的 API。

简单使用

• 引入依赖

<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>5.1.8.RELEASE</version>
</dependency>
1
2
3
4
5

• 简单使用

  Lettuce 使用的时候依赖于四个主要组件：

  • RedisURI：连接信息。
  • RedisClient：Redis 客户端，特殊地，集群连接有一个定制的 RedisClusterClient。
  • Connection：Redis 连接，主要是 StatefulConnection 或者 StatefulRedisConnection 的子类，连接的类型主要由连接的具体方式（单机、哨兵、集群、订阅发布等等）选定，比较重要。
  • RedisCommands：Redis 命令 API 接口，基本上覆盖了 Redis 发行版本的所有命令，提供了同步（sync）、异步（async）、反应式（reative）的调用方式，对于使用者而言，会经常跟 RedisCommands 系列接口打交道。

public static void main(String[] args) {
    RedisURI redisUri = RedisURI.builder()                    // <1> 创建单机连接的连接信息
        .withHost("192.168.221.128")
        .withPort(6379)
        .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
        .build();
    RedisClient redisClient = RedisClient.create(redisUri);   // <2> 创建客户端
    StatefulRedisConnection<String, String> connection = redisClient.connect();     // <3> 创建线程安全的连接
    RedisCommands<String, String> redisCommands = connection.sync();                // <4> 创建同步命令
    SetArgs setArgs = SetArgs.Builder.nx().ex(5);
    String result = redisCommands.set("name", "throwable", setArgs);
    System.out.println(result);
    result = redisCommands.get("name");
    System.out.println(result);
    // ... 其他操作
    connection.close();   // <5> 关闭连接
    redisClient.shutdown();  // <6> 关闭客户端
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

集成Spring boot

Lettuce 是 Spring Boot 2.x 默认的客户端，替换了 Jedis。集成之后我们不需要单独使用它，直接调用 Spring 的 RedisTemplate 操作，连接和创建和关闭也不需要我们操心。

• 引入依赖 jar 包：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
1
2
3
4

• application.yml 配置文件如下：

redis:
    port: 6379
    host: 127.0.0.1
    lettuce:
      pool:
        max-active: -1
        max-idle: 2000
        max-wait: -1
        min-idle: 1
        time-between-eviction-runs: 5000
1
2
3
4
5
6
7
8
9
10

• 使用方法

@RestController
@RequestMapping("/")
public class LettuceController {

    @Autowired
    RedisTemplate redisTemplate;

    @GetMapping("/lettuce/get")
    public ResponseEntity get() {
        redisTemplate.opsForValue().set("name", "chen");
        String name = (String) redisTemplate.opsForValue().get("name");
        return ResponseEntity.ok(name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Redisson

相关文档：

https://redisson.org/

https://github.com/redisson/redisson/wiki/ 目录

Redisson 是一个在 Redis 的基础上实现的 Java 驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的 Java 常用对象，还提供了许多分布式服务。其中包括 (BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service) Redisson 提供了使用 Redis 的最简单和最便捷的方法。Redisson 的宗旨是促进使用者对 Redis 的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。

简单使用

• 引入依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.16.0</version>
</dependency>
1
2
3
4
5

• 简单使用

public class RedissonDemo {
    public static void main(String[] args) {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        RedissonClient redissonClient = Redisson.create(config);
        redissonClient.getBucket("name").set("chen");
        System.out.println(redissonClient.getBucket("name").get());
    }
}
1
2
3
4
5
6
7
8
9

集成Spring boot

application加载

• 引入依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.0</version>
</dependency>
1
2
3
4
5

• application配置

spring:
  redis:
    timeout: 2000
    host: 127.0.0.1
    port: 6379
1
2
3
4
5

• 使用

@RestController
public class RedissonController {

    @Autowired
    RedissonClient redissonClient;

    @GetMapping("/redisson/get")
    public String get() {
        return redissonClient.getBucket("name").get().toString();
    }
}
1
2
3
4
5
6
7
8
9
10
11

配置文件加载

• 修改application

spring:
  redis:
    redisson:
      file: classpath:redisson.yml
1
2
3
4

• 添加redisson.yml文件

singleServerConfig:
  address: redis://127.0.0.1:6379
  #---------------------------------------------
  # 连接空闲超时，单位：毫秒
  idleConnectionTimeout: 10000
  # 连接超时，单位：毫秒
  connectTimeout: 10000
  # 命令等待超时，单位：毫秒
  timeout: 3000
  # 命令失败重试次数,如果尝试达到 retryAttempts（命令失败重试次数） 仍然不能将命令发送至某个指定的节点时，将抛出错误。
  # 如果尝试在此限制之内发送成功，则开始启用 timeout（命令等待超时） 计时。
  retryAttempts: 3
  # 命令重试发送时间间隔，单位：毫秒
  retryInterval: 1500
1
2
3
4
5
6
7
8
9
10
11
12
13
14

总结

共同点

三者都提供了基于Redis操作的Java API，只是封装程度，具体实现稍有不同。

区别

• Jedis 是Redis的Java实现的客户端。支持基本的数据类型如：String、Hash、List、Set、Sorted Set。 特点：使用阻塞的I/O，方法调用同步，程序流需要等到socket处理完I/O才能执行，不支持异步操作。Jedis客户端实例不是线程安全的，需要通过连接池来使用Jedis。

• Redisson 优点：分布式锁，分布式集合，可通过Redis支持延迟队列。

• Lettuce 用于线程安全同步，异步和响应使用，支持集群，Sentinel，管道和编码器。 基于Netty框架的事件驱动的通信层，其方法调用是异步的。Lettuce的API是线程安全的，所以可以操作单个Lettuce连接来完成各种操作。

项目地址

项目地址