【解决方案】Java 互联网项目中常见的 Redis 缓存应用场景 ...

目录

• 前言
  
• 一、常见 key-value
  
• 二、时效性强
  
• 三、计数器相干
  
• 四、高实时性
  
• 五、排行榜系列
  
• 六、文章小结
  

前言

在笔者 3 年的 Java 一线开辟经历中，尤其是一些移动端、用户量大的互联网项目，经常会使用到 Redis 作为缓存中间件的基本工具来解决一些特定的问题。
下面是笔者总结梳理的一些常见的 Redis 缓存应用场景，例如常见的 String 类型 Key-Value、对时效性要求高的场景、Hash 结构的场景以及对实时性要求高的场景等，基本涵盖了 Redis 中全部的 5 种基本类型。
假如你也在项目中经常使用 Redis 来作为缓存的中间件，那么你一定不会对下面的内容感到陌生。假如你还是刚入行不久，暂时还没接触到 Redis 这样的缓存中间件，那么也没关系，本篇文章对你也会有一定的帮助。
关于缓存的一些基本概念，大家可以看这里再回顾一下：https://www.cnblogs.com/CodeBlogMan/p/18022719
一、常见 key-value

首先介绍的是项目开辟中常见的一些String 类型的 key-value 结构场景，如：

• 使用 jsonStr 结构存储的用户登录信息，包括：手机号、token、唯一 uuid、昵称等；
  
• jsonStr 结构某个热门商品的信息，包括：商品名称、商品唯一id、所属商家、价格等；
  
• String 类型的、带过期时间的分布式锁，包括：锁的超时时间、随机生成的 value、判断加锁乐成、释放锁等。
  

下面用简单的 demo 来演示一下怎样获取用户登录信息。

1. @RestController
2. @RequestMapping("/member")
3. public class MemberController {
5.     @Resource
6.     private MemberService memberService;
8.     /**
9.      * 通过 userUuid 获取会员信息
10.      * @param userUuid
11.      * @return 会员信息
12.      */
13.     @GetMapping("/info")
14.     public Response<MemberVO> getMemberInfo(@RequestParam(value = "userUuid") String userUuid) {
15.         return ResponseBuilder.buildSuccess(this.memberService.info(userUuid));
16.     }
18. }

复制代码

1.     @Resource
2.     private RedisTemplate<String, String> redisTemplate;   
4.     private final String MEMBER_INFO_USER_UUID_KEY = "initial.member.user.uuid.key";
5.    
6.     @Override
7.     public MemberVO info(String userUuid) {
8.         //先查缓存
9.         String memberStr = redisTemplate.opsForValue().get(RedisKey.MEMBER_INFO_USER_UUID_KEY.concat(userUuid));
10.         if (StringUtils.isNotBlank(memberStr)){
11.             return JSON.parseObject(memberStr, MemberVO.class);
12.         }
13.         //缓存没有再查数据库
14.         LambdaQueryWrapper<Member> wrapper = new LambdaQueryWrapper<>();
15.         wrapper.eq(Member::getMemberUuid, userUuid)
16.                 .eq(Member::getEnableStatus, NumberUtils.INTEGER_ZERO)
17.                 .eq(Member::getDataStatus, NumberUtils.INTEGER_ZERO);
18.         return this.getOne(wrapper).convertExt(MemberVO.class);
19.     }

复制代码

1. /**
2. * 仅部分核心属性
3. */
4. @EqualsAndHashCode(callSuper = true)
5. @Data
6. public class MemberVO extends BaseVO {
7.     /**
8.      * 用户唯一uuid
9.      */
10.     private String memberUuid;
11.     /**
12.      * 登录 token
13.      */
14.     private String token;
15.     /**
16.      * 用户昵称
17.      */
18.     private String nickName;
19.     /**
20.      * 电话号码
21.      */
22.     private String mobile;
23.     /**
24.      * 头像地址
25.      */
26.     private String avatarImg;
27.     /**
28.      * 性别：1-male，2-female，3-unknown
29.      */
30.     private Integer gender;
31. }

复制代码

二、时效性强

在开辟的时候我们经常会碰到时效性强的一些场景，从业务上对过期时间的要求比较高，比如：

• 如某个项目大概活动的预览链接，设定该链接在 30 分钟后失效，即过半小时后不答应再访问该预览链接；
  
• 从 web 端跳转到 app 客户端访问一些特定的内容，使用剪切板复制的分享口令打开客户端，设定在 60 分钟后过期；
  
• 用户在客户端大概小步伐领取的优惠券，领取后放入“我的卡券”中，差别类型的卡券设定差别的过期时间，如某积分券在 30 天后过期等。
  

下面举两个例子，demo 虽然简单但是可以运行，不是伪代码：

1.     /**
2.      * 活动预览链接 30 分钟后过期
3.      */
4.     @Test
5.     public void testPreviewLinkExpire(){
6.         String baseUrl = "http://localhost:8089/initial/ealbum/preview/detail";
7.         Long projectId = UUIDUtils.generateUUIDToLong();
8.         String projectUuid = UUIDUtils.generateUUID();
9.         //这里是链接的签名，如果签名过期，那么意味着整个链接过期
10.         String tempLinkSign = DigestUtils.md5Hex(projectUuid);
11.         String signKey = RedisKey.INITIAL_EALBUM_TEMP_LINK_SIGN_KEY.concat(".").concat(projectId.toString());
12.         stringRedisTemplate.opsForValue().set(signKey, tempLinkSign, Duration.ofMinutes(30));
13.         String sign = stringRedisTemplate.opsForValue().get(signKey);
14.         if (StringUtils.isNotBlank(sign)){
15.             //拼接临时地址
16.             StringBuilder tempLinkUrl = new StringBuilder(baseUrl)
17.                     .append("?projectId=").append(projectId)
18.                     .append("&sign=").append(sign);
19.             log.info("打印看下预览地址：{}", tempLinkUrl);
20.         }
21.         throw new BusinessException("生成预览链接失败！");
22.     }

复制代码

1.     /**
2.      * 剪切板口令码1小时过期
3.      */
4.     @Test
5.     public void testClipboardTextKey(){
6.         //这里先随机生产一个 uuid 作为例子
7.         String articleId = UUIDUtils.generateUUID();
8.         String redisKey = RedisKey.CLIP_BOARD_TEXT_KEY.concat(".").concat(articleId);
9.         String value = JSON.toJSONString(ClipboardVO.builder()
10.                 .articleId(articleId)
11.                 .articleTitle("测试标题")
12.                 .copyright(NumberUtils.INTEGER_ZERO).build());
13.         //很简单的一个结构，就是常见的 String 类型的 key-value，但是对时效性有要求，一个小时后直接失效
14.         stringRedisTemplate.opsForValue().set(redisKey, value, Duration.ofHours(1));
15.         //这里去拿 value，判断是否过期
16.         ClipboardVO vo = Optional.ofNullable(stringRedisTemplate.opsForValue().get(redisKey))
17.                 .filter(StringUtils::isNotBlank)
18.                 .map(val -> JSON.parseObject(val, ClipboardVO.class))
19.                 .orElse(null);
20.         log.info("打印一下返回的vo：{}", vo);
21.     }

复制代码

三、计数器相干

关于计数器也是 Redis 的一个常见应用场景了，比如以下几点：

• 点赞数/收藏数：文章的点赞数，文章的收藏数，可以同步到文章表作为一个属性；
  
• 文章评论数：接纳 String 结构，redis-key 可以是文章 id 标识，redis-value 则是评论数，也可以同步到文章表作为一个属性；
  
• 未读消息数：接纳 Hash 结构，常量 redis-key，用户标识为 hash-key，数量为 hash-value，需要同步到关照表；
  
• 加入购物车的商品数：接纳 BoundHash 结构，redis-key 为用户标识，hash-key 为商品 id 标识，hash-value 为数量，需要同步到购物车的表。
  

下面举两个例子吧，部分实体、DTO/VO 之类的没有写明，大家能意会就好，重要的是思路：

1.     /**
2.      * 用户未读通知数量计数
3.      */
4.     @Test
5.     public void testNoticeCountNum() {
6.         //关于热 Key 这里场景有点不够：因为通知数量只有启动app和点击按钮的时候才会调用，并不是那么地频繁，QPS 几万应该没问题
7.         //但有大 key 的可能性，那么：1、定期清理缓存，配合数据库解决；2、Hash 底层会压缩数据；3、看占用内存的大小或者元素的数量；4、数据分片
8.         NoticeAddDTO dto = NoticeAddDTO.builder()
9.                 .targetUserUuid("123qwe456rty789uio")
10.                 .superType(NumberUtils.INTEGER_TWO)
11.                 .subType(5)
12.                 .content("内容内容").build();
13.         //无论何种业务系统的何种类型消息，先入数据库
14.         Notification notification = this.notificationService.addNotice(dto);
15.         //1、按消息的 tab 类型来做，可以为每一种类型都新建一个Redis-Key来单独存，这样是可行的，从某种程度上来说是拆 Key
16.         //2、思考了一下还是用 Hash 结构，用 List 或者 String 可以解决类型的问题，但是难以按照用户来取值
17.         HashOperations<String, String, Integer> hashOperations = redisTemplate.opsForHash();
18.         //由于一个小时会清除全部缓存，当前未读数量需要查数据库来确认
19.         this.notificationService.checkUnReadCount(notification);
20.         if (NumberUtils.INTEGER_ONE.equals(notification.getSuperType()) && NumberUtils.INTEGER_ONE.equals(notification.getSubType())) {
21.             //业务系统产生的消息，未读消息数+1；
22.             Long increment = hashOperations.increment(RedisKey.INITIAL_NOTICE_COMMENT_NUM_PERFIX, dto.getTargetUserUuid(), 1);
23.             log.info("新增的评论tab消息数量：{}", increment);
24.         }
25.         if (NumberUtils.INTEGER_TWO.equals(dto.getSuperType())) {
26.             Long increment = hashOperations.increment(RedisKey.INITIAL_NOTICE_NUM_PERFIX, dto.getTargetUserUuid(), 1);
27.             log.info("新增的通知tab消息数量：{}", increment);
28.         }
29.         //业务系统撤回消息，未读数-1
30.         if (NumberUtils.INTEGER_TWO.equals(dto.getSuperType())) {
31.             //Redis里不存在去做自减一，得到的就是-1；所以一定有值，不用判空只需判断正负
32.             Long num = hashOperations.increment(RedisKey.INITIAL_NOTICE_NUM_PERFIX, dto.getTargetUserUuid(), -1);
33.             log.info("撤回后通知tab消息数量：{}", num);
34.             int intNUm = num.intValue();
35.             //为了避免出现负数，要拿0作为界限来比
36.             int result = intNUm < NumberUtils.INTEGER_ZERO ? NumberUtils.INTEGER_ZERO : intNUm;
37.             hashOperations.put(RedisKey.INITIAL_NOTICE_NUM_PERFIX, dto.getTargetUserUuid(), result);
38.         }
39.     }

复制代码

1.     /**
2.      * 用户加入购物车的商品计数
3.      */
4.     @Resource
5.     private ShoppingCarService shoppingCarService;
6.     @Test
7.     public void testUserShoppingCarInfo(){
8.         //首选方案：boundHashOps() 在使用上的主要区别就是需要先绑定 Redis-Key，方便后续操作；而 opsForHash() 则是直接操作数据
9.         String userUuid = "1656698374114156635";
10.         String gooId = "3523465836543623675";
11.         Long shopId = 34776547437357643L;
12.         //1、首先是入参DTO的信息应该至少包含哪些？
13.         ShoppingCarGoodInfoDTO dto = ShoppingCarGoodInfoDTO.builder()
14.                 .userUuid(userUuid).goodId(gooId)
15.                     .goodName("商品名称").goodDesc("618专属活动商品")
16.                 .price(BigDecimal.valueOf(98.99D))
17.                 .shopId(shopId).shopName("xx品牌旗舰店")
18.                 .quantities(2).manufactureTime(1720146162L).build();
19.         ShoppingCar shoppingCar = dto.convertExt(ShoppingCar.class);
20.         //2、先入数据库
21.         this.shoppingCarService.save(shoppingCar);
22.         //3、再入 redis：将用户 uuid 作为 redis-key，goodId 作为 hash-key，商品的具体信息为 hash-value
23.         BoundHashOperations<String, String, String> operations = redisTemplate.boundHashOps(userUuid);
24.         //这样就是有多少个用户，就有多少个Redis-Key；虽然一般来说用不完，也不会造成大 Key 问题，但数量多了无疑是对资源的一种巨大消耗，要考虑成本
25.         String goodInfo = JSON.toJSONString(shoppingCar);
26.         operations.put(gooId, goodInfo);
27.         //入 redis 的时候直接设置7天过期时间，这样可以定期删除 Key 保证空间
28.         operations.expire(Duration.ofDays(7));
29.         //计数
30.         Long size = operations.size();
31.         log.info("打印看下数量：{}", size);
32.         //todo: 更新购物车时也是先入数据库，再更新 Redis，并设置过期时间；查询时先查 Redis，没有再查数据库，然后重新写入数据库，设置过期时间
33.     }

复制代码

四、高实时性

实时性要求高的场景，一般指的是：用户在使用某个功能时，服务可以或许近乎实时地提供效果。且并发量高时，假如每次都去请求数据库，那么所花费的开销对系统来说无疑是种挑战和压力。假如将数据存储在 Redis 中进行取用，那么其响应速度将会是极快的。
下面举 2 个例子：

• 用户在 app 客户端发表的评论，需要实时地展示在评论区，这个场景对性能有较高的要求，用 Redis 可以做到即进即出，而且方便入数据库；
  
• 文章系统在编写文章时会选用一些媒体资源如图片、视频等，那么对于媒资系统而言，将这些数据立即同步到媒资系统就十分有须要了；
  

1.     /**
2.      * 性能要求高，评论即进即出，而且可以入库
3.      */
4.     @Test
5.     public void testCommentList(){
6.         TestCommentAddDTO dto = TestCommentAddDTO.builder()
7.                 .parentId(NumberUtils.INTEGER_ZERO)
8.                 .articleType(NumberUtils.INTEGER_ONE)
9.                 .articleTitle("新闻06").articleId(12)
10.                 .content("评论一下看看").creatorName("用户375368")
11.                 .creatorUuid("abc123def789UUID").createTime(new Date())
12.                 .build();
13.         //评论队列先入 Redis 缓存，从队列左边进入，值得注意的是，List 结构只是表示队列的形式，具体的数据结构是 String 类型的
14.         Long num = stringRedisTemplate.opsForList().leftPush(RedisKey.COMMENT_IMPORT_LIST, JSON.toJSONString(dto));
15.         //这里返回的数量是该队列的大小
16.         log.info("评论队列先入 Redis 缓存，数量为：{}", num);
17.         //经验证，这里的方法是根据Redis-Key 弹出（即删除）全部的 Value，并且设置超时时间为 5 秒；leftPull 配合 rightPop 就是先进先出
18.         String str = stringRedisTemplate.opsForList().rightPop(RedisKey.COMMENT_IMPORT_LIST,5, TimeUnit.SECONDS);
19.         log.info("从右边弹出全部 Redis 队列缓存的内容，内容为：{}", str);
20.         //反序列化解析
21.         TestCommentAddDTO result = Optional.ofNullable(str)
22.                 .filter(StringUtils::isNotBlank)
23.                 .map(val -> JSON.parseObject(val, TestCommentAddDTO.class))
24.                 .orElse(null);
25.         log.info("打印一下：{}", result);
26.         //todo：接下来可以入数据库
27.     }

复制代码

1.     /**
2.      * 性能要求高，立即同步文章选用的媒体信息到媒资系统
3.      */
4.     @Test
5.     public void testMediaSet(){
6.         ArrayList<String> imageList = new ArrayList<>();
7.         imageList.add("20240702165612_image_xxx_filename_Media.png");
8.         imageList.add("20240702164556_image_xxx_filename_Media.png");
9.         ArrayList<String> videoList = new ArrayList<>();
10.         videoList.add("20240702152319_video_xxx_filename_Media.mp4");
11.         ArticleMediaDTO dto = ArticleMediaDTO.builder()
12.                 .articleId(123L)
13.                 .articleTitle("测文章")
14.                 .articleType(NumberUtils.INTEGER_TWO)
15.                 .imageMediaId(imageList)
16.                 .videoMediaId(videoList).build();
17.         //这里每次只添加一条，但是需要保证整个队列没有重复的元素，故选择Set
18.         stringRedisTemplate.opsForSet().add(RedisKey.INITIAL_ARTICLE_MEDIA_KEY_SET, JSON.toJSONString(dto));
19.         //这里pop()是随机弹出一个元素，由于每次都是及时弹出的，所以队列里有的话只会有一个，否则为空
20.         String str = stringRedisTemplate.opsForSet().pop(RedisKey.INITIAL_ARTICLE_MEDIA_KEY_SET);
21.         ArticleMediaDTO result = Optional.ofNullable(str)
22.                 .filter(StringUtils::isNotBlank)
23.                 .map(val -> JSON.parseObject(val, ArticleMediaDTO.class))
24.                 .orElse(null);
25.         log.info("打印一下弹出的内容：{}", result);
26.         //todo: 接下来还可以与 MQ 配合进行通知操作
27.     }

复制代码

五、排行榜系列

顾名思义，排行的场景很好理解，无论是 web 网页应用还是 app 客户端，都有很多需要排行的场景，如：

• 用户参与活动的成绩排名
  
• 用户参与某个抽奖游戏的积分排名
  
• 用户在 app 内的活泼度排名
  

而 Redis 提供的 ZSet 聚集数据类型结构能很好地实现各种复杂的排行榜需求，下面举一个 demo 来简单实现。

1.     /**
2.      * 计算用户成绩排名，ZSet 的 Score 需要根据一个权重来生成，最终 Redis 就会根据 Score 来排序
3.      */
4.     @Test
5.     public void testUserScoreRanking(){
6.         //1、首先看分数（平均分、总分、最高分），总之按照配置会得到有一个分数；如果是整数那么就直接看用时，如果是小数会取小数点后两位
7.         //2、如果分数相同，那么比谁的用时少（平均用时、总用时、最短用时），总之会得到一个用时，时间统一都精确到毫秒
8.         //3、如果分数和用时都完全一样，那么就看交卷时间，谁的的交卷时间早谁就排前面，这里的时间也精确到毫秒
9.         ScoreData scoreData = ScoreData.builder()
10.                 .finalScore(82.36D)
11.                 .spendTime(368956L)
12.                 .submitTime(1719915961902L).build();
13.         Long activityId = UUIDUtils.generateUUIDToLong();
14.         String userUuid = UUIDUtils.generateUUID();
15.         //注意：分数取大，用时取小，这样的组合无法组成权重；如果将用时取反，即剩余时间，那么剩余时间取大，两者都成正比就能形成一个权重了
16.         //具体：1、分数右移两位，组成权重的整数部分；
17.         BigDecimal scoreBigDecimal = BigDecimal.valueOf(scoreData.getFinalScore()).movePointRight(NumberUtils.INTEGER_TWO);
18.         //2、用一天的毫秒数 - 用时毫秒树 = 剩余时间，剩余时间小数点左移8位，组成权重的小数部分；
19.         long time = Constants.MAX_DAY_TIME - scoreData.getSpendTime();
20.         BigDecimal spendTimeBig = BigDecimal.valueOf(time).movePointLeft(8);
21.         //3、整数部分+小数部分，即为 ZSet 的权重
22.         BigDecimal weight = scoreBigDecimal.add(spendTimeBig);
23.         //Java 的 BigDecimal 类提供了任意精度的计算，能完全满足对当代数学算术运算结果的精度要求，广泛运用于金融、科学计算等领域。
24.         String rankingKey = RedisKey.INITIAL_ACTIVITY_PLAYER_SCORE_RANKING_KET.concat(".").concat(activityId.toString());
25.         //最后到这里就可以写进 ZSet 了
26.         stringRedisTemplate.opsForZSet().add(rankingKey, userUuid, weight.doubleValue());
27.     }

复制代码

六、文章小结

到这里本篇文章就结束了，关于在实际 Java 互联网项目开辟中常见的 Redis 缓存应用场景着实另有很多，以上只是我做的一些总结。
今天的分享就到这里，如有不足和错误，还请大家指正。大概你有其它想说的，也欢迎大家在评论区交流！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。