Springboot之登入模組探索（含Token，驗證碼，網路安全等知識）

簡介

登入模組很簡單，前端傳送賬號密碼的表單，後端接收驗證後即可~

淦！可是我想多了，於是有了以下幾個問題（裡面還包含網路安全問題）：

1.登入時的驗證碼

2.自動登入的實現

3.怎麼維護前後端登入狀態

在這和大家分享下我實現此功能的過程，包括一些技術和心得

1.登入時的驗證碼

為什麼要驗證碼，原因很簡單，防止指令碼無限次重複登入，來暴力破解使用者密碼或者攻擊伺服器

驗證碼的出現，使得每次登入都有個動態變數需要輸入，無法用指令碼寫死程式碼

具體可以參考：滑動驗證碼的設計和理解

2.自動登入的實現

所謂自動登入，指的是當使用者登入網站時勾選了自動登入，那麼下次再訪問網站就不需要輸入賬號密碼直接登入了

這說明，賬號密碼資訊是必須儲存在使用者這邊的，因此自動登入都是不安全的！（方便的代價呀）

儘管不安全，但是我們也必須要盡力讓它安全一點，有以下常用方法：

1.賬號密碼加密儲存

2.降低自動登入後使用者的許可權（如果使用者自動登入想改密碼，想給我轉錢等操作的話，就必須輸入賬號密碼再登入一次！）

3.進行ip檢測（之前登入的ip小本本記著），如果發現和上次不一致，則不允許自動登入

資料儲存在前端哪裡呢

瀏覽器有3個經常儲存資料的地方

1.Cookie （我用這個）

2.LocalStorage

3.SessionStorage

各位可以按F12直接觀看

 

 

如果你在多個大型網站下都按按F12，會發現SessionStorage基本沒資料

為啥，因為真的不好用，它並不是後臺的session那樣，生命週期是一個會話，這個SessionStorage儲存的資料只限於該標籤的頁面

意思是標籤1和標籤2即使是同個URL的網址，裡面的資料都是不互通的（這有個毛用）

 

那麼LocalStorage儲存的資料如何呢，答案是無限期本地儲存

不過後臺無法操作這裡的資料，只能由js程式碼操作（至於操作結果，完全看js，後端無法感知，不太可靠），我認為這裡不適合儲存敏感點的資訊，因為前端的功能是展示，狀態性的資料應該由後端直接掌控（後端能直接操作Cookie，保證完成任務）

你看英雄所見略同，CSDN網站的使用者密碼也是存在Cookie的

 

 

 Token就是登入後的令牌（下一點會講）

 

所以用Cookie就對啦，具體實現都很簡單，前端多個自動登入的選擇，選擇後多個引數傳給後端，後端根據引數往Cookie裡設定加密後的賬號密碼

等下次訪問時，用攔截器Interceptor進行攔截，檢測是否要自動登入即可~

3.如何維護前後端登入狀態

大家最先想到是用Session來維護，登入後在Session中存放使用者資訊，不過對分散式很不友好（什麼，你說你用不到分散式，我也沒用到，可是夢想還是要有的嘛），需要維護個分散式資料庫來進行資料同步才行

於是我用Token實現的，Token就是一串字串，最適合API鑑權（例如SSO單點登入這種），俗稱令牌

好處就是賬號密碼使用者輸入一次就夠了，特別是多個系統之間（一張身份的憑證都通用）

當使用者登入後，伺服器就會生成一個Token放在Cookie中，之後使用者的所有操作都帶這個Token訪問（將Token放入http頭部）

為什麼要將Token放入頭部

1.能抵擋下簡單的CSRF攻擊

2.瀏覽器跨域問題

什麼是CSRF攻擊

舉個例子：我登入了A網站，A網站給我返回了一些Cookie資訊，然後我再同一瀏覽器的另外標籤訪問了B網站，誰知這個B網站返回了一些攻擊程式碼（向A網站發起一些請求，比如轉錢給你，這時候由於是訪問A網站，會附帶A網站的Cookie，讓一切都好像是我在訪問一樣），這個就是CSRF攻擊

但B網站並不知道A網站這麼雞賊，會在頭部放了Token，所以這次攻擊請求是的頭部是沒Token的，因此檢測後發現非法，所以沒得逞

當然，這並不可靠，哪天B網站知道你頭部放了Token，它研究A網站的js程式碼，清楚邏輯之後也加上，那就防不住了（所以說前端的東西一切都不可靠）

正確做法應該是後端檢測頭部的Referer欄位，每個網頁裡發起請求，請求的頭部都會帶有此欄位，如

 

 

這說明這個請求是從 http://localhost:8099/swr 中發出的

B網站如果返回攻擊程式碼，這裡顯示的事B網站的網址，判斷出不是自家網站發出，就可以禁止訪問

瀏覽器跨域訪問會發生什麼

說到跨域（自家網站去請求別人家的網站），得先了解什麼是同源策略：

同源策略（Same origin policy）是一種約定，它是瀏覽器最核心也最基本的安全功能，如果缺少了同源策略，則瀏覽器的正常功能可能都會受到影響。可以說 Web 是構建在同源策略基礎之上的，瀏覽器只是針對同源策略的一種實現。

它的核心就在於它認為自任何站點裝載的信賴內容是不安全的。當被瀏覽器半信半疑的指令碼執行在沙箱時，它們應該只被允許訪問來自同一站點的資源，而不是那些來自其它站點可能懷有惡意的資源。

所謂同源是指：域名、協議、埠相同。

下表是相對於 http://www.laixiangran.cn/home/index.html 的同源檢測結果：

另外，同源策略又分為以下兩種：

1. DOM 同源策略：禁止對不同源頁面 DOM 進行操作。這裡主要場景是 iframe 跨域的情況，不同域名的 iframe 是限制互相訪問的。
2. XMLHttpRequest 同源策略：禁止使用 XHR 物件向不同源的伺服器地址發起 HTTP 請求。（就是ajax）

咳咳，這裡要說下第二種，其實設定一些引數之後，ajax訪問時允許跨域請求的，甚至允許跨域時帶上自身cookie

但是，帶上自己的Cookie多不安全，明明裡面只有1,2個資訊要傳給對方，現在被人全看見了（不好不好），所以要將Token放入頭部

你說為啥不放到引數裡，因為這會跟業務用的引數混淆，造成邏輯混亂（就好像你上學時要扔家裡的垃圾，你不會放到書包裡吧，都是手裡提著的）

每個請求都放token，所以要封裝起來，例如我是將ajax封裝起一個新的物件，然後在這個物件使用時新增Token

當然啦，封裝了ajax後還有其他好處（例如統一的成功，失敗回撥函式，統一的資料解析，統一的等待框等等），有興趣的同學可以看下

/**
 * 訪問後臺的物件，為ajax封裝
 * @param url 後臺資源路徑
 * @param param Map引數
 * @param contentType 傳輸型別
 * @param success   成功回撥函式
 * @param error 失敗回撥函式
 * @param requestType 請求型別（get.post,put,delete）
 * @constructor
 */
var Query = function (url, param, contentType, successFunc, errorFunc, requestType) {
    this.url = url;

    //先確認引數存在
    if (param) {
        //如果是get請求型別，則將引數拼接到url後面
        if (requestType == Query.GET_TYPE) {
            this.param = this._concatParamToURL(param, url);
        } else {
            //其他請求型別，要根據不同的傳輸格式來確定傳輸的值的型別
            if (contentType == Query.NOMAL_TYPE) {
                this.param = JSON.parse(this._convertParamToJson(param));
            } else {
                this.param = this._convertParamToJson(param);
            }
        }
    } else {
        this.param = null;
    }


    this.contentType = contentType;
    this.successFunc = successFunc;
    this.errorFunc = errorFunc;
    //請求超時，預設10秒
    this.timeout = 10000;
    //是否非同步請求，預設非同步
    this.async = true;
    this.requestType = requestType;
}

Query.JSON_TYPE = 'application/json';
Query.NOMAL_TYPE = 'application/x-www-form-urlencoded';

/**
 * ajax請求的訪問
 * 預設是post
 * @param url 要訪問的地址
 * @param paramMap 傳給後臺的Map引數，key為字串型別
 * @param callback 回撥函式
 * @param contentType 傳輸資料的格式  預設傳輸application/x-www-form-urlencoded格式
 */
Query.create = function (url, paramMap, successFunc, errorFunc) {
    return new Query(url, paramMap, Query.NOMAL_TYPE, successFunc, errorFunc, Query.GET_TYPE);
}

//-----------------------以下為RESTFul方法---------------------------
//ajax請求型別
Query.GET_TYPE = "get";
Query.POST_TYPE = "post";
Query.PUT_TYPE = "put";
Query.DELETE_TYPE = "delete";

//get方法預設是Query.NOMAL_TYPE
Query.createGetType = function (url, paramMap, successFunc, errorFunc) {
    return new Query(url, paramMap, Query.NOMAL_TYPE, successFunc, errorFunc, Query.GET_TYPE);
}
Query.createPostType = function (url, paramMap, successFunc, errorFunc) {
    return new Query(url, paramMap, Query.JSON_TYPE, successFunc, errorFunc, Query.POST_TYPE);
}
Query.createPutType = function (url, paramMap, successFunc, errorFunc) {
    return new Query(url, paramMap, Query.JSON_TYPE, successFunc, errorFunc, Query.PUT_TYPE);
}
Query.createDeleteType = function (url, paramMap, successFunc, errorFunc) {
    return new Query(url, paramMap, Query.JSON_TYPE, successFunc, errorFunc, Query.DELETE_TYPE);
}

/**
 * 將paramMap引數轉為json格式
 * @param paramMap
 * @private
 */
Query.prototype._convertParamToJson = function (paramMap) {

    return window.tool.strMap2Json(paramMap);

}

/**
 * 將引數拼接至URL尾部
 * @param paramMap
 * @param url
 * @private
 */
Query.prototype._concatParamToURL = function (paramMap, url) {
    let size = paramMap.size;

    if (size > 0) {
        let count = 0;
        url = url + "?";
        let urlParam = "";

        for (let [k, v] of paramMap) {
            urlParam = urlParam + encodeURIComponent(k) + "=" + encodeURIComponent(v);
            if (count < size-1) {
                urlParam = urlParam + " && ";
                count++;
            }
        }
        url = url + urlParam;
    }
    return url;
}

//ajax需要跳轉的介面
Query.REDIRECT_URL = "REDIRECT_URL";

/**
 * ajax成功返回時呼叫的方法
 * 會根據ajax的ContentType型別，轉換Response物件的data給回撥的成功函式
 * 如application/json格式型別，data會轉成json型別傳遞
 * @param queryResult 返回的值，通常為後臺的Response物件
 * @private
 */
Query.prototype._successFunc = function (queryResult) {
    var data = this.__afterSuccessComplete(queryResult);
    if (this.successFunc) {
        this.successFunc(data);
    }

    //如果有需要跳轉的頁面，則自動跳轉
    if (data && data.REDIRECT_URL != null) {
        window.location = data.REDIRECT_URL;
    }
}

/**
 * 會根據ajax的ContentType型別，轉換Response物件的data給回撥的失敗函式
 * 如application/json格式型別，data會轉成json型別傳遞
 * 如果對獲得的引數不滿意，可以用this.getMsg或this.getJsonMsg來進行獲取（this指Query物件）
 *
 * 這裡錯誤分3種
 * 1.是Web容器出錯
 * 2.是Filter過濾器主動報錯（如一些校驗失敗後主動丟擲，會有錯誤提示）
 * 3.是Spring丟擲，Spring異常會全域性捕捉進行封裝
 * @param queryResult 返回的值，通常為後臺的Response物件
 * @private
 */
Query.prototype._errorFunc = function (queryResult) {

    //返回的資訊
    var data = this.__afterErrorComplete(queryResult);
    //如果data裡面沒東西
    if (!data) {
        data = queryResult.statusText;
    }

    //是否呼叫者自身已解決了錯誤
    var handleError = false;

    //呼叫回撥函式，如果返回結果為true，則不會預設錯誤處理
    if (this.errorFunc instanceof Function) {
        handleError = this.errorFunc(data);
    }

    //錯誤編號
    var code;
    //錯誤資訊
    var msg;

    //沒有取消對錯誤的後續處理，那麼進行跳轉
    if (!handleError) {

        //如果data成功轉為Json物件
        if (data) {
            //Filter過濾器主動報錯（如一些校驗失敗後主動丟擲，會有錯誤提示）
            if (data.status) {
                code = data.status;
            }
            if (data.message) {
                msg = data.message;
            }
        }

        //最終跳轉至錯誤頁面
        var path = "/system/error";
        if (code && msg) {
            path = path + "/" + error.code + "/" + error.msg;
        }
        window.location.href = path;
    }
}

Query.SUCCESS_TYPE = "SUCCESS_TYPE";
Query.ERROR_TYPE = "ERROR_TYPE";
/**
 * 當一個請求完成時，無論成功或失敗，都要呼叫此函式做一些處理
 * @param queryResult 服務端返回的資料
 * @returns {*}
 * @private
 */
Query.prototype._afterComplete = function (queryResult) {
    this._cancleLoadDom();
}

/**
 * 成功的返回處理，會將data部分轉為物件
 * 預設application/json會進行單引號轉雙引號
 * @param queryResult 服務端返回的資料
 * @param queryResult
 * @returns {*}
 * @private
 */
Query.prototype.__afterSuccessComplete = function (queryResult) {
    this._afterComplete();
    this.response = queryResult;

    var data = queryResult.data;
    //data必須要有內容，且不是物件才有轉換的意義
    if (data && !(data instanceof Object)) {
            data = this.getJsonMsg();
    }
    return data;
}

/**
 * 失敗的返回處理
 * 最終會根據ajax的contentType來進行data相應型別轉換
 * 預設application/json會進行單引號轉雙引號
 * @param queryResult 服務端返回的資料
 * @private
 */
Query.prototype.__afterErrorComplete = function (queryResult) {
    this._afterComplete();
    this.response = queryResult;
    var data = queryResult.responseJSON;
    if (!data) {
        data = queryResult.responseText;
    }

    return data;
}

/**
 * 取消請求時的等待框
 * @private
 */
Query.prototype._cancleLoadDom = function () {
    //取消載入框
    if (this.loadDom) {
        $(this.loadDom).remove("#loadingDiv");
    }
}

/**
 * 正式傳送ajax
 * @private
 */
Query.prototype.sendMessage = function () {
    var self = this;
    var xhr = $.ajax(
        {
            url: this.url,
            type: this.requestType,
            contentType: this.contentType,
            data: this.param,
            // ajax傳送前呼叫的方法，初始化等待動畫
            // @param XHR  XMLHttpRequest物件
            beforeSend: function (XHR) {
                //試圖從Cookie中獲得token放入http頭部
                var token = window.tool.getCookieMap().get(window.commonStaticValue.TOKEN);
                if(token){
                    XHR.setRequestHeader(window.commonStaticValue.TOKEN,token);
                }

                //繫結本次請求的queryObj
                XHR.queryObj = self;
                if (self.beforeSendFunc instanceof Function) {
                    self.beforeSendFunc(XHR);
                }

                if (self.loadDom instanceof HTMLElement) {
                    self.loadDom.innerText = "";
                    $(self.loadDom).append("<div id='loadingDiv' class='loading'><img src='/image/loading.gif'/></div>");
                } else if (self.loadDom instanceof jQuery) {
                    self.loadDom.empty();
                    self.loadDom.append("<div id='loadingDiv' class='loading'><img src='/image/loading.gif'/></div>");
                }
            },
            //將QueryObj設定為上下文
            context: self,
            success: this._successFunc,
            error: this._errorFunc,
            complete:function(){
              console.log("ajax完成");
            },
            timeout: this.timeout,
            async: this.async
        }
    );
}

//-----------------------------------下面提供了獲取後臺返回資訊方法（幫忙封裝了）
/**
 * 獲取返回資訊Response的Meta頭
 */
Query.prototype.getMeta = function () {
    return this.response.meta;
}

/**
 * 獲得返回值裡的data部分
 * @returns {*}
 */
Query.prototype.getMsg = function () {
    return this.response.data;
}

/**
 * 獲得返回值裡的data部分，嘗試將其轉為Json物件
 */
Query.prototype.getJsonMsg = function () {
    var data = this.response.data;
    if (data) {
            //先將字串裡的&quot;轉為雙引號
            var data = window.tool.replaceAll(data, "&quot;", "\"");
            try{
                var jsonData = JSON.parse(data);
                return jsonData;
            }catch (e) {
                return data;
            }
    }
}

//------------------------以下為對Query的引數設定---------------------------
/**
 * 在ajax傳送前設定引數，可以有載入的動畫，並且請求完成後會自動取消
 * @param loadDom 需要顯示動畫的dom節點
 * @param beforeSendFunc ajax傳送前的自定義函式
 */
Query.prototype.setBeforeSend = function (loadDom, beforeSendFunc) {
    this.loadDom = loadDom;
    this.beforeSendFunc = beforeSendFunc;
}

/**
 * 設定超時時間
 * @param timeout
 */
Query.prototype.setTimeOut = function (timeout) {
    this.timeout = timeout;
}

Query.prototype.setAsync = function (async) {
    this.async = async;
}

預防XSS攻擊，Filter知識講解

網上有些文章說，後端設定HttpOnly，讓Cookie無法讓js讀寫，可以防止XSS攻擊。

(⊙o⊙)…簡直就是亂寫，首先要了解下什麼是XSS攻擊

Xss攻擊是什麼

舉個簡單的例子，假設你前端有個地方可以輸入，然後儲存的資料庫的地方

使用者A輸入了以下東西

<script>alert(123)</script>

然後這東西就到了後臺，當作一串字串儲存了起來

剛好你網站的html程式碼裡，有個地方是顯示使用者輸入過的東西的（例如評論區），然後上面的東西就被載入到html裡面，如

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8" />
        <title></title>
        <p><script>alert(123)</script></p>
    </head>
    <body>
    </body>
</html>

接下來每個人開啟你的網站，都會彈出123的對話方塊，這就是XSS攻擊

怎麼預防呢，在後端設定過濾器，對輸入進行過濾，先上程式碼

/**
 * @auther: NiceBin
 * @description: 系統的攔截器，註冊在FilterConfig類中進行
 *               不能使用@WebFilter，因為Filter要排序
 *               1.對ServletRequest進行封裝
 *               2.防止CSRF，檢查http頭的Referer欄位
 * @date: 2020/12/15 15:32
 */
@Component
public class SystemFilter implements Filter {
    private final Logger logger = LoggerFactory.getLogger(SystemFilter.class);
    @Autowired
    private Environment environment;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        logger.info("系統攔截器SystemFilter開始載入");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        SystemHttpServletRequestWrapper requestWrapper = new SystemHttpServletRequestWrapper((HttpServletRequest) request);

        //檢測http的Referer欄位，不允許跨域訪問
        String hostPath = environment.getProperty("server.host-path");
        String referer = requestWrapper.getHeader("Referer");
        if(!Tool.isNull(referer)){
            if(referer.lastIndexOf(hostPath)!=0){
                ((HttpServletResponse)response).setStatus(HttpStatus.FORBIDDEN.value()); //設定錯誤狀態碼
                return;
            }
        }
        chain.doFilter(requestWrapper,response);
    }

    @Override
    public void destroy() {

    }
}

乍一看，是不是沒發現哪裡預防了XSS，其實正在的關鍵點在22行和33行程式碼，裡面的SystemHttpServletRequestWrapper類才是關鍵，這個類是包裝類，是替換引數裡的ServletRequest類的，為的就是重寫裡面的方法，來達到預防XSS的目的，因為Spring也是根據ServletRequest類來進行前端引數讀取的，所以它就是後端獲得資料的源頭

/**
 * @auther: NiceBin
 * @description: 包裝的httpServlet，進行以下增強
 *               1.將流資料取出儲存，方便多次讀出
 *               2.防止XSS攻擊，修改讀取資料的方法，過濾敏感字元
 * @date: 2020/4/23 19:50
 */
public class SystemHttpServletRequestWrapper extends HttpServletRequestWrapper {
    private final byte[] body;
    private HttpServletRequest request;

    public SystemHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        //列印屬性
        //printRequestAll(request);
        body = HttpHelper.getBodyString(request).getBytes(Charset.forName("UTF-8"));  //HttpHelper是我自己寫的工具類
        this.request = request;
    }

    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream bais = new ByteArrayInputStream(body);
        return new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {

            }

            @Override
            public int read() throws IOException {
                return bais.read();
            }
        };
    }

    /**
     * 可以列印出HttpServletRequest裡屬性的值
     * @param request
     */
    public void printRequestAll(HttpServletRequest request){
        Enumeration e = request.getHeaderNames();
        while (e.hasMoreElements()) {
            String name = (String) e.nextElement();
            String value = request.getHeader(name);
            System.out.println(name + " = " + value);
        }
    }

    //以下為XSS預防
    @Override
    public String getParameter(String name) {
        String value = request.getParameter(name);
        if (!StringUtils.isEmpty(value)) {
            value = StringEscapeUtils.escapeHtml4(value);
        }
        return value;
    }

    @Override
    public String[] getParameterValues(String name) {
        String[] parameterValues = super.getParameterValues(name);
        if (parameterValues == null) {
            return null;
        }
        for (int i = 0; i < parameterValues.length; i++) {
            String value = parameterValues[i];
            parameterValues[i] = StringEscapeUtils.escapeHtml4(value);
        }
        return parameterValues;
    }
}

HttpHelper工具類：

public class HttpHelper {
    /**
     * 獲取請求中的Body內容
     * @param request
     * @return
     */
    public static String getBodyString(ServletRequest request) {
        StringBuilder sb = new StringBuilder();
        InputStream inputStream = null;
        BufferedReader reader = null;
        try {
            inputStream = request.getInputStream();
            reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
            String line = "";
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return sb.toString();
    }
}

可以看到SystemHttpServletRequestWrapper的64行開始，重寫了兩個獲取引數的方法，在獲取引數的時候進行過濾即可~

那64行往上是幹啥的咧，這個是將ServletRequest裡的資料讀出來儲存一份，因為ServletRequest裡的資料流只能讀取一次，很不方便

啥意思呢，就是你在這個Filter裡

inputStream = request.getInputStream();
reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));

String line = "";
while ((line = reader.readLine()) != null) {
    sb.append(line);
}

把資料讀完，下個Filter再執行這些程式碼，就沒資料了（從而導致Spring也接收不到資料）

所以要儲存起來，讓後面的過濾器Filter和攔截器Interceptor快樂的讀資料，沒有後顧之憂（例如上面提到的驗證碼設計，如果你想用攔截器攔截，然後進行驗證，則勢必會讀資料），既然封裝ServletRequest這麼重要，那必須得保證這個Filter第一個載入啊

在Springboot中，Filter的排序用@Order是沒用的，必須要用FilterRegistrationBean進行註冊才能排序，如：

/**
 * @auther: NiceBin
 * @description: 為了排序Filter，如果Filter有順序要求
 *               那麼需要在此註冊，設定order（值越低優先順序越高）
 *               其他沒順序需要的，可以@WebFilter註冊
 *               如@WebFilter(filterName = "SecurityFilter", urlPatterns = "/*", asyncSupported = true)
 * @date: 2020/12/15 15:48
 */
@Configuration
public class FilterConfig {

    @Autowired
    SystemFilter systemFilter;
    /**
     * 註冊SystemFilter，順序為1，任何其他filter不能比他優先
     * @return
     */
    @Bean
    public FilterRegistrationBean filterRegist(){
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(systemFilter);
        filterRegistrationBean.setName("SystemFilter");
        filterRegistrationBean.addUrlPatterns("/*");
        filterRegistrationBean.setAsyncSupported(true);
        filterRegistrationBean.setOrder(1);
        return filterRegistrationBean;
    }
}

當然了，如果你沒用Springboot，那web.xml中定義的順序就是Filter載入的順序

知識點提問：在我們之後的Filter或者Interceptor中，需要

SystemHttpServletRequestWrapper requestWrapper = (SystemHttpServletRequestWrapper) request

這樣強制轉換才能用嗎？

答案是不用的，你可以想想Spring也用了這個東西的，它怎麼知道你定義的類叫什麼名字，怎麼強制轉換，那麼這設計到Java什麼知識呢

沒錯，就是Java的多型性，我們看以下程式碼

public class Father {
    public void sayName(){
        System.out.println("我是爸爸");
    }
}

public class Son extends Father{
    public void sayName(){
        System.out.println("我是兒子");
    }
}

public class Test {

    @org.junit.Test
    public void test() throws Exception {
        Father father = new Son();
        otherMethod(father);
    }

    public void otherMethod(Father father){
        father.sayName();
    }
}

輸出：我是兒子

答錯了的留言，看看有多少小夥子~~ 接下來言歸正傳

選擇JWT生成Token

JWT全稱JSON Web Tokens 是一種規範化的 token（別人想的挺多挺全面的了，比你自己想的token要好一點）

一個 JWT token 是一個字串，它由三部分組成，頭部、載荷與簽名，中間用 . 分隔，例如：xxxxx.yyyyy.zzzzz

頭部（header）

頭部通常由兩部分組成：令牌的型別（即 JWT）和正在使用的簽名演算法（如 HMAC SHA256 或 RSA.）。

例如：

{
  "alg": "HS256",
  "typ": "JWT"
}

然後用 Base64Url 編碼得到頭部，即 xxxxx。Base64Url編碼後，才能在URL中正常傳輸（因為有人會把Token放在URL裡.....）

載荷（Payload）

載荷中放置了 token 的一些基本資訊，以幫助接受它的伺服器來理解這個 token。同時還可以包含一些自定義的資訊，使用者資訊交換，如:

{
  "sub": "1",

  "iss": "http://localhost:8000/auth/login",

  "iat": 1451888119,

  "exp": 1454516119,

  "nbf": 1451888119,

  "jti": "37c107e4609ddbcc9c096ea5ee76c667",

  "aud": "dev"

}

可以將載荷用別的方式加密一遍，這樣別人得到了token也看不懂

簽名（Signature）

簽名時需要用到前面編碼過的兩個字串，如果以 HMACSHA256 加密，就如下：

HMACSHA256(

    base64UrlEncode(header) + "." +

    base64UrlEncode(payload),

    secret

)

加密後再進行 base64url 編碼最後得到的字串就是 token 的第三部分 zzzzz。

組合便可以得到 token：xxxxx.yyyyy.zzzzz。

簽名的作用：保證 JWT 沒有被篡改過，原理如下：

HMAC 演算法是不可逆演算法，類似 MD5 和 hash ，但多一個金鑰，金鑰（即上面的 secret）由服務端持有，客戶端把 token 發給服務端後，服務端可以把其中的頭部和載荷再加上事先共享的 secret 再進行一次 HMAC 加密，得到的結果和 token 的第三段進行對比，如果一樣則表明資料沒有被篡改。

具體Java使用：

<dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.10.2</version>
        </dependency>
        <!--jwt一些工具類-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
</dependency>

**
 * @auther: NiceBin
 * @description: Jwt構造器，建立Token來進行身份記錄
 * jwt由3個部分構成：jwt頭，有效載荷（主體,payLoad），簽名
 * @date: 2020/5/7 22:40
 */
public class JwtTool {

    //以下為JwtTool生成時的主題
    //登入是否還有效
    public static final String SUBJECT_ONLINE_STATE = "online_state";

    //以下為載荷固定的Key值
    //主題
    public static final String SUBJECT = "subject";
    //釋出時間
    public static final String TIME_ISSUED = "timeIssued";
    //過期時間
    public static final String EXPIRATION = "expiration";

    /**
     * 生成token，引數都是載荷（自定義內容）
     * 其中Map裡為非必要資料，而其他引數為必要引數
     *
     * @param subject  主題，token生成幹啥用的，用上面的常量作為引數
     * @param liveTime 存活時間(秒單位)，建議使用TimeUnit方便轉換
     *                 如TimeUnit.HOURS.toSeconds(1);將1小時轉為秒 = 3600
     * @param claimMap 自定義荷載，可以為空
     * @return
     */
    public static String createToken(String subject, long liveTime, HashMap<String, String> claimMap) throws Exception {

        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

        //毫秒要轉為秒
        long now = System.currentTimeMillis() / 1000;

//        byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(EncrypRSA.keyString);
//
//        Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());

        JwtBuilder jwtBuilder = Jwts.builder()
                //加密演算法
                .setHeaderParam("alg", "HS256")
                //jwt簽名
                .signWith(signatureAlgorithm, EncrypRSA.convertSecretKey);  //這個Key是我自個的密碼，你們自己設個字串也成，這個得保密

        HashMap<String,String> payLoadMap = new HashMap<>();
        payLoadMap.put(SUBJECT,subject);
        payLoadMap.put(TIME_ISSUED,String.valueOf(now));
        //設定Token的過期時間
        if (liveTime >= 0) {
            long expiration = now + liveTime;
            payLoadMap.put(EXPIRATION,String.valueOf(expiration));
        } else {
            throw new SystemException(SystemStaticValue.TOOL_PARAMETER_EXCEPTION_CODE, "liveTime引數異常");
        }

        StringBuilder payLoad = new StringBuilder();



        if (!Collections.isEmpty(claimMap)) {
            payLoadMap.putAll(claimMap);
        }

        //拼接主題payLoad，採用 key1,value1,key2,value2的格式
        for (Map.Entry<String, String> entry : payLoadMap.entrySet()) {
            payLoad.append(entry.getKey()).append(',').append(entry.getValue()).append(',');
        }

        //對payLoad進行加密，這樣別人Base64URL解密後也不是明文
        String encrypPayLoad = EncrypRSA.encrypt(payLoad.toString());

        jwtBuilder.setPayload(encrypPayLoad);

        //會自己生成簽名，組裝
        return jwtBuilder.compact();
    }

    /**
     * 私鑰解密token資訊
     *
     * @param token
     * @return 存有之前定義的Key, value的Map，解析失敗則返回null
     */
    public static HashMap getMap(String token) {
        if (!Tool.isNull(token)) {
            try {
                String encrypPayLoad = Jwts.parser()
                        .setSigningKey(EncrypRSA.convertSecretKey)
                        .parsePlaintextJws(token).getBody();

                String payLoad = EncrypRSA.decrypt(encrypPayLoad);

                String[] payLoads = payLoad.split(",");
                HashMap<String, String> map = new HashMap<>();
                for (int i = 0; i < payLoads.length - 1; i=i+2) {
                    map.put(payLoads[i], payLoads[i + 1]);
                }
                return map;
            } catch (Exception e) {
                System.out.println("Token解析失敗");
                return null;
            }
        } else {
            return null;
        }
    }

    /**
     * 判斷token是否有效
     *
     * @param map 已經解析過token的map
     * @return true 為有效
     */
    public static boolean isAlive(HashMap<String, String> map) {

        if (!Collections.isEmpty(map)) {
            String tokenString = map.get(EXPIRATION);

            if (!Tool.isNull(tokenString)) {
                long expiration = Long.valueOf(tokenString) / 1000;
                long now = System.currentTimeMillis();
                if (expiration > now) {
                    return true;
                } else {
                    return false;
                }
            }
        }
        return false;
    }

    /**
     * 判斷token是否有效
     * @param token 還未被解析的token
     * @return
     */
    public static boolean isAlive(String token) {
        return JwtTool.isAlive(JwtTool.getMap(token));
    }
}

至此，Token的生成和使用就介紹完了，大家有沒興趣瞭解下重放攻擊（淦，我也是在某個博文看到的，又得花時間研究）

Https防止半路被截和重放攻擊

前面提到了Token就是身份令牌，可以相當於已登入一樣進入系統，那麼半路被人截了那就不好了

所以要用Https協議，具體怎麼設定大家自行百度吧（直接在tomcat操作的，不需要更改程式碼，證照也有免費的~）

這裡說下Https建立連線的過程，來看看為什麼就不會被人截獲了

1.伺服器先向CA（證照頒佈機構）申請一個證照（證照裡有自己的ip等等訊息），然後在自己伺服器設定好

2.瀏覽器向伺服器傳送HTTPS請求，伺服器將自己的證照發給瀏覽器

3.瀏覽器拿到證照後，檢視證照是否過期啊，ip是不是跟伺服器的一樣啊，跟檢查身份證跟你長得像不像一樣，檢查沒問題後，跟自己系統裡的CA列表比對，看看是誰發的（找不到就報錯，說證照不可信），比對成功後從列表裡拿出對應的CA公鑰解密證照（具體方法跟JWT的很像，瀏覽器用相同的演算法和公鑰對證照部分進行加密，看得到的值和證照的簽名是否一致），得到伺服器的公鑰

4.然後生成一個傳輸私鑰，用伺服器的公鑰加密，發給伺服器

5.伺服器用伺服器的私鑰解密，得到了傳輸祕鑰，然後用傳輸祕鑰進行加密要傳送的資訊發給瀏覽器

6.瀏覽器用祕鑰解密，然後用傳輸祕鑰進行加密要傳送的資訊發給伺服器（對稱加密）

7.重複5,6步驟直到結束

以上哪個步驟黑客得到資料都看不懂

至於為什麼能防重放攻擊，是因為Https通訊自帶序列號，如果黑客擷取了瀏覽器的請求，重複傳送一遍，那麼序列號會一樣，會被直接丟棄

 

至此分享完啦，喜歡的小夥伴給個贊呀~~

參考：https://learnku.com/articles/17883

　　   https://www.cnblogs.com/laixiangran/p/9064769.html

ServletRequest