秒杀系统学习笔记，限时抢购，抢购接口隐藏

限时抢购的实现

使用Redis来记录秒杀商品的时间，对秒杀过期的请求进行拒绝处理！

将秒杀商品放入Redis中并设置过期时间

使用String类型以kill+商品id的形式作为key以商品id作为value设置一定的过期时间（这里设置为180秒）

引入Redis依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
1
2
3
4

配置Redis

spring.redis.database=0
spring.redis.port=6379
spring.redis.host=localhost
1
2
3

在service中引入StringRedisTemplate对象

@Autowired
private StringRedisTemplate stringRedisTemplate;
1
2

秒杀时，先判断秒杀的商品是否已经过期，没有则可以进行抢购。

@Override
public int kill(Integer id) {
    //校验秒杀商品是否超时
    if (!stringRedisTemplate.hasKey("kill" + id)) {
        throw new RuntimeException("当前商品的抢购活动已经结束");
    }

    //校验库存
    Stock stock = checkStock(id);
    //更新库存
    updateSale(stock);
    //创建订单
    return createOrder(stock);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

抢购接口的隐藏

如果没有对接口做隐藏处理，用户在客户端浏览器进入控制台，可以获得我们的抢购接口的连接，写一个爬虫代码，在秒杀开始前直接在代码中请求接口完成下单，就会造成危害。因此需要对接口做隐藏处理。

• 每次点击秒杀按钮，先从服务器获取一个秒杀验证值（接口内判断是否到秒杀时间）。
• Redis以缓存用户ID和商品ID为key，秒杀地址为value缓存验证值。
• 用户请求秒杀商品的时候，要带上秒杀验证值进行校验。
• 

添加数据库表User

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `name` varchar(80) DEFAULT NULL COMMENT '用户名',
  `password` varchar(40) DEFAULT NULL COMMENT '用户密码',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

SET FOREIGN_KEY_CHECKS = 1;
1
2
3
4
5
6
7
8
9
10
11
12
13
14

创建User实体类

@Data
public class User {
    private Integer id;
    private String name;
    private String password;
}
1
2
3
4
5
6

创建UserDao及UserDaoMapper

@Mapper
public interface UserDao {
    User findById(Integer id);
}
1
2
3
4

<mapper namespace="com.lany.miaosha.dao.UserDao">
    <select id="findById" parameterType="Integer" resultType="User">
        select id, name, password
        from miaosha.user
        where id = #{id}
    </select>
</mapper>
1
2
3
4
5
6
7

编写业务代码

@Service
@Transactional
@Slf4j
public class OrderServiceImpl implements OrderService {

    @Autowired
    private StockDao stockDao;

    @Autowired
    private OrderDao orderDao;

    @Autowired
    private UserDao userDao;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    
    @Override
    public String getMd5(Integer id, Integer userid) {
        //检验用户的合法性
        User user = userDao.findById(userid);
        if (user == null) throw new RuntimeException("用户信息不存在!");
        log.info("用户信息:[{}]", user.toString());
        //检验商品的合法行
        Stock stock = stockDao.checkStock(id);
        if (stock == null) throw new RuntimeException("商品信息不合法!");
        log.info("商品信息:[{}]", stock.toString());
        //生成hashkey
        String hashKey = "KEY_" + userid + "_" + id;
        //生成md5//这里!QS#是一个盐 随机生成
        String key = DigestUtils.md5DigestAsHex((userid + id + "!Q*jS#").getBytes());
        stringRedisTemplate.opsForValue().set(hashKey, key, 3600, TimeUnit.SECONDS);
        log.info("Redis写入：[{}] [{}]", hashKey, key);
        return key;
    }
}
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

编写controller代码，生成验证码的方法

@RequestMapping("stock")
@RestController
@Slf4j
public class StockController {

    @Autowired
    private OrderService orderService;
//生成md5值的方法
@RequestMapping("md5")
public String getMd5(Integer id, Integer userid) {
    String md5;
    try {
        md5 = orderService.getMd5(id, userid);
    } catch (Exception e) {
        e.printStackTrace();
        return "获取md5失败: " + e.getMessage();
    }
    return "获取md5信息为: " + md5;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

前台通过调用stock/md5来生成一串验证码存入Redis中，然后在进行秒杀时携带该验证来进行秒杀。

编写秒杀接口

OrderController类

//开发一个秒杀方法 乐观锁防止超卖+ 令牌桶算法限流
@GetMapping("killtokenmd5")
public String killtoken(Integer id,Integer userid,String md5) {
    System.out.println("秒杀商品的id = " + id);
    //加入令牌桶的限流措施
    if (!rateLimiter.tryAcquire(3, TimeUnit.SECONDS)) {
        log.info("抛弃请求: 抢购失败,当前秒杀活动过于火爆,请重试");
        return "抢购失败,当前秒杀活动过于火爆,请重试!";
    }
    try {
        //根据秒杀商品id 去调用秒杀业务
        int orderId = orderService.kill(id,userid,md5);
        return "秒杀成功,订单id为: " + String.valueOf(orderId);
    } catch (Exception e) {
        e.printStackTrace();
        return e.getMessage();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

OrderServiceImpl类

@Override
public int kill(Integer id, Integer userid, String md5) {

    //校验redis中秒杀商品是否超时
    //        if(!stringRedisTemplate.hasKey("kill"+id))
    //            throw new RuntimeException("当前商品的抢购活动已经结束啦~~");

    //先验证签名
    String hashKey = "KEY_" + userid + "_" + id;
    String s = stringRedisTemplate.opsForValue().get(hashKey);
    if (s == null) throw new RuntimeException("没有携带验证签名,请求不合法!");
    if (!s.equals(md5)) throw new RuntimeException("当前请求数据不合法,请稍后再试!");

    //校验库存
    Stock stock = checkStock(id);
    //更新库存
    updateSale(stock);
    //创建订单
    return createOrder(stock);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

单用户限制访问频率

利用Redis给每个用户做访问统计，甚至是带上商品id，对单个商品做访问统计，这些都是可以的。

在用户申请下单时，检查用户的访问次数是否超过规定的访问次数，超过则不让它下单。

controller代码

//开发一个秒杀方法 乐观锁防止超卖+ 令牌桶算法限流
@GetMapping("killtokenmd5limit")
public String killtokenlimit(Integer id,Integer userid,String md5) {
  //加入令牌桶的限流措施
  if (!rateLimiter.tryAcquire(3, TimeUnit.SECONDS)) {
    log.info("抛弃请求: 抢购失败,当前秒杀活动过于火爆,请重试");
    return "抢购失败,当前秒杀活动过于火爆,请重试!";
  }
  try {
    //加入单用户限制调用频率
    int count = userService.saveUserCount(userid);
    log.info("用户截至该次的访问次数为: [{}]", count);
    boolean isBanned = userService.getUserCount(userid);
    if (isBanned) {
      log.info("购买失败,超过频率限制!");
      return "购买失败，超过频率限制!";
    }
    //根据秒杀商品id 去调用秒杀业务
    int orderId = orderService.kill(id,userid,md5);
    return "秒杀成功,订单id为: " + String.valueOf(orderId);
  } catch (Exception e) {
    e.printStackTrace();
    return e.getMessage();
  }
}
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

Service接口及实现

public interface UserService {
    //向redis中写入用户访问次数
    int saveUserCount(Integer userId);
    //判断单位时间调用次数
    boolean getUserCount(Integer userId);
}
1
2
3
4
5
6

实现

@Service
@Transactional
@Slf4j
public class UserServiceImpl  implements UserService{

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public int saveUserCount(Integer userId) {
        //根据不同用户id生成调用次数的key
        String limitKey = "LIMIT" + "_" + userId;
        //获取redis中指定key的调用次数
        String limitNum = stringRedisTemplate.opsForValue().get(limitKey);
        int limit =-1;
        if (limitNum == null) {
            //第一次调用放入redis中设置为0
            stringRedisTemplate.opsForValue().set(limitKey, "0", 3600, TimeUnit.SECONDS);
        } else {
            //不是第一次调用每次+1
            limit = Integer.parseInt(limitNum) + 1;
            stringRedisTemplate.opsForValue().set(limitKey, String.valueOf(limit), 3600, TimeUnit.SECONDS);
        }
        return limit;//返回调用次数
    }

    @Override
    public boolean getUserCount(Integer userId) {
        String limitKey = "LIMIT"+ "_" + userId;
        //跟库用户调用次数的key获取redis中调用次数
        String limitNum = stringRedisTemplate.opsForValue().get(limitKey);
        if (limitNum == null) {
            //为空直接抛弃说明key出现异常
            log.error("该用户没有访问申请验证值记录，疑似异常");
            return true;
        }
        return Integer.parseInt(limitNum) > 10; //false代表没有超过 true代表超过
    }
}

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

参考文章：编程不良人