SpringCloud(十一）- 秒杀 抢购

1、流程图

1.1 数据预热

1.2 抢购

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

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

1.5 查看订单状态

1.6 支付 (获取支付链接 )

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

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

2、incr 和 setnx

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、实现代码

主要是抢购的业务；

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、测试

4.1 初始化库存

4.2 抢购

4.2.1 抢购情况

4.2.2 redis中数据变化情况

4.3 查看订单详情

4.4 订单支付

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