在 Spring Boot 中整合、使用 Redis-工具盒子

Redis 是一款开源的，使用 C 开发的高性能内存 Key/Value 数据库，支持 String、Set、Hash、List、Stream 等等数据类型。它被广泛用于缓存、消息队列、实时分析、计数器和排行榜等场景。基本上是当代应用中必不可少的软件！

Spring Boot 对 Redis 提供了开箱即用的组件：spring-boot-starter-data-redis。通过这个 starter，我们只需要几行简单的配置就可以快速地在 Spring Boot 中整合、使用 Redis。

Spring Boot 整合 Redis {#spring-boot-整合-redis}

Maven 依赖 {#maven-依赖}

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

除了 spring-boot-starter-data-redis 外，还添加了 commons-pool2 依赖，是因为我们需要使用到连接池。

配置属性 {#配置属性}

只需要在 application.yaml | properties 中配置如下常用的基本属性即可：

spring: data: redis: # 连接地址 host: "localhost" # 端口 port: 6379 # 数据库 database: 0 # 用户名，如果有 # username: # 密码，如果有 # password: # 连接超时 connect-timeout: 5s # 读超时 timeout: 5s # Lettuce 客户端的配置 lettuce: # 连接池配置 pool: # 最小空闲连接 min-idle: 0 # 最大空闲连接 max-idle: 8 # 最大活跃连接 max-active: 8 # 从连接池获取连接最大超时时间，小于等于0则表示不会超时 max-wait: -1ms

注意，如果你使用的是 spring boot 2.x，上述配置的命名空间应该是 spring.redis 而不是 spring.data.redis。

更多完整的配置属性，请参阅官方文档。

使用 Jedis 客户端 {#使用-jedis-客户端}

Spring Data Redis 默认使用 Lettuce 作为 Redis 客户端。官方还对 Jedis 提供了支持，你可以根据你的喜好进行选择。

要替换为 Jedis，首先需要从 spring-boot-starter-data-redis 排除 lettuce ，并且添加 jedis 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

然后修改配置文件，把 lettuce 配置替换为 jedis 配置即可：

spring.data.redis.jedis.pool.enabled=true
spring.data.redis.jedis.pool.max-active=8
spring.data.redis.jedis.pool.max-idle=8
spring.data.redis.jedis.pool.max-wait=-1ms
spring.data.redis.jedis.pool.min-idle=0
spring.data.redis.jedis.pool.time-between-eviction-runs=

得益于 Spring Data Redis 提供的抽象、封装。在修改了底层客户端后，我们基本上不用修改任何业务代码。

推荐在项目中使用 lettuce 客户端，因为它是基于 Netty 开发，支持非阻塞式 IO，性能会更好。

使用 StringRedisTemplate {#使用-stringredistemplate}

配置就绪后，StringRedisTemplate 已经可用，你可以在任何地方注入、使用：

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class DemoApplicationTests {
static final Logger logger = LoggerFactory.getLogger(DemoApplicationTests.class);

// 注入 StringRedisTemplate
@Autowired
StringRedisTemplate stringRedisTemplate;

@Test
public void test() {
    
    // 设置
    this.stringRedisTemplate.opsForValue().set(&quot;title&quot;, &quot;spring 中文网&quot;, Duration.ofMinutes(5));

    // 读取
    String val = this.stringRedisTemplate.opsForValue().get(&quot;title&quot;);

    logger.info(&quot;value={}&quot;, val);
}

}

对于 StringRedisTemplate 更完整的方法列表，你可以参阅其 java doc。

自定义 RedisTemplate {#自定义-redistemplate}

如果基本的 StringRedisTemplate 不能满足你的需求，你也可以自定义 RedisTemplate 实现。

例如，我们想要自定义一个 JsonRedisTemplate，用于把任意 Java 对象序列化为 json 数据存储到 Redis，并且也能够把 Redis 中的 json 数据反序列化为任意 Java 对象。

如下：

import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
@Component
public class JsonRedisTemplate extends RedisTemplate<String, Object>{
public JsonRedisTemplate(RedisConnectionFactory redisConnectionFactory) {

    // 构造函数注入 RedisConnectionFactory，设置到父类
    super.setConnectionFactory(redisConnectionFactory);
    
    // 使用 Jackson 提供的通用 Serializer
    GenericJackson2JsonRedisSerializer serializer = new GenericJackson2JsonRedisSerializer();
    serializer.configure(mapper -&gt; {
        // 如果涉及到对 java.time 类型的序列化，反序列化那么需要注册 JavaTimeModule
        mapper.registerModule(new JavaTimeModule());
    });
    
    // String 类型的 key/value 序列化
    super.setKeySerializer(StringRedisSerializer.UTF_8);
    super.setValueSerializer(serializer);
    
    // Hash 类型的 key/value 序列化
    super.setHashKeySerializer(StringRedisSerializer.UTF_8);
    super.setHashValueSerializer(serializer);
}

}

首先，继承 RedisTemplate<K,V>，泛型 K 表示 Redis Key 类型，一般都是 String，泛型 V 表示 Redis Value 类型，既然我们需要的是一个通用的 JSON Template，所以设置为 Object，Value 值可以是任意对象。

在构造函数中注入 RedisConnectionFactory 设置到父类，这是必须的。

然后创建GenericJackson2JsonRedisSerializer 实例，它是基于 Jackson 的 RedisSerializer 实现，用于任意 Java 对象和 JSON 字符串之间的序列化/反序列化。使用该实例作为普通 Value 和 Hash Value 的序列化/反序列化器。注意，因为序列化的对象可能包含了 java.time 类型的日期字段，如：LocalTime、LocalDate 以及 LocalDateTime，所以需要注册 JavaTimeModule。

创建测试类进行测试。如下：

package cn.springdoc.demo.test;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import cn.springdoc.demo.redis.JsonRedisTemplate;
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class DemoApplicationTests {
static final Logger logger = LoggerFactory.getLogger(DemoApplicationTests.class);


// 注入 JsonRedisTemplate
@Autowired
JsonRedisTemplate jsonRedisTemplate;

@SuppressWarnings(&quot;unchecked&quot;)
@Test
public void test() {
    
    // Map
    Map&lt;String, Object&gt; map = new HashMap&lt;&gt;();
    map.put(&quot;title&quot;, &quot;spring 中文网&quot;);
    map.put(&quot;url&quot;, &quot;https://springdoc.cn&quot;);
    map.put(&quot;createAt&quot;, LocalDateTime.now());
    
    // 设置 key/value
    this.jsonRedisTemplate.opsForValue().set(&quot;key1-string&quot;, map, Duration.ofMinutes(5));
    // 读取 key/value
    map = (Map&lt;String, Object&gt;) this.jsonRedisTemplate.opsForValue().get(&quot;key1-string&quot;);
    logger.info(&quot;map={}&quot;, map);
    
    // 设置 Hash Value
    this.jsonRedisTemplate.opsForHash().put(&quot;key2-hash&quot;, &quot;app&quot;, map);
    // 读取 Hash Value
    map = (Map&lt;String, Object&gt;) this.jsonRedisTemplate.opsForHash().get(&quot;key2-hash&quot;, &quot;app&quot;);

    logger.info(&quot;map={}&quot;, map);
}

}

我们创建了一个 Map<String, Object> 对象，存储了 2 个 String 和一个 LocalDateTime 字段。然后使用 JsonRedisTemplate 把它存储为普通 Value 和 Hash Value。

存储成功后，再进行读取，反序列化为原来的 Map<String, Object> 对象。

运行测试，执行日志如下：

[           main] c.s.demo.test.DemoApplicationTests       : map={title=spring 中文网, url=https://springdoc.cn, createAt=2023-09-25T10:53:44.618386900}
[           main] c.s.demo.test.DemoApplicationTests       : map={title=spring 中文网, url=https://springdoc.cn, createAt=2023-09-25T10:53:44.618386900}

如你所见，序列化为 JSON、反序列化为对象都没问题。