SpringCloud(十一）- 秒杀抢购

V2AS问路

SpringCloud(十一）- 秒杀抢购

阅读原文时间：2023年07月08日阅读：3

1.1 数据预热

1.2 抢购

1.3 生成订单 (发送订单消息)

1.4 订单入库 (监听消费订单消息)

1.5 查看订单状态

1.6 支付 (获取支付链接 )

1.7 支付成功微信回调 (发送支付成功消息)

1.8 支付成功返回给前端成功 (监听支付成功消息)

2.1 incr

Redis Incr 命令将 key 中储存的数字值增一。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。且将key的有效时间设置为长期有效。

2.1.1 常见使用场景

2.1.1.1 计数

我们可能常会统计网站页面每天访问量，通过incr命令在redis中设置key，每次增加1，设置24小时过期。

2.1.1.2 限流

日常的开放平台API一般常有限流，利用redis的incr命令可以实现一般的限流操作。如限制某接口每分钟请求次数上限1000次

2.1.1.3 幂等

MQ防止重复消费也可以利用INCR命令实现，如订单防重，订单5分钟之内只能被消费一次，订单号作为redis的key

2.2 sexnx

Redis使用setnx命令实现分布式锁;

2.1.1 加锁

版本一#但是这种方式的缺点是容易产生死锁，因为客户端有可能忘记解锁，或者解锁失败。
setnx key value

版本二#给锁增加了过期时间，避免出现死锁。但这两个命令不是原子的，第二步可能会失败，依然无法避免死锁问题。
setnx key value
expire key seconds

版本三（推荐）#通过“set...nx...”命令，将加锁、过期命令编排到一起，它们是原子操作了，可以避免死锁。
set key value nx ex seconds

2.1.2 解锁

解锁就是删除代表锁的那份数据。

del key

参考博客：https://blog.csdn.net/weixin_45525272/article/details/126562119

主要是抢购的业务；

3.1模块分析

3.2 web模块

3.2.1 application.yml

点击查看代码

# 端口
server:
  port: 8106

# 服务名
spring:
  application:
    name: edocmall-seckill-web

# redis 配置
  redis:
    host: 127.0.0.1
    port: 6379

# eureka 注册中心的配置
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:8096/eureka  # 注册中心的地址

# 秒杀抢购自定义配置
kh96:
  seckill:
    buy-user-count-prefix: seckill-buy-user-count # 请求用户数量的限制头标识
    buy-prod-stock-count: 100 # 初始化腔骨商品的库存数量，存入redis，实际开发中，没有此配置(初始化商品库存，在洗头膏添加抢购商品是)
    buy-prod-stock-prefix: seckill-buy-prod-stock # 抢购商品数量 头标识
    buy-user-lock-prefix: seckill-buy-user-lock # 锁定抢购用户的头标识
    buy-prod-lock-prefix: seckill-buy-prod-lock # 锁定商品库存锁头标识

3.2.2 SeckillConfig 配置类

点击查看代码

/**
 * Created On : 9/11/2022.
 * <p>
 * Author : huayu
 * <p>
 * Description: SeckillConfig
 */
@Data
@Component
@ConfigurationProperties(prefix = "kh96.seckill")
public class SeckillConfig {

    /*
        请求用户数量的限制头标识
     */
    private String  buyUserCountPrefix;

    /*
        初始化抢购商品的库存数量
     */
    private Integer buyProdStockCount;

    /*
        抢购商品数量 头标识
     */
    private String buyProdStockPrefix;

    /*
        锁定抢购用户的头标识
     */
    private String buyUserLockPrefix;

    /*
        锁定商品库存锁头标识
     */
    private String buyProdLockPrefix;

}

3.2.3 抢购接口和实现类

3.2.3.1 接口

点击查看代码

/**
 * Created On : 9/11/2022.
 * <p>
 * Author : huayu
 * <p>
 * Description: 秒杀抢购的业务接口
 */
public interface SeckillService {

    /**
     * @author : huayu
     * @date   : 9/11/2022
     * @param  : [prodId, stockCount]
     * @return : void
     * @description : 初始化商品库存到缓存
     */
    boolean  initProdStock2Redis(String prodId,Integer stockCount);

    /**
     * @author : huayu
     * @date   : 9/11/2022
     * @param  : [productId]
     * @return : boolean
     * @description : 校验抢购商品的请求数量是否达到上限
     */
    boolean checkBuyUserCount(String productId);

    /**
     * @author : huayu
     * @date   : 9/11/2022
     * @param  : [prodId, buyCount]
     * @return : boolean
     * @description : 校验商品库存是否充足
     */
    boolean checkProdStockEnough(String prodId,Integer buyCount);

    /**
     * @author : huayu
     * @date   : 9/11/2022
     * @param  : [userId, prodId]
     * @return : boolean
     * @description : 校验用户是否已经抢购过当前商品
     */
    boolean checkBuyUserBought(String userId,String prodId);

    /**
     * @author : huayu
     * @date   : 9/11/2022
     * @param  : [userId]
     * @return : boolean
     * @description : 校验商品库存是否锁定
     */
    boolean checkProdStockLocked(String prodId);

    /**
     * @author : huayu
     * @date   : 9/11/2022
     * @param  : [prodId]
     * @return : boolean
     * @description : 释放库存锁
     */
    void unLockProdStock(String prodId);

    /**
     * @author : huayu
     * @date   : 9/11/2022
     * @param  : [prodId, butCount]
     * @return : void
     * @description : 扣减库存
     */
    void subProdStockCount(String prodId, Integer butCount);

}

3.2.3.2 实现类

点击查看代码

/**
 * Created On : 9/11/2022.
 * <p>
 * Author : huayu
 * <p>
 * Description: 抢购业务接口实现类
 */
@Service
public class SeckillServiceImpl implements SeckillService {

    @Autowired
    private RedisUtils redisUtils;

    @Autowired
    private SeckillConfig seckillConfig;

    @Override
    public boolean initProdStock2Redis(String prodId, Integer stockCount) {
        // 判断redis中，是否存在已经初始化的商品库存数据，如果已经存在，不需要再次初始化
        if (ObjectUtils.isEmpty(redisUtils.get(seckillConfig.getBuyProdStockPrefix() + ":" + prodId))){

            // 将商品库存添加到redis中
            return redisUtils.set(seckillConfig.getBuyProdStockPrefix() + ":" + prodId, stockCount);
        }

        // 已经存在商品库存，不需要设置
        return false;
    }

    @Override
    public boolean checkBuyUserCount(String prodId) {
        // 使用redis的incr操作，校验当前商品的抢购用户数是否达到上限
        return redisUtils.incr(seckillConfig.getBuyUserCountPrefix() + ":" + prodId, 1)
                > Integer.parseInt(redisUtils.get(seckillConfig.getBuyProdStockPrefix() + ":" + prodId).toString()) * 2;
    }

    @Override
    public boolean checkProdStockEnough(String prodId, Integer buyCount) {

        //校验商品库存，是否大于等于用户抢购数量，如果小于，代表库存不足
        //TODO 如果redis 没有查到库存(库存没初始化，或者后台误删，必须要进行数据库查询操作，获取库存，
        // 要加锁，只有一个线程取操作)，再同步到redis

        return Integer.parseInt(redisUtils.get(seckillConfig.getBuyProdStockPrefix() + ":" + prodId).toString())
                >= buyCount;

    }

    @Override
    public boolean checkBuyUserBought(String userId, String prodId) {

        //使用redis的分布式锁，sexnx,
        // 如果上锁成功，代表没有买过，可以继续购买,如果上锁失败，表示购买过不能继续购买
        //锁时长为正抢购活动时长
        return ! redisUtils.lock( seckillConfig.getBuyUserLockPrefix()+":"+userId,
                                null,
                                15*60); //模拟 抢购时长
    }

    @Override
    public boolean checkProdStockLocked(String prodId) {
        //使用redis的分布式锁，sexnx,如果上锁成功，代表库存没有被锁，如果上锁失败代表库存被其他用户锁定不能购买
        //锁库存必须要增加时长限制，防止库存锁释放失败，导致用户无法抢购，过期仍然会释放
        return ! redisUtils.lock(seckillConfig.getBuyProdLockPrefix()+":"+prodId,
                                null,
                                2*60); //模拟锁2分钟

    }

    @Override
    public void unLockProdStock(String prodId) {
        //删除redis中的 库存锁
        redisUtils.del(seckillConfig.getBuyProdLockPrefix()+":"+prodId);
    }

    @Override
    public void subProdStockCount(String prodId, Integer butCount) {
        //扣减 redis中缓存的商品库存数量
        //TODO redis缓存中操成功后，要发异步消息 到队列  更新数据库中商品库存呢
        redisUtils.decr(seckillConfig.getBuyProdStockPrefix() + ":" + prodId,
                butCount);

    }

}

3.2.4 远程调用订单模块进行下单

点击查看代码

/**
 * Created On : 10/11/2022.
 * <p>
 * Author : huayu
 * <p>
 * Description: SeckillOrderFeignService
 */
@FeignClient(value = "edocmall-seckill-order")
public interface SeckillOrderFeignService {

    /**
     * @author : huayu
     * @date   : 10/11/2022
     * @param  : [userId, prodId, buyCount]
     * @return : java.lang.String
     * @description : 远程调用订单中心，生成秒杀抢购订单的接口
     */
    @GetMapping("/createSeckillOrder")
    String feignInvokeCreateSeckillOrder(@RequestParam(value = "userId") String userId,
                              @RequestParam(value = "prodId") String prodId,
                              @RequestParam(value = "buyCount") Integer buyCount);

}

3.2.5 抢购控制层

点击查看代码

/**
 * Created On : 9/11/2022.
 * <p>
 * Author : huayu
 * <p>
 * Description: 秒杀操作入口
 */
@Slf4j
@RestController
@Api(tags = "秒杀操作")
public class SeckillController {

    @Autowired
    private SeckillService seckillService;

    @Autowired
    private SeckillOrderFeignService seckillOrderFeignService;

    /**
     * @author : zhukang
     * @date   : 2022/11/9
     * @param  : [userId, prodId, buyCount]
     * @return : com.kgc.scd.util.RequestResult<?>
     * @description : 模拟初始化商品库存，实际开发中，没有此操作，是在后台添加抢购商品预热是，直接同步到redis
     */
    @GetMapping("/initProdStock")
    @ApiOperation(value = "1 初始库存", notes = "抢购商品预热，初始化商品库存数量到redis中")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "初始化商品id",name = "prodId"),
            @ApiImplicitParam(value = "初始化商品数量",name = "stockCount")
    })
    public RequestResult<?> initProdStock(@RequestParam String prodId,
                                          @RequestParam Integer stockCount){

        log.info("------ 初始化商品：{}，库存数量：{}，到redis缓存中 ------", prodId, stockCount);

        // 增加业务逻辑处理：防止瞬时请求过多，使用redis的incr原子操作，进行请求用户数的统计计数，如果请求已经达到了上限（比如：设定请求用户数最多是抢购商品库存的2倍），其它后续所有的请求都默认无效，返回失败：当前请求用户过多，请稍后重试
        if(seckillService.initProdStock2Redis(prodId, stockCount)){
            return ResultBuildUtil.success("初始化商品库存成功！");
        }
        // 初始化商品库存失败
        return ResultBuildUtil.fail("601", "初始化商品库存失败，请确认redis库存是否已初始化！");
    }

    @GetMapping("/seckillBuy")
    @ApiOperation(value = "2 开始秒杀", notes = "基于redis，RabbitMQ消息队列，实现有序秒杀抢购功能")
    @ApiImplicitParams({
        @ApiImplicitParam(value = "用户id",name = "userId"),
        @ApiImplicitParam(value = "商品id",name = "prodId"),
        @ApiImplicitParam(value = "抢购数量",name = "buyCount")
    })
    public RequestResult<?> seckillBuy(@RequestParam String userId,
                                       @RequestParam String prodId,
                                       @RequestParam Integer buyCount){

        log.info("------ 用户：{}，购买商品：{}，购买数量：{}，开始抢购 ------", userId, prodId, buyCount);

        // TODO 增加请求许可校验（自定义注解+拦截器），校验请求此接口的所有用户是否是已登录用户，如果没有登录，提示请登录
        // TODO 增加接口参数的校验，判断用户是否是系统正常用户，不能是状态异常用户，判断商品的数据是否正确（切记：涉及系统内数据不要信任请求参数，要信任系统的缓存的数据库）

        // TODO 为了提高抢购入口的并发处理能力，要减少数据库交互，可以设计为根据商品编号，从redis缓存中查询商品，如果商品信息存在，则参与抢购，如果不存在，还是需要到数据库查询商品，如果数据库中存在，将商品信息存入redis缓存，如果数据库不存在，则直接提示抢购失败。
        // TODO 此种场景，正常情况，没有问题，可能存在的问题，某个商品，是首次参与抢购，缓存中没有数据，但是数据库有，虽然上面的处理方式，可以解决，但是在高并发场景下，同一时刻会有大批量的请求来秒杀此商品，此时同时去缓存中获取商品数据，没有获取到，又同时去数据库查询，就会导致数据库扛不住压力，可能直接数据库挂掉。
        // TODO 解决方式：缓存商品数据一般都是在后台添加抢购商品时，直接对商品进行预热处理，即：事先把参与抢购的商品直接同步到redis缓存中，这样当抢购开始，直接从redis缓存就可以获取到商品，而不会出现缓存击穿问题。
        // TODO 虽然商品数据预热方式，可以解决此类问题，但是可能还会存在例外（比如：缓存中的商品由于后台失误操作，导致设置的过期时间不对，缓存时间提前过期，或者缓存数据误删除），此种情况还是需要当缓存不存在商品数据，从数据库查询，放入缓存的逻辑。
        // TODO 解决方式：可以进行加锁，限制在高并发的情况下访问数据库，如果同一时刻，缓存中没有获取到商品数据库，就进入查询数据库操作，但是在进入查询前，增加分布式锁，只有获取到锁的请求，才可以查询数据库并加入到缓存中（加完就释放锁），获取不到锁的请求，直接返回失败（损失当前请求，后续请求进行弥补，只要一个操作成功，缓存中的数据就存在，后续的请求自然可以获取到数据）
        // TODO 极端情况：redis无法使用，必须要增加redis的高可用，确保redis永远是有效的，考虑的模式就是集群模式下的哨兵机制。或者把大批量的请求直接放到消息队列，进行缓冲处理。

        log.info("------------------------------ 进行请求用户数的统计计数，防止请求过多  -----------------------------------------");
        // 增加业务逻辑处理：防止瞬时请求过多，使用redis的incr原子操作，进行请求用户数的统计计数，如果请求已经达到了上限（比如：设定请求用户数最多是抢购商品库存的2倍），其它后续所有的请求都默认无效，返回失败：当前请求用户过多，请稍后重试
        if(seckillService.checkBuyUserCount(prodId)){
            return ResultBuildUtil.fail("602", "抢购失败，当前抢购用户过多，请稍后重试！");
        }

        log.info("------------------------------            查看库存是否充足           -----------------------------------------");
        //校验商品库存数量是否充足，可以进行后续抢购，日过不足,直接抢购失败
        log.info("------ 用户：{}，购买商品：{}，购买数量：{}，库存校验 ------", userId, prodId, buyCount);
        if(!seckillService.checkProdStockEnough(prodId,buyCount)){
            //库存不足，返回抢购失败
            log.info("------ 用户：{}，购买商品：{}，购买数量：{}，库存不足 ------", userId, prodId, buyCount);
            return ResultBuildUtil.fail("603", "抢购失败，库存不足，缺货！");
        }

        log.info("------------------------------            判断用户是否抢购过           -----------------------------------------");
        //增加幂等操作：当前抢购用户只能抢购一次，如果已经抢购过商品，不允许再次抢购(限制一个用户同一个抢购商品，整个抢购期间只能抢购一次)
        log.info("------ 用户：{}，购买商品：{}，购买数量：{}，锁定抢购用户,如果 已经抢购过商品，不允许再次抢购 ------", userId, prodId, buyCount);
        if(seckillService.checkBuyUserBought(userId,prodId)){
            //用户抢购过，返回抢购失败
            log.info("------ 用户：{}，购买商品：{}，购买数量：{}，重复抢购 ------", userId, prodId, buyCount);
            return ResultBuildUtil.fail("604", "抢购失败，重复抢购！");
        }

        log.info("------------------------------            用户获取库存锁           -----------------------------------------");
        //执行抢购业务，先给商品库存上锁(锁库存)，如果上锁成功，代表当前用户继续抢购商品，如果上锁失败，说明有人抢购，进行等待
        log.info("------ 用户：{}，购买商品：{}，购买数量：{}，(尝试获取库存锁) 执行抢购业务，先给商品库存上锁(锁库存),拿到 库存锁 才可以开始下单 ------", userId, prodId, buyCount);
        while (true){
            //死循环，尝试锁库存，如果锁库存成功，代表库存所已经被释放
            if(!seckillService.checkProdStockLocked(prodId)){
                log.info("------ 用户：{}，购买商品：{}，购买数量：{}，锁库存成功，拿到 库存锁 ，开始下单------", userId, prodId, buyCount);
                //结束循环，执行抢购下单
                break;
            }
            log.debug("------ 用户：{}，购买商品：{}，购买数量：{}，锁库存成功失败,等待。。。------", userId, prodId, buyCount);
        }

        log.info("------------------------------     已经获得库存锁，再次判断库存是否充足  -----------------------------------------");
        //考虑高并发的场景：
        //多人同时校验库存成功，但是进入到抢购下单业务时，库存呢只够部分人购买，需要再确定库存是否足够
        //校验商品库存数量是否充足，可以进行后续抢购，日过不足,直接抢购失败
        log.info("------ 用户：{}，购买商品：{}，购买数量：{}，锁库存后(拿到库存锁后)  再次 库存校验 ------",userId, prodId, buyCount);
        if(!seckillService.checkProdStockEnough(prodId,buyCount)){
            //释放库存锁，后续用户继续尝试购买
            //库存剩余2两，还有三个人买，库存不足，后续两个人各买一件
            //释放库存锁
            seckillService.unLockProdStock(prodId);
            log.info("------ 用户：{}，购买商品：{}，购买数量：{}，再次 库存校验，库存不足 ------", userId, prodId, buyCount);

            //库存不足，返回抢购失败
            log.info("------ 用户：{}，购买商品：{}，购买数量：{}，抢购下单中，库存不足 ------", userId, prodId, buyCount);
            return ResultBuildUtil.fail("605", "抢购失败，库存不足，缺货！");
        }

        log.info("------------------------------            开始扣减库存           -----------------------------------------");
        //执行扣减商品库存
        log.info("------ 用户：{}，购买商品：{}，购买数量：{}，扣减库存 ------", userId, prodId, buyCount);
        seckillService.subProdStockCount(prodId,buyCount);

        log.info("------------------------------               开始下单           -----------------------------------------");
        //开始调用订单中心的生成抢购订单接口，下单并返回给前端，抢购结果
        //先模拟下单成功，返回一个抢购订单号
        log.info("------ 用户：{}，购买商品：{}，购买数量：{}，开始下单 ------", userId, prodId, buyCount);
//        String seckillOrderNo = "SK"+ LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"))
//                + UUID.randomUUID().toString().substring(0,5);

        String seckillOrder = seckillOrderFeignService.feignInvokeCreateSeckillOrder(userId, prodId, buyCount);

        log.info("------------------------------       下单成功 主动释放库存锁        -----------------------------------------");
        //生成抢购订单成功，立刻释放库存锁，给其他抢购用户购买
        log.info("------ 用户：{}，购买商品：{}，购买数量：{}，下单成功，释放库存锁 ------", userId, prodId, buyCount);
        seckillService.unLockProdStock(prodId);

        log.info("------ 用户：{}，购买商品：{}，购买数量：{}，抢购成功 ------", userId, prodId, buyCount);

        //返回抢购成功，实际开发不能返回此种格式的数据
        //必须使用key和value的返回，方便前端获取订单号
        return ResultBuildUtil.success("抢购成功，抢购订单"+seckillOrder);
    }

}

3.3 订单模块

3.3.1 application.yml

点击查看代码

# 端口
server:
  port: 8107

# 服务名
spring:
  application:
    name: edocmall-seckill-order

  # redis
  redis:
    host: 127.0.0.1
    port: 6379

  # RabbitMQ
  rabbitmq:
    host: 1.117.75.57
    port: 5672
    username: admin
    password: admin

# eureka 注册中心的配置
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:8096/eureka  # 注册中心的地址

3.3.2 OrderMQDirectConfig

点击查看代码

/**
 * Created On : 1/11/2022.
 * <p>
 * Author : huayu
 * <p>
 * Description: Direct直连模式，自动配置类，自动创建队列，交换机，并将队列绑定到交换机，指定唯一路由
 */
@Configuration
public class OrderMQDirectConfig {

    /**
     * @author : huayu
     * @date   : 1/11/2022
     * @param  : []
     * @return : org.springframework.amqp.core.Queue
     * @description : directQueue
     */
    @Bean
    public Queue directQueue(){

        return new Queue(OrderMQConstant.SECKILL_SAVE_ORDER_QUEUE_KH96,true);
    }

    /**
     * @author : huayu
     * @date   : 1/11/2022
     * @param  : []
     * @return : org.springframework.amqp.core.DirectExchange
     * @description : 创建直连交换机
     */
    @Bean
    public DirectExchange directExchange(){
        // 创建支持持久化的直连交换机，指定交换机的名称
        return new DirectExchange(OrderMQConstant.SECKILL_SAVE_ORDER_EXCHANGE_KH96U);
    }

    /**
     * @author : huayu
     * @date   : 1/11/2022
     * @param  : []
     * @return : org.springframework.amqp.core.Binding
     * @description : 将直连队列和直连交换机进行绑定，并指定绑定的唯一路由键
     */
    @Bean
    public Binding directBinding(){
        // 将直连队列和直连交换机进行绑定，并指定绑定的唯一路由键
        return BindingBuilder.bind(directQueue())
                            .to(directExchange())
                            .with(OrderMQConstant.SECKILL_SAVE_ORDER_ROUTING_KH96);
    }

}

3.3.3 OrderMQConstant

点击查看代码

/**
 * Created On : 1/11/2022.
 * <p>
 * Author : huayu
 * <p>
 * Description: RabbitMQ 常量类，系统的所有队列名，交换机名，路由键名等，统一进行配置管理
 */
public class OrderMQConstant {

    //========================== 直连模式
    /**
     * Direct直连模式 队列名
     */
    public static final String SECKILL_SAVE_ORDER_QUEUE_KH96 ="seckill_save_order_queue_kh96";

    /**
     * Direct直连模式 交换机名
     */
    public static final String SECKILL_SAVE_ORDER_EXCHANGE_KH96U ="seckill_save_order_exchange_kh96";

    /**
     * Direct直连模式 路由键
     */
    public static final String SECKILL_SAVE_ORDER_ROUTING_KH96 ="seckill_save_order_routing_kh96";

    //========================== 扇形模式

    /**
     * Fanout 扇形模式 队列名
     */
    public static final String ACCOUNT_FANOUT_QUEUE_KH96 ="account_pay_result_queue_kh96";

}

3.3.4 下订单业务层

3.3.4.1 接口

点击查看代码

/**
 * Created On : 10/11/2022.
 * <p>
 * Author : huayu
 * <p>
 * Description:
 */
public interface SeckillOrderService {

    /**
     * @author : huayu
     * @date   : 11/11/2022
     * @param  : [seckillOrder]
     * @return : void
     * @description : 生成秒杀订单
     */
    void saveSeckillOrder(Map<String,Object> seckillOrder);

}

3.3.4.2实现类

点击查看代码

/**
 * Created On : 10/11/2022.
 * <p>
 * Author : huayu
 * <p>
 * Description: SeckillOrderServiceImpl
 */
@Service
@Slf4j
public class SeckillOrderServiceImpl implements SeckillOrderService {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Autowired
    private RedisUtils redisUtils;

    @Override
    public void saveSeckillOrder(Map<String, Object> seckillOrder) {

        //发送生成抢购订单的消息到消息队列，并在redis中添加此订单的记录，模拟交互
        //0 正在生成
        if(redisUtils.set(seckillOrder.get("seckillOrderNo").toString(),0)){
            //发送生成订单的消息
            rabbitTemplate.convertAndSend(OrderMQConstant.SECKILL_SAVE_ORDER_EXCHANGE_KH96U,
                    OrderMQConstant.SECKILL_SAVE_ORDER_ROUTING_KH96,
                    seckillOrder);

        }

    }

}

3.3.5 SeckillOrderSaveListener

点击查看代码

/**
 * Created On : 1/11/2022.
 * <p>
 * Author : huayu
 * <p>
 * Description: Direct 直连模式消费者 One
 */
@Slf4j
@Component
//指定接听的 消息队列 名字
@RabbitListener(queues = OrderMQConstant.SECKILL_SAVE_ORDER_QUEUE_KH96)
public class SeckillOrderSaveListener {

    @Autowired
    private RedisUtils redisUtils;

    /**
     * @author : huayu
     * @date   : 1/11/2022
     * @param  : [directMsgJson]
     * @return : void
     * @description : Direct 直连模式消费者One,消费信息
     */
    //指定消息队列中的消息，交给对应的方法处理
    @RabbitHandler
    public void saveSeckillOrder(Map<String,Object> seckillOrder){
        log.info("***** 秒杀抢购订单：{}，开始入库 ******",seckillOrder.get("seckillOrderNo"));

        //TODO 将消息中的订单实体对象，调入业务接口，插入到数据库

        redisUtils.set(seckillOrder.get("seckillOrderNo").toString(),1);

        log.info("***** 秒杀抢购订单：{}，入库成功 ******",seckillOrder.get("seckillOrderNo"));

    }

}

3.3.6 下单控制层

点击查看代码

/**
 * Created On : 10/11/2022.
 * <p>
 * Author : huayu
 * <p>
 * Description: 秒杀抢购订单入口
 */
@Slf4j
@RestController
public class SeckillOrderController {

    @Autowired
    private SeckillOrderService seckillOrderService;

    /**
     * @author : huayu
     * @date   : 10/11/2022
     * @param  : [userId, prodId, buyCount]
     * @return : java.lang.String
     * @description : 生成秒杀抢购订单
     */
    @GetMapping("/createSeckillOrder")
    public String createSeckillOrder(@RequestParam String userId,
                                     @RequestParam String prodId,
                                     @RequestParam Integer buyCount){

        log.info("****** 用户：{}，购买商品：{}，购买数量：{}，生成抢购订单 ******", userId, prodId, buyCount);

        //TODO 必须要有参数校验，必须要有用户，商品信息的校验，确定用户是否正常，商品是否还在抢购中
        //TODO 再次强调所有的中心模块，数据来源，不能信任外部接口来源的参数，都必须从数据库或者缓存中获取，尤其是跟金钱相关
        //TODO 所有的接口必需要校验结束，通过获取的数据，封装订单实体对象，用户不关系订单的生成业务，可以使用异步消息队列，实现晓峰，并快速响应

        //模拟生成一个抢购订单号，并封装成订单实体对象，通过map集合模拟
        String seckillOrderNo = "SK"+ LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"))
                + UUID.randomUUID().toString().substring(0,5);

        //创建订单实体对象
        Map<String, Object> seckillOrder = new HashMap<>();
        seckillOrder.put("userId",userId);
        seckillOrder.put("prodId",prodId);
        seckillOrder.put("buyCount",buyCount);

        //TODO 其他的订单属性封装，比如收货人，总价格，优惠，时间等
        seckillOrder.put("seckillOrderNo",seckillOrderNo);

        //发送到生成订单的消息队列中，使用异步处理
        seckillOrderService.saveSeckillOrder(seckillOrder);

        //返回抢购订单
        return  seckillOrder.toString();

    }

}

3.4 查询订单状态和订单支付部分不再赘述

4.1 初始化库存

4.2 抢购

4.2.1 抢购情况

4.2.2 redis中数据变化情况

4.3 查看订单详情

4.4 订单支付

支付的时候数注意穿透的路径；

手机扫一扫

移动阅读更方便

你可能感兴趣的文章

SpringCloud(十一）- 秒杀 抢购

1.1 数据预热

1.2 抢购

1.3 生成订单 (发送订单消息)

1.4 订单入库 (监听 消费订单消息)

1.5 查看订单状态

1.6 支付 (获取支付链接 )

1.7 支付成功 微信回调 (发送 支付成功消息)

1.8 支付成功 返回给前端成功 (监听 支付成功消息)

2.1 incr

2.1.1 常见使用场景

2.1.1.1 计数

2.1.1.2 限流

2.1.1.3 幂等

2.2 sexnx

2.1.1 加锁

2.1.2 解锁

3.1模块分析

3.2 web模块

3.2.1 application.yml

3.2.2 SeckillConfig 配置类

3.2.3 抢购接口和实现类

3.2.3.1 接口

3.2.3.2 实现类

3.2.4 远程调用订单模块进行下单

3.2.5 抢购 控制层

3.3 订单模块

3.3.1 application.yml

3.3.2 OrderMQDirectConfig

3.3.3 OrderMQConstant

3.3.4 下订单业务层

3.3.4.1 接口

3.3.4.2实现类

3.3.5 SeckillOrderSaveListener

3.3.6 下单 控制层

3.4 查询订单状态和订单支付部分不再赘述

4.1 初始化库存

4.2 抢购

4.2.1 抢购情况

4.3 查看订单详情

4.4 订单支付

SpringCloud(十一）- 秒杀抢购

1.4 订单入库 (监听消费订单消息)

1.7 支付成功微信回调 (发送支付成功消息)

1.8 支付成功返回给前端成功 (监听支付成功消息)

3.2.5 抢购控制层

3.3.6 下单控制层