一，涉及的技术
vue，nodejs
springboot，mybatis，redis，rabbitmq
二，设计图如下
三，整个流程描述
1，登录，校验用户名密码，生成唯一的token，token为key'，value为用户信息，存入redis
2，拦截器，通过token从redis取用户信息，如果没有则过滤，如果有则存入TheadLocal
3，拦截器，用uid从redis取访问频率标记，有则过滤，如果没有则存入频率标记，继续
4，点击秒杀按钮，生成验证码，用户id和商品id作为key，验证码结果为value，存入redis
5，用户填入验证码，从redis取出验证码结果对比，成功则生成地址随机码，存入redis
6，调用秒杀接口，带上地址随机码，从redis取出地址随机码对比
7，本地内存缓存了商品是否卖完的状态，先通过本地内存过滤掉有卖完标记的商品的请求
8，redis缓存了每个商品的数量，查询商品数量，大于1则redis库存减一，没有的就将请求过抛弃
9，查询订单缓存，如果已经买过了，就将请求抛弃
10，放入消息队列
11，从队列拉消息，加锁，控制同一个用户对同一个商品的操作只能串行进行
12，查数据库，得到商品的真实库存，如果没有则抛弃
13，查询订单缓存，如果已经买过了，就将请求抛弃
14，set 库存=库存-1 where 库存>0,如果成功则插入订单表，两边入库操作加事务
15，如果上一步成功，删除该用户的订单缓存
16，提供订单查询接口，前端读秒结束则调用，返回前端秒杀结果
四，设计原则
秒杀系统特点：瞬时大流量
设计原则：各种手段层层削流，保证数据库不会压垮
削峰手段：
1，验证码，防止机器刷单，延长客户下单时间，减少流量
2，前端异步调用后读秒，防止用户一直点击
3，访问频率限制，限制频繁点击，防止机器刷单
4，秒杀地址隐藏，验证码填写正确生成的秒杀地址只能用一次，配合验证码防止机器刷单
5，内存过滤，本地内存维护商品是否售罄标记，内存过滤对售罄商品的请求
6，预减库存，redis维护商品库存，预减库存
7，规则限流，一个人只能买一个商品，，维护订单缓存，过滤已经买过的请求
8，消息削峰
9，去重，分布式锁控制一个用户对一个商品的请求一定时间内只有一个，多余的抛弃
其他：
1，分库分表，库存表需要大量updtae操作，分表分散压力
2，静态资源存前端，后台只传资源名称
3，商品信息除了库存之外是不会变化的，预先加载到缓存，前端调用直接查缓存使用
4，秒杀相关表独立，设计秒杀订单表，秒杀商品表，与原有订单表，商品表通过id关联即可，保证秒杀活动不会影响主系统，并且这样数据量也少，增删改查性能更高
五，表设计
六，技术点总结
1，前端异步调用秒杀接口后读秒
读秒结束后查询后台订单缓存（下单成功会删除缓存，直接查库），查询结果就是秒杀结果，不要轮询，减少后台压力
目的：限流
2，分布式session
目的：因为系统可能集群部署，每次请求访问不同的服务器，所以seesion要存在redis中
拦截器，根据token从redis取用户信息，放到ThreadLocal
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { System.out.println(request.getServletPath() + "进入拦截器"); try { if (filter.contains(request.getServletPath())) { System.out.println("跳过拦截器"); return true; } //从根据token从redis取用户信息 UserInfo userInfo = getUser(request, response); if (userInfo != null) { // 存入ThreadLocal UserContext.setUser(userInfo); if (!frequencyControl(userInfo)) { System.out.println(CodeMsg.LOGIN_FREQUENCY.getMsg()); render(response, CodeMsg.LOGIN_FREQUENCY); return false; }else{ // 存入限频标记 redisService.set(MiaoshaKey.accessKey, userInfo.getId().toString(), userInfo.getNickname()); } } else { System.out.println(CodeMsg.SESSION_ERROR.getMsg()); render(response, CodeMsg.SESSION_ERROR); return false; } } catch (Exception e) { e.printStackTrace(); } finally { System.out.println("离开拦截器"); } return true; } private UserInfo getUser(HttpServletRequest request, HttpServletResponse response) throws Exception { String paramToken = request.getParameter(COOKI_NAME_TOKEN); String cookieToken = getCookieValue(request, COOKI_NAME_TOKEN); if (StringUtils.isEmpty(cookieToken) && StringUtils.isEmpty(paramToken)) { return null; } String token = StringUtils.isEmpty(paramToken) ? cookieToken : paramToken; UserInfo userInfo = redisService.get(MiaoshaKey.sessionKey, token, UserInfo.class); if (userInfo != null) { //延长时间 redisService.expire(MiaoshaKey.sessionKey, token); } return userInfo; }
如果查不到session说明失效或者未登录，要在response里面放标记告诉前端，前端调用公共拦截器检测到标记就跳到登录页面
private void render(HttpServletResponse response, CodeMsg cm) throws Exception { response.setContentType("application/json;charset=UTF-8"); if (cm.getCode() == CodeMsg.SESSION_ERROR.getCode()) { //配合前端使用 response.setHeader("x-auth-token", cm.getMsg()); } OutputStream out = response.getOutputStream(); String str = JSON.toJSONString(Result.error(cm)); out.write(str.getBytes("UTF-8")); out.flush(); }
前端调用公共拦截器，检查到消息头有x-auth-token则跳到登录页
import axios from 'axios'; Vue.prototype.$http = axios; axios.interceptors.response.use((response) => { if (response.headers["x-auth-token"]) { router.push({path: '/'}); } return response }, (error) => { return error; });
3，对单个用户请求限频
目的：防止单个用户频率点击，减少服务压力
private boolean frequencyControl(UserInfo user) { String userInfoFlag = redisService.get(MiaoshaKey.accessKey, user.getId().toString(), String.class); //锁定时间未过 if (userInfoFlag != null) { return false; } return true; }
4，生成随机码，存入redis，让用户输入，和redis取出的对比
目的：减少流量，防外挂刷服务
public BufferedImage createVerifyCode(UserInfo user, long goodsId) { if (user == null || goodsId <= 0) { return null; } int width = 80; int height = 32; //create the image BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); Graphics g = image.getGraphics(); // set the background color g.setColor(new Color(0xDCDCDC)); g.fillRect(0, 0, width, height); // draw the border g.setColor(Color.black); g.drawRect(0, 0, width - 1, height - 1); // create a random instance to generate the codes Random rdm = new Random(); // make some confusion for (int i = 0; i < 50; i++) { int x = rdm.nextInt(width); int y = rdm.nextInt(height); g.drawOval(x, y, 0, 0); } // generate a random code String verifyCode = generateVerifyCode(rdm); g.setColor(new Color(0, 100, 0)); g.setFont(new Font("Candara", Font.BOLD, 24)); g.drawString(verifyCode, 8, 24); g.dispose(); Integer rnd = calc(verifyCode); System.out.println(rnd); //把验证码存到redis中 redisService.set(MiaoshaKey.verifyCodeKey, MiaoshaKey.pin(user.getId(), goodsId), rnd); //输出图片 return image; }
5，秒杀地址隐藏，通过接口才能获取随机码，调用秒杀接口要带上随机码，验证通过秒杀请求才能有效
目的：防止用户用秒杀请求的地址一直请求服务，这样一个秒杀请求地址用一次就失效了
生成和检查随机码
public boolean checkPath(UserInfo user, long goodsId, String path) { if (user == null || path == null) { return false; } String pathOld = redisService.get(MiaoshaKey.getMiaoshaPath, MiaoshaKey.pin(user.getId(),goodsId), String.class); return path.equals(pathOld); } public String createPath(UserInfo user, long goodsId) { if (user == null || goodsId <= 0) { return null; } String str = MD5Util.md5(UUIDUtil.uuid() + "123456"); redisService.set(MiaoshaKey.getMiaoshaPath, MiaoshaKey.pin(user.getId(), goodsId), str); return str; }
6，内存过滤请求，本地维护一个localOverMap，key为商品id，value为是否卖完的标记
目的：内存标记可过滤一部分购买卖完商品的请求
...
//内存标记，减少redis访问 Boolean over = goodsInitialization.getLocalOverMap().get(seckillGoodsId); if (over) { return Result.error(CodeMsg.MIAO_SHA_OVER); }
... @PostConstruct public void init() { Long seckillSceneId=getSceneIdFromDB(); List<SeckillGoods> seckillGoodsList = goodsCache.get(seckillSceneId,seckillSceneId,0,Integer.MAX_VALUE); seckillGoodsList.stream().forEach(seckillGoods -> { redisService.set(MiaoshaKey.getMiaoshaGoodsStock, seckillGoods.getId().toString(), seckillGoods.getSeckillGoodsStock()); localOverMap.put(seckillGoods.getId(), false); }); new Timer("loading-SeckillScene-timer", true).schedule(new CurrentSceneTimerTask(), 0, (long) 60 * 1000 * 1000); }
7，预减库存，redis持有各个商品的库存，请求过来先减redis库存
目的：压力先通过redis抗，不要加锁，并发可能会将redis库存减为负数
...
//预减库存 long stock = redisService.decr(MiaoshaKey.getMiaoshaGoodsStock, seckillGoodsId.toString());//10 if (stock < 0) { goodsInitialization.getLocalOverMap().put(seckillGoodsId, true); return Result.error(CodeMsg.MIAO_SHA_OVER); }
... @PostConstruct public void init() { Long seckillSceneId=getSceneIdFromDB(); List<SeckillGoods> seckillGoodsList = goodsCache.get(seckillSceneId,seckillSceneId,0,Integer.MAX_VALUE); seckillGoodsList.stream().forEach(seckillGoods -> { // 预先把库存加载到redis redisService.set(MiaoshaKey.getMiaoshaGoodsStock, seckillGoods.getId().toString(), seckillGoods.getSeckillGoodsStock()); localOverMap.put(seckillGoods.getId(), false); }); new Timer("loading-SeckillScene-timer", true).schedule(new CurrentSceneTimerTask(), 0, (long) 60 * 1000 * 1000); }
8，订单缓存查询，一个人只能买一种商品的1件
目的：这个条件可以排除一部分买过此类商品的人再买的请求
...
//判断是否已经秒杀到了 List<SeckillOrder> seckillOrders = orderCache.get(user.getId(), user.getId(), 0, 1); if (seckillOrders != null && seckillOrders.size() > 0) { if(seckillOrders.stream().filter(a->a.getSeckillGoodsId().equals(seckillGoodsId)).count()>0){ return Result.error(CodeMsg.REPEATE_MIAOSHA); } }
...
9，进入消息队列
目的：削峰
...
//入队 MiaoshaMessage message = new MiaoshaMessage(); message.setSeckillGoodsId(seckillGoodsId); message.setUserId(user.getId()); rabbitmqService.send(message); return Result.success(0);//排队中
...
10，分布式锁，监听器收到消息之后，加分布式锁，保证一个用户对同一个商品的操作串行
目的：去重，一个用户对一个商品购买请求在一分钟内只能有一次，多的抛弃
防止第二次请求在第一次请求订单入库之前查询是否购买过，查不到则继续减库存，导致一个人买一种商品两件
...
//用户+商品级别的分布式锁 if (redisService.hasKey(MiaoshaKey.getUserAndGoodsLock, MiaoshaKey.pin(message.getUserId(), message.getSeckillGoodsId()))) { // 这个用户一分钟内时间下单多次，直接抛弃 return; } else { redisService.set(MiaoshaKey.getUserAndGoodsLock, MiaoshaKey.pin(message.getUserId(), message.getSeckillGoodsId()), "operating"); }
...
11，库存表按照id分8张表
目的：将db查库存减库存的压力分散到多张表
...
// 查询真实库存 long stockCount = seckillGoodsService.getStockCountByGoodsIdFromDB(message.getSeckillGoodsId()); if (stockCount <= 0) { return; } //查询订单是否购买过 List<SeckillOrder> seckillOrders = orderCache.get(message.getUserId(), message.getUserId(), 0, 1); if (!CollectionUtils.isEmpty(seckillOrders)) { if (seckillOrders.stream().filter(a -> a.getSeckillGoodsId().equals(message.getSeckillGoodsId())).count() > 0) { return; } }
...
12，减库存sql，set库存=库存-1 where 库存>0
目的：数据库层面防止超卖
<update id="reduceStock" parameterType="java.util.Map">
update seckill_goods${tableSuffix} set seckill_goods_stock=seckill_goods_stock-1 where id=#{id,jdbcType=BIGINT} and seckill_goods_stock>0
</update>
13，事务处理，创建订单放在一个事务里面
减库存：
成功则创建订单，创建订单成功删除该用户订单缓存，
失败则表示卖完，更新到商品内存卖完标记
异常则回滚
/** * 减库存，创建订单，事务 */
@Transactional
public void miaosha(UserInfo userInfo, SeckillGoods seckillGoods, Goods goods){ if(seckillGoodsService.reduce(seckillGoods.getId())){ try { //唯一键插入失败 orderService.createOrder(userInfo, seckillGoods,goods); //删除订单缓存 orderCache.delete(userInfo.getId()); }catch (Exception e){ throw new GlobalException(CodeMsg.REPEATE_MIAOSHA); } }else { //更新内存卖完标记 goodsInitialization.getLocalOverMap().put(seckillGoods.getId(),true); throw new GlobalException(CodeMsg.MIAO_SHA_OVER); } }
七，web地址
http://212.64.92.191:8888/