Spring Boot：Lettuce 原生 API 与 RedisTemplate 对比

素颜马尾好姑娘i 2024-03-24 11:28 58阅读 0赞

Spring Boot 中默认使用 Lettuce 作为 redis-cli 的底层实现。 Lettuce 基于 Netty 实现，提供了相对丰富地同步、异步操作接口。 今天我们将主要对比一下 Lettuce 原生 API 与 spring-boot-data-redis 对其封装后的接口（主要是 RedisTemplate）的使用。

## 01-Lettuce 原生 API ##

Lettuce 暴露给用户的接口是非常直观的，针对单实例、集群场景，提供了两个 client 接口：

*  io.lettuce.core.RedisClient
 *  io.lettuce.core.cluster.RedisClusterClient

它们都继承自 io.lettuce.core.AbstractRedisClient，封装了 Netty、ClientOptions（控制 client 行为，例如重连、超时等）和连接过程的实现。

RedisClient 对象的创建是非常简单的：

final RedisURI uri = RedisURI.builder()
                    .withPassword("redis123")
                    .withHost("example.samson.self")
                    .withPort(6379)
                    .withDatabase(0)
                    .build();
    final RedisClient redisClient = RedisClient.create(uri);
    /**
     * 上述 uri 对象等价于：
     * redis://redis123@example.samson.self:6379/0
     *
     */
    复制代码

创建了 RedisClient 实例后，可以通过 RedisClient\#connect() 方法获得 StatefulRedisConnection 连接对象。 获得连接对象后，可以通过如下接口进行同步、异步及响应式命令的执行：

final StatefulRedisConnection<String, String> connection = client.connect();
    final RedisCommands<String, String> sync = connection.sync();   // 同步操作
    final RedisAsyncCommands<String, String> async = connection.async(); // 异步操作
    final RedisReactiveCommands<String, String> reactive = connection.reactive(); // 响应式操作
    复制代码

下文以同步操作为例，演示下通过 Lettuce 原生 API 对 Redis 基本数据结构的操作。

// 字符串
    sync.set("str", "str_value");
    final String strValue = sync.get("str");
    System.out.println("strValue: " + strValue);
    
    // 列表
    sync.lpush("list", "value1", "value2");
    final Long listLen = sync.llen("list");
    final List<String> allList = sync.lrange("list", 0, listLen);
    System.out.println("allList: " + String.join(",", allList));
    
    // 集合
    sync.sadd("set", "set1", "set2");
    final Long setSize = sync.scard("set");
    final Set<String> allSet = sync.smembers("set");
    System.out.println("setSize: " + setSize);
    System.out.println("allSet: " + String.join(",", allSet));
    
    // 哈希表
    sync.hset("hashset", "key1", "value1");
    sync.hset("hashset", "key2", "value2");
    sync.hset("hashset", "key3", "value3");
    final Long hlen = sync.hlen("hashset");
    final Map<String, String> allHashset = sync.hgetall("hashset");
    System.out.println("hlen: " + hlen);
    System.out.println("allHashset: " + allHashset.entrySet().stream().map(k -> String.format("%s->%s", k.getKey(), k.getValue())).collect(Collectors.joining(",")));
    复制代码

### 01.1-使用 Lettuce 原生 API 实现订阅、发布功能 ###

发布功能比较容易实现，只需要通过 RedisCommands\#publish 接口向指定的 channel 发布消息即可。

final Long published = sync.publish("topic:foo", "hello, from idea!");
    复制代码

相比于发布，订阅实现则比较复杂。 Lettuce 提供了 RedisPubSubListener 接口，作为 channel 的监听器。 当特定事件（例如订阅、取消订阅、收到消息等）发生时，回调监听器的特定方法。 接下来，我将通过一个实例来演示，如果订阅一个 channel，并在收到消息时将消息打印到控制台。

RedisPubSubAdapter 是 Lettuce 提供的一个工具类，它实现了 RedisPubSubListener 接口，不过所有的方法都是空实现。

final LinkedBlockingQueue<String> messages = LettuceFactories.newBlockingQueue(); // 阻塞队列，用来存储 channel 中收到的消息
    
    final RedisClient client = getClient();
    final StatefulRedisPubSubConnection<String, String> pubSubConnection = client.connectPubSub(); // 获取订阅、发布连接
    // 向连接中添加一个 listener，且重写其 message 方法，在收到消息时，将消息添加到阻塞队列 messages 中
    pubSubConnection.addListener(new RedisPubSubAdapter<>(){
        @Override
        public void message(String channel, String message) {
            try {
                messages.put(message);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    // 订阅 channel
    final RedisPubSubCommands<String, String> sync = pubSubConnection.sync();
    sync.subscribe("topic:foo");
    复制代码

避免主线程退出，我们新创建一个线程，负责从阻塞队列 messages 中读取消息并打印到控制台：

final Thread backThread = new Thread() {
        @Override
        public void run() {
            while (true) {
                try {
                    final String message = messages.take(); // 从阻塞队列中获取消息并打印，若获取不到，则阻塞等待
                    System.out.println("channel [topic:foo] received message: " + message);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };
    backThread.start();
    
    // 避免主线程退出
    try {
        backThread.join();
    } catch (InterruptedException ie) {
        ie.printStackTrace();
    }
    复制代码

### 01.2-使用 Lettuce 原生 API 进行事务操作 ###

使用 Lettuce 进行 Redis 事务操作与使用 redis-cli 的操作非常相似。

final RedisClient client = getClient();
    final StatefulRedisConnection<String, String> connection = client.connect();
    final RedisCommands<String, String> sync = connection.sync();
    sync.multi(); // 开启事务
            
    // 事务执行
    sync.set("one", "1");
    sync.set("two", "2");
    sync.set("three", "3");
    
    final TransactionResult execResult = sync.exec();// 提交事务，Server 开始执行
    execResult.forEach(System.out::println);
    复制代码

Lettuce 不支持 Redis pipeline。

## 02-Spring Boot 对 Lettuce 的封装 ##

在前面的文章 [Spring Boot「17」整合 Redis][Spring Boot_17_ Redis] 中提到，spring-boot-data-redis 对 Redis 进行了封装，并向应用上下文容器中注入了两个工具类：

*  RedisTemplate
 *  StringRedisTemplate

其中，后者是 RedisTemplate 的一个派生类，它按照 String 类型来处理 Redis 中的键、值。

Spring Boot 中，与 Redis 的连接被封装为 RedisConnection 接口，有两个实现类分别用来封装底层 redis-cli 连接：

*  LettuceConnection
 *  JedisConnection

RedisTemplate 依靠 RedisConnectionFactory 来获取与 Redis 实例的连接对象。 Spring Boot 提供了 RedisConnectionFactory 的两个实现，分别针对 Lettuce 和 Jedis 两个常见的 redis-cli 实现：

*  LettuceConnectionFactory，获取 LettuceConnection 实例；
 *  JedisConnectionFactory，获取 JedisConnection 实例；

RedisConnectionFactory 和 RedisConnection 屏蔽了底层不同 redis-cli 实现 API 的差异，使 RedisTemplate 与底层实现解耦。 该接口中有三个关键的接口，针对不同的场景获得连接：

public interface RedisConnectionFactory extends PersistenceExceptionTranslator {
        RedisConnection getConnection(); // 获取与单 Redis 实例的连接
        RedisClusterConnection getClusterConnection(); // 获取与 Redis 集群的连接
        RedisSentinelConnection getSentinelConnection(); // 获取与 Redis 哨兵的连接
    }
    复制代码

LettuceConnectionFactory 是与 Lettuce 原生 API 深度耦合的。 通过查看它的源码，不难发现我在前面章节中介绍的 Lettuce 原生 API。 它持有一个 `AbstractRedisClient client` 对象，是与 Redis 交互的句柄； `LettuceConnectionProvider connectionProvider` 对象，负责从 RedisClient 中获取 Lettuce StatefulConnection<K, V> 连接。

在 Spring Boot 应用中，通过 StringRedisTemplate 进行基本数据结构的操作示例如下：

// 字符串
    final Valu  eOperations<String, String> opsForValue = stringRedisTemplate.opsForValue();
    opsForValue.set("str", "str_value");
    final String strValue = opsForValue.get("str");
    System.out.println("strValue: " + strValue);
    
    // 列表
    final ListOperations<String, String> opsForList = stringRedisTemplate.opsForList();
    opsForList.leftPush("list", "value1", "value2");
    final Long listLen = opsForList.size("list");
    final List<String> allList = opsForList.range("list", 0, listLen);
    System.out.println("allList: " + String.join(",", allList));
    
    // 集合
    final SetOperations<String, String> opsForSet = stringRedisTemplate.opsForSet();
    opsForSet.add("set", "set1", "set2");
    final Long setSize = opsForSet.size("set");
    final Set<String> allSet = opsForSet.members("set");
    System.out.println("setSize: " + setSize);
    System.out.println("allSet: " + String.join(",", allSet));
    
    // 哈希表
    final HashOperations<String, Object, Object> opsForHash = stringRedisTemplate.opsForHash();
    opsForHash.put("hashset", "key1", "value1");
    opsForHash.put("hashset", "key2", "value2");
    opsForHash.put("hashset", "key3", "value3");
    final Long hlen = opsForHash.size("hashset");
    final Map<Object, Object> allHashset = opsForHash.entries("hashset");
    System.out.println("hlen: " + hlen);
    System.out.println("allHashset: " + allHashset.entrySet().stream().map(k -> String.format("%s->%s", k.getKey(), k.getValue())).collect(Collectors.joining(",")));
    复制代码

### 02.1-使用 StringRedisTemplate 实现订阅、发布功能 ###

与 Lettuce 一样，发布消息非常简单：

stringRedisTemplate.convertAndSend("topic:foo", "hello, all! _from redis-template");
    复制代码

订阅实现起来相对复杂一点：

final RedisConnection connection = stringRedisTemplate.getConnectionFactory().getConnection();
    connection.subscribe((m, p) -> {
        try {
            messages.put(m.toString()); // 将消息添加到阻塞队列中
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }, "topic:foo".getBytes());
    复制代码

可以看到，StringRedisTemplate 实现订阅与 Lettuce 实现订阅的接口基本类似，都是在 Connection 上调用订阅方法，然后传递一个回调，在收到消息后调用。

除了上述这种方式外，Spring Boot 中还设计了一个 RedisMessageListenerContainer 的类。 官方文档对它的介绍是：

> Container providing asynchronous behaviour for Redis message listeners. Handles the low level details of listening, converting and message dispatching.

final RedisMessageListenerContainer container = new RedisMessageListenerContainer();
    container.setConnectionFactory(stringRedisTemplate.getConnectionFactory());
    container.addMessageListener((m, p) -> {
        try {
            messages.put(m.toString());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }, ChannelTopic.of("topic:foo"));
    
    container.afterPropertiesSet();
    container.start();
    复制代码

### 02.2-使用 StringRedisTemplate 进行事务操作 ###

Spring Boot 官网给出的 StringRedisTemplate 执行事务的方式是通过 StringRedisTemplate\#execute 方法。 例如：

List<String> results = stringRedisTemplate.execute(new SessionCallback<>() {
        @Override
        public List<String> execute(RedisOperations operations) throws DataAccessException {
            operations.multi(); // 开启事务
    
            ValueOperations opsForValue = operations.opsForValue();
            opsForValue.set("one", "1");
            opsForValue.set("two", "2");
            opsForValue.set("three", "3");
    
            return operations.exec(); // 提交事务
        }
    });
    System.out.println(results.size());
    复制代码

## 03-总结 ##

通过上面的 API 对比，不难发现 spring-boot-data-redis 对 redis-cli 的封装后暴露的接口是比较简单易用的。 在开发过程中，如果是 Spring Boot 应用，建议使用 RedisTemplate 及其子类来与 Redis 服务端进行交互。 这样做的好处是可以将业务实现与底层的 redis-cli 实现解耦，当底层不满足需求时，更换底层而不会影响到业务层的代码。

[Spring Boot_17_ Redis]: https://juejin.cn/post/7195144191029510202