当前位置： 首页 > news >正文

Java秒杀系统设计

news 来源：原创 2024/11/19 16:22:39

Java秒杀系统设计

系统大概的整体架构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W3bvuDBe-1665453447906)(%E7%A7%92%E6%9D%80%E7%B3%BB%E7%BB%9F%E8%AE%BE%E8%AE%A1.assets/image-20220927093908185.png)]

秒杀一般都是在高并发的场景下出现，这时候就需要考虑一些原则性的问题：

  1. 高并发

  2. 超卖

  3. 恶意请求

  4. 链接暴露

  5. 数据库

1.高并发

高并发是指在某一瞬间，一个接口突然收到爆发式请求，不做很好的限流保护，可能会造成系统的崩溃。

1.1生成订单代码

@Override
public void generateOrderByMq(GenerateOrderDto generateOrderDto) {
    log.info("------生成订单开始进行流量削峰-----");
    MqMessage<GenerateOrderMqDto> generateOrderDtoMqMessage = new MqMessage<>();
    GenerateOrderMqDto generateOrderMqDto = new GenerateOrderMqDto();
    generateOrderMqDto.setUserId(SecurityUtils.getUserId());
    generateOrderMqDto.setDeliveryType(generateOrderDto.getDeliveryType());
    generateOrderMqDto.setIsShopCar(generateOrderDto.getIsShopCar());
    generateOrderMqDto.setOneOrderDto(generateOrderDto.getOneOrderDto());
    generateOrderDtoMqMessage.setData(generateOrderMqDto);
    /*这里用mq的顺序队列 防止并发下库存出现混乱问题*/
    Boolean isSend = generateOrderProducer.sendOrderly(generateOrderDtoMqMessage);

}

1.2顺序消费生成者代码

package com.hjt.rocketmq.producer;

import com.hjt.constant.RocketMqConstant;
import com.hjt.message.MqMessage;
import com.hjt.myOrder.dto.GenerateOrderMqDto;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.SendStatus;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Objects;

/**
 * @author :hjt
 * @date : 2022/9/29
 */
@Component
public class GenerateOrderProducer {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    public Boolean sendOrderly(MqMessage<GenerateOrderMqDto> mqMessage) {
        // 有序消费
        SendResult sendResult = rocketMQTemplate.syncSendOrderly(RocketMqConstant.RQ_PRODUCER_GENERATE_ORDER_TOPIC, mqMessage, RocketMqConstant.RQ_PRODUCER_GENERATE_ORDER_KEY);
        SendStatus sendStatus = sendResult.getSendStatus();
        if (Objects.equals(sendStatus, SendStatus.SEND_OK)) {
            return true;
        }
        return false;
    }

}

1.3顺序队列消费者代码

package com.hjt.rocketmq.consumer;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSONUtil;
import com.hjt.constant.RocketMqConstant;
import com.hjt.myOrder.dto.GenerateOrderMqDto;
import com.hjt.myOrder.service.impl.OrderServiceImpl;
import com.hjt.util.OrderPreventMqConsumerUtil;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.ConsumeMode;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author :hjt
 * @date : 2022/9/29
 */
@Component
@RocketMQMessageListener(topic = RocketMqConstant.RQ_PRODUCER_GENERATE_ORDER_TOPIC,
        consumerGroup = RocketMqConstant.RQ_CONSUMER_GENERATE_ORDER_CONSUMER_GROUP, consumeMode = ConsumeMode.ORDERLY
)
public class GenerateOrderConsumer implements RocketMQListener<Message> {

    private static final Logger log = LoggerFactory.getLogger(GenerateOrderConsumer.class);

    @Autowired
    private OrderPreventMqConsumerUtil orderPreventMqConsumerUtil;


    @Autowired
    private OrderServiceImpl orderServiceImpl;


    @Override
    public void onMessage(Message message) {
        //防止消息被重复消费
        MessageExt messageExt = (MessageExt) message;
        String msgId = messageExt.getMsgId();
        log.info("msgId:" + msgId);
        //判断是否消费过
        boolean consumerMQ = orderPreventMqConsumerUtil.isConsumerMQ(msgId);
        if(consumerMQ){
            log.error("topic: " + RocketMqConstant.RQ_TOPIC_DELAYED_ORDER + " msgId: " + msgId + " 已被消费");
            return;
        }
        log.info("--------开始进行生成订单处理-----");
        String strBody = orderPreventMqConsumerUtil.exchangeStr(message.getBody());
        log.info("strBody: {}", strBody);
        //json转换
        GenerateOrderMqDto mqDto = JSONUtil.toBean(strBody, GenerateOrderMqDto.class);
        if(ObjectUtil.isNull(mqDto)){
            log.error("-----生成订单实体类为空-----");
            return;
        }
        /*这里是生成订单的业务逻辑*/
        Boolean isSuccess = orderServiceImpl.generateOrder(mqDto);
        if(!isSuccess){
            log.error("====生成订单信息失败===");
        }
        /*标记消息未已消费*/
        orderPreventMqConsumerUtil.addConsumerMQ(msgId);
    }

}

1.4生成订单代码

@Override
public Boolean generateOrder(GenerateOrderMqDto generateOrderMqDto) {
    //初始化返回类型
    List<ProductDto> products = new ArrayList<>();
    Long countAllPro = 0L;
    //计算总商品金额
    BigDecimal totalMoney = BigDecimal.ZERO;
    //商品id,多的以,分割
    String countAllProIds = "";

    List<OneOrderDto> oneOrderDto = generateOrderMqDto.getOneOrderDto();
    if (CollectionUtils.isEmpty(oneOrderDto)) {
        log.error("订单信息不能为空");
        return false;
    }
    //先根据雪花算法生成订单id
    Long orderId = snowFlake.nextId();
    //遍历计算每个商品对应的金额或者库存等等。。。
    for (int i = 0; i < oneOrderDto.size(); i++) {
        OneOrderDto oneOrder = oneOrderDto.get(i);
        //初始化商品
        Product product = null;
        //先查下该商品是否有库存
        LambdaQueryWrapper<Product> lambdaProduct = new LambdaQueryWrapper<>();
        lambdaProduct.eq(Product::getIsDelete, 0);
        lambdaProduct.eq(Product::getId, oneOrder.getProId());
        product = productMapper.selectOne(lambdaProduct);
        //商品已下架
        if (ObjectUtil.isNull(product)) {
            log.error("订单模块,商品id：" + oneOrder.getProId() + "已下架");
            return false;
        }
        //判断商品是否有库存
        if (product.getStock() <= 0) {
            log.error("订单模块,商品id：" + oneOrder.getProId() + "没有库存,请重新选择");
            return false;
        }

        /**对该商品进行加锁*/
        if (!versionLockUtil.versionLockReduceStock(product, lambdaProduct, oneOrder.getCount())) {
            log.error("订单模块,商品id：" + oneOrder.getProId() + "版本号机制获取库存失败,请稍微再试");
            return false;
        }

        //计算商品总金额
        countAllPro = countAllPro + oneOrder.getCount();

        //金额计算
        BigDecimal proCount = new BigDecimal(oneOrder.getCount());
        BigDecimal totalOnePro = product.getPrice().multiply(proCount);
        totalMoney = totalMoney.add(totalOnePro);
        //统计商品id
        countAllProIds = countAllProIds + String.valueOf(oneOrder.getProId()) + ",";

        //初始化
        ProductDto productDto = new ProductDto();
        productDto.setId(oneOrder.getProId());
        productDto.setStock(oneOrder.getCount());
        productDto.setPrice(product.getPrice());
        productDto.setProTitle(product.getProTitle());
        productDto.setOrderId(orderId);
        productDto.setUserId(SecurityUtils.getUserId());
        products.add(productDto);

        /*插入订单商品信息表*/
        OrderProductInfo orderProductInfo = new OrderProductInfo();
        orderProductInfo.setUserId(SecurityUtils.getUserId());
        orderProductInfo.setOrderId(orderId);
        orderProductInfo.setCount(oneOrder.getCount());
        orderProductInfo.setProductId(oneOrder.getProId());
        orderProductInfoMapper.insert(orderProductInfo);
    }
    Order oneOrder = new Order();
    oneOrder.setOrderId(orderId);
    //TODO 防止重复具体后续再实现

    //用rocketmq处理延迟付款
    MqMessage<List<ProductDto>> mqMessage = new MqMessage<>();
    mqMessage.setData(products);
    //  超时 没付款 回退库存 
    delayedOrderProducer.producerDelayedOrderSendOne(orderId, mqMessage);

   //初始化订单信息
    oneOrder.setCreateTime(LocalDateTime.now());
    oneOrder.setUserId(generateOrderMqDto.getUserId());
    oneOrder.setDeliveryType(generateOrderMqDto.getDeliveryType());
    //金额计算
    oneOrder.setTotal(totalMoney);
    oneOrder.setAllCount(countAllPro);
    oneOrder.setProId(countAllProIds);
    //未支付
    oneOrder.setIsPayed(false);
    oneOrder.setDeleteStatus(0);
    oneOrder.setVersion(0);
    orderMapper.insert(oneOrder);
    log.info("--------------订单信息初始化成功");

    /**异步修改商品库存*/
    this.asyncUpdateStockProducer(generateOrderMqDto.getOneOrderDto());
    return true;

}

需要注意的问题：

  1. mq队列不可以自定义抛出异常，例如：throw new BaseException(AuthException.AUTH_ERROR_MOBILE_EXIST);如果这样，mq会一直重试mq（重试16次，该消息会被重试16次，业务逻辑处理不好的话，会造成16次重复消费，导致业务上出现逻辑问题。）博主认为正确的做法应该是 记录错误的信息，然后就return返回了，后续再单独对这些错误的信息进行业务处理。

  2. mq防止被重复消费，这里博主用的是新建一张表，用一张表的主键去判断是否被消费过。（其实也可以用redis中set数据类型防止重复消费）

    ps：博主用上述代码，用JMeter测压测过1s1000000个请求生成订单也没问题。库存正常减少，包括生成订单后没付款也自己加回库存。

2.超卖解决方案

加乐观锁（为了效率问题抛弃悲观锁，且悲观锁可能会造成死锁问题）

乐观锁代码

/***
 * 版本号机制 更新库存（减库存）
 * @param product
 * @param lambdaProduct
 * @param count 商品库存
 */
public Boolean versionLockReduceStock(Product product, LambdaQueryWrapper<Product> lambdaProduct, Long count) {
    /*乐观锁  版本号机制*/
    /*用redis存版本号*/
    Long version = getVersion(product.getId());
    Product newProduct = productMapper.selectOne(lambdaProduct);
    Long newVersion = getVersion(newProduct.getId());

    /*redis获取库存*/
    Long stock = 0L;
    stock = getStock(product.getId());
    /*版本号一致就更新*/
    if (version.equals(newVersion)) {
        log.info("-----版本号一致,商品id为：" + product.getId() + "--- 版本号为:" + version);
        if (stock < count) {
            log.error("====当前商品没有足够的库存=====");
            return false;
        }
        stock = stock - count;
        log.info("当前库存为:" + newProduct);
        product.setStock(stock);
        redisUtil.set(RedisConstants.MODULES_ORDER_GENERATE_VERSION_KEY + String.valueOf(newProduct.getId()), newVersion + 1);
        /*redis修改库存*/
        if (redisUtil.set(RedisConstants.MODULES_ORDER_GENERATE_STOCK_KEY + newProduct.getId(), stock)) {
            return true;
        } else {
            return false;
        }
    }
    /*版本号不一致*/
    else {
        log.error("-----版本号不一致,商品id为：" + product.getId() + "--- 版本号为:" + version);
        /**睡眠2s 有3次机会*/
        for (int i = 0; i < 3; i++) {
            log.error("第：" + 1 + "次机会重试");
            ThreadUtil.safeSleep(2 * 1000);
            Product newestProduct = productMapper.selectOne(lambdaProduct);
            this.versionLockReduceStock(newestProduct, lambdaProduct, count);
        }

    }
    return false;
}

乐观锁建议是Version版本可以用redis来控制，用mysql中表的字段的话还需要update,如果请求多的时候，更新的语句其实本质上也是加锁，会造成程序的性能不高。

当然也可以用redisson的分布式锁，看门狗机制还是挺香的。

3.恶意请求（用Sentinel做限流）

sentinel详解介绍可以看我另外一篇文章。

用的是Sentinel进行请求保护

Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

建议nacos要和Sentinel结合，防止出现配置丢失

(ps：Sentinel如何安装使用请看我另外一篇博客)

/***
 * 秒杀流量削峰,避免1s收到很多请求
 * 这里用Sentinel防止生成订单被冲击
 */
@ApiOperation(value = "秒杀流量削峰,避免1s收到很多请求,生成订单(包含多个订单)")
@RequestMapping(method = RequestMethod.POST,value = "/generateOrderByMq")
@Log(title = "秒杀流量削峰,避免1s收到很多请求,生成订单(包含多个订单)")
@SentinelResource(value = "generateOrderByMq", blockHandler = "handleException",blockHandlerClass = OrderSentinelHandler.class)
public AjaxResult generateOrderByMq(@Valid @RequestBody GenerateOrderDto generateOrderDto) {
    orderService.generateOrderByMq(generateOrderDto);
    return AjaxResult.success();
}

主要代码

@SentinelResource(value = "generateOrderByMq", blockHandler = "handleException",blockHandlerClass = OrderSentinelHandler.class)

/**
 * @author :hjt
 * @date : 2022/10/10
 * Sentinel 自定义异常处理类
 * 异常状态码 8000-9000
 */
public class OrderSentinelHandler  {

    public static AjaxResult handleException(BlockException exception){
        return new AjaxResult(8001,"生成订单请求次数过多,请稍后再试");
    }
}

这里设置
在这里插入图片描述
QPS=并发量/平均响应时间

200只是个粗略的数值，具体可以根据你的业务进行调整。

4.链接暴露问题

链接加密（博主采用的是RSA加密算法）
具体加密算法可以看我这篇博客Java加密算法

这是请求订单的接口（加密后的参数这是前端直接传给我们的，这里我们模拟的是前端加密的场景）
Java代码例子

   //加密
    @Encrypt
    @PostMapping("/encryption")
    public GenerateOrderDto encryption(@Valid @RequestBody GenerateOrderDto generateOrderDto){
        GenerateOrderDto generateOrderDto1 = new GenerateOrderDto();
//        BeanUtil.copyProperties(generateOrderDto,generateOrderDto1);
        long time = System.currentTimeMillis();
        generateOrderDto.setTimestamp(time);
        return generateOrderDto;
    }
	//解密
    @Decrypt
    @PostMapping("/decryption")
    public AjaxResult Decryption(@RequestBody GenerateOrderDto generateOrderDto){
        return AjaxResult.success(generateOrderDto.toString());
    }

友情提示：
详情代码可以看下面我的个人项目地址 。https://github.com/hongjiatao/spring-boot-anyDemo

在这里插入图片描述
后端拿到参数进行解密
在这里插入图片描述
需要注意的是，再次请求该解密的接口，会报错。
在这里插入图片描述

这里博主还设置了一个参数只能被解密一次，也就是说前端传过来的加密参数只能用一次，这样做的好处就是即使黑客人员拿到我们加密后的参数，也无法大批量的去请求订单接口，有效的防止订单接口被黑客利用工具直接请求。

TODO // 2022/10/14写

5.数据库问题怎么防止被击穿。

后续补上。

个人搭建项目代码地址：
https://github.com/hongjiatao/spring-boot-anyDemo

欢迎收藏点赞三连。谢谢！有问题可以留言博主会24小时内无偿回复。

相关文章：

  • 昆明做网站首选互维/南宁网络推广有几家
  • 徐州做汽车销售的公司网站/今日头条新闻军事
  • wordpress菜单美化/免费发布信息网网站
  • 南通海洲建设集团网站/腾讯朋友圈广告投放价格
  • 张家港市人民政府关于网站建设/关键词优化好
  • 做网站怎么上传图片/腾讯与中国联通
  • （附源码）计算机毕业设计SSM基于Java的图书馆座位预约系统
  • 投资超百亿，这一重大水利项目让长江中下游地区防洪更安全了
  • 【Shell牛客刷题系列】SHELL13 去掉所有包含this的句子：awk与gawk命令的进阶使用
  • 多测师肖sir_高级讲师_第2个月第27讲解jmeter性能硬件指标
  • [Codeforces] combinatorics (R1600) Part.5
  • Python语法（1）- 基础语法，判断语句，循环语句，函数
  • 互联网摸鱼日报（2022-10-15）
  • 2022年了，我才开始学 typescript ，晚吗？（7.5k字总结）
  • 算法 - 查找众数及中位数
  • Hook--2.useRef、useCallback、useContext、useReducer
  • 实例展示如何使用JMeter操作Elasticsearch
  • leetcode 474一和零