Spring Boot 项目中 Redis 常见问题及解决方案

1. 缓存穿透

问题描述

缓存穿透是指查询一个不存在的数据，由于缓存中没有该数据，请求会直接打到数据库上，导致数据库压力过大。

解决方案

缓存空值：即使查询的数据不存在，也将空值缓存起来，并设置一个较短的过期时间。
布隆过滤器：在查询缓存之前，先通过布隆过滤器判断数据是否存在。

示例代码

@Service
public class UserService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public User getUserById(Long id) {
        String key = "user:" + id;
        // 从缓存中获取数据
        User user = (User) redisTemplate.opsForValue().get(key);
        if (user != null) {
            return user;
        }

        // 缓存中不存在，查询数据库
        user = userRepository.findById(id).orElse(null);
        if (user == null) {
            // 缓存空值，设置较短的过期时间
            redisTemplate.opsForValue().set(key, null, 60, TimeUnit.SECONDS);
        } else {
            // 缓存查询结果
            redisTemplate.opsForValue().set(key, user, 1, TimeUnit.HOURS);
        }
        return user;
    }
}

2. 缓存雪崩

问题描述

缓存雪崩是指大量缓存数据在同一时间失效，导致所有请求都打到数据库上，造成数据库压力过大甚至崩溃。

解决方案

设置不同的过期时间：为缓存数据设置随机的过期时间，避免大量缓存同时失效。
使用分布式锁：在缓存失效时，使用分布式锁保证只有一个线程去加载数据。

示例代码

@Service
public class ProductService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private RedissonClient redissonClient;

    public Product getProductById(Long id) {
        String key = "product:" + id;
        Product product = (Product) redisTemplate.opsForValue().get(key);
        if (product != null) {
            return product;
        }

        // 使用分布式锁防止缓存击穿
        RLock lock = redissonClient.getLock("lock:" + key);
        try {
            lock.lock();
            // 双重检查，防止其他线程已经加载了数据
            product = (Product) redisTemplate.opsForValue().get(key);
            if (product != null) {
                return product;
            }

            // 查询数据库
            product = productRepository.findById(id).orElse(null);
            if (product != null) {
                // 设置随机的过期时间
                int expireTime = 3600 + new Random().nextInt(600); // 1小时 + 随机10分钟
                redisTemplate.opsForValue().set(key, product, expireTime, TimeUnit.SECONDS);
            }
        } finally {
            lock.unlock();
        }
        return product;
    }
}

3. 缓存击穿

问题描述

缓存击穿是指某个热点数据在缓存中失效后，大量请求同时打到数据库上，导致数据库压力过大。

解决方案

使用互斥锁：在缓存失效时，使用互斥锁保证只有一个线程去加载数据。
永不过期策略：对热点数据设置永不过期，通过后台任务定期更新缓存。

示例代码

@Service
public class HotDataService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public String getHotData() {
        String key = "hot_data";
        String data = (String) redisTemplate.opsForValue().get(key);
        if (data != null) {
            return data;
        }

        // 使用 Redis 的 SETNX 实现互斥锁
        String lockKey = "lock:" + key;
        boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, "locked", 10, TimeUnit.SECONDS);
        if (locked) {
            try {
                // 双重检查
                data = (String) redisTemplate.opsForValue().get(key);
                if (data != null) {
                    return data;
                }

                // 模拟从数据库加载热点数据
                data = loadHotDataFromDB();
                redisTemplate.opsForValue().set(key, data, 1, TimeUnit.HOURS);
            } finally {
                // 释放锁
                redisTemplate.delete(lockKey);
            }
        } else {
            // 未获取到锁，等待重试
            try {
                Thread.sleep(100);
                return getHotData(); // 重试
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        return data;
    }

    private String loadHotDataFromDB() {
        // 模拟数据库查询
        return "hot_data_from_db";
    }
}

4. Redis 连接池耗尽

问题描述

在高并发场景下，Redis 连接池可能会被耗尽，导致请求失败。

解决方案

增加连接池大小：根据实际需求调整连接池的最大连接数。
优化连接使用：确保每次操作 Redis 后及时释放连接。

示例代码

在 application.yml 中配置连接池：

spring:
  redis:
    host: localhost
    port: 6379
    lettuce:
      pool:
        max-active: 50  # 最大连接数
        max-idle: 10   # 最大空闲连接数
        min-idle: 5    # 最小空闲连接数

5. Redis 序列化问题

问题描述

默认情况下，Spring Boot 使用 JdkSerializationRedisSerializer 进行序列化，可能导致存储的数据不易阅读或兼容性问题。

解决方案

使用更高效的序列化方式，如 Jackson2JsonRedisSerializer 或 StringRedisSerializer。

示例代码

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        // 使用 Jackson2JsonRedisSerializer 序列化值
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        template.setValueSerializer(serializer);
        template.setHashValueSerializer(serializer);

        // 使用 StringRedisSerializer 序列化键
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());

        return template;
    }
}