09月
12

发表于 • 字数统计 8979 • 被 1,004 人看爆

一，涉及的技术

vue，nodejs

springboot，mybatis，redis，rabbitmq

二，设计图如下

img

三，整个流程描述

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关联即可，保证秒杀活动不会影响主系统，并且这样数据量也少，增删改查性能更高

五，表设计

img

六，技术点总结

1，前端异步调用秒杀接口后读秒

读秒结束后查询后台订单缓存（下单成功会删除缓存，直接查库），查询结果就是秒杀结果，不要轮询，减少后台压力

目的：限流

img

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&gt;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);
        }
    }
分享到：