Redis在Spring Boot中从入门到精通：集群与三大场景深度解析

引言

在当今高速发展的互联网应用中，数据访问性能是决定用户体验的关键因素之一。Redis作为一个开源的高性能键值内存数据库，以其卓越的速度、丰富的数据结构和广泛的适用场景，成为了架构师的"瑞士军刀"。

无论是作为缓存、会话存储还是消息队列，Redis都能大显身手。本文将带你全面学习如何在Spring Boot中集成Redis，深入理解Redis集群的搭建与原理，并剖析其最核心的三大应用场景，让你真正掌握这把利器。

第一部分：入门篇 - Spring Boot快速集成Redis

目标： 在Spring Boot中成功连接Redis并执行基本操作。

1. 环境准备

安装Redis服务器。可以从官网下载安装，或使用Docker快速启动：
```
docker run -d --name redis -p 6379:6379 redis:latest
```
创建一个Spring Boot项目。

2. 添加依赖
在pom.xml中添加Spring Boot Redis Starter依赖。

<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>

3. 基础配置
在application.yml中配置Redis连接信息。

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    password: # 如果没有密码，可以不填
    database: 0 # 默认使用0号数据库
    lettuce:
      pool:
        max-active: 8   # 连接池最大连接数
        max-idle: 8     # 连接池最大空闲连接数
        min-idle: 0     # 连接池最小空闲连接数

4. 使用RedisTemplate操作Redis

Spring Data Redis提供了强大的RedisTemplate工具类。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class RedisService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // 设置值
    public void setValue(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    // 设置值并指定过期时间
    public void setValueWithExpire(String key, Object value, long timeout, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, timeout, unit);
    }

    // 获取值
    public Object getValue(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    // 删除键
    public Boolean deleteKey(String key) {
        return redisTemplate.delete(key);
    }

    // 判断键是否存在
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }
}

5. 测试
编写一个Controller进行测试，如果能够成功存储和读取数据，说明集成成功！

@RestController
public class TestController {

    @Autowired
    private RedisService redisService;

    @GetMapping("/test")
    public String test() {
        redisService.setValueWithExpire("name", "Redis入门用户", 10, TimeUnit.MINUTES);
        return "值是: " + redisService.getValue("name");
    }
}

第二部分：进阶篇 - Redis集群模式详解

单机Redis存在单点故障和容量瓶颈问题，生产环境必须使用集群。

1. 主从复制 (Master-Slave)

概念： 一个主节点(Master)负责写操作，多个从节点(Slave)负责读操作，并实时同步主节点的数据。
优点： 读写分离，提高读性能；数据备份，提高可靠性。
缺点： 主节点宕机需要手动切换，无法实现高可用。

2. 哨兵模式 (Sentinel)

概念： 在主从复制基础上，引入哨兵进程来监控所有节点。当主节点宕机时，哨兵会自动选举一个从节点升级为主节点。
优点： 实现了高可用，自动故障转移。
缺点： 写操作和存储能力仍然受单主节点限制，扩容复杂。

Spring Boot连接哨兵模式配置：

spring:
  redis:
    sentinel:
      master: mymaster # 主节点名称
      nodes: 192.168.1.10:26379,192.168.1.11:26379,192.168.1.12:26379 # 哨兵节点地址列表

3. 集群模式 (Cluster) - 生产环境推荐

概念： Redis官方提供的分布式解决方案。采用无中心结构，数据被分片(sharding)存储在多个节点上（通常16384个槽位）。每个节点负责一部分槽位，节点之间通过Gossip协议通信。
优点：
- 高可用： 每个分片通常都是主从结构，支持自动故障转移。
- 高扩展性： 数据分片存储，理论上可以线性扩展至1000+节点。
- 无中心架构： 客户端直接连接任意节点，节点间可转发请求。

Spring Boot连接集群模式配置：

spring:
  redis:
    cluster:
      nodes: 192.168.1.10:6379,192.168.1.11:6379,192.168.1.12:6379,192.168.1.13:6379,192.168.1.14:6379,192.168.1.15:6379
      max-redirects: 3 # 最大重定向次数
    password: your_password

第三部分：精通篇 - Redis三大核心场景剖析

场景一：缓存 - 这是Redis最经典的用法

目标： 减轻数据库压力，加速读写。

实现模式：

Cache-Aside (旁路缓存)：
- 读：先读缓存，命中则返回；未命中则读数据库，并将结果写入缓存。
- 写：直接更新数据库，然后删除缓存（推荐，避免数据不一致复杂性）。

代码示例：

public User getUserById(Long id) {
    String key = "user:" + id;
    // 1. 从缓存查询
    User user = (User) redisTemplate.opsForValue().get(key);
    if (user != null) {
        return user;
    }
    // 2. 缓存没有，从数据库查询
    user = userMapper.selectById(id);
    if (user != null) {
        // 3. 将数据写入缓存
        redisTemplate.opsForValue().set(key, user, 30, TimeUnit.MINUTES);
    }
    return user;
}

常见问题：
- 缓存穿透： 查询一个一定不存在的数据。解决方案：缓存空对象、使用布隆过滤器。
- 缓存击穿： 某个热点key过期瞬间，大量请求直接打到数据库。解决方案：设置热点key永不过期、使用互斥锁。
- 缓存雪崩： 大量key在同一时间过期，导致所有请求都打到数据库。解决方案：设置不同的过期时间、Redis高可用。

场景二：分布式锁

目标： 在分布式系统中，控制对共享资源的互斥访问。
核心命令： SET key value [EX seconds] [PX milliseconds] [NX|XX]
- EX 设置过期时间，这是防止死锁的关键！
- NX 只在键不存在时设置，这是实现互斥性的关键。

代码示例：

public boolean tryLock(String lockKey, String requestId, long expireTime) {
    // requestId用于标识加锁的客户端，解锁时可验证，避免解错锁
    Boolean result = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, requestId, expireTime, TimeUnit.SECONDS);
    return Boolean.TRUE.equals(result);
}

public boolean unlock(String lockKey, String requestId) {
    // 使用Lua脚本保证判断和删除的原子性
    String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
    Long result = redisTemplate.execute(
            new DefaultRedisScript<>(script, Long.class),
            Collections.singletonList(lockKey),
            requestId
    );
    return Boolean.TRUE.equals(result == 1);
}

场景三：计数器和排行榜

目标： 利用Redis原子操作实现高性能的计数和排序功能。
计数器实现：
- 使用INCR、INCRBY命令，原子性增加，可用于文章阅读量、用户点赞等。
- ```
// 文章阅读量+1
redisTemplate.opsForValue().increment("article:view:123");
```

排行榜实现：

使用ZSET（有序集合），成员为item，分数为排序依据。

// 添加或更新用户分数
redisTemplate.opsForZSet().add("leaderboard", "userA", 2500);
redisTemplate.opsForZSet().add("leaderboard", "userB", 1800);
// 获取Top 10
Set<ZSetOperations.TypedTuple<Object>> top10 = redisTemplate.opsForZSet()
                                        .reverseRangeWithScores("leaderboard", 0, 9);

总结

通过本文的学习，我们系统地掌握了Redis在Spring Boot中的应用：

入门： 学会了Spring Boot与Redis的单机集成和基本CRUD操作。
进阶： 理解了主从、哨兵、集群三种模式的演进与区别，并掌握了生产环境最推荐的集群配置方法。
精通： 深度剖析了Redis作为缓存、分布式锁、计数器/排行榜的三大核心场景，并给出了代码实现和问题解决方案。

Redis的魅力远不止于此，它在消息队列（Pub/Sub/Stream）、地理位置（GEO）、限流等场景中同样表现出色。希望这篇文章能成为你Redis之旅的坚实起点，在实践中不断探索，让Redis成为你构建高性能、高可用系统的得力助手。

Redis在Spring Boot中从入门到精通：集群与三大场景深度解析