Redis( stringRedisTemplate)添加缓存数据

素颜马尾好姑娘i 2024-04-07 13:35 56阅读 0赞

> 在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<Object, Object> 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<String, Object> 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<String> shopTypeList = new ArrayList<>();
            shopTypeList = stringRedisTemplate.opsForList().range(CACHE_SHOP_TYPE_KEY,0,-1);
            //2.判断是否缓存中了
            //3.中了返回
            if (!shopTypeList.isEmpty()){
                List<ShopType> typeList = new ArrayList<>();
                for (String str:shopTypeList) {
                    ShopType shopType = JSONUtil.toBean(str, ShopType.class);
                    typeList.add(shopType);
                }
                return Result.ok(typeList);
            }
            //不存在，从数据库中查询
            List<ShopType> 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<Content> getLike() {
>             String key = "carousel:like";
>             List<String> stringList = new ArrayList<>();
>             stringList = stringRedisTemplate.opsForSet().randomMembers(key, 6);
>             if (!stringList.isEmpty()){
>                 List<Content> contents = new ArrayList<>();
>                 for (String s : stringList) {
>                     Content content = JSONUtil.toBean(s, Content.class);
>                     contents.add(content);
>                 }
>                 return contents;
>             }
>             //查询数据库
>             //未命中查询数据库
>             List<Content> contents = baseMapper.selectList(new QueryWrapper<Content>().eq("category_id",3));
>     
>             //添加redis并返回6条数据
>             List<Content> 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<Movie> getpopularList() {
>             List<Movie> movies = new ArrayList<>();
>             Set<String> set = stringRedisTemplate.opsForZSet().reverseRange(MOVIE_POPULAR,0,-1);
>               //判断是否命中缓存
>               if (set != null && set.size()>0){
>                   List<String> zsetStrings = new ArrayList<>(set);
>                   //命中返回
>                   for (String zsetString : zsetStrings) {
>                      movies.add(JSONUtil.toBean(zsetString,Movie.class));
>                   }
>                   return movies;
>               }
>             movies = baseMapper.selectList(new QueryWrapper<Movie>().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;
>         }