我的項目之電商秒殺系統總結

一，涉及的技術

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&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);
        }
    }

七，web地址

http://212.64.92.191:8888/