缓存
本地缓存和分布式缓存
放入缓存的数据格式
- 即时性、数据一致性要求不高的
- 访问量大且更新效率不高的数据
本地缓存:放在本地内存中,先进行查询
redis依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
redis本地配置方案
- 引入data-redis-starter
- 简单配置redis的host等信息
- 使用springboot自动配置好的stringRedisTemplate
//springboot2.0以后默认使用Lettuce作为操作redis的客户端,它使用netty进行了网络通信
//Letuce bug导致堆外内存溢出 -Xmx300m:netty如果没有指定堆外内存,默认使用_Xmx300m
//可以通过Dio.netty.maxDirectMemory进行设置
//解决方案:不能只使用Dio.netty.maxDirectMemoy只去调整堆外内存
//1.升级Lettuce客户端
//2.切换使用jedis
lettuce可用数据传输量较大,但是会有后台内存溢出的bug,可进行包排除引入jedis
dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<exclusions>
<exclusion>
<groupId>io.lettuce</groupId>
<artifactId>lettuce-core</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency>
缓存击穿:
指查询一个一定不存在的数据,由于缓存是不命中,蒋去查询数据库,但数据库也无此记录,我们没有将这次查询的null写入缓存,这将导致这个不存在的数据每次请求都要到存储层去查询,失去了缓存的意义
风险:
利用不存在的数据进行攻击,数据库瞬间压力增大,最终导致崩溃
解决:
null结果缓存,并加入短暂过期时间
缓存雪崩
缓存雪崩是指在我们设置缓存时key采用了相同的过期时间,导致缓存在某一时刻同时失效,请求全部转发到DB,DB瞬间压力过重雪崩
解决:
原有的失效时间的基础上增加一个随机值,比如1-5分钟随机,这样每一个缓存的过期时间的重复率就会降低,就很难引发集体失效的事件
缓存击穿
-
对于一些设置了过期时间的key,如果这些key可能会在某些时间点被超高并发的请求,是一种非常热点的数据
-
如果这个key在大量请求同时进来刚好失效,那么所有对这个key的数据查询都落到db,我们称为缓存击穿
解决:
加锁
大量并发只让一个去查,其他人等待,查到以后释放锁,其他人获取到锁,先查缓存,就会有数据,不用去db
加锁
单节点加锁
- synchronized代码块
只要是同一把锁就能锁住需要这个锁的所有线程
synchronized(this){
}
当前对象加锁
springboot所有的组件在容器中都是单例的
或者直接在方法上加synchronized
批量数据竞争锁,当得到锁之后,我们应该再去缓存中确定一次,如果没有才需要继续查询
public Map<String, List<Catelog2Vo>> getCatalogJson() {
// 加入缓存逻辑,缓存中存的数据是Josn字符串,还用逆转为能用的对象类型[序列化和反序列化]
/*解决缓存穿透
* 空结果缓存,解决缓存穿透问题*/
/*解决缓存雪崩
* 设置过期时间(加随机值),解决缓存雪崩*/
/*解决缓存击穿
* 加锁,解决缓存击穿*/
String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
if (StringUtils.isEmpty(catalogJSON)){
// 缓存中没有,查询数据库
Map<String, List<Catelog2Vo>> catelogJsonFromDb = getCatalogJsonFromdb();
//查询到的数据再放入缓存
String s = JSON.toJSONString(catelogJsonFromDb);
redisTemplate.opsForValue().set("catalogJSON",s);
return catelogJsonFromDb;
}
//转为我们指定的对象
Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJSON,new TypeReference<Map<String, List<Catelog2Vo>>>(){});
return result;
}
/*从数据库查询和封装整个分类数据*/
public Map<String, List<Catelog2Vo>> getCatalogJsonFromdb() {
/*查询所有的一级分类*/
synchronized (this){
String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
if (!StringUtils.isEmpty(catalogJSON)){
/*缓存不为空,直接返回*/
Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJSON,new TypeReference<Map<String, List<Catelog2Vo>>>(){});
return result;
}
List<CategoryEntity> level1Categorys = getLevel1Categorys();
/*数据封装*/
Map<String, List<Catelog2Vo>> parent_cid = level1Categorys.stream().collect(Collectors.toMap(k ->
k.getCatId().toString(), v -> {
/*拿到每一个的一级分类,查询所有一级分类的二级分类*/
List<CategoryEntity> categoryEntitys = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", v.getCatId()));
List<Catelog2Vo> catelog2Vos = null;
if (categoryEntitys != null) {
catelog2Vos = categoryEntitys.stream().map(l2 -> {
Catelog2Vo catelog2Vo = new Catelog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
/*找当前二级分类的三级分类分装成vo*/
List<CategoryEntity> level3Catalog = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", l2.getCatId()));
if (level3Catalog!=null){
List<Catelog2Vo.Category3Vo> collect = level3Catalog.stream().map(l3 -> {
Catelog2Vo.Category3Vo category3Vo = new Catelog2Vo.Category3Vo( l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
return category3Vo;
}).collect(Collectors.toList());
catelog2Vo.setCatalog3List(collect);
}
return catelog2Vo;
}).collect(Collectors.toList());
}
return catelog2Vos;
}));
return parent_cid;
}
}
分布式加锁
分布式锁会较慢,进程锁较快
本地锁缺点,在分布式的情况下锁不住所有的服务,在分布式情况下,想要锁住所有,必须使用分布式锁
[外链图片转存中…(img-TaecYBWr-1667726316762)]
分布式锁会较慢,进程锁较快
本地锁缺点,在分布式的情况下锁不住所有的服务,在分布式情况下,想要锁住所有,必须使用分布式锁