秒杀

  boolean exist = redisClient.query(productId,userId);
  if(exist) {
    return -1;
  }
  int stock = redisClient.queryStock(productId);
  if(stock <=0) {
    return 0;
  }
  redisClient.incrby(productId, -1);
  redisClient.add(productId,userId);
  return 1;

boolean exist = redisClient.query(productId,userId);
   if(exist) {
    return -1;
   }
   synchronized(this) {
       int stock = redisClient.queryStock(productId);
       if(stock <=0) {
         return 0;
       }
       redisClient.incrby(productId, -1);
       redisClient.add(productId,userId);
   }
return 1;

boolean exist = redisClient.query(productId,userId);
if(exist) {
  return -1;
}
if(redisClient.incrby(productId, -1)<0) {
  return 0;
}
redisClient.add(productId,userId);
return 1;

StringBuilder lua = new StringBuilder();
  lua.append("if (redis.call('exists', KEYS[1]) == 1) then");
  lua.append("    local stock = tonumber(redis.call('get', KEYS[1]));");
  lua.append("    if (stock == -1) then");
  lua.append("        return 1;");
  lua.append("    end;");
  lua.append("    if (stock > 0) then");
  lua.append("        redis.call('incrby', KEYS[1], -1);");
  lua.append("        return stock;");
  lua.append("    end;");
  lua.append("    return 0;");
  lua.append("end;");
  lua.append("return -1;");

if (jedis.setnx(lockKey, val) == 1) {
   jedis.expire(lockKey, timeout);
}

String result = jedis.set(lockKey, requestId, "NX", "PX", expireTime);
if ("OK".equals(result)) {
    return true;
}
return false;

try {
  Long start = System.currentTimeMillis();
  while(true) {
      String result = jedis.set(lockKey, requestId, "NX", "PX", expireTime);
     if ("OK".equals(result)) {
        return true;
     }
     
     long time = System.currentTimeMillis() - start;
      if (time>=timeout) {
          return false;
      }
      try {
          Thread.sleep(50);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
  }
} finally{
    unlock(lockKey,requestId);
}  
return false;

@Service("seckillSkuRelationService")
public class SeckillSkuRelationServiceImpl extends ServiceImpl<SeckillSkuRelationDao, SeckillSkuRelationEntity> implements SeckillSkuRelationService {

    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        QueryWrapper<SeckillSkuRelationEntity> queryWrapper = new QueryWrapper<SeckillSkuRelationEntity>();
        String promotionSessionId = (String) params.get("promotionSessionId");
        String key = (String) params.get("key");
        if (!StringUtils.isEmpty(key)){
            queryWrapper.eq("sku_id", key).or().eq("seckill_price", key);
        }
        if (!StringUtils.isEmpty(promotionSessionId)){
            //根据场次id进行查询
            queryWrapper.eq("promotion_session_id", promotionSessionId);
        }

        IPage<SeckillSkuRelationEntity> page = this.page(
                new Query<SeckillSkuRelationEntity>().getPage(params),
                queryWrapper
        );

        return new PageUtils(page);
    }

}

@EnableAsync // 启用Spring异步任务支持
@EnableScheduling // 启用Spring的计划任务执行功能
@Async 异步
@Scheduled(cron = "* * * * * ?")

/**
 *
 * 定时任务
 *      1、@EnableScheduling 开启定时任务
 *      2、Scheduled 开启一个定时任务
 *      3、自动配置类 TaskSchedulingAutoConfiguration 属性绑定在TaskExecutionProperties
 *
 * 异步任务
 *      1、@EnableAsync 开启异步任务功能
 *      2、@Async 给希望异步执行的方法上标注
 *      3、自动配置类 TaskExecutionAutoConfiguration
 *
 */
@Slf4j
@Component
@EnableAsync // 启用Spring异步任务支持
@EnableScheduling // 启用Spring的计划任务执行功能
public class HelloSchedule {

    /**
     * 1、Spring中6位组成，不允许第7位的年
     * 2、在周几的位置，1-7代表周一到周日：MON-SUN
     * 3、定时任务应该阻塞，默认是阻塞的
     *      1、可以让业务以异步的方式运行，自己提交到线程池
     *          CompletableFuture.runAsync(() -> {
     *              xxxService.hello();
     *          })
     *      2、支持定时任务线程池，设置 TaskSchedulingProperties
     *          spring.task.scheduling.pool.size=5
     *      3、让定时任务异步执行
     *          异步执行
     *     解决：使用异步 + 定时任务来完成定时任务不阻塞的功能
     */
//    @Async 异步
//    @Scheduled(cron = "* * * * * ?")
//    public void hello() {
//        log.info("hello...");
//    }
}

/**
 *  * 秒杀商品的定时上架；
 *  *      每天晚上3点；上架最近三天需要秒杀的商品
 *  *      当天00:00:00 - 23:59:59
 *  *      明天天00:00:00 - 23:59:59
 *  *      后天00:00:00 - 23:59:59
 * @author Klaus
 * @date 2022/9/27
 */
@Slf4j
@Service
public class SeckillSkuScheduled {

    @Autowired
    SeckillService seckillService;

    @Scheduled(cron = "0 0 1/1 * * ? ")
    public void uploadSeckillSkuLatest3Days(){
         seckillService.uploadSeckillSkuLatest3Days();
    }
}

@FeignClient("gulimall-coupon")
public interface CouponFeignService {

    @GetMapping("/coupon/seckillsession/latest3DaySession")
    R getLatest3DaySession();
}

/**
 * 获取最近3天的秒杀活动场次
 * @return
 */
@GetMapping("/latest3DaySession")
public R getLatest3DaySession(){
    List<SeckillSessionEntity> sessionEntities = seckillSessionService.getLatest3DaySession();
    return R.ok().setData(sessionEntities);
}

    @Autowired
    SeckillSkuRelationService seckillSkuRelationService;
	/**
     * 获取最近3天的秒杀活动场次
     *
     * @return
     */
    @Override
    public List<SeckillSessionEntity> getLatest3DaySession() {
        //获取最近三天信息

        List<SeckillSessionEntity> list = this.list(new QueryWrapper<SeckillSessionEntity>	().between("start_time", startTime(), endTime()));
        
        return null;
    }
	private String startTime() {
        LocalDate now = LocalDate.now();
        LocalTime min = LocalTime.MIN;
        LocalDateTime start = LocalDateTime.of(now, min);
        String format = start.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        return format;
    }

    private String endTime() {
        LocalDate now = LocalDate.now();
        LocalDate localDate = now.plusDays(2);
        LocalTime max = LocalTime.MAX;
        LocalDateTime end = LocalDateTime.of(localDate, max);
        String format = end.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        return format;
    }

/**
 * 秒杀活动场次
 * 
 * @author klaus
 * @email klaus@gmail.com
 * @date 2022-08-22 13:18:54
 */
@Data
@TableName("sms_seckill_session")
public class SeckillSessionEntity implements Serializable {
	......

   /**
    * 所有秒杀活动商品关联
    */
   @TableField(exist = false)
   private List<SeckillSkuRelationEntity> relationSkus;

}

/**
 * 获取最近3天的秒杀活动场次
 *
 * @return
 */
@Override
public List<SeckillSessionEntity> getLatest3DaySession() {
    //获取最近三天信息

    List<SeckillSessionEntity> list = this.list(new QueryWrapper<SeckillSessionEntity>().between("start_time", startTime(), endTime()));
    if (list != null && list.size() > 0) {
        List<SeckillSessionEntity> collect = list.stream().map(session -> {
            //获取秒杀场次id
            Long id = session.getId();
            //根据秒杀场次id获取秒杀关联商品集合
            List<SeckillSkuRelationEntity> skuRelationEntities = seckillSkuRelationService.list(new QueryWrapper<SeckillSkuRelationEntity>().eq("promotion_session_id", id));
            if (skuRelationEntities != null && skuRelationEntities.size() > 0) {
                session.setRelationSkus(skuRelationEntities);
            }
            return session;
        }).collect(Collectors.toList());
        return collect;
    }
    return null;
}

/**
 * @author Klaus
 * @date 2022/9/28
 */
@Data
public class SeckillSessionWithSkus {

    private Long id;
    /**
     * 场次名称
     */
    private String name;
    /**
     * 每日开始时间
     */
    private Date startTime;
    /**
     * 每日结束时间
     */
    private Date endTime;
    /**
     * 启用状态
     */
    private Integer status;
    /**
     * 创建时间
     */
    private Date createTime;


    private List<SeckillSkuVo> relationSkus;
}

/**
 * @author Klaus
 * @date 2022/9/28
 */
@Data
public class SeckillSkuVo {

    private Long id;
    /**
     * 活动id
     */
    private Long promotionId;
    /**
     * 活动场次id
     */
    private Long promotionSessionId;
    /**
     * 商品id
     */
    private Long skuId;
    /**
     * 秒杀价格
     */
    private BigDecimal seckillPrice;
    /**
     * 秒杀总量
     */
    private BigDecimal seckillCount;
    /**
     * 每人限购数量
     */
    private BigDecimal seckillLimit;
    /**
     * 排序
     */
    private Integer seckillSort;
}

@Override
public void uploadSeckillSkuLatest3Days() {
    //1、扫描最近三天需要参与秒杀的活动
    R r = couponFeignService.getLatest3DaySession();
    if (r.getCode() == 0) {
        //远程调用成功，上架商品
        List<SeckillSessionWithSkus> sessionData = r.getData(new TypeReference<List<SeckillSessionWithSkus>>() {
        });
        if (sessionData != null && sessionData.size() > 0) {
            //缓存到redis
            //1、缓存活动信息
            saveSessionInfos(sessionData);
            //2、缓存活动的关联商品信息
            saveSessionSkuInfos(sessionData);
        }
    }
}

	private final String SESSIONS_CACHE_PREFOX = "seckill:sessions:";
	private void saveSessionInfos(List<SeckillSessionWithSkus> sessions) {
        if (sessions != null && sessions.size() > 0) {

            sessions.stream().forEach(session -> {
                long startTime = session.getStartTime().getTime();
                long endTime = session.getEndTime().getTime();
                String key = SESSIONS_CACHE_PREFOX + startTime + "_" + endTime;
                    //key不存在进行缓存操作
                    List<String> skuIds = session.getRelationSkus().stream().map(item -> item.getPromotionSessionId().toString() + "_" + item.getSkuId().toString()).collect(Collectors.toList());
                    //缓存所有活动信息
                    redisTemplate.opsForList().leftPushAll(key, skuIds);
            });
        }
    }

/**
 * @author Klaus
 * @date 2022/9/28
 */
@Data
public class SeckillSkuRedisTo {

    /**
     * 活动id
     */
    private Long promotionId;
    /**
     * 活动场次id
     */
    private Long promotionSessionId;
    /**
     * 商品id
     */
    private Long skuId;

    /**
     * 商品秒杀随机码
     */
    private String randomCode;

    /**
     * 秒杀价格
     */
    private BigDecimal seckillPrice;
    /**
     * 秒杀总量
     */
    private BigDecimal seckillCount;
    /**
     * 每人限购数量
     */
    private BigDecimal seckillLimit;
    /**
     * 排序
     */
    private Integer seckillSort;


    /**
     * 当前商品秒杀的开始时间
     */
    private Long startTime;

    /**
     * 当前商品秒杀的结束时间
     */
    private Long endTime;
    /**
     * sku的详细信息
     */
    private SkuInfoVo skuInfoVo;
}

/**
 * @author Klaus
 * @date 2022/9/28
 */
@Data
public class SkuInfoVo {
    private Long skuId;
    /**
     * spuId
     */
    private Long spuId;
    /**
     * sku名称
     */
    private String skuName;
    /**
     * sku介绍描述
     */
    private String skuDesc;
    /**
     * 所属分类id
     */
    private Long catalogId;
    /**
     * 品牌id
     */
    private Long brandId;
    /**
     * 默认图片
     */
    private String skuDefaultImg;
    /**
     * 标题
     */
    private String skuTitle;
    /**
     * 副标题
     */
    private String skuSubtitle;
    /**
     * 价格
     */
    private BigDecimal price;
    /**
     * 销量
     */
    private Long saleCount;
}

@FeignClient("gulimall-product")
public interface ProductFeignService {

    @RequestMapping("/product/skuinfo/info/{skuId}")
    R getSkuInfo(@PathVariable("skuId") Long skuId);
}

/**
   * 信息
   */
  @RequestMapping("/info/{skuId}")
  //@RequiresPermissions("product:skuinfo:info")
  public R info(@PathVariable("skuId") Long skuId){
SkuInfoEntity skuInfo = skuInfoService.getById(skuId);

      return R.ok().put("skuInfo", skuInfo);
  }

/**
 * @author Klaus
 * @date 2022/9/7
 */
@Configuration
public class MyRedissonConfig {

    /**
     * 所有对Redisson的使用都是通过RedissonClient对象
     * @return
     * @throws IOException
     */
    @Bean(destroyMethod="shutdown")
    public RedissonClient redisson() throws IOException {
        //1、创建配置
        //Redis url should start with redis:// or rediss://
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.10.103:6379");

        //2、根据config创建出Redisson实例
        RedissonClient redissonClient = Redisson.create(config);
        return redissonClient;
    }
}

private final String SKUKILL_CACHE_PREFOX = "seckill:skus:";

private final String SKU_STOCK_SEMAPHORE = "seckill:stock:";//+商品随机码
private void saveSessionSkuInfos(List<SeckillSessionWithSkus> sessions) {

    //准备hash操作
    BoundHashOperations<String, Object, Object> ops = redisTemplate.boundHashOps(SKUKILL_CACHE_PREFOX);

    if (sessions != null && sessions.size() > 0) {

        sessions.stream().forEach(session -> {

            String token = UUID.randomUUID().toString().replace("-", "");


            session.getRelationSkus().stream().forEach(seckillSkuVo -> {

                    //key不存在进行缓存商品
                    SeckillSkuRedisTo redisTo = new SeckillSkuRedisTo();
                    //1、sku的基本数据
                    R r = productFeignService.getSkuInfo(seckillSkuVo.getSkuId());
                    if (r.getCode() == 0) {
                        //远程调用成功
                        SkuInfoVo skuInfo = r.getData("skuInfo", new TypeReference<SkuInfoVo>() {
                        });
                        redisTo.setSkuInfoVo(skuInfo);
                    }
                    //2、sku的秒杀信息
                    BeanUtils.copyProperties(seckillSkuVo, redisTo);

                    //3、设置上当前商品的秒杀时间信息
                    redisTo.setStartTime(session.getStartTime().getTime());
                    redisTo.setEndTime(session.getEndTime().getTime());

                    //4、随机码   seckill?skuId=1&key=fewqfwrgvrw
                    redisTo.setRandomCode(token);

                    String jsonString = JSON.toJSONString(redisTo);
                    ops.put(seckillSkuVo.getPromotionSessionId().toString() + "_" + seckillSkuVo.getSkuId().toString(), jsonString);


                    //秒杀请求进来先获取信号量，获取不到就无法执行数据库的所有方法了
                    //如果当前这个场次的商品的库存信息已经上架就不需要上架
                    //5、使用库存作为分布式的信号量 -> 限流；
                    RSemaphore semaphore = redissonClient.getSemaphore(SKU_STOCK_SEMAPHORE + token);
                    //商品可以秒杀的数量作为信号量
                    semaphore.trySetPermits(seckillSkuVo.getSeckillCount().intValue());
                
            });
        });
    }
}

List<String> skuIds = session.getRelationSkus().stream().map(item -> item.getSkuId().toString()).collect(Collectors.toList());

ops.put(seckillSkuVo.getSkuId().toString(), jsonString);

/**
 *  * 秒杀商品的定时上架；
 *  *      每天晚上3点；上架最近三天需要秒杀的商品
 *  *      当天00:00:00 - 23:59:59
 *  *      明天天00:00:00 - 23:59:59
 *  *      后天00:00:00 - 23:59:59
 * @author Klaus
 * @date 2022/9/27
 */
@Slf4j
@Service
public class SeckillSkuScheduled {

    @Autowired
    SeckillService seckillService;

    @Autowired
    RedissonClient redissonClient;

    private final String UPLOAD_LOCK = "seckill:upload:lock";

    /**
     * todo 幂等性处理
     */
//     @Scheduled(cron = "*/5 * * * * ? ")
    @Scheduled(cron = "0 0 1/1 * * ? ")
    public void uploadSeckillSkuLatest3Days(){
        //1、重复上架无需处理
        log.info("上架秒杀的商品信息...");
        //分布式锁。锁的业务执行完成，状态已经更新完成，释放锁以后，其他人获取到就会拿到最新的状态
        RLock lock = redissonClient.getLock(UPLOAD_LOCK);
        lock.lock(10, TimeUnit.SECONDS);
        try {
            seckillService.uploadSeckillSkuLatest3Days();

        } finally {
            lock.unlock();
        }
    }
}

private void saveSessionInfos(List<SeckillSessionWithSkus> sessions) {
    if (sessions != null && sessions.size() > 0) {

        sessions.stream().forEach(session -> {
            long startTime = session.getStartTime().getTime();
            long endTime = session.getEndTime().getTime();
            String key = SESSIONS_CACHE_PREFOX + startTime + "_" + endTime;
            Boolean hasKey = redisTemplate.hasKey(key);
            if (!hasKey) {
                //key不存在进行缓存操作
                List<String> skuIds = session.getRelationSkus().stream().map(item -> item.getPromotionSessionId().toString() + "_" + item.getSkuId().toString()).collect(Collectors.toList());
                //缓存所有活动信息
                redisTemplate.opsForList().leftPushAll(key, skuIds);
            }
        });
    }
}

private void saveSessionSkuInfos(List<SeckillSessionWithSkus> sessions) {

    //准备hash操作
    BoundHashOperations<String, Object, Object> ops = redisTemplate.boundHashOps(SKUKILL_CACHE_PREFOX);

    if (sessions != null && sessions.size() > 0) {

        sessions.stream().forEach(session -> {

            String token = UUID.randomUUID().toString().replace("-", "");


            session.getRelationSkus().stream().forEach(seckillSkuVo -> {
                if (!ops.hasKey(seckillSkuVo.getPromotionSessionId().toString() + "_" + seckillSkuVo.getSkuId().toString())) {
                    //key不存在进行缓存商品
                    SeckillSkuRedisTo redisTo = new SeckillSkuRedisTo();
                    //1、sku的基本数据
                    R r = productFeignService.getSkuInfo(seckillSkuVo.getSkuId());
                    if (r.getCode() == 0) {
                        //远程调用成功
                        SkuInfoVo skuInfo = r.getData("skuInfo", new TypeReference<SkuInfoVo>() {
                        });
                        redisTo.setSkuInfoVo(skuInfo);
                    }
                    //2、sku的秒杀信息 vo->to
                    BeanUtils.copyProperties(seckillSkuVo, redisTo);

                    //3、设置上当前商品的秒杀时间信息
                    redisTo.setStartTime(session.getStartTime().getTime());
                    redisTo.setEndTime(session.getEndTime().getTime());

                    //4、随机码   seckill?skuId=1&key=fewqfwrgvrw
                    redisTo.setRandomCode(token);

                    String jsonString = JSON.toJSONString(redisTo);
                    ops.put(seckillSkuVo.getPromotionSessionId().toString() + "_" + seckillSkuVo.getSkuId().toString(), jsonString);


                    //秒杀请求进来先获取信号量，获取不到就无法执行数据库的所有方法了
                    //如果当前这个场次的商品的库存信息已经上架就不需要上架
                    //5、使用库存作为分布式的信号量 -> 限流；
                    RSemaphore semaphore = redissonClient.getSemaphore(SKU_STOCK_SEMAPHORE + token);
                    //商品可以秒杀的数量作为信号量
                    semaphore.trySetPermits(seckillSkuVo.getSeckillCount().intValue());
                }

            });
        });
    }
}

@Controller
public class SeckillController {

    @Autowired
    SeckillService seckillService;

    /**
     * 返回当前时间可以参与的秒杀商品信息
     * @return
     */
    @ResponseBody
    @GetMapping("/currentSeckillSkus")
    public R getCurrentSeckillSkus(){
        List<SeckillSkuRedisTo> tos = seckillService.getCurrentSeckillSkus();
        return R.ok().setData(tos);
    }

/**
     * 返回当前时间可以参与的秒杀商品信息
     */
    @Override
    public List<SeckillSkuRedisTo> getCurrentSeckillSkus() {
        //1、确定当前时间属于哪个秒杀场次
        long time = System.currentTimeMillis();

        Set<String> keys = redisTemplate.keys(SESSIONS_CACHE_PREFOX + "*");
        for (String key : keys) {
            //seckill:sessions:1664301600000_1664305200000->1664301600000_1664305200000
            String replace = key.replace(SESSIONS_CACHE_PREFOX, "");
            //[1664301600000 _ 1664305200000]
            //        0             1
            String[] s = replace.split("_");
            Long start = Long.parseLong(s[0]);
            Long end = Long.parseLong(s[1]);
            if (time >= start && time <= end) {
                //当前时间在秒杀时间范围内
                //2、获取这个秒杀场次需要的所有商品信息
                List<String> range = redisTemplate.opsForList().range(key, -100, 100);
                BoundHashOperations<String, String, String> hashOps = redisTemplate.boundHashOps(SKUKILL_CACHE_PREFOX);
                assert range != null;
                List<String> list = hashOps.multiGet(range);
                if (list != null && list.size() > 0) {
                    List<SeckillSkuRedisTo> collect = list.stream().map(item -> {
                        SeckillSkuRedisTo skuRedisTo = JSON.parseObject((String) item, SeckillSkuRedisTo.class);
//                        skuRedisTo.setRandomCode(null);当前秒杀开始就需要随机码

                        return skuRedisTo;
                    }).collect(Collectors.toList());
                    return collect;
                }
                break;
            }
        }
        return null;
    }

@FeignClient(value = "gulimall-seckill", fallback = SeckillFeignServiceFallBack.class )
public interface SeckillFeignService {

    @GetMapping("/sku/seckill/{skuId}")
    R getSkuSeckillInfo(@PathVariable("skuId")Long skuId);
}

@ResponseBody
@GetMapping("/sku/seckill/{skuId}")
public R getSkuSeckillInfo(@PathVariable("skuId")Long skuId){
    SeckillSkuRedisTo to = seckillService.getSkuSeckillInfo(skuId);

    return R.ok().setData(to);
}

@Override
    public SeckillSkuRedisTo getSkuSeckillInfo(Long skuId) {
        //1、找到所有需要参与秒杀的商品的key
        BoundHashOperations<String, String, String> hashOps = redisTemplate.boundHashOps(SKUKILL_CACHE_PREFOX);
        Set<String> keys = hashOps.keys();
        if (keys != null && keys.size() > 0) {
            //todo 正则匹配2位数
            String regx = "\\d\\d_" + skuId;
            //创建匹配模式
//            Pattern pattern = Pattern.compile("\\d_");//匹配一个或多个数字字符
            //2.选择匹配对象
//            Matcher matcher = pattern.matcher(skuId.toString());

            for (String key : keys) {
                log.info("test:{}",  Pattern.matches(regx, key));
                // 6_4
                if (Pattern.matches(regx, key)) {
//                if (regx.matches(key)) {
//                if (matcher.find()) {
                    String json = hashOps.get(key);
                    SeckillSkuRedisTo skuRedisTo = JSON.parseObject(json, SeckillSkuRedisTo.class);

                    //处理随机码
                    long current = System.currentTimeMillis();
                    if (current >= skuRedisTo.getStartTime() && current <= skuRedisTo.getEndTime()) {

                    } else {
                        //在时间范围外直接置空
                        skuRedisTo.setRandomCode(null);
                    }
                    return skuRedisTo;
                }
            }
        }

        return null;
    }

/**
 * 展示当前sku的详情
 * @param skuId
 * @return
 */
@GetMapping("/{skuId}.html")
public String skuItem(@PathVariable("skuId")Long skuId, Model model) throws ExecutionException, InterruptedException {


    System.out.println("准备查询" + skuId + "详情");
    SkuItemVo vo = skuInfoService.item(skuId);
    //页面渲染
    model.addAttribute("item", vo);

    return "item";
}

	@Resource
    SeckillFeignService seckillFeignService;
	@Override
    public SkuItemVo item(Long skuId) throws ExecutionException, InterruptedException {
        SkuItemVo skuItemVo = new SkuItemVo();

        ......

        CompletableFuture<Void> seckillFuture = CompletableFuture.runAsync(() -> {
            // 秒杀信息
            R r = seckillFeignService.getSkuSeckillInfo(skuId);
            if (r.getCode() == 0) {
                //远程调用成功
                SeckillInfoVo data = r.getData(new TypeReference<SeckillInfoVo>() {
                });
                if (data != null) {
                    skuItemVo.setSeckillInfo(data);
                }
            }
        }, productThreadPoolExecutor);

        //等待所有的任务都完成
        CompletableFuture.allOf(saleAttrFuture, descFuture, baseAttrFuture, imageFuture, seckillFuture).get();

        return skuItemVo;
    }

@EnableRedisHttpSession
@Configuration
public class GulimallSessionConfig {

    @Bean
    public CookieSerializer cookieSerializer(){
        DefaultCookieSerializer cookieSerializer = new DefaultCookieSerializer();

        cookieSerializer.setDomainName("gulimall.com");
        cookieSerializer.setCookieName("KLAUSSESSION");
        return cookieSerializer;
    }

    @Bean
    public RedisSerializer<Object> springSessionDefaultRedisSerializer() {
        return new GenericJackson2JsonRedisSerializer();
    }
}

@Component
public class LoginUserInterceptor implements HandlerInterceptor {


    public static ThreadLocal<MemberRespVo> loginUser = new ThreadLocal<>();

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        ///order/order/status/{orderSn}
        String uri = request.getRequestURI();//  /order/order/status/
        //                  路径匹配器
        boolean match = new AntPathMatcher().match("/kill", uri);

        if (match){
            //路径匹配进行登录拦截
            MemberRespVo attribute = (MemberRespVo) request.getSession().getAttribute(AuthServerConstant.LOGIN_USER);
            //判断用户是否登录
            if (attribute != null){
                //登录了
                loginUser.set(attribute);
                return true;
            }else {
                //未登录就去登录
                request.getSession().setAttribute("msg", "请先进行登录");
                response.sendRedirect("http://auth.gulimall.com/login.html");
                return false;
            }
        }
        return true;
    }
}

@Configuration
public class SeckillWebConfig implements WebMvcConfigurer {
    @Autowired
    LoginUserInterceptor loginUserInterceptor;


    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginUserInterceptor).addPathPatterns("/**");
    }
}

@GetMapping("/kill")
public String secKill(@RequestParam("killId") String killId,
                      @RequestParam("key") String key,
                      @RequestParam("num") Integer num,
                      Model model){
    String orderSn = seckillService.kill(killId, key, num);
    
    model.addAttribute("orderSn", orderSn);
    //1、判断是否登录
    return "success";
}

/**
 * @author Klaus
 * @date 2022/9/29
 */
@Data
public class SeckillOrderTo {

    private String orderSn;//订单号

    private Long promotionSessionId;//活动场次id

    private Long skuId;//商品id


    private BigDecimal seckillPrice;//秒杀价

    private Integer num;//购买数量

    private Long memberId;//会员id

//    private List<String> skuAttrs;//商品属性集

}

@Override
public String kill(String killId, String key, Integer num) {
    long s1 = System.currentTimeMillis();
    //获取当前登录的信息
    MemberRespVo respVo = LoginUserInterceptor.loginUser.get();

    //获取当前秒杀商品的详细信息
    BoundHashOperations<String, String, String> hashOps = redisTemplate.boundHashOps(SKUKILL_CACHE_PREFOX);

    String json = hashOps.get(killId);
    if (StringUtils.isEmpty(json)) {
        return null;
    } else {
        SeckillSkuRedisTo redis = JSON.parseObject(json, SeckillSkuRedisTo.class);
        //1、校验合法性
        Long startTime = redis.getStartTime();
        Long endTime = redis.getEndTime();
        long current = System.currentTimeMillis();

        //过期时间
        long ttl = endTime - current;
        if (current >= startTime && current <= endTime) {
            //2、校验随机码和商品id
            String randomCode = redis.getRandomCode();
            //   1_49
            String seckillSkuId = redis.getPromotionSessionId() + "_" + redis.getSkuId();
            if (randomCode.equals(key) && killId.equals(seckillSkuId)) {
                //3、验证购物数量是否合理
                if (num <= redis.getSeckillLimit().intValue()) {
                    //4、验证这个人是否已经购买过。幂等性；如果秒杀成功，就去占位，userId_sessionId_skuId
                    String redisKey = respVo.getId() + "_" + seckillSkuId;
                    //自动过期                     SEINX 原子性
                    Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent(redisKey, num.toString(), ttl, TimeUnit.MILLISECONDS);
                    if (aBoolean) {
                        //占位成功说明从来没有买过
                        RSemaphore semaphore = redissonClient.getSemaphore(SKU_STOCK_SEMAPHORE + randomCode);

                        //120 ms ->  20ms
                        boolean b = semaphore.tryAcquire(num);
                        if (b) {
                            //秒杀成功；
                            //快速下单，发送MQ消息 10ms
                            //创建随机订单号
                            String timeId = IdWorker.getTimeId();
                            SeckillOrderTo orderTo = new SeckillOrderTo();
                            orderTo.setOrderSn(timeId);
                            orderTo.setMemberId(respVo.getId());
                            orderTo.setNum(num);
                            orderTo.setPromotionSessionId(redis.getPromotionSessionId());
                            orderTo.setSkuId(redis.getSkuId());
                            orderTo.setSeckillPrice(redis.getSeckillPrice());

                            //String exchange, String routingKey, Object message, MessagePostProcessor messagePostProcessor
                            rabbitTemplate.convertAndSend("order-event-exchange", "order.seckill.order", orderTo);
                            long s2 = System.currentTimeMillis();
                            log.info("耗时...{}", (s2 - s1));
                            //返回订单号
                            return timeId;
                        }
                        //信号量为0时，虽然data为空，但缓存还会存一份
                        redisTemplate.opsForValue().get(redisKey);
                        return null;
                    } else {
                        //说明已经买过了
                        return null;
                    }

                }
            } else {
                return null;
            }
        } else {
            return null;
        }
    }
    return null;
}

/**
 * @author Klaus
 * @date 2022/9/20
 */
@Configuration
public class MyRabbitConfig {

    @Autowired
    RabbitTemplate rabbitTemplate;

    /**
     * 使用JSON序列化机制，进行消息转换
     * @return
     */
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }


}

//String exchange, String routingKey, Object message, MessagePostProcessor messagePostProcessor
rabbitTemplate.convertAndSend("order-event-exchange", "order.seckill.order", orderTo);

@Configuration
public class MyMQConfig {
    
    ......
    
    @Bean
    public Exchange orderEventExchange(){
        //String name, boolean durable, boolean autoDelete, Map<String, Object> arguments
        return new TopicExchange("order-event-exchange", true, false);
    }
    
    ......
    
    /**
     * 秒杀削峰队列
     * @return
     */
    @Bean
    public Queue orderSeckillOrderQueue(){
        return new Queue("order.seckill.order.queue", true, false, false);
    }

    @Bean
    public Binding orderSeckillOrderBinding(){
        return new Binding("order.seckill.order.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.seckill.order", null);

    }
}

/**
 * 削峰队列监听器
 * @author Klaus
 * @date 2023/4/28
 */
@Slf4j
@RabbitListener(queues = "order.seckill.order.queue")
@Component
public class OrderSeckillListener {

    @Autowired
    OrderService orderService;

    @RabbitHandler
    public void listener(SeckillOrderTo seckillOrder, Channel channel, Message message) throws IOException {

        try {
            log.info("准备创建秒杀单的详细信息....");
            orderService.createSeckillOrder(seckillOrder);
            //手动调用支付宝收单

            //签收订单
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (Exception e) {

            channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
        }

    }
}

	@Override
    public void createSeckillOrder(SeckillOrderTo seckillOrder) {
        //todo 保存订单信息
        OrderEntity orderEntity = new OrderEntity();
        orderEntity.setOrderSn(seckillOrder.getOrderSn());
        orderEntity.setMemberId(seckillOrder.getMemberId());

        orderEntity.setStatus(OrderStatusEnum.CREATE_NEW.getCode());

        BigDecimal amount = seckillOrder.getSeckillPrice().multiply(new BigDecimal("" + seckillOrder.getNum()));
        orderEntity.setPayAmount(amount);
        orderEntity.setTotalAmount(amount);//todo

        //保存订单
        this.save(orderEntity);
        //todo 保存订单项信息
        OrderItemEntity itemEntity = new OrderItemEntity();
        itemEntity.setOrderSn(seckillOrder.getOrderSn());
        itemEntity.setRealAmount(amount);
        //todo 获取当前sku的详细信息进行设置 seckillservice-> productFeignService.getSpuInfoBySkuId()
        R r = productFeignService.getSpuInfoBySkuId(seckillOrder.getSkuId());
        if (r.getCode() == 0) {
            SpuInfoVo data = r.getData(new TypeReference<SpuInfoVo>() {
            });
            itemEntity.setSpuId(data.getId());
            itemEntity.setSpuName(data.getSpuName());
            itemEntity.setSpuBrand(data.getBrandId().toString());
            itemEntity.setCategoryId(data.getCatalogId());



        }
        //1、找到所有需要参与秒杀的商品信息
        R info = seckillFeignService.getSkuSeckillInfo(seckillOrder.getSkuId());
        if (info.getCode() == 0){
            SeckillSkuRedisTo data = info.getData(new TypeReference<SeckillSkuRedisTo>() {
            });
            itemEntity.setSkuName(data.getSkuInfoVo().getSkuTitle());
            itemEntity.setSkuPic(data.getSkuInfoVo().getSkuDefaultImg());
            //todo 销售属性组合

        }


        itemEntity.setSkuId(seckillOrder.getSkuId());
        itemEntity.setSkuQuantity(seckillOrder.getNum());

        //保存订单项
        orderItemService.save(itemEntity);
    }
/**
     * 保存订单数据
     * @param order
     */
    private void saveOrder(OrderCreateTo order) {
        OrderEntity orderEntity = order.getOrder();
        orderEntity.setModifyTime(new Date());
        //插入订单
        this.save(orderEntity);

        List<OrderItemEntity> orderItems = order.getOrderItems();
        //seata不支持批量保存...且在高并发环境此业务不适用Seata
        orderItemService.saveBatch(orderItems);
//        for (OrderItemEntity orderItem : orderItems) {
//            orderItemService.save(orderItem);
//        }
    }