Redis框架在项目中的实战

<!-- Spring Boot 整合 Redis（默认内置 Lettuce） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- Redisson 核心依赖（适配 Spring Boot） -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.23.0</version> <!-- 选稳定版本 -->
</dependency>

redis.lettuce.client.enable=true # 启用Lettuce客户端
# 连接池配置（核心）
redis.lettuce.client.pool.minIdle=6 # 最小空闲连接（保活）
redis.lettuce.client.pool.maxIdle=21 # 最大空闲连接
redis.lettuce.client.pool.maxTotal=100 # 最大连接数
redis.lettuce.client.pool.maxWaitMillis=4000 # 最大等待时间
redis.lettuce.client.sentinel.mastername=master # 监控的主节点名称
redis.lettuce.client.sentinel.password=***
redis.lettuce.client.sentinel.database=0
redis.lettuce.client.sentinel.nodeInfo[0]=10.193.114.0:26379 # 哨兵节点列表
redis.lettuce.client.sentinel.nodeInfo[0]=10.193.114.2:26379 # 哨兵节点列表
redis.lettuce.client.sentinel.nodeInfo[0]=10.193.114.3:26379 # 哨兵节点列表

@Component
public class CacheService {
    // 注入 Spring 封装的 RedisTemplate（底层是 Lettuce）
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    // 存储合约基础信息（String 类型）
    public void setTestInfo(String testKey, Object testInfo) {
        // 底层通过 Lettuce 发送 SET 命令到 Redis 哨兵集群
        redisTemplate.opsForValue().set(
            testKey, 
            testInfo, 
            1, // 过期时间 1 小时
            TimeUnit.HOURS
        );
    }

    public Object getTestInfo(String testKey) {
        // 底层通过 Lettuce 发送 GET 命令
        return redisTemplate.opsForValue().get(testKey);
    }

    // 异步操作（Lettuce 核心优势，高并发场景用）
    public void setTestInfoAsync(String testKey, Object testInfo) {
        // 异步设置，不阻塞主线程（高并发场景推荐）
        redisTemplate.opsForValue().setAsync(testKey, testInfo);
    }
}

@Component
public class TestMapService {
    // 注入 RedissonClient（底层复用 Lettuce 连接）
    @Resource
    private RedissonClient redissonClient;

    // 批量存储合约信息到分布式 Map
    public void batchSaveTestInfo(List<TestInfoPO> testList) {
        // 获取 Redis 中的分布式 Map（INFO:TEST_KEY）
        RMap<String, TestInfoPO> testMap = 
            redissonClient.getMap("INFO:TEST_KEY");
        
        // 批量存入：INFO:TEST_KEY
        testList.forEach(d -> {
            String key = ...
            testMap.put(key, d); // 原子操作，线程安全
        });
    }

    // 获取单个test信息
    public TestInfoPO getTestInfo(String testId) {
        RMap<String, TestInfoPO> testMap = redissonClient.getMap("INFO:TEST_KEY");
        String key = ...;
        return testMap.get(key);
    }
}

@Component
public class UpdateService {
    @Resource
    private RedissonClient redissonClient;

    // 修改（加分布式锁）
    public void updateTestInfo(String testtId, TestInfoPO newInfo) {
        // 1. 定义锁的唯一标识
        String lockKey = "lock:test:update:" + testId;
        RLock lock = redissonClient.getLock(lockKey);

        try {
            // 2. 获取锁：最多等5秒，持有锁10秒（自动释放，防止死锁）
            boolean locked = lock.tryLock(5, 10, TimeUnit.SECONDS);
            if (!locked) {
                throw new RuntimeException("正在修改中，请稍后重试");
            }

            // 3. 执行业务逻辑
            // ... 你的更新数据库/缓存逻辑 ...

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("获取锁失败", e);
        } finally {
            // 4. 释放锁（必须在 finally 中，防止锁泄露）
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // 设置 JSON 序列化器
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        template.setValueSerializer(serializer);
        template.setKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }
}