SpringBoot4整合Redis的缓存实战:序列化配置与多级缓存详解
作者:gis开发之家
缓存是高并发系统的"第一道防线"。本文将系统讲解 Spring Cache 抽象、Redis 整合、缓存三大问题(穿透/击穿/雪崩)的解决方案、多级缓存与分布式锁,帮你构建生产级缓存体系。
一、为什么要用缓存?
没有缓存的痛点
用户请求 → Controller → Service → 数据库(磁盘 I/O)
↑
每次都查 DB
响应慢、数据库压力大
加了缓存之后
用户请求 → Controller → Service → Cache(内存/Redis)
↓(命中)返回
↓(未命中)→ 数据库 → 回填缓存
效果:
- 响应时间:50ms → 2ms
- 数据库 QPS:10000 → 500
二、Spring Cache 抽象:一套 API 适配所有缓存
核心注解
| 注解 | 作用 | 类比 SQL |
|---|---|---|
@Cacheable | 先查缓存,没有再执行方法 | SELECT |
@CachePut | 执行方法后更新缓存 | UPDATE |
@CacheEvict | 删除缓存 | DELETE |
@Caching | 组合多个缓存操作 | 复合操作 |
@CacheConfig | 类级别公共配置 | — |
开启缓存
@SpringBootApplication
@EnableCaching
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}@Cacheable 实战
@Service
public class UserService {
@Autowired
private UserMapper userMapper;
@Cacheable(value = "user", key = "#id", unless = "#result == null")
public User getUserById(Long id) {
System.out.println("查询数据库..."); // 只有缓存未命中时才打印
return userMapper.selectById(id);
}
}调用两次:
userService.getUserById(1L); // 打印"查询数据库..." userService.getUserById(1L); // 不打印,直接从缓存返回
key 生成策略
@Cacheable(value = "user", key = "#id")
// key = "user::1"
@Cacheable(value = "user", key = "#root.methodName + ':' + #id")
// key = "user::getUserById:1"
@Cacheable(value = "user", key = "T(String).format('%s:%s', #id, #type)")
// key = "user::1:vip"@CachePut 更新缓存
@CachePut(value = "user", key = "#user.id")
public User updateUser(User user) {
userMapper.updateById(user);
return user; // 返回值自动写入缓存
}@CacheEvict 删除缓存
@CacheEvict(value = "user", key = "#id")
public void deleteUser(Long id) {
userMapper.deleteById(id);
}
// 删除整个分区
@CacheEvict(value = "user", allEntries = true)
public void clearUserCache() {}三、Spring Boot 4 整合 Redis
引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 连接池(推荐 Lettuce + commons-pool2) -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>配置(application.yml)
spring:
data:
redis:
host: localhost
port: 6379
password:
database: 0
timeout: 5000ms
lettuce:
pool:
max-active: 16
max-idle: 8
min-idle: 2
max-wait: 3000ms序列化配置(非常重要!)
默认 JDK 序列化会导致 Redis 中数据不可读,必须自定义:
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(factory);
// Key 用 String 序列化
StringRedisSerializer keySerializer = new StringRedisSerializer();
template.setKeySerializer(keySerializer);
template.setHashKeySerializer(keySerializer);
// Value 用 JSON 序列化(Jackson)
Jackson2JsonRedisSerializer<Object> valueSerializer =
new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JavaTimeModule());
valueSerializer.setObjectMapper(mapper);
template.setValueSerializer(valueSerializer);
template.setHashValueSerializer(valueSerializer);
template.afterPropertiesSet();
return template;
}
}✅ 配置后 Redis 中数据:
key: user::1
value: {"id":1,"username":"zhangsan","email":"zs@test.com"}直接使用 RedisTemplate
@Service
public class CacheService {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
public void set(String key, Object value, long expireSeconds) {
redisTemplate.opsForValue().set(key, value, Duration.ofSeconds(expireSeconds));
}
public Object get(String key) {
return redisTemplate.opsForValue().get(key);
}
public void delete(String key) {
redisTemplate.delete(key);
}
public Boolean hasKey(String key) {
return redisTemplate.hasKey(key);
}
}四、缓存穿透、击穿、雪崩(三大杀手)
缓存穿透:查不存在的数据
场景: 恶意请求 id = -1、id = 999999999
请求 → 缓存(没有)→ 数据库(没有)→ 每次都打到 DB
解决方案1:缓存空值
@Cacheable(value = "user", key = "#id", unless = "#result == null")
public User getUserById(Long id) {
User user = userMapper.selectById(id);
if (user == null) {
// 缓存空值,过期时间短一些
redisTemplate.opsForValue().set("user::" + id, "", Duration.ofMinutes(5));
}
return user;
}解决方案2:布隆过滤器
// 启动时将所有存在的 ID 加入布隆过滤器
@PostConstruct
public void init() {
List<Long> allIds = userMapper.selectAllIds();
allIds.forEach(id -> bloomFilter.put(id));
}
public User getUserById(Long id) {
if (!bloomFilter.mightContain(id)) {
return null; // 一定不存在
}
return userMapper.selectById(id);
}缓存击穿:热点 Key 过期瞬间
场景: 某个热点数据(如首页推荐)过期瞬间,大量并发请求同时打到 DB
解决方案1:互斥锁(Mutex)
public User getUserById(Long id) {
String key = "user::" + id;
User user = (User) redisTemplate.opsForValue().get(key);
if (user != null) {
return user;
}
// 尝试获取锁
String lockKey = "lock::" + key;
Boolean locked = redisTemplate.opsForValue()
.setIfAbsent(lockKey, "1", Duration.ofSeconds(10));
if (locked != null && locked) {
try {
// 双重检查
user = (User) redisTemplate.opsForValue().get(key);
if (user != null) {
return user;
}
// 查数据库
user = userMapper.selectById(id);
redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
return user;
} finally {
redisTemplate.delete(lockKey); // 释放锁
}
} else {
// 没拿到锁,稍等重试
Thread.sleep(100);
return getUserById(id); // 递归重试
}
}解决方案2:逻辑过期(不设物理过期)
// 缓存永不过期,后台异步更新
@Scheduled(fixedRate = 1800000) // 每 30 分钟更新
public void refreshHotData() {
List<Long> hotIds = getHotUserIds();
hotIds.forEach(id -> {
User user = userMapper.selectById(id);
redisTemplate.opsForValue().set("user::" + id, user);
});
}缓存雪崩:大量 Key 同时过期
场景: 大批缓存同时过期 → 请求全部打到 DB → DB 崩溃
解决方案:过期时间加随机值
int baseExpire = 30; // 基础 30 分钟 int randomExpire = new Random().nextInt(10); // 随机 0-10 分钟 redisTemplate.opsForValue().set(key, value, Duration.ofMinutes(baseExpire + randomExpire));
解决方案:集群 + 哨兵 + 限流
五、多级缓存(Caffeine + Redis)
架构
请求 → Caffeine(本地缓存,L1)→ Redis(分布式缓存,L2)→ 数据库
↑ 命中率 90%+ ↑ 命中率 99%+
纳秒级 毫秒级
整合 Caffeine
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
</dependency>配置
@Configuration
public class CacheConfig {
@Bean
public Cache<String, Object> caffeineCache() {
return Caffeine.newBuilder()
.maximumSize(10000) // 最大条目
.expireAfterWrite(Duration.ofMinutes(10)) // 写入后过期
.recordStats() // 统计
.build();
}
}多级缓存 Service
@Service
public class MultiLevelCacheService {
@Autowired
private Cache<String, Object> caffeineCache;
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Autowired
private UserMapper userMapper;
public User getUser(Long id) {
String key = "user::" + id;
// L1: Caffeine
Object cached = caffeineCache.getIfPresent(key);
if (cached != null) {
return (User) cached;
}
// L2: Redis
cached = redisTemplate.opsForValue().get(key);
if (cached != null) {
caffeineCache.put(key, cached); // 回填 L1
return (User) cached;
}
// 数据库
User user = userMapper.selectById(id);
if (user != null) {
redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
caffeineCache.put(key, user);
}
return user;
}
}六、分布式锁(Redisson)
引入依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.32.0</version>
</dependency>配置
@Configuration
public class RedissonConfig {
@Value("${spring.data.redis.host}")
private String host;
@Value("${spring.data.redis.port}")
private int port;
@Bean
public RedissonClient redissonClient() {
Config config = new Config();
config.useSingleServer()
.setAddress("redis://" + host + ":" + port)
.setConnectionPoolSize(16);
return Redisson.create(config);
}
}使用分布式锁
@Service
public class StockService {
@Autowired
private RedissonClient redissonClient;
@Autowired
private StockMapper stockMapper;
public boolean deductStock(Long productId, int count) {
RLock lock = redissonClient.getLock("stock:" + productId);
try {
// 尝试加锁,最多等待 3 秒,锁 10 秒后自动释放
boolean acquired = lock.tryLock(3, 10, TimeUnit.SECONDS);
if (!acquired) {
return false; // 获取锁失败
}
// 核心业务逻辑
Stock stock = stockMapper.selectById(productId);
if (stock.getCount() < count) {
return false;
}
stock.setCount(stock.getCount() - count);
stockMapper.updateById(stock);
return true;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return false;
} finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock(); // 释放锁
}
}
}
}Redisson 锁特性:
- 自动续期(看门狗机制)
- 可重入
- 公平锁 / 读写锁 / 红锁
七、缓存最佳实践清单
| 实践 | 说明 |
|---|---|
| ✅ 设置过期时间 | 防止内存泄漏 |
| ✅ 过期时间加随机值 | 防止雪崩 |
| ✅ 缓存空值 | 防止穿透 |
| ✅ 热点数据互斥锁 | 防止击穿 |
| ✅ 先更新 DB,再删缓存 | Cache Aside 模式 |
| ✅ 批量操作使用 Pipeline | 减少网络往返 |
| ✅ 大 Value 拆分 | 防止网络阻塞 |
| ✅ 监控命中率 | 低于 80% 需优化 |
八、Spring Boot 4 新变化
spring-boot-starter-data-redis默认 Lettuce- 对
java.time序列化支持开箱即用 - AOT 模式下 Redis 序列化器兼容性提升
九、常见坑位总结
坑1:缓存雪崩
过期时间加随机值
坑2:缓存与数据库不一致
更新策略:先更 DB → 再删缓存(延时双删更安全)
坑3:Redis 中存 JDK 序列化乱码
自定义 JSON 序列化
坑4:@Cacheable 在同类方法自调用失效
同 @Transactional,用代理对象调用
坑5:大 Key 导致 Redis 阻塞
Value 控制在 10KB 以内,超过拆分
十、本篇总结
- Spring Cache 抽象:@Cacheable / @CachePut / @CacheEvict
- Redis 必须配置 JSON 序列化
- 穿透 → 缓存空值 / 布隆过滤器
- 击穿 → 互斥锁 / 逻辑过期
- 雪崩 → 过期时间加随机值 + 集群
- 分布式锁用 Redisson,别自己实现 SETNX
以上就是SpringBoot4整合Redis的缓存实战:序列化配置与多级缓存详解的详细内容,更多关于SpringBoot整合Redis缓存的资料请关注脚本之家其它相关文章!
