高并发场景下的流量包扣减流程实现

敲键盘的小夜猫

已于 2024-04-03 08:29:10 修改

阅读量509

点赞数 10

文章标签： redis java

于 2024-04-02 23:39:57 首次发布

本文链接：https://blog.csdn.net/qq_30294911/article/details/137293033

版权

背景介绍

在低并发场景下，直接通过RPC调用进行业务处理通常是一种简单而有效的方案。这种方法不仅省去了复杂的中间件和额外的通信开销，而且配合强一致性的业务逻辑，可以确保数据的一致性。然而，在高并发场景下，这种简单直接的方式可能会显露出其不足之处。在海量用户请求的情况下，频繁的RPC调用会导致系统资源过度占用，从而导致系统性能持续下降，最终可能导致系统崩溃。

这里以短链预扣减流程为例阐述优化过程，创建短链会先判断当前用户当天所持有的流量包是否有剩余次数，随后扣减/更新流量包，再创建短链，反之不允许创建。

在这种情况下，用户请求首先需要经过扣减流量包的步骤，耗时约150毫秒，接着是短链的创建，耗时约50毫秒，最后还需发送MQ消息，耗时约50毫秒。整个流程的耗时达到250毫秒。在高并发和海量用户请求的情况下，这样的处理机制会更加严重，因为大量的请求同时涌入系统，会导致系统资源被持续占用，进而影响系统的性能。针对这个问题，采用预扣减机制是一个有效的缓解方法。预扣减机制可以在用户实际进行操作之前，提前检查用户的流量包情况并进行扣减。

预扣减模型简介

采用预扣减机制后，用户请求仅需耗时100毫秒，因为在预扣减判断、创建和发送MQ消息之后，就可以立即返回响应消息了。

这种预扣减模型也可以应用于秒杀抢购场景中，其实现流程如图：

代码实现

创建短链、扣减流量包、发送MQ消息

短链服务关键代码

#用于rpc调用token验证
rpc.token=8b15-65c987e9320b


@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class UseTrafficRequest {


    /**
     * 账号
     */
    private Long accountNo;

    /**
     * 业务id, 短链码
     */
    private String bizId;
}

@FeignClient(name = "account-service")
public interface TrafficFeignService {

    /**
     * 使用流量包
     *
     * @param shortLinkCode 业务id,短链则是短链码
     * @return
     */
    @PostMapping(value = "/api/traffic/v1/reduce", headers = {"rpc-token=${rpc.token}"})
    JsonData useTraffic(@RequestBody UseTrafficRequest request);
}

扣减流量包关键代码

//先判断是否短链码被占用
ShortLinkDO shortLinCodeDOInDB = shortLinkManager.findByShortLinCode(shortLinkCode);

  if (shortLinCodeDOInDB == null) {
    boolean reduceFlag = reduceTraffic(eventMessage,shortLinkCode);
    if (reduceFlag) {
    ShortLinkDO shortLinkDO = ShortLinkDO.builder().accountNo(accountNo).code(shortLinkCode)                               .title(addRequest.getTitle()).originalUrl(addRequest.getOriginalUrl())
                                .domain(domainDO.getValue()).groupId(linkGroupDO.getId())
                                .expired(addRequest.getExpired()).sign(originalUrlDigest)
                                .state(ShortLinkStateEnum.ACTIVE.name()).del(0).build();
                        shortLinkManager.addShortLink(shortLinkDO);
                        return true;
               }
    }
    
    /**
     * 扣减流量包
     *
     * @param eventMessage
     * @return
     */
    private boolean reduceTraffic(EventMessage eventMessage,String shortLinkCode) {
        //处理流量包扣减
        //根据短链类型，检查是否有足够多的流量包  分布式事务问题
        UseTrafficRequest request = UseTrafficRequest.builder()
                .accountNo(eventMessage.getAccountNo())
                .bizId(shortLinkCode)
                .build();

        JsonData jsonData = trafficFeignService.useTraffic(request);
        //使用流量包
        if (jsonData.getCode() != 0) {
            log.error("流量包不足，扣减失败操:{}", eventMessage);
            return false;
        }
        return true;
    }

账号服务关键代码

@Value("${rpc.token}")
private String rpcToken;
    
@PostMapping("reduce")
public JsonData useTraffic(@RequestBody UseTrafficRequest useTrafficRequest, HttpServletRequest request){

        //具体使用流量包逻辑
        String requestToken = request.getHeader("rpc-token");

        if (rpcToken.equalsIgnoreCase(requestToken)) {
            JsonData jsonData = trafficService.reduce(useTrafficRequest);
            return jsonData;
        } else {
            return JsonData.buildError("非法访问");
        }
    }

日剩余流量包计算存储

/**
  * 1天总的流量包
  */
public static final String DAY_TOTAL_TRAFFIC = "lock:traffic:day_total:%s";

//先更新，再扣减当前使用的流量包
int rows = trafficManager.addDayUsedTimes(accountNo,useTrafficVO.getCurrentTrafficDO().getId(),1);

        if(rows != 1){throw new BizException(BizCodeEnum.TRAFFIC_REDUCE_FAIL);}

        //往Redis设置流量包总次数，短链服务那边递减次数，如果有新增流量包，则删除这个key TODO
        long leftSeconds = TimeUtil.getRemainSecondsOneDay(new Date());
        String totalKey = String.format(RedisKey.DAY_TOTAL_TRAFFIC, accountNo);
        //减少1是减去此次的流量次数
        redisTemplate.opsForValue().set(totalKey, useTrafficVO.getDayTotalLeftTimes() - 1, leftSeconds, TimeUnit.SECONDS);
        return JsonData.buildSuccess();

    /** TimeUtil
     * 获取当天剩余的秒数,用于流量包过期配置
     * @param currentDate
     * @return
     */
    public static Integer getRemainSecondsOneDay(Date currentDate) {
        LocalDateTime midnight = LocalDateTime.ofInstant(currentDate.toInstant(),
                ZoneId.systemDefault()).plusDays(1).withHour(0).withMinute(0)
                .withSecond(0).withNano(0);

        LocalDateTime currentDateTime = LocalDateTime.ofInstant(currentDate.toInstant(),
                ZoneId.systemDefault());
        long seconds = ChronoUnit.SECONDS.between(currentDateTime, midnight);
        return (int) seconds;
    }

预扣减流量包Lua脚本

  //需要预先检查下是否有足够多的可以进行创建
        String cacheKey = String.format(RedisKey.DAY_TOTAL_TRAFFIC, accountNo);

        //检查key是否存在，然后递减，是否大于等于0，使用lua脚本
        // 如果key不存在，则未使用过，lua返回值是0； 新增流量包的时候，不用重新计算次数，直接删除key,消费的时候回计算更新

        String script = "if redis.call('get',KEYS[1]) then return redis.call('decr',KEYS[1]) else return 0 end";
        Long leftTimes = redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Arrays.asList(cacheKey), "");
        log.info("今日流量包剩余次数:{}", leftTimes);

        if (leftTimes >= 0) {
            String newOriginalUrl = CommonUtil.addUrlPrefix(request.getOriginalUrl());
            request.setOriginalUrl(newOriginalUrl);

            EventMessage eventMessage = EventMessage.builder().accountNo(accountNo)
                    .content(JsonUtil.obj2Json(request))
                    .messageId(IDUtil.geneSnowFlakeID().toString())
                    .eventMessageType(EventMessageType.SHORT_LINK_ADD.name())
                    .build();

            rabbitTemplate.convertAndSend(rabbitMQConfig.getShortLinkEventExchange(), rabbitMQConfig.getShortLinkAddRoutingKey(), eventMessage);

        } else {
            return JsonData.buildResult(BizCodeEnum.TRAFFIC_REDUCE_FAIL);
        }