Redis应用与Spring Boot集成实战（基于Redis Cluster）

已于 2025-03-23 16:19:18 修改
阅读量1.3k 收藏 14
点赞数 20
分类专栏： java实战 文章标签： redis spring boot
于 2025-03-13 21:14:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u010702254/article/details/146242325
版权

目录

Redis应用与Spring Boot集成实战（基于Redis Cluster）

Redis是一种高性能的键值存储数据库，广泛应用于缓存、会话管理、排行榜等场景。本文将介绍Redis Cluster架构的特点、应用场景，并通过Spring Boot集成实战展示如何在项目中使用Redis Cluster。配置信息将以YAML格式提供，包含详细注释说明，同时代码中也增加了注释以提升可读性。

Redis 集群架构综合对比

以下是对 Redis 三种集群架构（主从复制、哨兵模式、Redis Cluster）的综合对比表格，涵盖多个关键维度，帮助全面理解它们的优劣：

维度主从复制哨兵模式Redis Cluster
架构特点一个 master 负责写，多个 slave 负责读主从复制 + 哨兵进程监控和自动故障转移数据分片 + 多主多从 + 自动故障转移
高可用性低（master 故障需手动切换）中（哨兵自动切换，但仍依赖单 master）高（多主架构，故障自动转移）
数据一致性弱（异步复制，可能丢失数据）弱（异步复制，可能丢失数据）弱（异步复制，可能丢失数据）
可扩展性低（写能力无法水平扩展）低（写能力无法水平扩展）高（支持动态添加节点，水平扩展）
性能读性能高，写性能受 master 限制读性能高，写性能受 master 限制读写性能高（多 master 分担写负载）
运维复杂度低（配置简单，仅需主从同步）中（需额外配置和管理哨兵节点）高（需管理槽分配、节点状态和集群扩展）
故障恢复手动切换 master自动故障转移（slave 提升为 master）自动故障转移（集群内节点接管失效节点）
数据分片无（所有数据存储在 master）无（所有数据存储在 master）有（16384 个槽，数据自动分片）
节点管理简单（主从关系明确）中等（需维护哨兵与主从节点）复杂（需监控槽分布和节点健康）
适用场景小型应用，读多写少，预算有限中型应用，需一定高可用性大型分布式应用，需高可用性和扩展性
客户端支持简单（只需连接 master 和 slave）需支持哨兵协议（如 Jedis Sentinel）需支持 Cluster 协议（如 Jedis Cluster）
  • 高可用性：Redis Cluster 的多主多从架构使其在节点故障时仍能保持服务可用性，优于主从复制和哨兵模式。
  • 数据一致性：三种模式均采用异步复制，存在数据丢失风险，强一致性需求需额外机制保障。
  • 可扩展性：Redis Cluster 支持动态添加节点和数据分片，是唯一可水平扩展写能力的架构。
  • 性能：Redis Cluster 通过多 master 分担负载，显著提升写性能，适合高并发场景。
  • 运维复杂度：Redis Cluster 需管理槽分配和节点状态，运维成本较高，但功能更强大。

Redis Cluster是Redis的高可用和可扩展解决方案，通过数据分片和自动故障转移实现分布式存储。以下是Redis Cluster的主要特点：

  • 数据分片：数据根据槽（slot）分布到多个节点，默认有16384个槽。
  • 高可用：支持主从复制和自动故障转移。
  • 水平扩展：可动态添加或删除节点以扩展容量。

Redis Cluster的应用场景

Redis Cluster支持多种使用场景，以下是具体示例：

  • 缓存：存储热点数据，分片到多个节点，减轻数据库压力。
  • 会话管理：在分布式系统中存储用户会话，确保高可用和一致性。
  • 排行榜：利用有序集合（ZSet）实现实时排行榜，支持大规模并发。
  • 消息队列：通过列表（List）实现简单的生产者-消费者模式。
  • 分布式锁：使用SETNX命令实现跨节点的分布式锁。

Spring Boot集成Redis Cluster实战

以下是Spring Boot集成Redis Cluster的完整步骤，包括依赖添加、详细的YAML配置和带注释的代码示例。

1. 添加依赖

在pom.xml中添加Spring Data Redis依赖以支持Redis操作：

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

2. 配置Redis Cluster（YAML格式）

在application.yml中配置Redis Cluster的详细参数，包含节点信息、连接池设置和超时配置：

spring:
  redis:
    # Redis Cluster配置
    cluster:
      nodes:
        - localhost:7001  # 集群节点1
        - localhost:7002  # 集群节点2
        - localhost:7003  # 集群节点3
        - localhost:7004  # 集群节点4（可选，视实际集群规模）
        - localhost:7005  # 集群节点5（可选）
        - localhost:7006  # 集群节点6（可选）
      max-redirects: 3  # 最大重定向次数，处理MOVED和ASKED重定向
    # 通用连接配置
    password: your_password  # Redis认证密码（若无则省略）
    timeout: 5000  # 命令执行超时时间（毫秒）
    database: 0  # 默认数据库索引（Redis Cluster中通常固定为0）
    # Lettuce客户端配置（Spring Boot默认使用Lettuce）
    lettuce:
      pool:
        max-active: 16  # 连接池最大连接数，-1表示无限制
        max-idle: 8  # 连接池最大空闲连接数
        min-idle: 2  # 连接池最小空闲连接数，确保低负载时仍有可用连接
        max-wait: 10000  # 获取连接的最大等待时间（毫秒），-1表示无限等待
      shutdown-timeout: 200  # 客户端关闭时的超时时间（毫秒）
    # 可选：连接重试配置
    connect-timeout: 10000  # 建立连接的超时时间（毫秒）
    retries: 3  # 连接失败时的重试次数

配置说明：

  • spring.redis.cluster.nodes：Redis Cluster的节点列表，至少需要3个主节点以保证高可用。
  • spring.redis.cluster.max-redirects：处理Redis Cluster中的槽重定向（MOVED/ASKED）的最大次数。
  • spring.redis.password：若Redis设置了密码，则需配置。
  • spring.redis.lettuce.pool：配置Lettuce连接池，控制连接资源的使用。
  • spring.redis.connect-timeout和retries：增强连接的健壮性，适用于网络不稳定场景。

3. 使用RedisTemplate操作Redis Cluster

RedisTemplate是Spring Data Redis提供的核心工具，在Redis Cluster中会自动处理节点路由和故障转移。

示例：操作字符串和列表

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

@Component
public class RedisUtil {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 设置键值对
     * @param key 键名
     * @param value 值
     */
    public void setValue(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 获取键对应的值
     * @param key 键名
     * @return 值，若不存在返回null
     */
    public String getValue(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 向列表左侧添加元素
     * @param key 列表键名
     * @param value 元素值
     */
    public void addToList(String key, String value) {
        redisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * 从列表右侧弹出一个元素
     * @param key 列表键名
     * @return 弹出的元素，若列表为空返回null
     */
    public String getFromList(String key) {
        return redisTemplate.opsForList().rightPop(key);
    }
}

4. 使用Spring Cache简化缓存操作

Redis Cluster可作为Spring Cache的后端，通过注解简化缓存管理。

启用缓存：

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class RedisConfig {
    // 可选：自定义缓存管理器配置
}

使用缓存注解：

import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    /**
     * 从缓存获取用户，若无则查询数据库并缓存
     * @param id 用户ID
     * @return 用户对象
     */
    @Cacheable(value = "user", key = "#id")
    public User getUserById(Long id) {
        // 模拟数据库查询
        return new User(id, "User" + id);
    }

    /**
     * 更新用户并更新缓存
     * @param user 用户对象
     * @return 更新后的用户对象
     */
    @CachePut(value = "user", key = "#user.id")
    public User updateUser(User user) {
        // 更新数据库逻辑
        return user;
    }

    /**
     * 删除用户并清除缓存
     * @param id 用户ID
     */
    @CacheEvict(value = "user", key = "#id")
    public void deleteUser(Long id) {
        // 删除数据库记录逻辑
    }
}

注解说明：

  • @Cacheable：优先从Redis Cluster获取缓存，若无则执行方法并缓存。
  • @CachePut：更新方法返回值到Redis Cluster缓存。
  • @CacheEvict：从Redis Cluster中移除指定缓存。

5. 发布/订阅功能

Redis Cluster支持发布/订阅模式，适用于实时消息传递场景。

配置消息监听器：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.listener.ChannelTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;

@Configuration
public class RedisConfig {
    /**
     * 配置Redis消息监听容器
     * @param connectionFactory Redis连接工厂
     * @param listenerAdapter 消息监听适配器
     * @return 配置好的消息监听容器
     */
    @Bean
    public RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                                   MessageListenerAdapter listenerAdapter) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(listenerAdapter, new ChannelTopic("chat")); // 监听"chat"频道
        return container;
    }

    /**
     * 配置消息监听适配器，绑定消息处理方法
     * @return 消息监听适配器
     */
    @Bean
    public MessageListenerAdapter listenerAdapter() {
        return new MessageListenerAdapter(new MessageReceiver(), "onMessage");
    }
}

import org.springframework.stereotype.Component;

@Component
public class MessageReceiver {
    /**
     * 处理接收到的消息
     * @param message 消息内容
     */
    public void onMessage(String message) {
        System.out.println("Received message: " + message);
    }
}

发布消息：

/**
 * 向指定频道发布消息
 * @param channel 频道名称
 * @param message 消息内容
 */
public void publishMessage(String channel, String message) {
    redisTemplate.convertAndSend(channel, message);
}

调用示例：

redisUtil.publishMessage("chat", "Hello, Redis Cluster Pub/Sub!");

6. 事务支持

Redis Cluster支持事务，确保多个命令的原子性执行。

事务示例：

/**
 * 使用事务原子性地设置多个键值对
 */
public void transactionExample() {
    redisTemplate.multi(); // 开启事务
    redisTemplate.opsForValue().set("key1", "value1");
    redisTemplate.opsForValue().set("key2", "value2");
    redisTemplate.exec(); // 提交事务
}

以下是针对用户需求的回答，我将为您补充分布式锁应用的内容（尽量全面），并提供一个综合全面的集群架构对比表格。

分布式锁应用

分布式锁的概念与必要性

在分布式系统中，多个进程或服务可能同时访问共享资源（如数据库、缓存或文件），若不加以控制，可能导致竞争条件、数据不一致甚至系统错误。分布式锁是一种协调机制，用于确保在任意时刻只有一个客户端能够持有锁并访问共享资源。相比单机环境下的锁，分布式锁需要考虑网络延迟、节点故障和一致性等问题。

Redis Cluster 因其高性能、分布式存储和高可用性，成为实现分布式锁的热门选择。通过 Redis 的原子操作（如 SETNX），我们可以在分布式环境中高效地实现锁机制。

Redis Cluster 中实现分布式锁的方法

Redis 提供了 SETNX（SET if Not eXists）命令，可以实现分布式锁的基本功能。以下是详细的实现步骤和代码示例：

获取锁
  • 使用 SETNX 命令尝试设置一个键值对，只有在键不存在时才能成功，表示获取锁。
  • 为锁设置过期时间（通过 SET 的 EX 参数或单独的 EXPIRE 命令），防止因客户端异常退出导致锁无法释放（死锁）。
释放锁
  • 检查锁的值是否与客户端持有的值一致，若一致则删除键，完成锁释放。
  • 使用 Lua 脚本或事务确保检查和删除的原子性，避免误删其他客户端的锁。
代码示例

以下是一个基于 Spring Data Redis 的分布式锁实现：

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

import java.util.concurrent.TimeUnit;
import java.util.UUID;

@Component
public class RedisLockUtil {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    private static final String LOCK_KEY_PREFIX = "lock:";

    /**
     * 尝试获取分布式锁
     * @param lockName 锁名称
     * @param lockValue 锁值（唯一标识，如 UUID）
     * @param expireTime 锁过期时间（秒）
     * @return true：获取成功；false：获取失败
     */
    public boolean tryLock(String lockName, String lockValue, long expireTime) {
        String lockKey = LOCK_KEY_PREFIX + lockName;
        Boolean success = redisTemplate.opsForValue().setIfAbsent(lockKey, lockValue, expireTime, TimeUnit.SECONDS);
        return success != null && success;
    }

    /**
     * 释放分布式锁
     * @param lockName 锁名称
     * @param lockValue 锁值（用于验证是否为持有者）
     */
    public void unlock(String lockName, String lockValue) {
        String lockKey = LOCK_KEY_PREFIX + lockName;
        String currentValue = redisTemplate.opsForValue().get(lockKey);
        if (lockValue.equals(currentValue)) {
            redisTemplate.delete(lockKey);
        }
    }

    /**
     * 重试获取锁（带等待时间）
     * @param lockName 锁名称
     * @param lockValue 锁值
     * @param expireTime 锁过期时间（秒）
     * @param timeout 等待超时时间（毫秒）
     * @param retryInterval 重试间隔（毫秒）
     * @return true：获取成功；false：超时未获取
     * @throws InterruptedException 中断异常
     */
    public boolean tryLockWithRetry(String lockName, String lockValue, long expireTime, long timeout, long retryInterval) 
            throws InterruptedException {
        String lockKey = LOCK_KEY_PREFIX + lockName;
        long startTime = System.currentTimeMillis();
        
        while (System.currentTimeMillis() - startTime < timeout) {
            if (tryLock(lockName, lockValue, expireTime)) {
                return true;
            }
            Thread.sleep(retryInterval); // 等待后重试
        }
        return false;
    }
}
使用示例

以下是如何在业务中使用分布式锁的代码：

@Autowired
private RedisLockUtil redisLockUtil;

public void processResource() throws InterruptedException {
    String lockName = "resource_lock";
    String lockValue = UUID.randomUUID().toString();
    long expireTime = 30; // 锁过期时间 30 秒

    // 简单获取锁
    if (redisLockUtil.tryLock(lockName, lockValue, expireTime)) {
        try {
            System.out.println("锁获取成功，开始处理资源...");
            // 执行临界区代码
            Thread.sleep(5000); // 模拟耗时操作
        } finally {
            redisLockUtil.unlock(lockName, lockValue);
            System.out.println("锁已释放");
        }
    } else {
        System.out.println("锁获取失败");
    }

    // 带重试机制获取锁
    long timeout = 10000; // 等待 10 秒
    long retryInterval = 500; // 每 500 毫秒重试一次
    if (redisLockUtil.tryLockWithRetry(lockName, lockValue, expireTime, timeout, retryInterval)) {
        try {
            System.out.println("通过重试获取锁成功，开始处理...");
        } finally {
            redisLockUtil.unlock(lockName, lockValue);
        }
    } else {
        System.out.println("重试超时，锁获取失败");
    }
}

注意事项与最佳实践

  1. 锁过期时间设置

    • 设置合理的过期时间（如 30 秒），太短可能导致任务未完成锁就释放，太长则可能延长死锁恢复时间。
    • 可结合业务逻辑动态调整，或实现锁续期机制（如 Redisson 的 Watchdog）。

  2. 锁的唯一性

    • 使用 UUID 或其他唯一标识作为锁值，确保释放时不会误删其他客户端的锁。

  3. 高并发下的锁竞争

    • 在高并发场景中，建议引入重试机制（如指数退避算法），避免客户端频繁请求加重 Redis 负担。

  4. 锁重入问题

    • Redis Cluster 原生的分布式锁不支持重入（即同一客户端重复获取锁）。若需支持重入，可在业务层记录锁状态，或使用 Redisson 框架。

  5. 集群故障与锁丢失

    • Redis Cluster 的主节点故障转移可能导致锁丢失（因异步复制未同步锁数据）。对于强一致性需求，可结合其他机制（如 Zookeeper）或评估业务容忍度。

  6. 性能优化

    • 减少锁的粒度（如按资源 ID 加锁而非全局锁），提高并发性能。
    • 使用 Lua 脚本确保释放锁的原子性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值