一、controller中的代码，获取目录信息
@ResponseBody
@GetMapping("/index/catalog.json")
public Map<String, List<Category2Vo>> getCatalogJson(){
Map<String, List<Category2Vo>> catalogJson = categoryService.getCatalogJson();
return catalogJson;
}
二、service层
三、serviceImpl层
@Override
public Map<String, List<Category2Vo>> getCatalogJson() {
//注意：给缓存中放json字符串，拿出的json字符串还要逆转为能用的对象类型（也就是序列化和反序列化的过程）。
//1、加入缓存逻辑，缓存中存的数据都是json字符串。json好处是跨语言，跨平台兼容。
String catalogJSON = stringRedisTemplate.opsForValue().get("catalogJSON");
if (StringUtils.isEmpty(catalogJSON)) {
//2、缓存中没有，则查数据库
Map<String, List<Category2Vo>> catalogJsonFromDB = this.getCatalogJsonFromDBWithRedissonLock();//使用redisson分布式锁
//Map<String, List<Category2Vo>> catalogJsonFromDB = this.getCatalogJsonFromDBWithRedisLock();//使用原生的redis的setnx加分布式锁
//Map<String, List<Category2Vo>> catalogJsonFromDB = this.getCatalogJsonFromDBWithLocalLock();//单实例下使用synchronized加锁即可
//3、查到的数据在放入缓存,将查出来的对象转为json放在缓存中 --重要：此处不是原子性操作，应该放到查数据库的方法中，让它受锁的管制。因此下方代码注释掉了，放到查数据库的方法中。
// String s = JSON.toJSONString(catalogJsonFromDB);
// stringRedisTemplate.opsForValue().set("catalogJSON",s);
// return catalogJsonFromDB;
}
Map<String, List<Category2Vo>> result = JSON.parseObject(catalogJSON, new TypeReference<Map<String, List<Category2Vo>>>() {
});
return result;
}
//从数据库查询并封装分类数据 --本地synchronized锁。在分布式情况下，有几个实例就会查几次数据库，因此可能会导致几次刷新前台数据显示不一致情况。所以分布式情况下，应该使用分布式锁。
public Map<String, List<Category2Vo>> getCatalogJsonFromDBWithLocalLock() {
synchronized (this) {
return getDataFromDB();
}
}
//上面方法的进化：从数据库查询并封装分类数据 --使用redis做分布式锁
public Map<String, List<Category2Vo>> getCatalogJsonFromDBWithRedisLock() {
//1、占分布式锁.其实就是去redis占坑，就是大家都像redis中set一个值，谁set成功了，就代表谁抢占锁成功了。获取锁和设置过期时间要保证原子操作，所以这里这么设置
String uuid = UUID.randomUUID().toString();
Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuid,30,TimeUnit.SECONDS);
if (lock) {
//1、加锁成功（占到坑位了） 可以执行业务了
//设置过期时间(防止删除锁之前的代码出问题，就会导致锁一直无法释放，变成死锁) --注意，必须和加锁是原子操作，不然万一加锁了，然后还没等设置过期时间，程序崩了，锁就永远无法释放了。
//stringRedisTemplate.expire("lock",30, TimeUnit.SECONDS); --这个就不是原子操作，如果它之前崩了，它就没设置上过期时间，就又死锁了
Map<String, List<Category2Vo>> dataFromDB = getDataFromDB();//防止这里出现问题，上方需要设置锁的超市时间
//stringRedisTemplate.delete("lock");//业务执行完要删除锁，不然别人一直获取不到 如果业务执行过长，锁过期了，别人就拿到锁了，这里在删除锁，就删除了别人的锁了。就更多人获取锁了。因此要改成uuid的方
//获取值对比+对比成功删除必须是原子操作才可以，因此下方的方式看起来对，其实也是不对的。 这就需要使用redis+lua脚本结合来完成了
/*String lockValue = stringRedisTemplate.opsForValue().get("lock");
if(uuid.equals(lockValue)){
//我删我自己的锁 --注意这里也是不对的，因为获取值对比和删锁不是原子操作，也可能删除了别人的锁。
stringRedisTemplate.delete("lock");
}*/
//使用lua脚本去解锁，保证了获取值对比+对比成功删除必须是原子操作
String lua = "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
"then\n" +
" return redis.call(\"del\",KEYS[1])\n" +
"else\n" +
" return 0\n" +
"end";
stringRedisTemplate.execute(new DefaultRedisScript<Integer>(lua,Integer.class),Arrays.asList("lock"),uuid);
return dataFromDB;
} else {
//2、加锁失败...需要重试（因为本地锁synchronized是自旋锁，一直在自选等待重新获取锁。分布式锁用redis也得写重试机制）
//如果嫌弃调用太快了，可以使用休眠100ms，在执行重试
return getCatalogJsonFromDBWithRedisLock();//自旋的方式，调用自己，持续尝试获取锁。
}
}
//上面方法的再次进化：从数据库查询并封装分类数据 --使用redisson做分布式锁
public Map<String, List<Category2Vo>> getCatalogJsonFromDBWithRedissonLock() {
RLock lock = redisson.getLock("CatalogJson-lock");
lock.lock();
Map<String, List<Category2Vo>> dataFromDB;
try{
dataFromDB = getDataFromDB();
}finally{
lock.unlock();
}
return dataFromDB;
}
//查数据库并放入缓存的方法
private Map<String, List<Category2Vo>> getDataFromDB() {
//查出所有1级分类
List<CategoryEntity> level1Categorys = this.getLevel1Categorys();
//封装数据
Map<String, List<Category2Vo>> parent_cid = level1Categorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
//每个一级分类，查到这个一级分类的二级分类
List<CategoryEntity> categoryEntities = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", v.getCatId()));
//封装上面的结果
List<Category2Vo> category2Vos = null;
if (categoryEntities != null) {
category2Vos = categoryEntities.stream().map(l2 -> {
Category2Vo category2Vo = new Category2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
//找当前二级分类的三级分类封装成vo
List<CategoryEntity> level3Catelog = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", l2.getCatId()));
if (level3Catelog != null) {
List<Category2Vo.Catelog3Vo> collect = level3Catelog.stream().map(l3 -> {
//封装成指定格式
Category2Vo.Catelog3Vo catelog3Vo = new Category2Vo.Catelog3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
return catelog3Vo;
}).collect(Collectors.toList());
category2Vo.setCatelog3List(collect);
}
return category2Vo;
}).collect(Collectors.toList());
}
return category2Vos;
}));
//3、查到的数据在放入缓存,将查出来的对象转为json放在缓存中 --重要：此处不是原子性操作，应该放到getCatalogJsonFromDB方法中，让它受synic..管制
String s = JSON.toJSONString(parent_cid);
stringRedisTemplate.opsForValue().set("catalogJSON", s);
return parent_cid;
}