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等分布式事务方案
先操作缓存还是先操作数据库？
- 先删除缓存，再操作数据库
- 先操作数据库，再删除缓存 ✅

最佳实践方案

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

代码实操

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

@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

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实现短信登陆