Redis( stringRedisTemplate)添加缓存数据

在redis中添加缓存数据大致思路:

1，从redis中获取数据，如果存在，直接返回客户端

2，不存在，查询数据库，并写入redis缓存

3，如果从数据库查询为空，返回错误信息

4，写入redis缓存并返回数据

通过String类型添加商品数据

string思路：如果缓存中存在，需要把获取到的JSON数据转换为实体类

                    如果缓存不存在，则需要把查询到的数据转为JSON写入redis

 public Result queryById(Long id) {
       String shopKey = CACHE_SHOP_KEY + id;
        //从redis中获取缓存
        String shopJson = stringRedisTemplate.opsForValue().get(shopKey);
        //判断是否存在
        //如果存在直接返回查询结果
        if (!StringUtils.isEmpty(shopJson)){
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //如果不存在，查询数据库
        Shop shop = this.getById(id);

        //如果数据库中也不存在，返回错误信息
        if (shop==null){
            return Result.fail("商品不存在");
        }
        //将对象转为json存储
        String shoptoJson = JSONUtil.toJsonStr(shop);
        //如果存在写入redis缓存并返回查询信息
        stringRedisTemplate.opsForValue().set(shopKey,shoptoJson);
        return Result.ok(shop);
    }

通过hash方式进行存储

hssh思路：如果缓存中存在，需要通过hutool工具类将map转换为对象并返回客户端

                  如果缓存中不存在，查询数据库，并将实体类转为map写入缓存，因为本文使用的是StringRedisTemple所以需要将实体类中非String类型字段转换为String类型进行存储，最终返回数据到客户端

public Result queryById(Long id) {
        /**
         * 添加商户缓存,采用map形式
         */
       String shopKey = CACHE_SHOP_KEY + id;
       //如果缓存中有数据,直接返回客户端
        Map shopMap = stringRedisTemplate.opsForHash().entries(shopKey);
        if (shopMap!=null && shopMap.size()>0){
            //将map转换为对象
            Shop shop = BeanUtil.fillBeanWithMap(shopMap, new Shop(), false);
            return Result.ok(shop);
        }
        //如果缓存中没有数据,查询数据库并写入redis缓存
        Shop shop = this.getById(id);
        if (shop==null){
            return Result.fail("不存在此商品");
        }
        //将对象中的非String类型转为String类型
        Map shopMaps = BeanUtil.beanToMap(shop, new HashMap<>(),
                CopyOptions.create().
                        setIgnoreNullValue(true).setFieldValueEditor((filedName, filedValue) -> {
                            if (filedValue == null) {
                                filedValue = "0";
                            } else {
                                filedValue = filedValue + "";
                            }
                            return filedValue;
                        }));

        stringRedisTemplate.opsForHash().putAll(shopKey,shopMaps);
        return Result.ok(shop);
    }

通过List进行存储

通过List存储思路：通过list获取商品类型，判断是否命中缓存，如果命中缓存，遍历从Redis中获取到的集合并遍历设置到泛型为当前实体类对象的类型的集合，

                              如果缓存未命中，从数据库中查询数据，并获取到这个集合，遍历这个集合，并转换为JSON类型添加到一个泛型为String的集合，通过调用rightPushAll来完成redis的写入

 public Result queryTypeList() {
        //1.在redis中间查询,通过list获取商品类型
        List shopTypeList = new ArrayList<>();
        shopTypeList = stringRedisTemplate.opsForList().range(CACHE_SHOP_TYPE_KEY,0,-1);
        //2.判断是否缓存中了
        //3.中了返回
        if (!shopTypeList.isEmpty()){
            List typeList = new ArrayList<>();
            for (String str:shopTypeList) {
                ShopType shopType = JSONUtil.toBean(str, ShopType.class);
                typeList.add(shopType);
            }
            return Result.ok(typeList);
        }
        //不存在，从数据库中查询
        List shopTypes = this.query().orderByAsc("sort").list();
        if (shopTypes==null && shopTypes.size()>0){
            return Result.fail("没有商品类型信息");
        }
        //存在添加redis缓存
        for(ShopType shopType : shopTypes){
            String s = JSONUtil.toJsonStr(shopType);
            shopTypeList.add(s);
        }
        stringRedisTemplate.opsForList().rightPushAll(CACHE_SHOP_TYPE_KEY,shopTypeList);
        return Result.ok(shopTypes);
    }

通过set进行存储

public List getLike() {
        String key = "carousel:like";
        List stringList = new ArrayList<>();
        stringList = stringRedisTemplate.opsForSet().randomMembers(key, 6);
        if (!stringList.isEmpty()){
            List contents = new ArrayList<>();
            for (String s : stringList) {
                Content content = JSONUtil.toBean(s, Content.class);
                contents.add(content);
            }
            return contents;
        }
        //查询数据库
        //未命中查询数据库
        List contents = baseMapper.selectList(new QueryWrapper().eq("category_id",3));

        //添加redis并返回6条数据
        List contentList = new ArrayList<>();
        for (int i = 0; i < contents.size(); i++) {
            String s = JSONUtil.toJsonStr(contents.get(i));
            stringRedisTemplate.opsForSet().add(key,s);
            if (i<6){
                contentList.add(contents.get(i));
            }
        }
        return contentList;
    }

通过zset进行存储

 public List getpopularList() {
        List movies = new ArrayList<>();
        Set set = stringRedisTemplate.opsForZSet().reverseRange(MOVIE_POPULAR,0,-1);
          //判断是否命中缓存
          if (set != null && set.size()>0){
              List zsetStrings = new ArrayList<>(set);
              //命中返回
              for (String zsetString : zsetStrings) {
                 movies.add(JSONUtil.toBean(zsetString,Movie.class));
              }
              return movies;
          }
        movies = baseMapper.selectList(new QueryWrapper().orderByDesc("score").last("limit 0,6"));
        //写入redis数据库
          for (Movie movie : movies) {
              String s = JSONUtil.toJsonStr(movie);
              stringRedisTemplate.opsForZSet().add(MOVIE_POPULAR,s,movie.getScore());
          }
        return movies;
    }