目录
一、什么是缓存
缓存就是数据交换的缓冲区，是临时存储数据的地方，一般读写性能较高。
缓存的作用：降低后端负载，提高读写效率，降低响应时间
缓存的成本：数据一致性成本、代码维护成本、运维成本
二、添加Redis缓存操作
三、缓存更新策略
缓存的更新策略
业务场景
- 低一致性：使用内存淘汰机制，例如店铺类型查询的缓存
- 高一致性：主动更新，并以超时剔除作为兜底方案，例如店铺详情查询的缓存
主动更新策略
操作缓存和数据库时要考虑3个问题：
1、删除缓存还是更新缓存？
更新缓存：每次更新数据库都更新缓存，无效写操作很多但是一直没查就很亏
删除操作：更新数据库的时删除缓存，下次查询才有（推荐）
2、如何保证缓存与数据库操作同时成功或失败？
单体系统：将缓存和数据库操作放到一个事务里面
分布式系统：利用tcc等分布式事务方案
3、先操作缓存还是先操作数据库？（重点）（面试题）
先删除缓存：a在删除完缓存后，正在改数据库，这时候来了线程查询数据库，然后更新到缓存，这时候如果a更新完数据库，缓存和数据库就是不一致了
先改数据库：如果缓存过期失效了，a在去数据库查的过程中，b改了数据库，然后更新缓存，这时候a查到数据再更新缓存。缓存和数据库就不一致了。但是这种情况发送的概率远远小于前者。
因为后面的情况发生概率小，要满足很多条件，所以推荐用后者。推荐先改数据库再改缓存。
案例
我们要加上事务注解，保证他们同时成功或同时失败，删之前也要判断一下看id是不是空
四、缓存穿透
1、是什么
缓存穿透是指客户端请求的数据在缓存和数据库都没有，这样缓存永远不会生效，这些请求都会打到数据库。
2、解决方案
（1）缓存空对象
第一次他随便乱打个没有的id来查询缓存和数据库，我们就会返回null，然后把null也存到缓存中。
这样再他下一次带这个id来请求的时候，就会从缓存中拿到null。
优点：简单实现，维护方便
缺点：
额外的内存消耗，缓存了很多没用的数据（可以通过设置时间来缓解）
可能造成短期的不一致。因为是随便乱打的id发的请求，我们帮这个id存缓存了，以后要是真的有这个id了，到时候拿这个id来查也是null（也是控制缓存的时间来缓解，也可以当我们新增数据的时候，主动插入缓存替换掉null）
（2）布隆过滤器
在请求到缓存前加层布隆过滤器，如果这个数据存不存在，直接拒绝，不给继续请求。
布隆过滤器是怎么知道在不在呢？
是通过hash算法算出哈希值，将这些哈希值换成2进制位保存到布隆过滤器，判断数据是否存在的时候就判断对应的位置是0还是1。这种统计不是百分百准确
不存在的时候百分百不存在，说存在不一定存在，可以起到一定过滤作用。还是有一定击穿风险
优点：内存占用少，没有存多余的key
缺点：实现复杂，存在误判的可能。
（3）其他策略
- 做好数据的基础格式校验
- 增强id复杂度，避免被猜测id的规律
- 加强用户权限校验
- 做好热点参数的限流
3、实践
以缓存null值为例，在查询的接口做更改：
当我们查到数据不存在的时候，将这个id作为key，value为空值存储到redis中。
在判断完商品是否存在后加上判断查出来的是否为空值，为空就返回不存在
五、缓存雪崩
1、是什么
缓存雪崩是指同一时段大量的缓存key同时失效或redis服务宕机，导致大量请求打崩数据库
2、解决方案
给不同的key的TTL(过期时间)添加随机值（可以设置成30分钟到40分钟之间的随机数）
利用Redis集群提高服务器的可用性（哨兵机制）
给缓存业务添加降级限流策略（比如当服务器出现问题的时候，拒绝服务，牺牲部分服务来保证安全）
给业务添加多级缓存（nginx、redis、jvm都可以添加缓存，最后才到数据库）
六、缓存击穿
1、是什么
缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的Key突然失效了，无数请求访问会瞬间给数据库带来巨大冲击。
高并发访问可以理解为做活动的商品，同一时间有无数的请求来访问这个商品。
缓存重建比较复杂就是缓存可能会过期失效，失效的时候重新添加到缓存的时间很久（可能业务非常复杂，要多表查询运算才能得到的结果）
2、解决方案
互斥锁
如果查到缓存中没有，就加锁查数据库冲击，写入缓存之后再释放锁。这个期间内，所有访问的请求都没有拿到锁只能等待重试，直到缓存更新完毕读取缓存。
优点：没有额外的内存消耗、保证缓存和数据库一致性，实现简单
缺点：线程需要等待，性能受影响用户体验不好。可能有死锁的风险
逻辑过期
设置缓存过期时间的时候，不是真正的设置，而是设置在value里面，如果查询缓存发现逻辑删除时间过期了，就new一个新的线程加锁来查询数据库更新缓存，更新完毕后才释放锁，自己返回旧数据。这个期间内其他线程都没有拿到锁，都返回旧数据，直到更新完毕
优点：线程不用等待，性能好。
缺点：不保证一致性，有额外内存消耗，实现复杂。
3、实践-互斥锁
用什么锁
我们平时用synchronized和lock锁的时候，如果没有拿到锁就要等待，而我们这次是没有拿到锁和拿到锁都有不同的操作要执行。所有用不了这两个
我们可以用redis里面String数据类型的setnx命令来设置锁（当key不存在的时候才可以赋值，存在就不能赋值了）
加锁：setnx lock 1
释放锁：del lock
为了避免死锁，我们通常还会设置上有效期
加锁和释放锁的方法：
实现代码
最后开启JMeter做测试，模拟1000个线程发请求，发现能扛住200qps
4、实践-逻辑删除
要用逻辑删除肯定要多个属性过期时间，我们就可以采用这种方式多增加一个类，这个类有过期时间属性，然后多一个object类，存放要存入redis的数据，这样就不用在原来的类上改动
编写添加到redis的方法
这个plusSeconds就是设置过期时间，用户参数传进来
重写查询的方法
七、缓存工具封装
我们发现缓存的操作还是挺复杂的，我们将来使用的时候不可能每次都这样重新写一遍。 我们可以将这些解决方案封装成工具。
我们封装四个方法，1和3可以是平时添加缓存用的，2和4一般是缓存热点数据用防止击穿问题
1、封装存储方法：将任意java对象序列化为json并存储在string类型的key中，并且设置ttl过期时间
2、封装存储方法（逻辑过期）：将任意java对象序列化为json并存储在string类型的key中，并且设置逻辑过期时间，用于处理缓存击穿问题
3、查询缓存（空值解决击穿）：根据指定key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透
4、查询缓存（逻辑删除解决穿透）：根据指定key查询缓存，并反序列化为指定类型，需要用逻辑过期解决缓存击穿
工具类：
@Slf4j
@Component
public class CacheClient {
@Autowired
private StringRedisTemplate stringRedisTemplate;
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
public CacheClient(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
}
/**
* 向缓存中添加 key
* */
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));
}
/**
* 缓存穿透
* */
public <R,ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit){
String key = keyPrefix + id;
// 1、根据 Id 查询 Redis
String json = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
// 2、判断 shopJSON 是否为空
if (StrUtil.isNotBlank(json)) {
// 3、存在，直接返回
R r = JSONUtil.toBean(json, type);
return r;
}
// 增加对空字符串的判断
if(json != null){
return null;
}
// 4、不存在，查询数据库
R r = dbFallback.apply(id);
// 5、不存在，返回错误
if(r == null){
// 店铺不存在时，缓存空值
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
return null;
}
// 6、存在，写入 Redis
this.set(key, r, time, unit);
return r;
}
public <R, ID> R queryWithLogicalExpire(String keyPrefix, ID id,Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit){
String key = keyPrefix + id;
// 1、根据 Id 查询 Redis
String json = stringRedisTemplate.opsForValue().get(key);
// 2、判断 shopJSON 是否为空
if (StrUtil.isBlank(json)) {
// 3、存在，直接返回
return null;
}
// 命中，需要先把 json 反序列化为对象
RedisData redisData = JSONUtil.toBean(json, RedisData.class);
LocalDateTime expireTime = redisData.getExpireTime();
R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
// 判断是否过期
if(expireTime.isAfter(LocalDateTime.now())){
return r;
}
// 已过期，需要缓存重建
// 获取互斥锁
String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
boolean isLock = tryLock(lockKey);
if (isLock) {
// 开辟独立线程
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);
}
});
}
// 6、存在，写入 Redis
this.set(key, r, time, unit);
return r;
}
// 获取锁
private boolean tryLock(String key){
Boolean isTrue = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", RedisConstants.LOCK_SHOP_TTL, TimeUnit.SECONDS);
return BooleanUtil.isTrue(isTrue);
}
// 释放锁
private void unLock(String key){
stringRedisTemplate.delete(key);
}
}
调用的service
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Autowired
private CacheClient cacheClient;
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
@Override
public Result queryById(Long id) {
// 解决缓存穿透
// Shop shop = cacheClient.queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, this::getById, RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
// 互斥锁解决缓存击穿
// Shop shop = queryWithMetux(id);
// 使用逻辑过期时间解决缓存击穿问题
// Shop shop = queryWithLogicalExpire(id);
Shop shop = cacheClient.queryWithLogicalExpire(CACHE_SHOP_KEY, id, Shop.class, this::getById, RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
if(shop == null){
return Result.fail("店铺不存在！");
}
// 7、返回
return Result.ok(shop);
}
public Shop queryWithLogicalExpire(Long id){
// 1、根据 Id 查询 Redis
String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
// 2、判断 shopJSON 是否为空
if (StrUtil.isBlank(shopJson)) {
// 3、存在，直接返回
return null;
}
// 命中，需要先把 json 反序列化为对象
RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
LocalDateTime expireTime = redisData.getExpireTime();
Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
// 判断是否过期
if(expireTime.isAfter(LocalDateTime.now())){
return shop;
}
// 已过期，需要缓存重建
// 获取互斥锁
String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
boolean isLock = tryLock(lockKey);
if (isLock) {
// 开辟独立线程
CACHE_REBUILD_EXECUTOR.submit(() -> {
try {
// 缓存重建
this.saveShop2Redis(id, 20L);
}catch (Exception e) {
throw new RuntimeException(e);
} finally {
unLock(lockKey);
}
});
}
// 6、存在，写入 Redis
stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
return shop;
}
}