Redis( stringRedisTemplate)添加缓存数据-阿里云开发者社区

Redis( stringRedisTemplate)添加缓存数据

2023-07-25 115

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

本文涉及的产品

云数据库 Redis 版，社区版 2GB

简介： 在redis中添加缓存数据大致思路:1，从redis中获取数据，如果存在，直接返回客户端2，不存在，查询数据库，并写入redis缓存3，如果从数据库查询为空，返回错误信息4，写入redis缓存并返回数据

通过String类型添加商品数据

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

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

1. public Result queryById(Long id) {
2. String shopKey = CACHE_SHOP_KEY + id;
3. //从redis中获取缓存
4. String shopJson = stringRedisTemplate.opsForValue().get(shopKey);
5. //判断是否存在
6. //如果存在直接返回查询结果
7. if (!StringUtils.isEmpty(shopJson)){
8. Shop shop = JSONUtil.toBean(shopJson, Shop.class);
9. return Result.ok(shop);
10.         }
11. //如果不存在，查询数据库
12. Shop shop = this.getById(id);
13. 
14. //如果数据库中也不存在，返回错误信息
15. if (shop==null){
16. return Result.fail("商品不存在");
17.         }
18. //将对象转为json存储
19. String shoptoJson = JSONUtil.toJsonStr(shop);
20. //如果存在写入redis缓存并返回查询信息
21.         stringRedisTemplate.opsForValue().set(shopKey,shoptoJson);
22. return Result.ok(shop);
23.     }

通过hash方式进行存储

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

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

1. public Result queryById(Long id) {
2. /**
3.          * 添加商户缓存,采用map形式
4.          */
5. String shopKey = CACHE_SHOP_KEY + id;
6. //如果缓存中有数据,直接返回客户端
7.         Map<Object, Object> shopMap = stringRedisTemplate.opsForHash().entries(shopKey);
8. if (shopMap!=null && shopMap.size()>0){
9. //将map转换为对象
10. Shop shop = BeanUtil.fillBeanWithMap(shopMap, new Shop(), false);
11. return Result.ok(shop);
12.         }
13. //如果缓存中没有数据,查询数据库并写入redis缓存
14. Shop shop = this.getById(id);
15. if (shop==null){
16. return Result.fail("不存在此商品");
17.         }
18. //将对象中的非String类型转为String类型
19.         Map<String, Object> shopMaps = BeanUtil.beanToMap(shop, new HashMap<>(),
20.                 CopyOptions.create().
21.                         setIgnoreNullValue(true).setFieldValueEditor((filedName, filedValue) -> {
22. if (filedValue == null) {
23.                                 filedValue = "0";
24.                             } else {
25.                                 filedValue = filedValue + "";
26.                             }
27. return filedValue;
28.                         }));
29. 
30.         stringRedisTemplate.opsForHash().putAll(shopKey,shopMaps);
31. return Result.ok(shop);
32.     }

通过List进行存储

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

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

1. public Result queryTypeList() {
2. //1.在redis中间查询,通过list获取商品类型
3.         List<String> shopTypeList = new ArrayList<>();
4.         shopTypeList = stringRedisTemplate.opsForList().range(CACHE_SHOP_TYPE_KEY,0,-1);
5. //2.判断是否缓存中了
6. //3.中了返回
7. if (!shopTypeList.isEmpty()){
8.             List<ShopType> typeList = new ArrayList<>();
9. for (String str:shopTypeList) {
10. ShopType shopType = JSONUtil.toBean(str, ShopType.class);
11.                 typeList.add(shopType);
12.             }
13. return Result.ok(typeList);
14.         }
15. //不存在，从数据库中查询
16.         List<ShopType> shopTypes = this.query().orderByAsc("sort").list();
17. if (shopTypes==null && shopTypes.size()>0){
18. return Result.fail("没有商品类型信息");
19.         }
20. //存在添加redis缓存
21. for(ShopType shopType : shopTypes){
22. String s = JSONUtil.toJsonStr(shopType);
23.             shopTypeList.add(s);
24.         }
25.         stringRedisTemplate.opsForList().rightPushAll(CACHE_SHOP_TYPE_KEY,shopTypeList);
26. return Result.ok(shopTypes);
27.     }

通过set进行存储

1. public List<Content> getLike() {
2. String key = "carousel:like";
3.         List<String> stringList = new ArrayList<>();
4.         stringList = stringRedisTemplate.opsForSet().randomMembers(key, 6);
5. if (!stringList.isEmpty()){
6.             List<Content> contents = new ArrayList<>();
7. for (String s : stringList) {
8. Content content = JSONUtil.toBean(s, Content.class);
9.                 contents.add(content);
10.             }
11. return contents;
12.         }
13. //查询数据库
14. //未命中查询数据库
15.         List<Content> contents = baseMapper.selectList(new QueryWrapper<Content>().eq("category_id",3));
16. 
17. //添加redis并返回6条数据
18.         List<Content> contentList = new ArrayList<>();
19. for (int i = 0; i < contents.size(); i++) {
20. String s = JSONUtil.toJsonStr(contents.get(i));
21.             stringRedisTemplate.opsForSet().add(key,s);
22. if (i<6){
23.                 contentList.add(contents.get(i));
24.             }
25.         }
26. return contentList;
27.     }

通过zset进行存储

1. public List<Movie> getpopularList() {
2.         List<Movie> movies = new ArrayList<>();
3.         Set<String> set = stringRedisTemplate.opsForZSet().reverseRange(MOVIE_POPULAR,0,-1);
4. //判断是否命中缓存
5. if (set != null && set.size()>0){
6.               List<String> zsetStrings = new ArrayList<>(set);
7. //命中返回
8. for (String zsetString : zsetStrings) {
9.                  movies.add(JSONUtil.toBean(zsetString,Movie.class));
10.               }
11. return movies;
12.           }
13.         movies = baseMapper.selectList(new QueryWrapper<Movie>().orderByDesc("score").last("limit 0,6"));
14. //写入redis数据库
15. for (Movie movie : movies) {
16. String s = JSONUtil.toJsonStr(movie);
17.               stringRedisTemplate.opsForZSet().add(MOVIE_POPULAR,s,movie.getScore());
18.           }
19. return movies;
20.     }

Redis( stringRedisTemplate)添加缓存数据

热门文章

最新文章

相关课程

相关电子书

相关实验场景