JWT簡介

1.什么是JWT

在介紹JWT之前，我們先來回顧一下利用token進行用戶身份驗證的流程：

1. 客戶端使用用戶名和密碼請求登錄
2. 服務(wù)端收到請求，驗證用戶名和密碼
3. 驗證成功后，服務(wù)端會簽發(fā)一個token，再把這個token返回給客戶端
4. 客戶端收到token后可以把它存儲起來，比如放到cookie中
5. 客戶端每次向服務(wù)端請求資源時需要攜帶服務(wù)端簽發(fā)的token，可以在cookie或者header中攜帶
6. 服務(wù)端收到請求，然后去驗證客戶端請求里面帶著的token，如果驗證成功，就向客戶端返回請求數(shù)據(jù)

這種基于token的認證方式相比傳統(tǒng)的session認證方式更節(jié)約服務(wù)器資源，并且對移動端和分布式更加友好。其優(yōu)點如下：

• 支持跨域訪問：cookie是無法跨域的，而token由于沒有用到cookie(前提是將token放到請求頭中)，所以跨域后不會存在信息丟失問題
• 無狀態(tài)：token機制在服務(wù)端不需要存儲session信息，因為token自身包含了所有登錄用戶的信息，所以可以減輕服務(wù)端壓力
• 更適用CDN：可以通過內(nèi)容分發(fā)網(wǎng)絡(luò)請求服務(wù)端的所有資料
• 更適用于移動端：當客戶端是非瀏覽器平臺時，cookie是不被支持的，此時采用token認證方式會簡單很多
• 無需考慮CSRF：由于不再依賴cookie，所以采用token認證方式不會發(fā)生CSRF，所以也就無需考慮CSRF的防御

而JWT就是上述流程當中token的一種具體實現(xiàn)方式，其全稱是JSON Web Token，官網(wǎng)地址：https://jwt.io/

通俗地說，JWT的本質(zhì)就是一個字符串，它是將用戶信息保存到一個Json字符串中，然后進行編碼后得到一個JWT token，并且這個JWT token帶有簽名信息，接收后可以校驗是否被篡改，所以可以用于在各方之間安全地將信息作為Json對象傳輸。JWT的認證流程如下：

1. 首先，前端通過Web表單將自己的用戶名和密碼發(fā)送到后端的接口，這個過程一般是一個POST請求。建議的方式是通過SSL加密的傳輸(HTTPS)，從而避免敏感信息被嗅探
2. 后端核對用戶名和密碼成功后，將包含用戶信息的數(shù)據(jù)作為JWT的Payload，將其與JWT Header分別進行Base64編碼拼接后簽名，形成一個JWT Token，形成的JWT Token就是一個如同lll.zzz.xxx的字符串
3. 后端將JWT Token字符串作為登錄成功的結(jié)果返回給前端。前端可以將返回的結(jié)果保存在瀏覽器中，退出登錄時刪除保存的JWT Token即可
4. 前端在每次請求時將JWT Token放入HTTP請求頭中的Authorization屬性中(解決XSS和XSRF問題)
5. 后端檢查前端傳過來的JWT Token，驗證其有效性，比如檢查簽名是否正確、是否過期、token的接收方是否是自己等等
6. 驗證通過后，后端解析出JWT Token中包含的用戶信息，進行其他邏輯操作(一般是根據(jù)用戶信息得到權(quán)限等)，返回結(jié)果

2.為什么要用JWT

2.1 傳統(tǒng)Session認證的弊端

我們知道HTTP本身是一種無狀態(tài)的協(xié)議，這就意味著如果用戶向我們的應(yīng)用提供了用戶名和密碼來進行用戶認證，認證通過后HTTP協(xié)議不會記錄下認證后的狀態(tài)，那么下一次請求時，用戶還要再一次進行認證，因為根據(jù)HTTP協(xié)議，我們并不知道是哪個用戶發(fā)出的請求，所以為了讓我們的應(yīng)用能識別是哪個用戶發(fā)出的請求，我們只能在用戶首次登錄成功后，在服務(wù)器存儲一份用戶登錄的信息，這份登錄信息會在響應(yīng)時傳遞給瀏覽器，告訴其保存為cookie，以便下次請求時發(fā)送給我們的應(yīng)用，這樣我們的應(yīng)用就能識別請求來自哪個用戶了，這是傳統(tǒng)的基于session認證的過程

然而，傳統(tǒng)的session認證有如下的問題：

• 每個用戶的登錄信息都會保存到服務(wù)器的session中，隨著用戶的增多，服務(wù)器開銷會明顯增大
• 由于session是存在與服務(wù)器的物理內(nèi)存中，所以在分布式系統(tǒng)中，這種方式將會失效。雖然可以將session統(tǒng)一保存到Redis中，但是這樣做無疑增加了系統(tǒng)的復(fù)雜性，對于不需要redis的應(yīng)用也會白白多引入一個緩存中間件
• 對于非瀏覽器的客戶端、手機移動端等不適用，因為session依賴于cookie，而移動端經(jīng)常沒有cookie
• 因為session認證本質(zhì)基于cookie，所以如果cookie被截獲，用戶很容易收到跨站請求偽造攻擊。并且如果瀏覽器禁用了cookie，這種方式也會失效
• 前后端分離系統(tǒng)中更加不適用，后端部署復(fù)雜，前端發(fā)送的請求往往經(jīng)過多個中間件到達后端，cookie中關(guān)于session的信息會轉(zhuǎn)發(fā)多次
• 由于基于Cookie，而cookie無法跨域，所以session的認證也無法跨域，對單點登錄不適用

2.2 JWT認證的優(yōu)勢

對比傳統(tǒng)的session認證方式，JWT的優(yōu)勢是：

• 簡潔：JWT Token數(shù)據(jù)量小，傳輸速度也很快
• 因為JWT Token是以JSON加密形式保存在客戶端的，所以JWT是跨語言的，原則上任何web形式都支持
• 不需要在服務(wù)端保存會話信息，也就是說不依賴于cookie和session，所以沒有了傳統(tǒng)session認證的弊端，特別適用于分布式微服務(wù)
• 單點登錄友好：使用Session進行身份認證的話，由于cookie無法跨域，難以實現(xiàn)單點登錄。但是，使用token進行認證的話， token可以被保存在客戶端的任意位置的內(nèi)存中，不一定是cookie，所以不依賴cookie，不會存在這些問題
• 適合移動端應(yīng)用：使用Session進行身份認證的話，需要保存一份信息在服務(wù)器端，而且這種方式會依賴到Cookie（需要 Cookie 保存 SessionId），所以不適合移動端

因為這些優(yōu)勢，目前無論單體應(yīng)用還是分布式應(yīng)用，都更加推薦用JWT token的方式進行用戶認證

JWT結(jié)構(gòu)

JWT由3部分組成：標頭(Header)、有效載荷(Payload)和簽名(Signature)。在傳輸?shù)臅r候，會將JWT的3部分分別進行Base64編碼后用.進行連接形成最終傳輸?shù)淖址甁 W T S t r i n g = B a s e 64 ( H e a d e r ) . B a s e 64 ( P a y l o a d ) . H M A C S H A 256 ( b a s e 64 U r l E n c o d e ( h e a d e r ) + " . " + b a s e 64 U r l E n c o d e ( p a y l o a d ) , s e c r e t ) JWTString = Base64(Header).Base64(Payload).HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret) JWTString=Base64(Header).Base64(Payload).HMACSHA256(base64UrlEncode(header)+"."+base64UrlEncode(payload),secret)

1.Header

JWT頭是一個描述JWT元數(shù)據(jù)的JSON對象，alg屬性表示簽名使用的算法，默認為HMAC SHA256（寫為HS256）；typ屬性表示令牌的類型，JWT令牌統(tǒng)一寫為JWT。最后，使用Base64 URL算法將上述JSON對象轉(zhuǎn)換為字符串保存

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

2.Payload

有效載荷部分，是JWT的主體內(nèi)容部分，也是一個JSON對象，包含需要傳遞的數(shù)據(jù)。 JWT指定七個默認字段供選擇

iss：發(fā)行人
exp：到期時間
sub：主題
aud：用戶
nbf：在此之前不可用
iat：發(fā)布時間
jti：JWT ID用于標識該JWT

這些預(yù)定義的字段并不要求強制使用。除以上默認字段外，我們還可以自定義私有字段，一般會把包含用戶信息的數(shù)據(jù)放到payload中，如下例：

{
  "sub": "1234567890",
  "name": "Helen",
  "admin": true
}

請注意，默認情況下JWT是未加密的，因為只是采用base64算法，拿到JWT字符串后可以轉(zhuǎn)換回原本的JSON數(shù)據(jù)，任何人都可以解讀其內(nèi)容，因此不要構(gòu)建隱私信息字段，比如用戶的密碼一定不能保存到JWT中，以防止信息泄露。JWT只是適合在網(wǎng)絡(luò)中傳輸一些非敏感的信息

3.Signature

簽名哈希部分是對上面兩部分數(shù)據(jù)簽名，需要使用base64編碼后的header和payload數(shù)據(jù)，通過指定的算法生成哈希，以確保數(shù)據(jù)不會被篡改。首先，需要指定一個密鑰（secret）。該密碼僅僅為保存在服務(wù)器中，并且不能向用戶公開。然后，使用header中指定的簽名算法（默認情況下為HMAC SHA256）根據(jù)以下公式生成簽名H M A C S H A 256 ( b a s e 64 U r l E n c o d e ( h e a d e r ) + " . " + b a s e 64 U r l E n c o d e ( p a y l o a d ) , s e c r e t ) HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret) HMACSHA256(base64UrlEncode(header)+"."+base64UrlEncode(payload),secret)在計算出簽名哈希后，JWT頭，有效載荷和簽名哈希的三個部分組合成一個字符串，每個部分用.分隔，就構(gòu)成整個JWT對象

注意JWT每部分的作用，在服務(wù)端接收到客戶端發(fā)送過來的JWT token之后：

• header和payload可以直接利用base64解碼出原文，從header中獲取哈希簽名的算法，從payload中獲取有效數(shù)據(jù)
• signature由于使用了不可逆的加密算法，無法解碼出原文，它的作用是校驗token有沒有被篡改。服務(wù)端獲取header中的加密算法之后，利用該算法加上secretKey對header、payload進行加密，比對加密后的數(shù)據(jù)和客戶端發(fā)送過來的是否一致。注意secretKey只能保存在服務(wù)端，而且對于不同的加密算法其含義有所不同，一般對于MD5類型的摘要加密算法，secretKey實際上代表的是鹽值

JWT的種類

其實JWT(JSON Web Token)指的是一種規(guī)范，這種規(guī)范允許我們使用JWT在兩個組織之間傳遞安全可靠的信息，JWT的具體實現(xiàn)可以分為以下幾種：

• nonsecure JWT：未經(jīng)過簽名，不安全的JWT
• JWS：經(jīng)過簽名的JWT
• JWE：payload部分經(jīng)過加密的JWT

1.nonsecure JWT

未經(jīng)過簽名，不安全的JWT。其header部分沒有指定簽名算法

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

并且也沒有Signature部分

2.JWS

JWS ，也就是JWT Signature，其結(jié)構(gòu)就是在之前nonsecure JWT的基礎(chǔ)上，在頭部聲明簽名算法，并在最后添加上簽名。創(chuàng)建簽名，是保證jwt不能被他人隨意篡改。我們通常使用的JWT一般都是JWS

為了完成簽名，除了用到header信息和payload信息外，還需要算法的密鑰，也就是secretKey。加密的算法一般有2類：

• 對稱加密：secretKey指加密密鑰，可以生成簽名與驗簽
• 非對稱加密：secretKey指私鑰，只用來生成簽名，不能用來驗簽(驗簽用的是公鑰)

JWT的密鑰或者密鑰對，一般統(tǒng)一稱為JSON Web Key，也就是JWK

到目前為止，jwt的簽名算法有三種：

• HMAC【哈希消息驗證碼(對稱)】：HS256/HS384/HS512
• RSASSA【RSA簽名算法(非對稱)】（RS256/RS384/RS512）
• ECDSA【橢圓曲線數(shù)據(jù)簽名算法(非對稱)】（ES256/ES384/ES512）

Java中使用JWT

官網(wǎng)推薦了6個Java使用JWT的開源庫，其中比較推薦使用的是java-jwt和jjwt-root

1.java-jwt

1.1 對稱簽名

首先引入依賴

<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.10.3</version>
</dependency>

生成JWT的token

public class JWTTest {
    @Test
    public void testGenerateToken(){
        // 指定token過期時間為10秒
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.SECOND, 10);
        String token = JWT.create()
                .withHeader(new HashMap<>())  // Header
                .withClaim("userId", 21)  // Payload
                .withClaim("userName", "baobao")
                .withExpiresAt(calendar.getTime())  // 過期時間
                .sign(Algorithm.HMAC256("!34ADAS"));  // 簽名用的secret
        System.out.println(token);
    }
}

注意多次運行方法生成的token字符串內(nèi)容是不一樣的，盡管我們的payload信息沒有變動。因為JWT中攜帶了超時時間，所以每次生成的token會不一樣，我們利用base64解密工具可以發(fā)現(xiàn)payload確實攜帶了超時時間

解析JWT字符串

@Test
public void testResolveToken(){
    // 創(chuàng)建解析對象，使用的算法和secret要與創(chuàng)建token時保持一致
    JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("!34ADAS")).build();
    // 解析指定的token
    DecodedJWT decodedJWT = jwtVerifier.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyTmFtZSI6ImJhb2JhbyIsImV4cCI6MTU5OTkyMjUyOCwidXNlcklkIjoyMX0.YhA3kh9KZOAb7om1C7o3vBhYp0f61mhQWWOoCrrhqvo");
    // 獲取解析后的token中的payload信息
    Claim userId = decodedJWT.getClaim("userId");
    Claim userName = decodedJWT.getClaim("userName");
    System.out.println(userId.asInt());
    System.out.println(userName.asString());
    // 輸出超時時間
    System.out.println(decodedJWT.getExpiresAt());
}

運行后發(fā)現(xiàn)報異常，原因是之前生成的token已經(jīng)過期

再運行一次生成token的方法，然后在過期時間10秒之內(nèi)將生成的字符串拷貝到解析方法中，運行解析方法即可成功

我們可以將上述方法封裝成工具類

public class JWTUtils {
    // 簽名密鑰
    private static final String SECRET = "!DAR$";
    /**
     * 生成token
     * @param payload token攜帶的信息
     * @return token字符串
     */
    public static String getToken(Map<String,String> payload){
        // 指定token過期時間為7天
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DATE, 7);
        JWTCreator.Builder builder = JWT.create();
        // 構(gòu)建payload
        payload.forEach((k,v) -> builder.withClaim(k,v));
        // 指定過期時間和簽名算法
        String token = builder.withExpiresAt(calendar.getTime()).sign(Algorithm.HMAC256(SECRET));
        return token;
    }
    /**
     * 解析token
     * @param token token字符串
     * @return 解析后的token
     */
    public static DecodedJWT decode(String token){
        JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(SECRET)).build();
        DecodedJWT decodedJWT = jwtVerifier.verify(token);
        return decodedJWT;
    }
}

1.2 非對稱簽名

生成jwt串的時候需要指定私鑰，解析jwt串的時候需要指定公鑰

private static final String RSA_PRIVATE_KEY = "...";
private static final String RSA_PUBLIC_KEY = "...";
/**
     * 生成token
     * @param payload token攜帶的信息
     * @return token字符串
     */
public static String getTokenRsa(Map<String,String> payload){
    // 指定token過期時間為7天
    Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.DATE, 7);
    JWTCreator.Builder builder = JWT.create();
    // 構(gòu)建payload
    payload.forEach((k,v) -> builder.withClaim(k,v));
    // 利用hutool創(chuàng)建RSA
    RSA rsa = new RSA(RSA_PRIVATE_KEY, null);
    // 獲取私鑰
    RSAPrivateKey privateKey = (RSAPrivateKey) rsa.getPrivateKey();
    // 簽名時傳入私鑰
    String token = builder.withExpiresAt(calendar.getTime()).sign(Algorithm.RSA256(null, privateKey));
    return token;
}
/**
     * 解析token
     * @param token token字符串
     * @return 解析后的token
     */
public static DecodedJWT decodeRsa(String token){
    // 利用hutool創(chuàng)建RSA
    RSA rsa = new RSA(null, RSA_PUBLIC_KEY);
    // 獲取RSA公鑰
    RSAPublicKey publicKey = (RSAPublicKey) rsa.getPublicKey();
    // 驗簽時傳入公鑰
    JWTVerifier jwtVerifier = JWT.require(Algorithm.RSA256(publicKey, null)).build();
    DecodedJWT decodedJWT = jwtVerifier.verify(token);
    return decodedJWT;
}

2.jjwt-root

2.1 對稱簽名

引入依賴

<!-- https://mvnrepository.com/artifact/io.jsonwebtoken/jjwt -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

使用方法類似，可參考下列代碼

public class JwtUtils {
    // token時效：24小時
    public static final long EXPIRE = 1000 * 60 * 60 * 24;
    // 簽名哈希的密鑰，對于不同的加密算法來說含義不同
    public static final String APP_SECRET = "ukc8BDbRigUDaY6pZFfWus2jZWLPHO";
    /**
     * 根據(jù)用戶id和昵稱生成token
     * @param id  用戶id
     * @param nickname 用戶昵稱
     * @return JWT規(guī)則生成的token
     */
    public static String getJwtToken(String id, String nickname){
        String JwtToken = Jwts.builder()
                .setHeaderParam("typ", "JWT")
                .setHeaderParam("alg", "HS256")
                .setSubject("baobao-user")
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
                .claim("id", id)
                .claim("nickname", nickname)
            	// HS256算法實際上就是MD5加鹽值，此時APP_SECRET就代表鹽值
                .signWith(SignatureAlgorithm.HS256, APP_SECRET)
                .compact();
        return JwtToken;
    }
    /**
     * 判斷token是否存在與有效
     * @param jwtToken token字符串
     * @return 如果token有效返回true，否則返回false
     */
    public static boolean checkToken(String jwtToken) {
        if(StringUtils.isEmpty(jwtToken)) return false;
        try {
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
    /**
     * 判斷token是否存在與有效
     * @param request Http請求對象
     * @return 如果token有效返回true，否則返回false
     */
    public static boolean checkToken(HttpServletRequest request) {
        try {
            // 從http請求頭中獲取token字符串
            String jwtToken = request.getHeader("token");
            if(StringUtils.isEmpty(jwtToken)) return false;
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
    /**
     * 根據(jù)token獲取會員id
     * @param request Http請求對象
     * @return 解析token后獲得的用戶id
     */
    public static String getMemberIdByJwtToken(HttpServletRequest request) {
        String jwtToken = request.getHeader("token");
        if(StringUtils.isEmpty(jwtToken)) return "";
        Jws<Claims> claimsJws = Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        Claims claims = claimsJws.getBody();
        return (String)claims.get("id");
    }
}

注意：

• jjwt在0.10版本以后發(fā)生了較大變化，pom依賴要引入多個

  <dependency>
      <groupId>io.jsonwebtoken</groupId>
      <artifactId>jjwt-api</artifactId>
      <version>0.11.2</version>
  </dependency>
  <dependency>
      <groupId>io.jsonwebtoken</groupId>
      <artifactId>jjwt-impl</artifactId>
      <version>0.11.2</version>
      <scope>runtime</scope>
  </dependency>
  <dependency>
      <groupId>io.jsonwebtoken</groupId>
      <artifactId>jjwt-jackson</artifactId> <!-- or jjwt-gson if Gson is preferred -->
      <version>0.11.2</version>
      <scope>runtime</scope>
  </dependency>

• 標準規(guī)范中對各種加密算法的secretKey的長度有如下要求：

  • HS256：要求至少 256 bits (32 bytes)
  • HS384：要求至少384 bits (48 bytes)
  • HS512：要求至少512 bits (64 bytes)
  • RS256 and PS256：至少2048 bits
  • RS384 and PS384：至少3072 bits
  • RS512 and PS512：至少4096 bits
  • ES256：至少256 bits (32 bytes)
  • ES384：至少384 bits (48 bytes)
  • ES512：至少512 bits (64 bytes)

  在jjwt0.10版本之前，沒有強制要求，secretKey長度不滿足要求時也可以簽名成功。但是0.10版本后強制要求secretKey滿足規(guī)范中的長度要求，否則生成jws時會拋出異常

  

• 新版本的jjwt中，之前的簽名和驗簽方法都是傳入密鑰的字符串，已經(jīng)過時。最新的方法需要傳入Key對象

public class JwtUtils {
    // token時效：24小時
    public static final long EXPIRE = 1000 * 60 * 60 * 24;
    // 簽名哈希的密鑰，對于不同的加密算法來說含義不同
    public static final String APP_SECRET = "ukc8BDbRigUDaY6pZFfWus2jZWLPHOsdadasdasfdssfeweee";
    /**
     * 根據(jù)用戶id和昵稱生成token
     * @param id  用戶id
     * @param nickname 用戶昵稱
     * @return JWT規(guī)則生成的token
     */
    public static String getJwtToken(String id, String nickname){
        String JwtToken = Jwts.builder()
                .setSubject("baobao-user")
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
                .claim("id", id)
                .claim("nickname", nickname)
                // 傳入Key對象
                .signWith(Keys.hmacShaKeyFor(APP_SECRET.getBytes(StandardCharsets.UTF_8)), SignatureAlgorithm.HS256)
                .compact();
        return JwtToken;
    }
    /**
     * 判斷token是否存在與有效
     * @param jwtToken token字符串
     * @return 如果token有效返回true，否則返回false
     */
    public static Jws<Claims> decode(String jwtToken) {
        // 傳入Key對象
        Jws<Claims> claimsJws = Jwts.parserBuilder().setSigningKey(Keys.hmacShaKeyFor(APP_SECRET.getBytes(StandardCharsets.UTF_8))).build().parseClaimsJws(jwtToken);
        return claimsJws;
    }
}

2.2 非對稱簽名

生成jwt串的時候需要指定私鑰，解析jwt串的時候需要指定公鑰

private static final String RSA_PRIVATE_KEY = "...";
private static final String RSA_PUBLIC_KEY = "...";
/**
     * 根據(jù)用戶id和昵稱生成token
     * @param id  用戶id
     * @param nickname 用戶昵稱
     * @return JWT規(guī)則生成的token
     */
public static String getJwtTokenRsa(String id, String nickname){
    // 利用hutool創(chuàng)建RSA
    RSA rsa = new RSA(RSA_PRIVATE_KEY, null);
    RSAPrivateKey privateKey = (RSAPrivateKey) rsa.getPrivateKey();
    String JwtToken = Jwts.builder()
        .setSubject("baobao-user")
        .setIssuedAt(new Date())
        .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
        .claim("id", id)
        .claim("nickname", nickname)
        // 簽名指定私鑰
        .signWith(privateKey, SignatureAlgorithm.RS256)
        .compact();
    return JwtToken;
}
/**
     * 判斷token是否存在與有效
     * @param jwtToken token字符串
     * @return 如果token有效返回true，否則返回false
     */
public static Jws<Claims> decodeRsa(String jwtToken) {
    RSA rsa = new RSA(null, RSA_PUBLIC_KEY);
    RSAPublicKey publicKey = (RSAPublicKey) rsa.getPublicKey();
    // 驗簽指定公鑰
    Jws<Claims> claimsJws = Jwts.parserBuilder().setSigningKey(publicKey).build().parseClaimsJws(jwtToken);
    return claimsJws;
}

實際開發(fā)中的應(yīng)用

在實際的SpringBoot項目中，一般我們可以用如下流程做登錄：

1. 在登錄驗證通過后，給用戶生成一個對應(yīng)的隨機token(注意這個token不是指jwt，可以用uuid等算法生成)，然后將這個token作為key的一部分，用戶信息作為value存入Redis，并設(shè)置過期時間，這個過期時間就是登錄失效的時間
2. 將第1步中生成的隨機token作為JWT的payload生成JWT字符串返回給前端
3. 前端之后每次請求都在請求頭中的Authorization字段中攜帶JWT字符串
4. 后端定義一個攔截器，每次收到前端請求時，都先從請求頭中的Authorization字段中取出JWT字符串并進行驗證，驗證通過后解析出payload中的隨機token，然后再用這個隨機token得到key，從Redis中獲取用戶信息，如果能獲取到就說明用戶已經(jīng)登錄

public class JWTInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String JWT = request.getHeader("Authorization");
        try {
            // 1.校驗JWT字符串
            DecodedJWT decodedJWT = JWTUtils.decode(JWT);
            // 2.取出JWT字符串載荷中的隨機token，從Redis中獲取用戶信息
            ...
            return true;
        }catch (SignatureVerificationException e){
            System.out.println("無效簽名");
            e.printStackTrace();
        }catch (TokenExpiredException e){
            System.out.println("token已經(jīng)過期");
            e.printStackTrace();
        }catch (AlgorithmMismatchException e){
            System.out.println("算法不一致");
            e.printStackTrace();
        }catch (Exception e){
            System.out.println("token無效");
            e.printStackTrace();
        }
        return false;
    }
}

在實際開發(fā)中需要用下列手段來增加JWT的安全性：

• 因為JWT是在請求頭中傳遞的，所以為了避免網(wǎng)絡(luò)劫持，推薦使用HTTPS來傳輸，更加安全
• JWT的哈希簽名的密鑰是存放在服務(wù)端的，所以只要服務(wù)器不被攻破，理論上JWT是安全的。因此要保證服務(wù)器的安全
• JWT可以使用暴力窮舉來破解，所以為了應(yīng)對這種破解方式，可以定期更換服務(wù)端的哈希簽名密鑰(相當于鹽值)。這樣可以保證等破解結(jié)果出來了，你的密鑰也已經(jīng)換了