JWT令牌的應(yīng)用場景?

• JWT令牌最典型的應(yīng)用場景就是登錄認(rèn)證。

1. 在瀏覽器發(fā)起請求來執(zhí)行登錄操作，此時會訪問登錄的接口，如果登錄成功之后，我們需要生成一個jwt令牌，將生成的 jwt令牌返回給前端。

2. 前端拿到j(luò)wt令牌之后，會將jwt令牌存儲起來。在后續(xù)的每一次請求中都會將jwt令牌攜帶到服務(wù)端。

3. 服務(wù)端統(tǒng)一攔截請求之后，先來判斷一下這次請求有沒有把令牌帶過來，如果沒有帶過來，直接拒絕訪問，如果帶過來了，還要校驗一下令牌是否是有效。如果有效，就直接放行進行請求的處理。

在JWT登錄認(rèn)證的場景中我們發(fā)現(xiàn)，整個流程當(dāng)中涉及到兩步操作：

1. 在登錄成功之后，要生成令牌。

2. 每一次請求當(dāng)中，要接收令牌并對令牌進行校驗。

稍后我們再來學(xué)習(xí)如何來生成jwt令牌，以及如何來校驗jwt令牌。

2.3.2 生成和校驗JWT令牌

那簡單介紹了什么是JWT令牌以及JWT令牌的組成之后，接下來我們就來學(xué)習(xí)如何基于Java代碼來生成和校驗JWT令牌。?

首先我們先來實現(xiàn)JWT令牌的生成。

• 要想使用JWT令牌，需要先引入JWT的依賴： ?

<!-- JWT依賴-->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

• 在引入完JWT依賴后，就可以調(diào)用工具包中提供的API來完成JWT令牌的生成和校驗
• 工具類：Jwts
• 無論是JWT令牌的生成還是校驗，都需要用到工具類Jwts

生成JWT代碼實現(xiàn)： ?

   /**
       生成JWT令牌
     */
    @Test
    public void testGenerateJwt() {
        // 封裝JWT令牌當(dāng)中所存儲的自定義數(shù)據(jù)
        Map<String,Object> claims = new HashMap<>();
        claims.put("id",1);
        claims.put("name","Tom");
                     // 構(gòu)建JWT令牌,通過該方法可以讓你通過鏈?zhǔn)骄幊虂砼渲肑WT的各個部分,來設(shè)置JWT令牌在生成的時候所需要設(shè)置的一些參數(shù)
        // 比如設(shè)置數(shù)字簽名對應(yīng)的算法,以及生成數(shù)字簽名時指定的密鑰,以及在JWT令牌當(dāng)中要存儲的一些自定義的數(shù)據(jù),都是需要在生成令牌的時候來指定的
        String jwt = Jwts.builder()
                // 設(shè)置簽名算法:指定數(shù)字簽名的算法 在進行數(shù)字簽名時指定的密鑰,密鑰就是一個字符串
                .signWith(SignatureAlgorithm.HS256,"success")
                // 設(shè)置自定義的數(shù)據(jù),JWT令牌的第二個部分:Payload有效載荷,指定在生成JWT令牌時JWT令牌當(dāng)中所存儲的內(nèi)容,也就是我們自定義的數(shù)據(jù)
                // 在Java程序當(dāng)中可以把自定義的數(shù)據(jù)封裝到Map集合當(dāng)中,也就是Key-Value形式的鍵值對
                .setClaims(claims)
                // 設(shè)置JWT令牌的有效期為1個小時:令牌的有效期指的就是這個令牌在什么時間范圍內(nèi)有效,一旦超過這個有效期,令牌就會失效
                                        // 拿到當(dāng)前時間的毫秒值
                .setExpiration(new Date(System.currentTimeMillis() + 3600 * 1000))
                // 調(diào)用compact()方法之后就可以拿到一個字符串類型的返回值,這個字符串類型的返回值就是我們所生成的JWT令牌
                // 說白了就是調(diào)用compact()方法來獲取最終的JWT字符串
                .compact();
        // 將令牌輸出到控制臺
        System.out.println(jwt);
    }

運行測試方法： ?

eyJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoiVG9tIiwiaWQiOjEsImV4cCI6MTY5MzEwOTQ3OX0.FzJbatpMm2FjiqTRDU_JC2RXSkZdvwonVknPjGOxG6c?

• 輸出的結(jié)果就是生成的JWT令牌,，通過英文的點對三個部分進行分割，我們可以將生成的令牌復(fù)制一下，然后打開JWT的官網(wǎng)，將生成的令牌直接放在Encoded位置，此時就會自動的將令牌解析出來。 ?

• 第一部分解析出來，看到JSON格式的原始數(shù)據(jù)，所使用的簽名算法為HS256。
• 第二個部分是我們自定義的數(shù)據(jù)，之前我們自定義的數(shù)據(jù)就是id，還有一個exp代表的是我們所設(shè)置的JWT令牌的過期時間 / 有效期。
• 由于前兩個部分是base64編碼，所以是可以直接解碼出來。但最后一個部分并不是base64編碼，是經(jīng)過簽名算法計算出來的，所以最后一個部分是不會解析的。

實現(xiàn)了JWT令牌的生成，下面我們接著使用Java代碼來校驗JWT令牌(解析生成的令牌)： ?

校驗/解析JWT令牌：?

   /**
     * 校驗/解析JWT令牌
     */
    @Test // 進行單元測試的注解
    public void testParseJwt() {
        Claims claims = Jwts.parser()
                // 指定簽名密鑰(必須保證和生成令牌時使用的簽名密鑰相同)
                .setSigningKey("success")
                // 傳遞要解析的JWT令牌
                .parseClaimsJws("eyJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoiVG9tIiwiaWQiOjEsImV4cCI6MTY5MzEwOTQ3OX0.FzJbatpMm2FjiqTRDU_JC2RXSkZdvwonVknPjGOxG6c")
                // 獲取JWT令牌中自定義的內(nèi)容
                .getBody();
        System.out.println(claims);
    }

運行測試方法后得到解析結(jié)果：

結(jié)論：如果篡改令牌中的任何一個字符，在對令牌進行解析時都會報錯，所以JWT令牌是非常安全可靠的。 ?

通過以上測試，我們在使用JWT令牌時需要注意：

• JWT校驗時使用的簽名秘鑰，必須和生成JWT令牌時使用的秘鑰是配套的。

• 如果JWT令牌解析校驗時報錯，則說明 JWT令牌被篡改 或 失效了，令牌非法。

2.3.3 登錄下發(fā)令牌

JWT令牌的生成和校驗的基本操作我們已經(jīng)學(xué)習(xí)完了，接下來我們就需要在案例當(dāng)中通過JWT令牌技術(shù)來跟蹤會話。具體的思路我們前面已經(jīng)分析過了，主要就是兩步操作： ?

1. 生成令牌

   • 在登錄成功之后來生成一個JWT令牌，并且把這個令牌直接返回給前端，前端就需要將該令牌存儲起來，然后在后續(xù)的請求當(dāng)中，每一次請求時都需要將這個令牌攜帶到服務(wù)端

2. 校驗令牌(解析令牌)

   • 服務(wù)端攔截前端請求，從請求中獲取到令牌，對令牌進行解析校驗：如果令牌不存在或者是令牌解析錯誤(令牌被篡改)，直接給前端響應(yīng)一個未登錄的錯誤結(jié)果，然后前端會自動地跳轉(zhuǎn)到登錄頁面；如果說令牌存在，并且令牌校驗也通過了，就說明這個令牌時有效的，然后我們直接放行，讓它去執(zhí)行對應(yīng)的業(yè)務(wù)操作即可

那我們首先來完成：登錄成功之后生成JWT令牌(令牌的生成)，并且把JWT令牌返回給前端(令牌的下發(fā))。

JWT令牌怎么返回給前端呢？

• 此時我們就需要再來看一下接口文檔當(dāng)中關(guān)于登錄接口的描述（主要看響應(yīng)數(shù)據(jù)）： ?

響應(yīng)數(shù)據(jù)

• 參數(shù)格式：application/json

參數(shù)說明：

響應(yīng)數(shù)據(jù)樣例：

3.1.4 備注說明

解讀完接口文檔中的描述了，目前我們先來完成令牌的生成和令牌的下發(fā)，我們只需要生成一個令牌返回給前端就可以了。 ?

實現(xiàn)步驟：

1. 引入JWT令牌操作的工具類

   • 在項目工程下創(chuàng)建com.gch.utils包，并把提供JWT工具類復(fù)制到該包下

2. 登錄成功后，調(diào)用工具類生成JWT令牌，并返回

JWT工具類

package com.gch.utils;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;
import java.util.Map;

/**
 * JWT令牌操作的工具類
 */
public class JwtUtils {
    /** 簽名密鑰 */
    private static String signKey = "itheima";
    /** JWT令牌的有效期/有效時間 */
    private static Long expire = 43200000L;

    /**
     * 生成JWT令牌
     * @param claims JWT第二部分負(fù)載 payload 中存儲的內(nèi)容
     * @return
     */
    public static String generateJwt(Map<String, Object> claims){
        String jwt = Jwts.builder()
                // 自定義信息(有效載荷)
                .addClaims(claims)
                // 簽名算法
                .signWith(SignatureAlgorithm.HS256, signKey)
                // 過期時間
                .setExpiration(new Date(System.currentTimeMillis() + expire))
                .compact();
        return jwt;
    }

    /**
     * 解析/校驗JWT令牌
     * @param jwt JWT令牌
     * @return JWT第二部分負(fù)載 payload 中存儲的內(nèi)容
     */
    public static Claims parseJWT(String jwt){
        Claims claims = Jwts.parser()
                // 指定簽名密鑰
                .setSigningKey(signKey)
                // 指定令牌Token
                .parseClaimsJws(jwt)
                .getBody();
        return claims;
    }
}

改造之前的Controller代碼：

package com.gch.controller;

@Slf4j
@RestController
@RequestMapping("/login")
/**
   登錄功能控制器
 */
public class LoginController {
    @Autowired
    private EmpService empService;
    /**
     * 處理登錄請求
     * @param emp 員工對象
     * @return 響應(yīng)
     */
    @PostMapping
    public Result login(@RequestBody Emp emp) {
        // 1.記錄日志
        log.info("處理該用戶登錄請求,username:{}, password:{}", emp.getUsername(), emp.getPassword());
        // 2.調(diào)用service進行查詢,查詢/校驗該用戶信息是否存在
        Emp e = empService.login(emp);
        // 登錄成功 => 生成令牌并下發(fā)令牌
        if(e != null){
            // 封裝JWT令牌當(dāng)中所存儲的自定義數(shù)據(jù)
            Map<String,Object> claims = new HashMap<>();
            claims.put("id",e.getId());
            claims.put("name",e.getName());
            claims.put("username",e.getUsername());
            // 生成JWT令牌,jwt當(dāng)中就包含了當(dāng)前登錄的員工信息
            String jwt = JwtUtils.generateJwt(claims);
            return Result.success(jwt);
        }

        // 登錄失敗 => 返回錯誤信息
        return Result.error("用戶名或密碼錯誤");
    }
}

重啟服務(wù)，打開Postman測試登錄接口：

登錄請求完成后，可以看到服務(wù)端已經(jīng)生成了JWT令牌并且將JWT令牌已經(jīng)響應(yīng)給了前端，此時前端就會將JWT令牌存儲在瀏覽器本地。

接下來在后續(xù)的請求當(dāng)中，前端都會在請求頭當(dāng)中來攜帶JWT令牌到服務(wù)端，而服務(wù)端需要來統(tǒng)一攔截所有的請求，來判斷是否攜帶的有合法的JWT令牌。?

怎樣來統(tǒng)一攔截到所有的請求，來驗證令牌的有效性？

統(tǒng)一攔截的兩種解決方案：

1. Filter過濾器

2. Interceptor攔截器

我們首先來學(xué)習(xí)過濾器Filter。

2.4 過濾器Filter

什么是Filter？

• Filter表示過濾器，是 JavaWeb三大組件(Servlet、Filter過濾器、Listener監(jiān)聽器)之一。對于這三大組件來說，Servlet以及Listener現(xiàn)在已經(jīng)很少使用了，而現(xiàn)在唯一使用比較多的就是Filter過濾器。

• 過濾器可以把對資源的請求攔截下來，從而實現(xiàn)一些特殊的功能

  • 使用了過濾器之后，要想訪問Web服務(wù)器上的資源，必須先經(jīng)過濾器，過濾器處理完畢之后，才可以訪問對應(yīng)的資源。資源訪問完畢之后，它還會再回到過濾器，然后再給瀏覽器響應(yīng)對應(yīng)的數(shù)據(jù)。

• 過濾器一般完成一些通用的操作，比如：登錄校驗、統(tǒng)一編碼處理、敏感字符處理等。

• 我們拿登錄校驗來說，如果沒有過濾器，?我們是需要在每一個接口方法當(dāng)中都需要來編寫登錄校驗的邏輯，導(dǎo)致這一部分的邏輯重復(fù)編寫多次，代碼繁瑣，可讀性變差。
• 而現(xiàn)在有了過濾器就不需要那么繁瑣了，此時我們就可以直接將登錄校驗的邏輯直接定義在過濾器Filter當(dāng)中，我只需要定義這么一次就可以了。

下面我們通過Filter快速入門程序掌握過濾器的基本使用操作：

• 第1步，定義過濾器 ：1.定義一個類，實現(xiàn) Filter 接口，并重寫其所有方法。

• 第2步，配置過濾器：Filter類上加 @WebFilter 注解，配置攔截資源的路徑。引導(dǎo)類上加 @ServletComponentScan 開啟Servlet組件支持。

定義過濾器 ?

@WebFilter(urlPatterns = "/*") //配置過濾器要攔截的請求路徑（ /* 表示攔截瀏覽器的所有請求 ）
//定義一個類，實現(xiàn)一個標(biāo)準(zhǔn)的Filter過濾器的接口
public class DemoFilter implements Filter {
    @Override //初始化方法, Web服務(wù)器啟動，創(chuàng)建Filter時調(diào)用，只調(diào)用一次
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init 初始化方法執(zhí)行了");
    }

    @Override //攔截到請求之后調(diào)用, 調(diào)用多次
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("Demo 攔截到了請求...放行前邏輯");
        //放行操作
        chain.doFilter(request,response);
    }

    @Override //銷毀方法, 服務(wù)器關(guān)閉時調(diào)用，只調(diào)用一次
    public void destroy() {
        System.out.println("destroy 銷毀方法執(zhí)行了");
    }
}

• init方法：過濾器的初始化方法。在web服務(wù)器啟動的時候會自動的創(chuàng)建Filter過濾器對象，在創(chuàng)建過濾器對象的時候會自動調(diào)用init初始化方法，這個方法只會被調(diào)用一次。

• doFilter方法：這個方法是在每一次攔截到請求之后都會被調(diào)用，所以這個方法是會被調(diào)用多次的，每攔截到一次請求就會調(diào)用一次doFilter()方法。

• destroy方法： 與init對應(yīng)的另外一種方法，是銷毀的方法。當(dāng)我們關(guān)閉服務(wù)器的時候，它會自動的調(diào)用銷毀方法destroy，而這個銷毀方法也只會被調(diào)用一次。

• 說明：IDEA之所以默認(rèn)只選擇了doFilter()方法，是因為init初始化以及的destory銷毀這兩個方法并不常用，所以在Filter接口當(dāng)中，針對于這兩個方法已經(jīng)提供了默認(rèn)實現(xiàn)，所以在這里我們可以不用實現(xiàn)init和的destory這兩個方法。

• 在定義完Filter之后，F(xiàn)ilter其實并不會生效，還需要完成Filter的配置，F(xiàn)ilter的配置非常簡單，只需要在Filter類上添加一個注解：@WebFilter，通過該注解來標(biāo)識當(dāng)前是一個過濾器組件，并指定屬性urlPatterns，通過這個屬性指定過濾器要攔截哪些請求。??

當(dāng)我們在Filter類上面加了@WebFilter注解之后，接下來我們還需要在啟動類上面加上一個注解@ServletComponentScan，因為Filter是Java Web三大組件之一，并不是SpringBoot當(dāng)中提供的，通過這個@ServletComponentScan注解來開啟SpringBoot項目對于Servlet組件的支持。 ?

@ServletComponentScan
@SpringBootApplication
public class TliasWebManagementApplication {
    public static void main(String[] args) {
        SpringApplication.run(TliasWebManagementApplication.class, args);
    }
}

重新啟動服務(wù)，打開瀏覽器，執(zhí)行部門管理的請求，可以看到控制臺輸出了過濾器中的內(nèi)容： ?

一旦攔截到請求，它就會自動的調(diào)用doFilter()方法。?

注意事項：

• 在過濾器Filter中，如果不執(zhí)行放行操作，將無法訪問后面的資源。
• 放行操作：調(diào)用FilterChain當(dāng)中的chain.doFilter(request, response)；參數(shù)：請求對象，響應(yīng)對象

總結(jié)：?

2.4.2 Filter詳解

Filter過濾器的快速入門程序我們已經(jīng)完成了，接下來我們就要詳細的介紹一下過濾器Filter在使用中的一些細節(jié)。主要介紹以下3個方面的細節(jié)：

1. 過濾器的執(zhí)行流程

2. 過濾器的攔截路徑配置

3. 過濾器鏈

2.4.2.1 執(zhí)行流程

首先我們先來看下過濾器的執(zhí)行流程：

過濾器當(dāng)中我們攔截到了請求之后，如果希望繼續(xù)訪問后面的web資源，就要執(zhí)行放行操作，放行就是調(diào)用 FilterChain對象當(dāng)中的doFilter()方法，在調(diào)用doFilter()這個方法之前所編寫的代碼屬于放行之前的邏輯。 ?

在放行后訪問完 web 資源之后還會回到過濾器當(dāng)中，回到過濾器之后如有需求還可以執(zhí)行放行之后的邏輯，放行之后的邏輯我們寫在doFilter()這行代碼之后。

@WebFilter(urlPatterns = "/*") 
public class DemoFilter implements Filter {
    
    @Override //初始化方法, 只調(diào)用一次
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init 初始化方法執(zhí)行了");
    }
    
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        
        System.out.println("DemoFilter   放行前邏輯.....");

        //放行請求
        filterChain.doFilter(servletRequest,servletResponse);

        System.out.println("DemoFilter   放行后邏輯.....");
        
    }

    @Override //銷毀方法, 只調(diào)用一次
    public void destroy() {
        System.out.println("destroy 銷毀方法執(zhí)行了");
    }
}

2.4.2.2 攔截路徑

執(zhí)行流程我們搞清楚之后，接下來再來介紹一下過濾器的攔截路徑，Filter可以根據(jù)需求，配置不同的攔截資源路徑：

下面我們來測試"攔截具體路徑"：

@WebFilter(urlPatterns = "/login") ?//攔截/login具體路徑

@WebFilter(urlPatterns = "/depts/*") //攔截所有以/depts開頭，后面是什么無所謂?

2.4.2.3 過濾器鏈

最后我們在來介紹下過濾器鏈 ?

什么是過濾器鏈呢？

• 所謂過濾器鏈指的是在一個web應(yīng)用程序當(dāng)中，可以配置多個過濾器，多個過濾器就形成了一個過濾器鏈。 ?

比如：在我們web服務(wù)器當(dāng)中，定義了兩個過濾器，這兩個過濾器就形成了一個過濾器鏈。

• 而這個鏈上的過濾器在執(zhí)行的時候會一個一個的執(zhí)行，會先執(zhí)行第一個Filter，放行之后再來執(zhí)行第二個Filter，如果執(zhí)行到了最后一個過濾器放行之后，才會訪問對應(yīng)的web資源。
• 訪問完web資源之后，按照我們剛才所介紹的過濾器的執(zhí)行流程，還會回到過濾器當(dāng)中來執(zhí)行過濾器放行后的邏輯。
• 而在執(zhí)行放行后的邏輯的時候，順序是反著的，先要執(zhí)行過濾器2放行之后的邏輯，再來執(zhí)行過濾器1放行之后的邏輯，最后在給瀏覽器響應(yīng)數(shù)據(jù)。

說明：?

通過控制臺日志的輸出，大家發(fā)現(xiàn)AbcFilter先執(zhí)行，DemoFilter后執(zhí)行，這是為什么呢？

• 其實是和過濾器的類名有關(guān)系。
• 順序：以注解方式配置的Filter過濾器，它的執(zhí)行優(yōu)先級是按過濾器類名(字符串)的自動排序確定的，類名排名越靠前，優(yōu)先級越高。
• 假如我們想讓DemoFilter先執(zhí)行，怎么辦呢？答案就是修改類名。
• 修改AbcFilter類名為XbcFilter

2.4.3 登錄校驗-Filter

2.4.3.1 分析

過濾器Filter的快速入門以及使用細節(jié)我們已經(jīng)介紹完了，接下來最后一步，我們需要使用過濾器Filter來完成案例當(dāng)中的登錄校驗功能。

我們先來回顧下前面分析過的登錄校驗的基本流程：

• 要進入到后臺管理系統(tǒng)，我們必須先完成登錄操作，此時就需要訪問登錄接口login。

• 登錄成功之后，我們會在服務(wù)端生成一個JWT令牌，并且把JWT令牌返回給前端，前端會將JWT令牌存儲下來。

• 在后續(xù)的每一次請求當(dāng)中，都會將JWT令牌攜帶到服務(wù)端，請求到達服務(wù)端之后，要想去訪問對應(yīng)的業(yè)務(wù)功能，此時我們必須先要校驗令牌的有效性。

• 對于校驗令牌的這一塊操作，我們使用登錄校驗的過濾器，在過濾器當(dāng)中來校驗令牌的有效性。如果令牌是無效的，就響應(yīng)一個錯誤的信息，也不會再去放行訪問對應(yīng)的資源了。如果令牌存在，并且它是有效的，此時就會放行去訪問對應(yīng)的web資源，執(zhí)行相應(yīng)的業(yè)務(wù)操作。

大概清楚了在Filter過濾器的實現(xiàn)步驟了，那在正式開發(fā)登錄校驗過濾器之前，我們思考兩個問題：

1. 所有的請求，攔截到了之后，都需要校驗令牌嗎？

   • 答案：登錄請求例外

2. 攔截到請求后，什么情況下才可以放行，執(zhí)行業(yè)務(wù)操作？

   • 答案：有令牌，且令牌校驗通過(合法)；否則都返回未登錄錯誤結(jié)果

2.4.3.2 具體流程

我們要完成登錄校驗，主要是利用Filter過濾器實現(xiàn)，而登錄校驗Filter過濾器的流程步驟：

基于上面的業(yè)務(wù)流程，我們分析出具體的操作步驟：

1. 獲取請求url

2. 判斷請求url中是否包含login，如果包含，說明是登錄操作，放行

3. 獲取請求頭中的令牌（token）

4. 判斷令牌是否存在，如果不存在，返回錯誤結(jié)果（未登錄）

5. 解析token，如果解析失敗，返回錯誤結(jié)果（未登錄）

6. 放行

2.4.3.3 代碼實現(xiàn)

分析清楚了以上的問題后，我們就參照接口文檔來開發(fā)登錄功能了，登錄接口描述如下：

• 基本信息 ?

• 請求參數(shù)

參數(shù)格式：application/json

參數(shù)說明：

請求數(shù)據(jù)樣例：

• 響應(yīng)數(shù)據(jù)

參數(shù)格式：application/json

參數(shù)說明：

響應(yīng)數(shù)據(jù)樣例：

• 備注說明

用戶登錄成功后，系統(tǒng)會自動下發(fā)JWT令牌，然后在后續(xù)的每次請求中，都需要在請求頭header中攜帶到服務(wù)端，請求頭的名稱為 token ，值為登錄時下發(fā)的JWT令牌。 => 前端

如果檢測到用戶未登錄，則會返回如下固定錯誤信息：

登錄校驗過濾器：LoginCheckFilter ?

package com.gch.filter;

import com.alibaba.fastjson2.JSONObject;
import com.gch.pojo.Result;
import com.gch.utils.JwtUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Slf4j
@WebFilter(urlPatterns = "/*") //攔截所有請求
public class LoginCheckFilter  implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws IOException, ServletException {
        //前置：強制轉(zhuǎn)換為http協(xié)議的請求對象、響應(yīng)對象 （轉(zhuǎn)換原因：要使用子類中特有方法）
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        //1.獲取請求url
        String url = request.getRequestURL().toString();
        log.info("請求路徑url：{}", url); //請求路徑：http://localhost:8080/login


        //2.判斷請求url中是否包含login，如果包含，說明是登錄操作，則執(zhí)行放行操作
        if(url.contains("/login")){
            log.info("登錄操作,放行...");
            chain.doFilter(request, response);//放行請求
            return;//結(jié)束當(dāng)前方法的執(zhí)行
        }


        //3.獲取請求頭中的令牌（token） 為什么填token,因為接口文檔中已經(jīng)說明了請求頭名稱為token
        String token = request.getHeader("token");
        log.info("從請求頭中獲取的令牌：{}",token);


        //4.判斷令牌是否存在，如果不存在，返回錯誤結(jié)果（未登錄）
        if(!StringUtils.hasLength(token)){ // StringUtils是Spring當(dāng)中提供的一個工具類
            log.info("請求頭token為空,Token不存在");

            Result responseResult = Result.error("NOT_LOGIN");
            //響應(yīng)數(shù)據(jù)要為JSON數(shù)據(jù)格式,由于之前都是在Controller當(dāng)中操作的,加了@RestController注解后會自動的將方法的返回值轉(zhuǎn)為JSON格式
            //但是我們現(xiàn)在是在過濾器當(dāng)中,并不是在Controller當(dāng)中,所以我們現(xiàn)在要手動轉(zhuǎn)換 對象 => JSON
            //把Result對象轉(zhuǎn)換為JSON格式字符串 ===> 阿里巴巴fastJSON(fastjson是阿里巴巴提供的用于實現(xiàn)對象和json的轉(zhuǎn)換工具類)
            String json = JSONObject.toJSONString(responseResult);
            //將響應(yīng)的內(nèi)容類型設(shè)置為JSON格式,并且使用UTF-8字符編碼。
            response.setContentType("application/json;charset=utf-8");
            //響應(yīng)
            response.getWriter().write(json);

            return;
        }

        //5.校驗JWT令牌,解析token，如果解析失敗，返回錯誤結(jié)果（未登錄）
        try {
            JwtUtils.parseJWT(token);
        }catch (Exception e){ // jwt令牌解析失敗
            log.info("令牌解析失敗!");
            Result responseResult = Result.error("NOT_LOGIN");
            //把Result對象轉(zhuǎn)換為JSON格式字符串 (fastjson是阿里巴巴提供的用于實現(xiàn)對象和json的轉(zhuǎn)換工具類)
            String json = JSONObject.toJSONString(responseResult);
            response.setContentType("application/json;charset=utf-8");
            //響應(yīng)
            response.getWriter().write(json);

            return;
        }

        //6.放行
        log.info("令牌合法,放行");
        chain.doFilter(request, response);
    }
}

在上述過濾器的功能實現(xiàn)中，我們使用到了一個第三方j(luò)son處理的工具包fastjson。我們要想使用，需要引入如下依賴： ?

 <!-- 阿里巴巴fastJSON,用來進行JSON格式轉(zhuǎn)換的工具包-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.32</version>
        </dependency>

登錄校驗的過濾器我們編寫完成了，接下來我們就可以重新啟動服務(wù)來做一個測試：

測試前先把之前所編寫的測試使用的過濾器，暫時注釋掉。直接將@WebFilter注解給注釋掉即可。

2.5 攔截器Interceptor

學(xué)習(xí)完了過濾器Filter之后，接下來我們繼續(xù)學(xué)習(xí)攔截器Interseptor。

攔截器我們主要分為三個方面進行講解：

1. 介紹下什么是攔截器，并通過快速入門程序上手?jǐn)r截器

2. 攔截器的使用細節(jié)

3. 通過攔截器Interceptor完成登錄校驗功能

我們先學(xué)習(xí)第一塊內(nèi)容：攔截器快速入門

2.5.1 快速入門

什么是攔截器？

• 攔截器是一種動態(tài)攔截方法調(diào)用的機制，類似于過濾器Filter。

• 攔截器是Spring框架中提供的，用來動態(tài)攔截控制器方法的執(zhí)行，也就是Controller方法的執(zhí)行。

攔截器的作用：

• 攔截請求，攔截到請求之后就可以在指定方法調(diào)用前后，根據(jù)業(yè)務(wù)需要執(zhí)行預(yù)先設(shè)定的代碼。

在攔截器當(dāng)中，我們通常也是做一些通用性的操作，比如：我們可以通過攔截器來攔截前端發(fā)起的請求，將登錄校驗的邏輯全部編寫在攔截器當(dāng)中。在校驗的過程當(dāng)中，如發(fā)現(xiàn)用戶登錄了(攜帶了JWT令牌且是合法令牌)，就可以直接放行，去訪問Spring當(dāng)中的資源。如果校驗時發(fā)現(xiàn)并沒有登錄或是非法令牌，就可以直接給前端響應(yīng)未登錄的錯誤信息。

攔截器Interceptor快速入門?

下面我們通過快速入門程序，來學(xué)習(xí)下攔截器的基本使用。攔截器的使用步驟和過濾器類似，也分為兩步：

1. 定義攔截器，實現(xiàn)攔截器的標(biāo)準(zhǔn)接口 - HandlerInterceptor接口，并重寫其中所有方法(一共有三個方法，并且這三個方法都有默認(rèn)實現(xiàn)，我們可以根據(jù)自己的需要來重寫其中的方法)。

2. 注冊配置攔截器：首先自定義一個類，我們稱之為配置類，讓配置類去實現(xiàn)接口WebMvcConfigurer，重寫addInterceotor()方法，并且在配置類上加上注解@Configuration，來標(biāo)識當(dāng)前類是Spring當(dāng)中的一個配置類。

自定義攔截器：實現(xiàn)HandlerInterceptor接口，并重寫其所有方法 ?

package com.gch.interceptor;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 自定義登錄校驗攔截器
 */
@Component
public class LoginCheckInterceptor implements HandlerInterceptor {
    /**
     * 目標(biāo)資源方法執(zhí)行前執(zhí)行,這里的目標(biāo)資源方法指的就是Controller當(dāng)中的方法,會在Controller方法運行之前運行
     * @return 返回值類型為boolean 返回true:代表放行,就代表它可以去運行Controller當(dāng)中的方法了
     *         返回false:不放行,代表攔截住了,不允許執(zhí)行Controller當(dāng)中的方法
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle .... ");
        //true表示放行
        return true;
    }

    /**
     * 目標(biāo)資源方法執(zhí)行后執(zhí)行,也就是Controller方法運行完成之后來運行
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle ... ");
    }

    /**
     * 視圖渲染完畢后執(zhí)行，最后執(zhí)行的一個方法
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion .... ");
    }
}

注冊配置攔截器：實現(xiàn)WebMvcConfigurer接口，并重寫addInterceptors方法?

package com.gch.config;

import com.gch.interceptor.LoginCheckInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * 自定義配置類,注冊配置攔截器
 */
@Configuration // 該注解標(biāo)識當(dāng)前類是Spring當(dāng)中的配置類
public class WebConfig implements WebMvcConfigurer {
    /** 自定義的攔截器對象 */
    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;
    /**
     * 注冊攔截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //    注冊自定義攔截器對象  設(shè)置攔截器攔截的請求路徑（ /** 表示攔截所有請求）
        registry.addInterceptor(loginCheckInterceptor).addPathPatterns("/**");
    }
}

重新啟動SpringBoot服務(wù)，打開Postman測試：

2.5.2 Interceptor詳解

攔截器的入門程序完成之后，接下來我們來介紹攔截器的使用細節(jié)。攔截器的使用細節(jié)我們主要介紹兩個部分：

1. 攔截器的攔截路徑配置

2. 攔截器的執(zhí)行流程

2.5.2.1 攔截器 - 攔截路徑

首先我們先來看攔截器的攔截路徑的配置，在注冊配置攔截器的時候，我們要指定攔截器的攔截路徑，通過addPathPatterns("要攔截路徑")方法，就可以指定要攔截哪些資源。

在入門程序中我們配置的是/**，表示攔截所有資源，而在配置攔截器時，不僅可以指定要攔截哪些資源，還可以指定不攔截哪些資源，只需要調(diào)用excludePathPatterns("不攔截路徑")方法，指定哪些資源不需要攔截。?

2.5.2.2 攔截器的執(zhí)行流程

介紹完攔截路徑的配置之后，接下來我們再來介紹攔截器的執(zhí)行流程。

通過執(zhí)行流程，大家就能夠清晰的知道過濾器與攔截器的執(zhí)行時機。

• 當(dāng)我們打開瀏覽器來訪問部署在web服務(wù)器當(dāng)中的web應(yīng)用時，此時我們所定義的過濾器會攔截到這次請求。攔截到這次請求之后，它會先執(zhí)行放行前的邏輯，然后再執(zhí)行放行操作。而由于我們當(dāng)前是基于springboot開發(fā)的，所以放行之后是進入到了spring的環(huán)境當(dāng)中，也就是要來訪問我們所定義的controller當(dāng)中的接口方法。

• Tomcat并不識別所編寫的Controller程序，但是它識別Servlet程序，所以在Spring的Web環(huán)境中提供了一個非常核心的Servlet：DispatcherServlet（前端控制器），所有請求都會先進行到DispatcherServlet，再將請求轉(zhuǎn)給Controller。

• 當(dāng)我們定義了攔截器后，會在執(zhí)行Controller的方法之前，請求被攔截器攔截住。執(zhí)行preHandle()方法，這個方法執(zhí)行完成后需要返回一個布爾類型的值，如果返回true，就表示放行本次操作，才會繼續(xù)訪問controller中的方法；如果返回false，則不會放行（controller中的方法也不會執(zhí)行）。

• 在controller當(dāng)中的方法執(zhí)行完畢之后，再回過來執(zhí)行postHandle()這個方法以及afterCompletion() 方法，然后再返回給DispatcherServlet，最終再來執(zhí)行過濾器當(dāng)中放行后的這一部分邏輯的邏輯。執(zhí)行完畢之后，最終給瀏覽器響應(yīng)數(shù)據(jù)。

接下來我們就來演示下過濾器和攔截器同時存在的執(zhí)行流程： ?

以上就是攔截器的執(zhí)行流程。通過執(zhí)行流程分析，大家應(yīng)該已經(jīng)清楚了過濾器和攔截器之間的區(qū)別，其實它們之間的區(qū)別主要是兩點：

• 接口規(guī)范不同：過濾器需要實現(xiàn)Filter接口，而攔截器需要實現(xiàn)HandlerInterceptor接口。

• 攔截范圍不同：過濾器Filter會攔截所有的資源，而Interceptor攔截器它是Spring當(dāng)中提供的，它只會攔截Spring環(huán)境中的資源。

2.5.3 登錄校驗- Interceptor

通過攔截器來完成案例當(dāng)中的登錄校驗功能。

登錄校驗的業(yè)務(wù)邏輯以及操作步驟我們前面已經(jīng)分析過了，和登錄校驗Filter過濾器當(dāng)中的邏輯是完全一致的?，F(xiàn)在我們只需要把這個技術(shù)方案由原來的過濾器換成攔截器Interceptor就可以了。 ?

登錄校驗攔截器 ?

package com.gch.interceptor;

import com.alibaba.fastjson2.JSONObject;
import com.gch.pojo.Result;
import com.gch.utils.JwtUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.event.WindowFocusListener;

/**
 * 自定義登錄校驗攔截器
 */
@Slf4j
@Component // 當(dāng)前攔截器對象由Spring創(chuàng)建和管理
public class LoginCheckInterceptor implements HandlerInterceptor {
    /**
     * 目標(biāo)資源方法執(zhí)行前執(zhí)行,這里的目標(biāo)資源方法指的就是Controller當(dāng)中的方法,會在Controller方法運行之前運行
     * @return 返回值類型為boolean 返回true:代表放行,就代表它可以去運行Controller當(dāng)中的方法了
     *         返回false:不放行,代表攔截住了,不允許執(zhí)行Controller當(dāng)中的方法
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle .... ");
        // 1.獲取請求url
        String url = request.getRequestURL().toString();
        log.info("攔截到了請求,請求路徑url:{}",url);

        // 2.判斷請求url中是否包含login,如果包含,說明是登錄操作,則執(zhí)行放行操作
        if(url.contains("/login")){
            log.info("登錄操作,放行...");
            // true表示放行
            return true;
        }

        // 3.獲取請求頭中的Token令牌
        String token = request.getHeader("token");
        log.info("從請求頭中獲取的令牌:{}",token);

        // 4.判斷令牌是否存在,如果不存在,返回錯誤結(jié)果(說明未登錄)
        if(!StringUtils.hasLength(token)){
            log.info("請求頭token令牌為空,Token不存在");
            // 響應(yīng)錯誤結(jié)果
            Result responseResult = Result.error("NOT_LOGIN");
            // 將響應(yīng)結(jié)果的數(shù)據(jù)格式轉(zhuǎn)為JSON數(shù)據(jù)格式
            String json = JSONObject.toJSONString(responseResult);
            // 將響應(yīng)的內(nèi)容類型設(shè)置為JSON格式,并且使用UTF-8編碼
            response.setContentType("application/json;charset=utf-8");
            // 響應(yīng)
            response.getWriter().write(json);
            // 不放行
            return false;
        }

        // 5.校驗JWT令牌,解析Token,如果解析失敗,返回錯誤結(jié)果
        try {
            JwtUtils.parseJWT(token);
        }catch (Exception e){
            log.info("Token解析失敗...");
            // 響應(yīng)錯誤結(jié)果
            Result responseResult = Result.error("NOT_LOGIN");
            // 將響應(yīng)結(jié)果的數(shù)據(jù)格式轉(zhuǎn)為JSON數(shù)據(jù)格式
            String json = JSONObject.toJSONString(responseResult);
            // 將響應(yīng)的內(nèi)容類型設(shè)置為JSON格式,并且使用UTF-8編碼
            response.setContentType("application/json;charset=utf-8");
            // 響應(yīng)
            response.getWriter().write(json);
            // 不放行
            return false;
        }

        // 6.校驗JWT令牌成功,放行
        log.info("Token合法,放行...");
        //true表示放行
        return true;
    }
}

注冊配置攔截器 ?

package com.gch.config;

import com.gch.interceptor.LoginCheckInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * 自定義配置類,注冊配置攔截器
 */
@Configuration // 該注解標(biāo)識當(dāng)前類是Spring當(dāng)中的配置類
public class WebConfig implements WebMvcConfigurer {
    /** 自定義的攔截器對象 */
    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;
    /**
     * 注冊攔截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //    注冊自定義攔截器對象
        registry.addInterceptor(loginCheckInterceptor)
             // 設(shè)置攔截器攔截的請求路徑（ /** 表示攔截所有請求）
                .addPathPatterns("/**")
                // 設(shè)置不攔截的請求路徑
                .excludePathPatterns("/login");
    }
}

說明：登錄校驗的過濾器和攔截器，我們只需要使用其中的一種就可以了。 ?

3. 異常處理

3.1 當(dāng)前問題

登錄功能和登錄校驗功能我們都實現(xiàn)了，下面我們學(xué)習(xí)下今天最后一塊技術(shù)點：異常處理。首先我們先來看一下系統(tǒng)出現(xiàn)異常之后會發(fā)生什么現(xiàn)象，再來介紹異常處理的方案。

我們打開瀏覽器，訪問系統(tǒng)中的新增部門操作，系統(tǒng)中已經(jīng)有了 "就業(yè)部" 這個部門，我們再來增加一個就業(yè)部，看看會發(fā)生什么現(xiàn)象。 ?

點擊確定之后，窗口關(guān)閉了，頁面沒有任何反應(yīng)，就業(yè)部也沒有添加上。 而此時，大家會發(fā)現(xiàn)，網(wǎng)絡(luò)請求報錯了。 ?

狀態(tài)碼為500，表示服務(wù)器端異常，我們打開idea，來看一下，服務(wù)器端出了什么問題。 ?

上述錯誤信息的含義是，dept部門表的name字段的值就業(yè)部重復(fù)了，因為在數(shù)據(jù)庫表dept中已經(jīng)有了就業(yè)部，我們之前設(shè)計這張表時，為name字段建議了唯一約束，所以該字段的值是不能重復(fù)的。

而當(dāng)我們再添加就業(yè)部，這個部門時，就違反了唯一約束，此時就會報錯。

我們來看一下出現(xiàn)異常之后，最終服務(wù)端給前端響應(yīng)回來的數(shù)據(jù)長什么樣。 ?

響應(yīng)回來的數(shù)據(jù)是一個JSON格式的數(shù)據(jù)。但這種JSON格式的數(shù)據(jù)還是我們開發(fā)規(guī)范當(dāng)中所提到的統(tǒng)一響應(yīng)結(jié)果Result嗎？

• 顯然并不是。由于返回的數(shù)據(jù)不符合開發(fā)規(guī)范，所以前端并不能解析出響應(yīng)的JSON數(shù)據(jù)。 ?

接下來我們需要思考的是出現(xiàn)異常之后，當(dāng)前案例項目的異常是怎么處理的？

• 答案：沒有做任何的異常處理

當(dāng)我們沒有做任何的異常處理時，我們?nèi)龑蛹軜?gòu)處理異常的方案：

• Mapper接口在操作數(shù)據(jù)庫的時候出錯了，此時異常會往上拋(誰調(diào)用Mapper就拋給誰)，會拋給Service。

• Service 中也存在異常了，會拋給Controller。

• 而在Controller當(dāng)中，我們也沒有做任何的異常處理，所以最終異常會再往上拋。最終拋給框架之后，框架就會返回一個JSON格式的數(shù)據(jù)，里面封裝的就是錯誤的信息，但是框架返回的JSON格式的數(shù)據(jù)并不符合我們的開發(fā)規(guī)范。

3.2 解決方案

那么在三層構(gòu)架項目中，出現(xiàn)了異常，該如何處理?

• 方案一：在所有Controller的所有方法中進行try…catch處理

  • 缺點：雖然實現(xiàn)簡單，但是操作繁瑣，代碼臃腫（不推薦）

• 方案二：全局異常處理器

  • 定義一個全局異常處理器來捕獲整個項目當(dāng)中所有的異常

  • 好處：簡單、優(yōu)雅（推薦）

  • 有了全局異常處理器之后，如果Mapper當(dāng)中遇到異常不用處理，直接拋給Service，Service當(dāng)中遇到異常不用處理，拋給Controller，Controller也不用處理，最終該異常就會交給全局異常處理器來處理，全局異常處理器處理完該異常之后，再給前端響應(yīng)標(biāo)準(zhǔn)的統(tǒng)一響應(yīng)結(jié)果Result，Result當(dāng)中來封裝錯誤的信息。

3.3 全局異常處理器

我們該怎么樣定義全局異常處理器？

• 定義全局異常處理器非常簡單，就是定義一個類，在類上加上一個注解@RestControllerAdvice，加上這個注解就代表我們定義了一個全局異常處理器。

• 在全局異常處理器當(dāng)中，需要定義一個方法來捕獲異常，在這個方法上需要加上注解@ExceptionHandler。通過@ExceptionHandler注解當(dāng)中的value屬性來指定我們要捕獲的是哪一類型的異常。

• Exception.class就代表我們當(dāng)前要捕獲所有的異常，捕獲到異常之后，我們就可以在該方法中來處理異常。

提問： 我們響應(yīng)回去的是一個對象Result，而前端需要的是一個JSON格式的數(shù)據(jù)，那這個Result對象是怎樣轉(zhuǎn)換成JSON格式的呢？

• @RestControllerAdvice = @ControllerAdvice + @ResponseBody{將方法的返回值轉(zhuǎn)換為JSON然后再響應(yīng)回去給前端}

package com.gch.exception;

import com.gch.pojo.Result;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

/**
 * 全局異常處理器
 */
@RestControllerAdvice // 代表我們定義一個全局異常處理器
public class GolobalExceptionHandler {
    /**
     * 捕獲并處理異常
     * @param ex 異常對象
     * @return
     * @ExceptionHandler注解用于指定處理特定類型異常的方法,通過value屬性來指定我們要捕獲的是哪一類型的異常來進行處理
     */
    @ExceptionHandler(Exception.class) // 捕獲所有異常
    public Result handleException(Exception ex) {
        // 打印堆棧中的異常對象
        ex.printStackTrace();
        // 捕獲到異常之后,響應(yīng)一個標(biāo)準(zhǔn)的Result
        return Result.error("對不起,操作失敗,請聯(lián)系管理員");
    }
}

以上就是全局異常處理器的使用，主要涉及到兩個注解：

• @RestControllerAdvice //表示當(dāng)前類為全局異常處理器

• @ExceptionHandler //指定可以捕獲哪種類型的異常進行處理文章來源地址http://www.zghlxwxcb.cn/news/detail-828157.html

到了這里，關(guān)于SpringBootWeb 登錄認(rèn)證[Cookie + Session + Token + Filter + Interceptor]的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！