Redis 7.x 系列【34】Spring Boot 集成

有道无术，术尚可求，有术无道，止于术。

本系列Redis 版本 7.2.5

源码地址：https://gitee.com/pearl-organization/study-redis-demo

文章目录

- 1. 前言
- 2. Spring Data Redis
- 3. Spring Boot Data Redis Starter
- - 3.1 起步依赖
  - 3.2 自动配置
- 4. 配置
- - 4.1 客户端类型
  - 4.2 连接池
  - 4.3 连接配置
  - - 4.3.1 单机
    - 4.3.2 哨兵
    - 4.3.3 集群
  - 4.4 连接、读取超时
  - 4.5 SSL Bundle
  - 4.6 Redis Repository
  - 4.7 Lettuce 独有
- 5. 入门案例
- - 5.1 引入依赖
  - 5.2 配置连接
  - 5.3 操作模板类

1. 前言

在使用客户端连接 Redis 时，例如 Jedis ：

        // 创建连接池
        JedisPool pool = new JedisPool("localhost", 6379,"default","123456");
        // 获取客户端
        try (Jedis jedis = pool.getResource()) {
            // 存入一个字符串
            jedis.set("foo", "bar");
        }

直接集成客户端，需要我们自己维护连接配置，获取客户端连接，再执行操作，最后还需要释放资源。Spring 提供了 Spring Data Redis 和 Spring Boot Data Redis Starter ，在 Spring Boot 环境中，可以很方便的连接并操作 Redis。

注意：本篇主要是介绍在 Spring Boot 中如何配置连接 Redis，关于使用细节方面，请参考 Spring Data Redis 专栏

2. Spring Data Redis

官方文档

Spring Data Redis 用于简化 Redis 的配置和操作，提供了与存储进行交互的低级和高级抽象，从而使用户无需担心基础设施问题。

核心特性：

连接：支持多个 Redis 客户端包（如 Lettuce 和 Jedis ），提供低级抽象，简化了连接管理。
异常转换：将 Redis 客户端异常转换为 Spring 的数据访问异常层次结构，便于异常处理。
RedisTemplate：提供了一个高级抽象，用于执行各种 Redis 操作，包括异常转换和序列化支持，简化了 Redis 操作。
发布/订阅支持：如为消息驱动的 POJO 提供的 MessageListenerContainer ，支持发布/订阅模式。
Redis Sentinel 和 Redis Cluster 支持：提供对 Redis 的高可用性和集群配置的支持。
响应式API：默认使用 Lettuce 提供响应式编程能力，支持非阻塞的异步操作。
序列化器：包括JDK、String、JSON和 Spring Object/XML映射序列化器，方便数据序列化和反序列化。
JDK集合实现：在Redis之上实现JDK集合，允许以分布式方式使用集合数据结构。
原子计数器支持类：提供原子计数器类，支持分布式环境下的计数器操作。
排序和管道功能：支持排序和管道化功能，提高数据处理效率。
对SORT、SORT/GET模式及返回批量值的专门支持：提供对Redis排序命令及其变体的深入支持。
Spring 3.1缓存抽象实现（Spring Cache）：为Spring 3.1的缓存抽象提供 Redis 实现，支持缓存数据的存储和检索。
仓库接口自动实现：包括使用 @EnableRedisRepositories 注解支持自定义查询方法的仓库接口自动实现，简化了数据访问层的开发。
CDI 支持：提供对依赖注入（CDI）的支持，便于在 Spring 应用中使用 CDI 方式管理仓库。

3. Spring Boot Data Redis Starter

在Spring Data Redis 的基础上，提供了 Spring Boot 启动器：

spring-boot-starter-data-redis：适用传统应用程序
spring-boot-starter-data-redis-reactive：适用响应式应用程序

3.1 起步依赖

在 Spring Boot 中集成 Redis ，只需要引入以下依赖即可：

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

spring-boot-starter-data-redis 中包含了 Lettuce 客户端和 Spring Data Redis ，无需再引入其他依赖：

在这里插入图片描述

3.2 自动配置

在 spring-boot-autoconfigure 包中，提供了 Redis 自动配置功能：

在这里插入图片描述

核心类介绍：

ClientResourcesBuilderCustomizer：客户端资源定制器，允许开发者对 Redis 连接进行细粒度的控制和优化。
JedisClientConfigurationBuilderCustomizer：Jedis 配置定制器，用于添加自定义的 Jedis 客户端配置。
LettuceClientConfigurationBuilderCustomizer：Lettuce 配置定制器，用于添加自定义的 Lettuce 客户端配置。
JedisConnectionConfiguration： Jedis 连接自动配置类
LettuceConnectionConfiguration：Lettuce 连接自动配置类
RedisAutoConfiguration： Redis 自动配置类，主动注册 RedisTemplate 、StringRedisTemplate
RedisProperties：Redis属性配置类，加载 application.yml 中的配置到应用环境中
RedisConnectionDetails：获取 Redis 连接信息
RedisReactiveAutoConfiguration：Reactive Redis 环境下的自动配置类，主动注册ReactiveRedisTemplate、ReactiveStringRedisTemplate
RedisRepositoriesAutoConfiguration： Redis Repository 自动配置类，可以通过定义 Repository 接口操作 Redis
RedisUrlSyntaxFailureAnalyzer：URL 语法错误分析器

4. 配置

Spring Boot Redis 官方配置说明

RedisProperties 提供了 Redis 在 Spring Boot 环境中的所有配置项，配置前缀为 spring.data.redis 。

4.1 客户端类型

客户端类型对应的配置项为 spring.data.redis.client-type ，可配置项对应的类为 RedisProperties.ClientType：

    public static enum ClientType {
        LETTUCE,
        JEDIS;
    }

默认为 LETTUCE ，并且 Spring Boot 起步依赖中也包含了该包，如果想要使用 JEDIS ，可以如下配置：

spring:
  data:
    redis:
      client-type: jedis
      # 设置连接到 Redis 时使用的客户端名称（自定义），可用于日志记录和监控目的
      client-name: spring-boot-redis

此外还需要额外引入 Jedis 客户端包：

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

4.2 连接池

连接池（Connection Pool）需要在具体的客户端下进行配置，例如 jedis 连接池：

spring:
  data:
    redis:
      client-type: jedis
      jedis:
        pool:
          enabled: true
          max-active: 8
          max-idle: 8
          max-wait: 10000
          min-idle: 0
          time-between-eviction-runs: 10000

例如 lettuce 连接池：

spring:
  data:
    redis:
      client-type: lettuce
      lettuce:
        pool:
          enabled: true
          max-active: 8
          max-idle: 8
          max-wait: 10000
          min-idle: 0
          time-between-eviction-runs: 10000

关于连接池的配置项说明如下：

enabled：是否启用连接池，设置为 true （默认）表示开启，推荐使用连接池。
max-active：连接池中最大活跃连接数，默认 8 。可以限制客户端同时占用的资源数量，避免过多的连接占用Redis 服务器资源或客户端资源。
max-idle：连接池中最大空闲连接数，默认 8 。
min-idle：连接池中最小空闲连接数，默认 0 （不会强制保持任何空闲连接）。
max-wait：当连接池中没有可用连接时，获取连接的最大等待时间（以毫秒为单位），默认 -1 （一直等待）。如果没有可用的连接，则尝试获取连接的操作将抛出异常。
timeBetweenEvictionRuns：空闲连接检测器两次运行之间的间隔时间（以毫秒为单位）。设置为 10 秒时，连接池将每 10 秒检查一次空闲连接，并根据需要关闭那些超过最大空闲时间限制的连接。以保持连接池的健康状态，避免因为长时间未使用的连接而占用资源。

4.3 连接配置

Spring Boot 默认支持三种部署方式的连接，都配置了的情况下，加载优先级为：集群 > 哨兵 > 单机。

4.3.1 单机

单机模式用于开发、测试，不具备高可用性，可以使用 spring.data.redis.url 直接配置所有的连接信息，规则如下：

redis://:{认证密码}@{Ip}:{端口}/{数据库序列号}

示例：

spring:
  data:
    redis:
      url: redis://:123456@127.0.0.1:6379/0

也可以分别配置：

spring:  
  data:  
    redis:  
      # Ip
      host: 127.0.0.1  
      # 端口
      port: 6379  
      # 数据库序列号
      database: 0 
      # 认证用户名
      username: default
      # 认证密码
      password: 123456

4.3.2 哨兵

哨兵模式相关的配置前缀为 spring.data.redis.sentinel ，示例：

spring:
  data:
    redis:
      client-type: lettuce
      database: 0
      # 哨兵模式
      sentinel:
        master: mymaster
        nodes: 192.168.56.104:26379,192.168.56.105:26379,192.168.56.106:26379
        # username: sentinel
        password: sentinel123456
      lettuce:
        pool:
          enabled: true
          max-active: 8
          max-idle: 8
          max-wait: 10000
          min-idle: 0
          time-between-eviction-runs: 10000

关于哨兵的配置项说明如下：

master：主节点名称。
nodes：Sentinel 节点的地址列表，多个以逗号分割，哨兵会获取到真实的主从节点地址并连接。
username：Redis Sentinel 认证用户名。
password：Redis Sentinel 认证用密码。

4.3.3 集群

集群模式相关的配置前缀为 spring.data.redis.cluster ，示例：

spring:
  data:
    redis:
      client-type: lettuce
      # 集群模式
      # 认证用户名
      # username: cluster
      # 认证密码
      password: cluster123456
      cluster:
        max-redirects: 5
        nodes:
          - 192.168.56.101:6379
          - 192.168.56.101:6380
          - 192.168.56.101:6381
          - 192.168.56.101:6382
          - 192.168.56.101:6383
          - 192.168.56.101:6390
      lettuce:
        pool:
          enabled: true
          max-active: 8
          max-idle: 8
          max-wait: 10000
          min-idle: 0
          time-between-eviction-runs: 10000
        shutdown-timeout: 10000
      connect-timeout: 10000
      timeout: 10000

关于哨兵的配置项说明如下：

max-redirects：集群连接时的最大重定向次数。当应用程序需要连接到集群中的某个节点时，如果该节点不可用或者出现了故障，可以尝试重新路由请求到其他节点，重定向次数设置了最大尝试次数。
nodes：指定了集群中各个节点的地址和端口。

4.4 连接、读取超时

可以配置 Redis 连接、读取超时时间，示例：

spring:  
  data:  
    redis:  
      connect-timeout: 10000 
      timeout: 10000

关于超时配置项说明如下：

connect-timeout：指定客户端尝试连接到 Redis 服务器时的超时时间（毫秒为单位）。在指定时间内没有成功建立到 Redis 服务器的连接，将抛出异常。
timeout：指定 Redis 读取超时时间（毫秒为单位）。

4.5 SSL Bundle

支持基于 Spring Boot SSL Bundle 机制，配置 SSL 证书。

示例：

spring:
  data:
    redis:
      url: redis://:123456@127.0.0.1:6379/0
      ssl:
      	# 是否开启 SSL
        enabled: true
        # Bundle 名称
        bundle: secure-service
  ssl:
    bundle:
      jks:
        secure-service:
          key:
            alias: "server"
          keystore:
            location: "classpath:server.p12"
            password: "secret"
            type: "PKCS12"

4.6 Redis Repository

可以开启通过定义 Repository 接口操作 Redis ：

spring:
  data:
    redis:
      repositories:
        enabled: true

4.7 Lettuce 独有

相比于 Jedis ，Lettuce 还提供了一些独有的配置：

spring:
  data:
    redis:
      lettuce:
        pool:
          enabled: true
        cluster:
          refresh:
            adaptive: true
            dynamic-refresh-sources: true
            period: 10000
        shutdown-timeout: 10000

Lettuce 独有的配置项主要是集群自动刷新，例如，集群某个节点迁移了哈希槽，需要刷新本地的集群信息，说明如下：

shutdown-timeout：连接池在关闭时的超时时间，单位是毫秒
cluster.refresh.adaptive：启用自适应集群拓扑刷新。 Lettuce 会动态地根据 Redis 集群的拓扑情况来更新本地的集群信息，以确保客户端能够正确地与集群通信。
cluster.refresh.dynamic-refresh-sources：启用动态刷新源。 Lettuce 在需要时从多个源刷新集群的拓扑信息，确保及时获取最新的集群状态。
cluster.refresh.period：了集群拓扑刷新的周期，单位是毫秒。

5. 入门案例

5.1 引入依赖

创建一个 Spring Boot 项目，引入依赖：

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

5.2 配置连接

支持单机、复制、哨兵、集群模式，这里添加一个最简单的单机连接：

spring:
  data:
    redis:
      client-type: lettuce
      # URL
      # url: redis://:123456@127.0.0.1:6379/0
      # # Ip
       host: 127.0.0.1
      # # 端口
       port: 6379
      # # 数据库序列号
       database: 0
      # # 认证用户名
       username: default
      # # 认证密码
       password: 123456
      lettuce:
        pool:
          enabled: true
          max-active: 8
          max-idle: 8
          max-wait: 10000
          min-idle: 0
          time-between-eviction-runs: 10000
        shutdown-timeout: 10000
      connect-timeout: 10000
      timeout: 10000

5.3 操作模板类

RedisTemplate 是在 Spring Boot 环境中和 Redis 打交道的一个模板类，简化了与 Redis 数据库的交互过程，我们可以更加便捷地进行 Redis 的各种操作，如数据存取、异常处理及序列化等。

StringRedisTemplate是 RedisTemplate 的一个扩展，由于大多数针对 Redis 的操作都是基于字符串的，所以提供了一个专用的类来处理这些操作。

在Spring Boot自动配置中，已经帮我们注册了这个两个对象：

@AutoConfiguration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean(RedisConnectionDetails.class)
	PropertiesRedisConnectionDetails redisConnectionDetails(RedisProperties properties) {
		return new PropertiesRedisConnectionDetails(properties);
	}

	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate")
	@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

	@Bean
	@ConditionalOnMissingBean
	@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
		return new StringRedisTemplate(redisConnectionFactory);
	}
}

RedisTemplate 提供了丰富的 API ，可以很方便的进行各种数据类型进行操作，同时也支持事务、管道、脚本、发布订阅等。

在这里插入图片描述
示例，创建一个需要存储的用户对象， RedisTemplate 默认使用 JDK 序列化，所以需要实现 Serializable ：

public class User implements Serializable {

    private String name;

    private Integer age;

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
}

使用 RedisTemplate 进行操作：

@SpringBootTest
public class RedisTest {

    @Autowired
    RedisTemplate<Object, Object> redisTemplate;

    @Test
    public void test() {
        // 增
        User user = new User("张三", 18);
        redisTemplate.boundHashOps("session").put("id:8989", user);

        // 查
        User getUser = (User)redisTemplate.boundHashOps("session").get("id:8989");
        System.out.println(getUser);
    }
}