SpringBoot整合Redis实现查询缓存（缓存穿透、缓存雪崩、缓存击穿概念及其解决方法，缓存工具封装）
文章目录
- 一、基本流程
- 二、缓存更新策略的方案
- 三、基础代码实现
-
- 1. 读操作
-
-
- 1.1 示例1：商铺信息缓存
- 1.2 示例2：商铺类别列表缓存
-
- 2. 写操作
-
-
- 2.1 示例3：更新商铺信息
-
- 四、缓存穿透(理论)
-
- 4.1 解决方案
-
-
- 4.1.1 被动解决
- 4.1.2 主动方式
-
- 4.2 代码修改
- 五、缓存雪崩(理论)
-
- 解决方案
- 六、缓存击穿(理论)
-
- 6.1 解决方案
- 6.2 解决代码
-
-
- 6.2.1基于互斥锁方式解决缓存击穿问题
-
-
- 6.2.1.1 具体流程
- 6.2.1.1 代码示例：商铺查询
-
- 6.2.2基于逻辑过期方式解决缓存击穿问题
-
-
- 6.2.1.1 具体流程
- 6.2.1.1 代码实现
-
-
- 八、缓存工具封装
-
- 8.1 如何封装
- 8.2 代码
一、基本流程
- 用户访问数据，即浏览该页面
- 渲染该页面数据的后端，首先查看redis中是否有这部分数据
- 有则直接从redis中查出来，返回给前端渲染
- 没有数据则从数据库中获取，返回给前端，并将数据存入redis中
二、缓存更新策略的方案
- 低一致性需求：使用Redis自带的内存淘汰机制
- 高一致性需求：主动更新，并以超时剔除作为兜底方案
- 读操作：缓存命中直接返回；缓存未命中则查询数据库，并写入缓存，设定超时时间
- 写操作：先写数据库，然后再删除缓存，要确保数据库与缓存操作的原子性
三、基础代码实现
1. 读操作
1.1 示例1：商铺信息缓存
@Resource
private StringRedisTemplate stringRedisTemplate;
@Override
public Result queryById(Long id) {
//1. 从redis红查询商铺缓存
String key = RedisConstants.CACHE_SHOP_KEY + id;
String shopJson = stringRedisTemplate.opsForValue().get(key);
//2. 判断是否存在
if(StringUtils.isNotBlank(shopJson)){
//存在，直接返回
Shop shop = JSONUtil.toBean(shopJson, Shop.class);
return Result.ok(shop);
}
//3. 判断命中是否是空值
if(shopJson !=null){
//返回错误信息
return Result.fail("店铺信息不存在");
}
//4. 不存在，根据id查询数据库
Shop shop = this.getById(id);
//5. 数据库不存在，返回错误
if(shop == null){
//5.1 将空值写入redis
stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
//5.2 返回错误信息
return Result.fail("店铺不存在");
}
//6. 存在，写入redis
stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
//7. 返回
return Result.ok(shop);
}
1.2 示例2：商铺类别列表缓存
@Resource
private StringRedisTemplate stringRedisTemplate;
@Override
public Result queryList() {
//1. 从Redis中查
String key = RedisConstants.CACHE_SHOP_TYPE_LIST;
Boolean hasKey = stringRedisTemplate.hasKey(key);
//2. redis中存在即返回
if(hasKey){
List<String> range = stringRedisTemplate.opsForList().range(key, 0, -1);
List<ShopType> shopTypeList = range.stream()
.map(item -> JSONUtil.toBean(item,ShopType.class))
.sorted(Comparator.comparingInt(ShopType::getSort))
.collect(Collectors.toList());
return Result.ok(shopTypeList);
}
//3. redis中不存在，即查数据库
List<ShopType> typeList = this.lambdaQuery().orderByAsc(ShopType::getSort).list();
//4. 写入redis中一份
//4.1 假如mysql中也为空，则存一份空，创建key，防止缓存穿透
if(CollectionUtils.isEmpty(typeList)){
stringRedisTemplate.opsForValue()
.set(key, Collections.emptyList().toString(),RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
return Result.fail("商铺分类信息为空");
}
//4.2 数据存在，写入缓存
List<String> cache = typeList.stream()
.sorted(Comparator.comparingInt(ShopType::getSort))
.map(JSONUtil::toJsonStr)
.collect(Collectors.toList());
stringRedisTemplate.opsForList().rightPushAll(key,cache);
stringRedisTemplate.expire(key,RedisConstants.CACHE_SHOP_TYPE_TTL,TimeUnit.MINUTES);
//返回数据
return Result.ok(typeList);
}
2. 写操作
2.1 示例3：更新商铺信息
@Override
@Transactional
public Result updateShop(Shop shop) {
Long id = shop.getId();
if(id == null) {
return Result.fail("店铺id不能为空");
}
//1. 更新数据库
this.updateById(shop);
//2. 删除缓存
stringRedisTemplate.delete(RedisConstants.CACHE_SHOP_KEY+id);
return Result.ok();
}
四、缓存穿透(理论)
上文代码已处理该问题。
缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存就永远不会生效，这些请求都会打到数据库，给数据库带来巨大压力
4.1 解决方案
4.1.1 被动解决
- 缓存空对象：若redis和数据库中均没有，在redis中创建一个空对象(短期TTL)，即返回一个空值。
- 优点：实现简单，维护方便
- 缺点：额外的内存消耗、可能造成短期的不一致
- 布隆过滤：一种算法。在客户端和redis之间加入一层布隆过滤器，客户端先访问布隆过滤器，不存在则布隆过滤器直接拒绝。
- 优点：内存占用少，没有多余key
- 缺点：实现复杂、存在误判风险
4.1.2 主动方式
- 增强id的复杂度，避免被猜到id规律
- 做好数据的基础格式校验(主要是在前端做)
- 加强用户权限校验
- 做好热点参数的限流
4.2 代码修改
- 若信息在redis和数据库都不存在时，将空值写入redis
- 当redis命中时，判断是否为空值
五、缓存雪崩(理论)
缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量请求达到数据库，带来巨大压力。
解决方案
- 给不同的key的TTL添加随机值
- 利用Redis集群提高服务的可用性
- 给缓存业务添加降级限流策略
- 给业务添加多级缓存
六、缓存击穿(理论)
缓存击穿问题也称热点key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求瞬间给数据库带来巨大的冲击。
6.1 解决方案
- 互斥锁：只有获取互斥锁的人才可以重建缓存数据，重建后释放锁；未获取到互斥锁的线程，进行休眠，一会儿后再重试。
- 优点：没有额外的内存消耗、保持一致、实现简单
- 缺点：线程需要等待，性能受到影响、可能有死锁风险
- 逻辑过期：给热点key不再设置TTL，改为添加一个过期时间字段，进行逻辑维护。当查询缓存时，发现逻辑时间已经过期，则获取互斥锁，开启一个新的线程进行更新数据，更新完释放锁，在更新完毕之前获取的都是旧数据。
- 优点：线程无需等待，性能较好
- 缺点：不保证一致性、有额外内存消耗、实现复杂
6.2 解决代码
6.2.1基于互斥锁方式解决缓存击穿问题
6.2.1.1 具体流程
- 首先从redis中查询商铺缓存
- 加入缓存存在则直接返回，若不存在则判断其命中值是否非空
- 若命中值非空，则代表该数据是redis和数据库中均没有的值，且redis已经设置了一个值为空的数据防止缓存穿透对数据库产生高压，直接返回null即可；若命中值为空，则开始互斥锁方式缓存重建
- 缓存重建，第一个进行缓存重建的线程拿到互斥锁，进行查库，若库中也无，则创建一个值为空的key防止缓存穿透，若库中有，则存一遍redis；没有拿到锁但是进入缓存重建的程序，进行等待，等拿到互斥锁的线程放开锁，当拿到锁的时候缓存已经重建好了，但有双重校验机制，则不再进行缓存重建，直接拿到redis中的数据返回
6.2.1.1 代码示例：商铺查询
@Override
public Result queryById(Long id) {
Shop shop = queryWithMutex(id);
if(shop==null){
return Result.fail("店铺不存在");
}
//7. 返回
return Result.ok(shop);
}
public Shop queryWithMutex(Long id){
//1. 从redis中查询商铺缓存
String key = RedisConstants.CACHE_SHOP_KEY + id;
String shopJson = stringRedisTemplate.opsForValue().get(key);
//2. 判断是否存在
if(StringUtils.isNotBlank(shopJson)){
//存在，直接返回
return JSONUtil.toBean(shopJson, Shop.class);
}
//3. 判断命中是否是空值
if(shopJson !=null){
//返回错误信息
return null;
}
//4. 开始实现缓存重建
//4.1 获取互斥锁
String lockKey = "lock:shop:"+id;
Shop shop = null;
try{
Boolean isLock = tryLock(lockKey);
//4.2 判断是否获取成功
while (!isLock) {
//4.3 失败，休眠并重试
Thread.sleep(50);
}
//doubleCheck
key = RedisConstants.CACHE_SHOP_KEY + id;
shopJson = stringRedisTemplate.opsForValue().get(key);
if (StringUtils.isNotBlank(shopJson)) {
return JSONUtil.toBean(shopJson, Shop.class);
}
if (shopJson != null) {
return null;
}
//4.3 成功，根据id查询数据库
shop = this.getById(id);
//5. 数据库不存在，返回错误
if (shop == null) {
//5.1 将空值写入redis
stringRedisTemplate.opsForValue().set(key, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
//5.2 返回错误信息
return null;
}
//6. 存在，写入redis
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
}catch (InterruptedException e){
throw new RuntimeException(e);
}finally {
//7.释放互斥锁
unLock(lockKey);
}
//8. 返回
return shop;
}
//获取锁
private Boolean tryLock(String key){
Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
return BooleanUtil.isTrue(flag);
}
//释放锁
private void unLock(String key){
stringRedisTemplate.delete(key);
}
6.2.2基于逻辑过期方式解决缓存击穿问题
6.2.1.1 具体流程
- 首先从redis中获取缓存数据，如果不存在直接返回null；若存在，进行下一步
- 首先将拿到的数据反序列化为能用的数据，然后判断其中的超时时间是否在当前时间之后，若是，则直接返回数据，若不是，则开始缓存重建
- 首先判断是否拿到互斥双检锁，没拿到锁直接拿着旧数据返回，拿到锁则开辟一个另外的线程进行缓存重建，也是先返回旧数据。
6.2.1.1 代码实现
@Data
public class RedisData {
private LocalDateTime expireTime;
private Object data;
}
@Resource
private StringRedisTemplate stringRedisTemplate;
@Override
public Result queryById(Long id) {
Shop shop = queryWithExpire(id);
//7. 返回
return Result.ok(shop);
}
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
//逻辑过期方法
public Shop queryWithExpire(Long id){
//1. 从redis中查询商铺缓存
String key = RedisConstants.CACHE_SHOP_KEY + id;
String shopJson = stringRedisTemplate.opsForValue().get(key);
//2. 判断是否存在
if(StringUtils.isBlank(shopJson)){
//3. 不存在，直接返回
return null;
}
//4. 命中，需要先把json反序列化为对象
RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
Shop shop = JSONUtil.toBean((JSONObject)redisData.getData(), Shop.class);
LocalDateTime expireTime = redisData.getExpireTime();
//5. 判断是否过期
if(expireTime.isAfter(LocalDateTime.now())){
//5.1 未过期，直接返回
return shop;
}
//5.2 已过期，需要重新缓存重建
//6. 缓存重建
//6.1 获取互斥锁
String lockKey = RedisConstants.LOCK_SHOP_KEY+id;
Boolean isLock = tryLock(lockKey);
//6.2 判断是否获取锁成功
if (isLock){
//doubleCheck
redisData = JSONUtil.toBean(shopJson, RedisData.class);
expireTime = redisData.getExpireTime();
if(expireTime.isAfter(LocalDateTime.now())){
return shop;
}
//6.3 成功，开启独立线程，实现缓存重建
CACHE_REBUILD_EXECUTOR.submit(()->{
try {//重建缓存
this.saveShop2Redis(id,30*60L);
}catch (Exception e){
throw new RuntimeException(e);
}finally {//释放锁
unLock(lockKey);
}
});
}
//6.4 返回过期的商铺信息
return shop;
}
//存储逻辑过期函数
public void saveShop2Redis(Long id,Long expireSeconds){
//1. 查询店铺数据
Shop shop = getById(id);
//2. 封装逻辑过期时间
RedisData redisData = new RedisData();
redisData.setData(shop);
redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
//3. 写入redis
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(redisData));
}
八、缓存工具封装
8.1 如何封装
- 方法1：将任意java对象序列化为json并存储在string类型的key中，并可以设置TTL过期时间
- 方法2：将任意java对象序列化为json并存储在string类型的key中，并可以设置逻辑过期时间，用于解决缓存击穿问题
- 方法3：根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
- 方法4：根据指定的key查询缓存，并反序列化为指定类型，需要用逻辑过期来解决缓存击穿问题
8.2 代码
基本就是上文代码改泛型。
@Component
@Slf4j
public class CacheClient {
private StringRedisTemplate stringRedisTemplate;
public CacheClient(StringRedisTemplate stringRedisTemplate){
this.stringRedisTemplate = stringRedisTemplate;
}
public void set(String key, Object value, Long time, TimeUnit unit){
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,unit);
}
public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit){
RedisData redisData = new RedisData();
redisData.setData(value);
redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData),time,unit);
}
public <R,ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback, Long time, TimeUnit unit){
String key = keyPrefix + id;
String json = stringRedisTemplate.opsForValue().get(key);
if(StringUtils.isNotBlank(json)){
return JSONUtil.toBean(json, type);
}
if(json != null){
return null;
}
R r = dbFallback.apply(id);
if(r == null){
stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
//5.2 返回错误信息
return null;
}
//6. 存在，写入redis
this.set(key,r,time,unit);
return r;
}
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
public <R, ID> R queryWithLogicExpire(String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback, Long time, TimeUnit unit){
String key = RedisConstants.CACHE_SHOP_KEY + id;
String shopJson = stringRedisTemplate.opsForValue().get(key);
if(StringUtils.isBlank(shopJson)){
return null;
}
RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
R r = JSONUtil.toBean((JSONObject)redisData.getData(), type);
LocalDateTime expireTime = redisData.getExpireTime();
if(expireTime.isAfter(LocalDateTime.now())){
return r;
}
String lockKey = RedisConstants.LOCK_SHOP_KEY+id;
Boolean isLock = tryLock(lockKey);
if (isLock){
redisData = JSONUtil.toBean(shopJson, RedisData.class);
expireTime = redisData.getExpireTime();
if(expireTime.isAfter(LocalDateTime.now())){
return r;
}
CACHE_REBUILD_EXECUTOR.submit(()->{
try {//重建缓存
R r1 = dbFallback.apply(id);
this.setWithLogicalExpire(key,r1,time,unit);
}catch (Exception e){
throw new RuntimeException(e);
}finally {//释放锁
unLock(lockKey);
}
});
}
return r;
}
//获取锁
private Boolean tryLock(String key){
Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
return BooleanUtil.isTrue(flag);
}
//释放锁
private void unLock(String key){
stringRedisTemplate.delete(key);
}
}