Loading

Redis缓存

什么是缓存

缓存就是数据交换的缓冲区(称作Cache),是存贮数据的临时地方,一般读写性能较高。

缓存的作用

  • 降低后端负载
  • 提高读写效率,降低响应时间

缓存的成本

  • 数据一致性成本
  • 代码维护成本
  • 运维成本

添加Redis缓存

缓存工作模型

代码实现

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;

public static final String CACHE_SHOP_KEY = "cache:shop:";

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Shop queryById(Long id) {
        String key = RedisConstants.CACHE_SHOP_KEY + id;
        // 从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        // 判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            // 存在
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return shop;
        }
        // 不存在,查询数据库
        Shop shop = getById(id);
        if (shop != null) {
            // 存在,写入redis
            stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop));
        }
        return shop;
    }
}

缓存更新策略

三种策略

内存淘汰 超时剔除 主动更新
说明 不用自己维护,利用Redis的内存淘汰机制,当内存不足时自动淘汰部分数据。下次查询时更新缓存 给缓存数据添加TTL时间,到期后自动删除缓存,下次查询时更新缓存 编写业务逻辑,在修改数据库的同时,更新缓存
一致性 一般
维护成本

业务场景:

  • 低一致性需求:使用内存淘汰机制。例如店铺类型的查询缓存
  • 高一致性需求:主动更新,并以超时剔除作为兜底方案。例如店铺详情查询的缓存

主动更新策略

三种模式

  • Cache Aside Pattern:由缓存的调用者,在更新数据库的同时更新缓存。 ✅
  • Read/Write Through Pattern:缓存与数据库整合为一个服务,由服务来维护一致性。调用者调用该服务,无需关心缓存一致性问题。
  • Write Behind Caching Pattern:调用者只操作缓存,由其他线程异步的将缓存数据持久化到数据库,保证最终一致。

三个问题

  • 删除缓存还是更新缓存?
    • 更新缓存:每次更新数据时都更新缓存,无效写操作太多 ❌
    • 删除缓存:更新数据库时让缓存失效,查询时再更新缓存 ✅
  • 如何保证缓存与数据库的操作的同时成功或失败?
    • 单体系统,将缓存与数据库操作放在同一个事务
    • 分布式系统,利用TCC等分布式事务方案
  • 先操作缓存还是先操作数据库?
    • 先删除缓存,再操作数据库
    • 先操作数据库,再删除缓存 ✅

最佳实践方案

  1. 第一致性需求:使用Redis自带的内存淘汰机制
  2. 高一致性需求:主动更新,并以超时剔除作为兜底方案
    • 读操作:
      • 缓存命中则直接返回
      • 缓存未命中查询数据库,并写入缓存,设定超时时间
    • 写操作
      • 先写数据库,然后再删除缓存
      • 要确保数据库与缓存操作的原子性

代码实操

在查询操作中添加超时时间

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Shop queryById(Long id) {
        String key = RedisConstants.CACHE_SHOP_KEY + id;
        // 从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        // 判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            // 存在
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return shop;
        }
        // 不存在,查询数据库
        Shop shop = getById(id);
        if (shop != null) {
            // 存在,写入redis
            stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        }
        return shop;
    }
}

更新操作

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    @Transactional
    public Boolean update(Shop shop) {
        Long id = shop.getId();
        if (id == null) {
            return null;
        }
        // 1.更新数据库
        Boolean state1 = updateById(shop);
        // 2.删除缓存
        String key = RedisConstants.CACHE_SHOP_KEY + shop.getId();
        Boolean state2 = stringRedisTemplate.delete(key);
        return state1 && state2;
    }
}

缓存穿透

缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在,这样缓存永远不会生效,这些请求都会到达数据库。

常见的两种解决方案

  • 缓存空对象
    • 优点:实现简单
    • 缺点:额外的内存消耗,可能造成短期的不一致
  • 布隆过滤
    • 优点:内存占用少,没有多余key
    • 缺点:实现复杂,存在误判可能

通常采用第一种方式

实现思路

代码实操

更新之前的查询代码,解决内存穿透问题

@Override
public Shop queryById(Long id) {
    String key = RedisConstants.CACHE_SHOP_KEY + id;
    // 从redis查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    // 判断是否存在
    if (StrUtil.isNotBlank(shopJson)) {
        // 存在
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return shop;
    }
    // 判断命中的是否为空值 => shopJson == ""
    if (shopJson != null) {
        // 返回错误信息
        return null;
    }
    // 不存在,查询数据库
    Shop shop = getById(id);
    if (shop != null) {
        // 存在,写入redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
    } else {
        // 不存在,写入空值,解决内存穿透问题
        stringRedisTemplate.opsForValue().set(key, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
    }
    return shop;
}

当查询不存在的数据时,缓存为空值

总结

缓存穿透产生的原因是什么?

  • 用户请求的数据在缓存中和数据库中都不存在,不断发起这样的请求,给数据库带来巨大的压力

缓存穿透的解决方案有哪些?

  • 缓存null值
  • 布隆过滤
  • 增强id的复杂度,避免被猜测id规律
  • 做好数据的基础格式校验
  • 加强用户权限校验
  • 做好热点参数的限流

缓存雪崩

缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机,导致大量请求到达数据库,带来巨大压力

解决方案

  • 给不同的Key的TTL添加随机值

  • 利用Redi集群提高服务的可用性

  • 给缓存业务添加降级限流策略

  • 给业务添加多级缓存

缓存击穿

缓存击穿问题也叫热点Key问题,就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了,无数的请求访问会在瞬间给数据库带来巨大冲击。

解决方案

  • 互斥锁

  • 逻辑过期

    KEY VALUE
    heima:user:1

优缺点

解决方案 优点 缺点
互斥锁 没有额外的内存消耗
保证一致性
实现简单
线程需要等待,性能受影响
可能有死锁风险
逻辑过期 线程无需等待,性能较好 不保证一致性
有额外的内存消耗
实现复杂

互斥锁

  • 优点
    • 没有额外的内存消耗
    • 保证一致性
    • 实现简单
  • 缺点
    • 线程需要等待,性能受影响
    • 可能有死锁风险

逻辑过期

  • 优点
    • 线程无需等待,性能较好
  • 缺点
    • 不保证一致性
    • 有额外的内存消耗
    • 实现复杂

代码实操

互斥锁解决

利用互斥锁解决缓存击穿问题

public Shop queryWithMutex(Long id) {
    String key = RedisConstants.CACHE_SHOP_KEY + id;
    // 从redis查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    // 判断是否存在
    if (StrUtil.isNotBlank(shopJson)) {
        // 存在
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return shop;
    }
    // 判断命中的是否为空值 => shopJson == ""
    if ("".equals(shopJson)) {
        // 返回错误信息
        return null;
    }
    // 实现缓存重建
    // 获取互斥锁
    String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
    Shop shop = null;
    try {
        boolean isLock = tryLock(lockKey);
        if (!isLock) {
            // 失败,休眠并重试
            Thread.sleep(50);
            return queryWithMutex(id);
        }
        // 成功,查询数据库
        shop = getById(id);
        if (shop != null) {
            // 存在,写入redis
            stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        } else {
            // 不存在,写入空值,解决内存穿透问题
            stringRedisTemplate.opsForValue().set(key, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
        }
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    } finally {
        // 释放互斥锁
        unLock(lockKey);
    }
    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);
}

逻辑过期解决

基于逻辑过期方式解决缓存击穿问题,数据需要提前写入Redis

代码

private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
public Shop queryWithLogicalExpire(Long id) {
    String key = CACHE_SHOP_KEY + id;
    // 从redis查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    // 判断是否存在
    if (StrUtil.isBlank(shopJson)) {
        // 不存在,直接返回
        return null;
    }
    // 命中,需要先把json反序列化为对象
    RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
    Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
    LocalDateTime expireTime = redisData.getExpireTime();
    // 判断是否过期
    if (expireTime.isAfter(LocalDateTime.now())) {
        // 未过期,直接返回店铺信息
        return shop;
    }
    // 过期,需要重建缓存
    // 缓存重建
    // 获取互斥锁
    String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
    boolean isLock = tryLock(lockKey);
    // 判断是否获取锁成功
    if (isLock) {
        // DoubleCheck
        String doubleShopJson = stringRedisTemplate.opsForValue().get(key);
        RedisData doubleRedisData = JSONUtil.toBean(doubleShopJson, RedisData.class);
        if (doubleRedisData.getExpireTime().isAfter(LocalDateTime.now())) {
            // 未过期,直接返回店铺信息
            return JSONUtil.toBean((JSONObject) doubleRedisData.getData(), Shop.class);
        }
        // 成功,开启独立线程,实现缓存重建
        CACHE_REBUILD_EXECUTOR.submit(() -> {
            try {
                // 重建缓存
                saveShop2Redis(id, 1800L);
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                // 释放锁
                unLock(lockKey);
            }
        });
    }
    // 返回过期的商铺信息
    return shop;
}
// 数据预热
private void saveShop2Redis(Long id, Long expireSeconds) {
    // 查询店铺数据
    Shop shop = getById(id);
    // 逻辑过期时间
    RedisData redisData = new RedisData();
    redisData.setData(shop);
    redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
    // 写入redis
    String key = RedisConstants.CACHE_SHOP_KEY + id;
    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
}

缓存工具封装

基于StringRedisTemplate封装一个缓存工具类,满足下列需求:

  • 方法1:将任意java对象序列化为json并存储在string类型中的key中,并且可以设置TTL过期时间
  • 方法2:将任意java对象序列化为json并存储在string类型中的key中,并且可以设置逻辑过期时间,用于处理缓存击穿问题。
  • 方法3:根据指定key查询缓存,并反序列化为指定类型,利用缓存空值的方式解决缓存穿透问题
  • 方法4:根据指定key查询缓存,并反序列化为指定类型,需要利用逻辑过期解决缓存击穿问题

方法1+方法3:设置过期时间,解决缓存穿透

方法2+方法4:针对热点key,解决缓存击穿

工具类

@Slf4j
@Component
public class CacheClient {

    private final 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)));
        // 写入Redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

    // 解决缓存穿透问题
    public <R, ID> R queryWithPassThrough(
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
        String key = keyPrefix + id;
        // 从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 判断是否存在
        if (StrUtil.isNotBlank(json)) {
            // 存在
            return JSONUtil.toBean(json, type);
        }
        // 判断命中的是否为空值 => "".equals(shopJson)
        if (json != null) {
            // 返回错误信息
            return null;
        }
        // 不存在,查询数据库
        R r = dbFallback.apply(id);
        if (r != null) {
            // 存在,写入redis
            this.set(key, r, time, unit);
        } else {
            // 不存在,写入空值,解决内存穿透问题
            stringRedisTemplate.opsForValue().set(key, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
        }
        return r;
    }


    // 解决缓存击穿问题,逻辑锁
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
    public <R, ID> R queryWithLogicalExpire(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
        String key = keyPrefix + id;
        // 从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 判断是否存在
        if (StrUtil.isBlank(json)) {
            // 不存在,直接返回
            return null;
        }
        // 命中,需要先把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(json, 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) {
            // DoubleCheck
            String json2 = stringRedisTemplate.opsForValue().get(key);
            RedisData redisData2 = JSONUtil.toBean(json2, RedisData.class);
            if (redisData2.getExpireTime().isAfter(LocalDateTime.now())) {
                // 未过期,直接返回店铺信息
                return JSONUtil.toBean((JSONObject) redisData2.getData(), type);
            }
            // 成功,开启独立线程,实现缓存重建
            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);
    }
}

使用方法

@Override
public Shop queryById(Long id) {
    // 缓存穿透
     Shop shop = cacheClient.queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);
    // 逻辑过期解决缓存击穿
    // Shop shop = cacheClient.queryWithLogicalExpire(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);
    return shop;
}




相关文章:
Redis快速入门
使用Redis实现短信登陆

posted @ 2022-10-30 14:04  sw-code  阅读(141)  评论(0编辑  收藏  举报