文章目录
一、基本流程
- 用户访问数据,即浏览该页面
- 渲染该页面数据的后端,首先查看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);
}
}