[大数据]继承框架 - 秒杀接口实现

秒杀接口实现

每个商品有sku商品sku 可以查到商品信息，商品信息，可以查到商品的当前库存信息，redis 单例执行

1. 后台定时任务推送什么时间显示对应的秒杀商品信息，对于后台设置的商品进行定时推送秒杀信息，查询秒杀表，拿到商家信息，商品信息，秒杀唯一标识，秒杀商品数量。秒杀时间范围。

2. 校验商品库存数量，校验商品信息，校验是否已经完成，符合推送的信息，后台定时任务推送秒杀信息到redis 秒杀列表，锁定库存，前端展示库存减去预上架库存，举例真实库存100 秒杀20 前端请求均显示，系统库存 80，推送秒杀id 对应的商品库存数量

结论成立，用户通过网页查看秒杀列表可以看到，当前秒杀商品的列表信息， 和对应的秒杀商品库存
后端代码，查询redis 秒杀商品信息集合、返回前端

考虑到系统瓶颈，多个用户下单，到分布式系统，会存在系统压力，网关方面做限流处理，单机可以使用retaLimit，分布式需要使用 sentinel设置接口流量，和返回报错信息，比如限流50/qps

前端组装用户唯一id令牌进来（对应商品信息，及用户id加盐，同时添加某个秒杀id），到getway网关
网关限流分流到接口

网关做一次校验，校验用户信息是否非法，是否是登录状态。

• 进入方法之后秒杀接口进行二次校验 校验用户信息是否满足系统秒杀权限 redis

• 校验用户频率，（例入，一个小时内只能抢两次，每次成功频率需要三分钟之后。 用户拿到katelimit
  令牌之后，存储用户令牌，+用户频率，和成功时间，设置过期时间一小时，第二次进来，获取用户频率如果大于等于两次，或者一次，时间小于两分钟，进行拒绝）

• 校验该商品的redis 是否过期如果过期，该商品活动已经结束

• 循环队列，队列是否存在该用户盐，如果存在，返回，系统正在努力加载中，请稍后。 校验所有库存，如果库存为空，返回抢光了。

• 放入公有队列，队列最大数量是库存数量，容错策略抛出系统繁忙，请稍后再试 检验完成，参与分布式系统秒杀服务

• 判断队列是否执行，未执行开启队列线程执行队列依次请求 返回加载中

异步方法执行。

用户满足校验，尝试到redis循环扣减redis对应商品库存。（比如库存50 分为5个仓，循环5个线程一组获取，每个仓存在10个库存）尝试库存数量减1，失败循环库存，若全部失败不成功，显示抢光了

用户扣减成功，进行后续操作，同时redis 记录用户频率次数，时间。

对于拿到令牌的用户，进行后续逻辑，生成临时订单，临时订单生成，待用户确认订单，设置超时时间，用户确认订单，进入支付订单信息生成，入表。

用户取消订单，释放库存，详情可查看最新剩余库存数量。供下一位尝试获取。

用户确认订单，到待支付页面，设置用户支付时间，用户支付成功回调，同步生成真实订单，生成真实库存扣减，后续动作完成。

用户在队列中，关闭应用，如果抢订单成功，通过消息，通知用户抢购成功，点击消息，跳转到订单确认页面

用户，刷新期间，禁止页面，如果抢订单，mq 发送前端，告知抢成功，回调到抢卷成功页面（也可以前端使用轮询接口查询用户是否生成订单表）

// 来源 https://blog.csdn.net/yanglingzhi888/article/details/125357203

/**
 * 扣库存
 *
 * @author yuhao.wang
 */
@Service
public class StockService {
    Logger logger = LoggerFactory.getLogger(StockService.class);
 
    /**
     * 不限库存
     */
    public static final long UNINITIALIZED_STOCK = -3L;
 
    /**
     * Redis 客户端
     */
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    /**
     * 执行扣库存的脚本
     */
    public static final String STOCK_LUA;
 
    static {
        /**
         *
         * @desc 扣减库存Lua脚本
         * 库存（stock）-1：表示不限库存
         * 库存（stock）0：表示没有库存
         * 库存（stock）大于0：表示剩余库存
         *
         * @params 库存key
         * @return
         *   -3:库存未初始化
         *   -2:库存不足
         *   -1:不限库存
         *   大于等于0:剩余库存（扣减之后剩余的库存）
         *      redis缓存的库存(value)是-1表示不限库存，直接返回1
         */
        StringBuilder sb = new StringBuilder();
        sb.append("if (redis.call('exists', KEYS[1]) == 1) then");
        sb.append("    local stock = tonumber(redis.call('get', KEYS[1]));");
        sb.append("    local num = tonumber(ARGV[1]);");
        sb.append("    if (stock == -1) then");
        sb.append("        return -1;");
        sb.append("    end;");
        sb.append("    if (stock >= num) then");
        sb.append("        return redis.call('incrby', KEYS[1], 0 - num);");
        sb.append("    end;");
        sb.append("    return -2;");
        sb.append("end;");
        sb.append("return -3;");
        STOCK_LUA = sb.toString();
    }
 
    /**
     * @param key           库存key
     * @param expire        库存有效时间,单位秒
     * @param num           扣减数量
     * @param stockCallback 初始化库存回调函数
     * @return -2:库存不足; -1:不限库存; 大于等于0:扣减库存之后的剩余库存
     */
    public long stock(String key, long expire, int num, IStockCallback stockCallback) {
        long stock = stock(key, num);
        // 初始化库存
        if (stock == UNINITIALIZED_STOCK) {
            RedisLock redisLock = new RedisLock(redisTemplate, key);
            try {
                // 获取锁
                if (redisLock.tryLock()) {
                    // 双重验证，避免并发时重复回源到数据库
                    stock = stock(key, num);
                    if (stock == UNINITIALIZED_STOCK) {
                        // 获取初始化库存
                        final int initStock = stockCallback.getStock();
                        // 将库存设置到redis
                        redisTemplate.opsForValue().set(key, initStock, expire, TimeUnit.SECONDS);
                        // 调一次扣库存的操作
                        stock = stock(key, num);
                    }
                }
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
            } finally {
                redisLock.unlock();
            }
 
        }
        return stock;
    }
 
    /**
     * 加库存(还原库存)
     *
     * @param key    库存key
     * @param num    库存数量
     * @return
     */
    public long addStock(String key, int num) {
 
        return addStock(key, null, num);
    }
 
    /**
     * 加库存
     *
     * @param key    库存key
     * @param expire 过期时间（秒）
     * @param num    库存数量
     * @return
     */
    public long addStock(String key, Long expire, int num) {
        boolean hasKey = redisTemplate.hasKey(key);
        // 判断key是否存在，存在就直接更新
        if (hasKey) {
            return redisTemplate.opsForValue().increment(key, num);
        }
 
        Assert.notNull(expire,"初始化库存失败，库存过期时间不能为null");
        RedisLock redisLock = new RedisLock(redisTemplate, key);
        try {
            if (redisLock.tryLock()) {
                // 获取到锁后再次判断一下是否有key
                hasKey = redisTemplate.hasKey(key);
                if (!hasKey) {
                    // 初始化库存
                    redisTemplate.opsForValue().set(key, num, expire, TimeUnit.SECONDS);
                }
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            redisLock.unlock();
        }
 
        return num;
    }
 
    /**
     * 获取库存
     *
     * @param key 库存key
     * @return -1:不限库存; 大于等于0:剩余库存
     */
    public int getStock(String key) {
        Integer stock = (Integer) redisTemplate.opsForValue().get(key);
        return stock == null ? -1 : stock;
    }
 
    /**
     * 扣库存
     *
     * @param key 库存key
     * @param num 扣减库存数量
     * @return 扣减之后剩余的库存【-3:库存未初始化; -2:库存不足; -1:不限库存; 大于等于0:扣减库存之后的剩余库存】
     */
    private Long stock(String key, int num) {
        // 脚本里的KEYS参数
        List<String> keys = new ArrayList<>();
        keys.add(key);
        // 脚本里的ARGV参数
        List<String> args = new ArrayList<>();
        args.add(Integer.toString(num));
 
        long result = redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                Object nativeConnection = connection.getNativeConnection();
                // 集群模式和单机模式虽然执行脚本的方法一样，但是没有共同的接口，所以只能分开执行
                // 集群模式
                if (nativeConnection instanceof JedisCluster) {
                    return (Long) ((JedisCluster) nativeConnection).eval(STOCK_LUA, keys, args);
                }
 
                // 单机模式
                else if (nativeConnection instanceof Jedis) {
                    return (Long) ((Jedis) nativeConnection).eval(STOCK_LUA, keys, args);
                }
                return UNINITIALIZED_STOCK;
            }
        });
        return result;
    }
 
}