继承框架 - 秒杀接口实现

秒杀接口实现

每个商品有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;
    }
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190