【Redis】五种数据String,List,Hash,Set,Zset类型的缓存操作分享

14天阅读挑战赛
努力是为了不平庸~

String类型的缓存操作：

缓存思路：

首先根据对应的key值去redis中获取String类型的缓存数据；

将获取到的String类型的数据加以判断，如果存在数据则使用JSON.parseArray()转换成对应的集合数据，直接返回给前端处理；

如果不存在对应的数据，则查询数据库获取数据集合，再将查到的数据使用；JSONUtil.toJsonStr()缓存到Redis中。并将获取到的数据集合返回给客户端进行处理。

  public Result queryTypeList() {
        //1.根据Key值获取Redis中的缓存值
        String s = stringRedisTemplate.opsForValue().get("shop::Type");
        log.info("中Redis中获取到的数据是"+s);
        //2.判断是否有值，有值则返回
        if (!StringUtil.isNullOrEmpty(s)) {
            List<ShopType> shopTypeList = JSON.parseArray(s, ShopType.class);
            return Result.ok(shopTypeList);
        }

           //3.没有值则查询数据库
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.orderByAsc("sort");
        List<ShopType> shopTypeList = shopTypeMapper.selectList(queryWrapper);
            //4.将查到的数据缓存到redis中
            stringRedisTemplate.opsForValue().set("shop::Type", JSONUtil.toJsonStr(shopTypeList));
        if (null == shopTypeList){
            return Result.fail("数据为空");
        }
            return Result.ok(shopTypeList);
    }

List数据类型的操作

缓存思路：

首先创建一个List<String>类型的集合数据，用于接收数据以及缓存的数据源，

使用range()方法获取对应的List数据集合

将数据集合加以判断，是否存在数据，如果存在则创建以实体为泛型的数据集合，并遍历数据，使用JSONUtil.toBean()获取数据集合所需要的实体对象，并且封装到该数据集合中。再将数据返回给客户端处理；

如果数据不存在则查询数据库，将查询到的数据进行遍历,使用JSONUtil.toJsonStr()方法转换为String类型的json格式并封装进Lsit<String>作为Redis的数据源缓存;

之后再将从数据库获取到的数据返回给客户端处理。

  @Override
    public Result queryTypeList() {
        List<String> range = new ArrayList<>();
         range = stringRedisTemplate.opsForList().range("shop::Type", 0, -1);
        log.info("列表数据是"+range);
        //如果有值返回
        if (null != range && range.size()>0) {
            List<ShopType> shopTypeList = new ArrayList<>();
        for (String s : range){
            ShopType shopType = JSONUtil.toBean(s, ShopType.class);
            shopTypeList.add(shopType);
            }
            return Result.ok(shopTypeList);
        }

        //缓存为空---查询数据库数据
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.orderByAsc("sort");
        List<ShopType> shopTypeList = shopTypeMapper.selectList(queryWrapper);
        for (ShopType shopType : shopTypeList){
            String s = JSONUtil.toJsonStr(shopType);
            range.add(s);
        }
            //缓存到redis中
            stringRedisTemplate.opsForList().rightPushAll("shop::Type",range);
        if (null == shopTypeList){
            return Result.fail("数据为空");
        }
            return Result.ok(shopTypeList);

    }

hash的数据类型操作：

缓存思路：

首先通过opsForHash().entries().values()获取Collection的集合对象，并判断数据是否存在。如果存在则先创建List<ShopType>的集合对象，用于接收Collection集合对象遍历所得到的数据，并返回给客户端；

如果不存在则查询数据库，并遍历缓存到redis中，并将数据返回给客户端

 public Result queryTypeList() {
        //1.根据Key值获取Redis中的缓存值
        Collection<Object> shopTypes = stringRedisTemplate.opsForHash().entries("shop::type::hash").values();
        log.info("中Redis中获取到的数据是" + shopTypes);
        //2.判断是否有值，有值则返回
        if (!shopTypes.isEmpty()) {
            List<ShopType> shopTypeList = new ArrayList<>();
            shopTypes.forEach(a -> shopTypeList.add(JSONObject.parseObject(a.toString(), ShopType.class)));
            return Result.ok(shopTypeList);
        }
        //3.没有值则查询数据库
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.orderByAsc("sort");
        List<ShopType> shopTypeList = shopTypeMapper.selectList(queryWrapper);
        //4.将查到的数据缓存到redis中
        shopTypeList.forEach(shopType -> stringRedisTemplate.opsForHash().put("shop::type::hash",shopType.getId().toString(),JSONObject.toJSONString(shopType)));
        if (null == shopTypeList) {
            return Result.fail("数据为空");
        }
        return Result.ok(shopTypeList);
    }

Set数据类型的缓存操作：
缓存思路：

首先通过members()方法根据key获取到set集合数据，如果数据存在，先创建List<ShopType> shopTypeList用于封装数据返回给客户端，循环获取到的数据封装进该集合中，如果数据不存在则从数据库中获取数据，之后循环遍历通过opsForSet().add();方法放入缓存中，再将源数据返回给客户端。

   public Result queryTypeList() {
        //1.根据Key值获取Redis中的缓存值
        Set<String> members = stringRedisTemplate.opsForSet().members("shop::type::set");
        log.info("中Redis中获取到的数据是" + members);
        //2.判断是否有值，有值则返回
        if (!members.isEmpty()) {
            List<ShopType> shopTypeList = new ArrayList<>();
            members.forEach(a -> shopTypeList.add(JSONUtil.toBean(a, ShopType.class)));
            return Result.ok(shopTypeList);
        }
        //3.没有值则查询数据库
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.orderByAsc("sort");
        List<ShopType> shopTypeListDate = shopTypeMapper.selectList(queryWrapper);
        //4.将查到的数据缓存到redis中
        shopTypeListDate.forEach(shopType -> stringRedisTemplate.opsForSet().add("shop::type::set",JSONUtil.toJsonStr(shopType)));
        if (null == shopTypeListDate) {
            return Result.fail("数据为空");
        }
        return Result.ok(shopTypeListDate);
    }

zset数据类型的缓存操作：
缓存思路：首先通过range()方法根据key获取到set集合数据，如果数据存在，先创建List<ShopType> shopTypeList用于封装数据返回给客户端，循环获取到的数据封装进该集合中，如果数据不存在则从数据库中获取数据，之后循环遍历通过opsForZSet() .add();方法放入缓存中，再将源数据返回给客户端。

    @Override
    public Result queryTypeList() {
        //1.根据Key值获取Redis中的缓存值
        Set<String> range = stringRedisTemplate.opsForZSet().range("shop::type::zet", 0, -1);
        log.info("中Redis中获取到的数据是" + range);
        //2.判断是否有值，有值则返回
        if (!range.isEmpty()) {
            List<ShopType> shopTypeList = new ArrayList<>();
            range.forEach(a -> shopTypeList.add(JSONUtil.toBean(a, ShopType.class)));
            return Result.ok(shopTypeList);
        }
        //3.没有值则查询数据库
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.orderByAsc("sort");
        List<ShopType> shopTypeListDate = shopTypeMapper.selectList(queryWrapper);
        //4.将查到的数据缓存到redis中
        shopTypeListDate.forEach(shopType -> stringRedisTemplate.opsForZSet().add("shop::type::zet",JSONUtil.toJsonStr(shopType),shopType.getSort()));
        if (null == shopTypeListDate) {
            return Result.fail("数据为空");
        }
        return Result.ok(shopTypeListDate);
    }