1.缓存击穿、穿透、雪崩
1.缓存穿透
指查询一个一定不存在的数据，由于缓存是不命中，将去查询数据库，但是数据库也无此纪录，我们没有将这次查询的null写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。
风险：
利用不存在的数据进行攻击，数据库瞬时压力增大，最终导致崩溃
解决：
null结果缓存，并加入短暂过期时间
2.缓存雪崩
缓存雪崩：缓存雪崩是指在我们设置缓存是Key采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部转发到DB，DB瞬时压力过重雪崩。
解决：原有的失效时间上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。
3.缓存击穿
缓存击穿：
- 对于一些设置了过期时间的key，如果这些key可能会在某些时间点被超高并发地访问，是一种非常“热点”地数据。
- 如过这个热点 key 在大量请求同时进来前正好失效，那么所有对这个key的数据查询都落到db，我们称为缓存击穿。
解决：
加锁
大量并发只让一个去查，其他人等待，查到以后释放锁，其他人获取到锁，悬停，先查缓存，就会有数据，不用去db
2.解决问题
先解决缓存穿透和雪崩
private static final String CATALOG_JSON="CATALOG_JSON";
@Override
public Map<String, List<Catelog2Vo>> getCatalogJson() {
/**
* 空结果缓存:解决缓存穿透
* 设置过期时间(加随机值) 缓存雪崩
* 加锁 解决缓存击穿
*/
Object result = redisTemplate.opsForValue().get(CATALOG_JSON);
if(result!=null){
return (Map<String, List<Catelog2Vo>>) result;
}
Map<String, List<Catelog2Vo>> map = getCatalogJsonFromDB();
if (map==null){
/**
* 解决缓存穿透
*/
map=new HashMap<>();
}
redisTemplate.opsForValue().set(CATALOG_JSON,map, Duration.ofDays(1));
return map;
}解决缓存击穿
1.使用本地锁解决
springboot容器对象默认是单例模式，所以可以synchronized锁住同一个对象，在使用双重检测模式，可以并发执行
public synchronized Map<String, List<Catelog2Vo>> getCatalogJsonFromDB() {
Object result = redisTemplate.opsForValue().get(CATALOG_JSON);
if (result != null) {
return (Map<String, List<Catelog2Vo>>) result;
}
//1.查出所有1级分类
List<CategoryEntity> selectList = baseMapper.selectList(null);
/**
* 将数据库的多次查询变成一次
*/
//2. 封装数据
List<CategoryEntity> level1Category = selectList.stream().filter(s -> s.getParentCid().equals(0L)).collect(Collectors.toList());
Map<String, List<Catelog2Vo>> map = level1Category.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
//1.每一个的一级分类,查到1级分类的所有二级分类
List<CategoryEntity> categoryEntities = selectList.stream().filter(s -> s.getParentCid().equals(v.getCatId())).collect(Collectors.toList());
List<Catelog2Vo> catelog2VoList = categoryEntities.stream().map(c -> {
Catelog2Vo catelog2Vo = new Catelog2Vo();
catelog2Vo.setId(c.getCatId().toString());
catelog2Vo.setName(c.getName());
catelog2Vo.setCatalog1Id(v.getCatId().toString());
List<CategoryEntity> categoryEntities1 = selectList.stream().filter(s -> s.getParentCid().equals(c.getCatId())).collect(Collectors.toList());
List<Catelog2Vo.Catelog3Vo> collect = categoryEntities1.stream().map(c3 -> {
Catelog2Vo.Catelog3Vo catelog3Vo = new Catelog2Vo.Catelog3Vo();
catelog3Vo.setId(c3.getCatId().toString());
catelog3Vo.setName(c3.getName());
catelog3Vo.setCatalog2Id(c.getCatId().toString());
return catelog3Vo;
}).collect(Collectors.toList());
catelog2Vo.setCatalog3List(collect);
return catelog2Vo;
}).collect(Collectors.toList());
return catelog2VoList;
}));
return map;
} public Map<String, List<Catelog2Vo>> getCatalogJson() {
/**
* 空结果缓存:解决缓存穿透
* 设置过期时间(加随机值) 缓存雪崩
* 加锁 解决缓存击穿
*/
Object result = redisTemplate.opsForValue().get(CATALOG_JSON);
if (result != null) {
return (Map<String, List<Catelog2Vo>>) result;
}
Map<String, List<Catelog2Vo>> map = getCatalogJsonFromDB();
if (map == null) {
/**
* 解决缓存穿透
*/
map = new HashMap<>();
}
redisTemplate.opsForValue().set(CATALOG_JSON, map, Duration.ofDays(1));
return map;
}以上代码逻辑还是会有问题，并发的时候会导致一号线程查完数据库，还没放入缓存就释放锁了，导致二号线程查询缓存没有数据，又去查了一次数据库，没有保证只有一个线程去查数据库
正确的做法
public synchronized Map<String, List<Catelog2Vo>> getCatalogJsonFromDB() {
Object result = redisTemplate.opsForValue().get(CATALOG_JSON);
if (result != null) {
return (Map<String, List<Catelog2Vo>>) result;
}
//1.查出所有1级分类
List<CategoryEntity> selectList = baseMapper.selectList(null);
/**
* 将数据库的多次查询变成一次
*/
//2. 封装数据
List<CategoryEntity> level1Category = selectList.stream().filter(s -> s.getParentCid().equals(0L)).collect(Collectors.toList());
Map<String, List<Catelog2Vo>> map = level1Category.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
//1.每一个的一级分类,查到1级分类的所有二级分类
List<CategoryEntity> categoryEntities = selectList.stream().filter(s -> s.getParentCid().equals(v.getCatId())).collect(Collectors.toList());
List<Catelog2Vo> catelog2VoList = categoryEntities.stream().map(c -> {
Catelog2Vo catelog2Vo = new Catelog2Vo();
catelog2Vo.setId(c.getCatId().toString());
catelog2Vo.setName(c.getName());
catelog2Vo.setCatalog1Id(v.getCatId().toString());
List<CategoryEntity> categoryEntities1 = selectList.stream().filter(s -> s.getParentCid().equals(c.getCatId())).collect(Collectors.toList());
List<Catelog2Vo.Catelog3Vo> collect = categoryEntities1.stream().map(c3 -> {
Catelog2Vo.Catelog3Vo catelog3Vo = new Catelog2Vo.Catelog3Vo();
catelog3Vo.setId(c3.getCatId().toString());
catelog3Vo.setName(c3.getName());
catelog3Vo.setCatalog2Id(c.getCatId().toString());
return catelog3Vo;
}).collect(Collectors.toList());
catelog2Vo.setCatalog3List(collect);
return catelog2Vo;
}).collect(Collectors.toList());
return catelog2VoList;
}));
if (map == null) {
/**
* 解决缓存穿透
*/
map = new HashMap<>();
}
redisTemplate.opsForValue().set(CATALOG_JSON, map, Duration.ofDays(1));
return map;
}把存入缓存这一操作也放入同步代码块里
@Override
public Map<String, List<Catelog2Vo>> getCatalogJson() {
/**
* 空结果缓存:解决缓存穿透
* 设置过期时间(加随机值) 缓存雪崩
* 加锁 解决缓存击穿
*/
Object result = redisTemplate.opsForValue().get(CATALOG_JSON);
if (result != null) {
return (Map<String, List<Catelog2Vo>>) result;
}
Map<String, List<Catelog2Vo>> map = getCatalogJsonFromDB();
return map;
} 
本地锁只能锁住当前进程，所以我们需要分布式锁
3.本地锁在分布式下会有的问题
就是每个锁只能锁住当前进程，也就是每个服务都会查一遍数据库
