什麼是 JWT？它是如何工作的？詳情 - java,jwt 江南一點雨動態日志

鬆哥最近輔導了幾個小夥伴秋招，有小夥伴在面小紅書時遇到這個問題，這個問題想回答全面還是有些挑戰，鬆哥結合之前的一篇舊文和大夥一起來聊聊。

一無狀態登錄

1.1 什麼是有狀態

有狀態服務，即服務端需要記錄每次會話的客户端信息，從而識別客户端身份，根據用户身份進行請求的處理，典型的設計如 Tomcat 中的 Session。例如登錄：用户登錄後，我們把用户的信息保存在服務端 session 中，並且給用户一個 cookie 值，記錄對應的 session，然後下次請求，用户攜帶 cookie 值來（這一步有瀏覽器自動完成），我們就能識別到對應 session，從而找到用户的信息。這種方式目前來看最方便，但是也有一些缺陷，如下：

服務端保存大量數據，增加服務端壓力
服務端保存用户狀態，不支持集羣化部署

1.2 什麼是無狀態

微服務集羣中的每個服務，對外提供的都使用 RESTful 風格的接口。而 RESTful 風格的一個最重要的規範就是：服務的無狀態性，即：

服務端不保存任何客户端請求者信息
客户端的每次請求必須具備自描述信息，通過這些信息識別客户端身份

那麼這種無狀態性有哪些好處呢？

客户端請求不依賴服務端的信息，多次請求不需要必須訪問到同一台服務器
服務端的集羣和狀態對客户端透明
服務端可以任意的遷移和伸縮（可以方便的進行集羣化部署）
減小服務端存儲壓力

1.3 如何實現無狀態

無狀態登錄的流程：

首先客户端發送賬户名/密碼到服務端進行認證
認證通過後，服務端將用户信息加密並且編碼成一個 token（一般是 JWT），返回給客户端
以後客户端每次發送請求，都需要攜帶認證的 token
服務端對客户端發送來的 token 進行解密，判斷是否有效，並且獲取用户登錄信息

二 JWT

2.1 JWT 簡介

JWT，全稱是 Json Web Token，是一種 JSON 風格的輕量級的授權和身份認證規範，可實現無狀態、分佈式的 Web 應用授權：

JWT 作為一種規範，並沒有和某一種語言綁定在一起，常用的 Java 實現是 GitHub 上的開源項目 jjwt，地址如下：https://github.com/jwtk/jjwt

2.2 JWT 數據格式

JWT 包含三部分數據：

Header：頭部，通常頭部有兩部分信息：
- 聲明類型，這裏是JWT
- 加密算法，自定義

我們會對頭部進行 Base64Url 編碼（可解碼），得到第一部分數據。

Payload：載荷，就是有效數據，在官方文檔中(RFC7519)，這裏給了7個示例信息：
- iss (issuer)：表示簽發人
- exp (expiration time)：表示token過期時間
- sub (subject)：主題
- aud (audience)：受眾
- nbf (Not Before)：生效時間
- iat (Issued At)：簽發時間
- jti (JWT ID)：編號

這部分也會採用 Base64Url 編碼，得到第二部分數據。

Signature：簽名，是整個數據的認證信息。一般根據前兩步的數據，再加上服務的的密鑰secret（密鑰保存在服務端，不能泄露給客户端），通過 Header 中配置的加密算法生成。用於驗證整個數據完整和可靠性。

生成的數據格式如下圖：

注意，這裏的數據通過 . 隔開成了三部分，分別對應前面提到的三部分，另外，這裏數據是不換行的，圖片換行只是為了展示方便而已。

2.3 JWT 交互流程

流程圖：

步驟翻譯：

應用程序或客户端向授權服務器請求授權
獲取到授權後，授權服務器會嚮應用程序返回訪問令牌
應用程序使用訪問令牌來訪問受保護資源（如 API）

因為 JWT 簽發的 token 中已經包含了用户的身份信息，並且每次請求都會攜帶，這樣服務的就無需保存用户信息，甚至無需去數據庫查詢，這樣就完全符合了 RESTful 的無狀態規範。

2.4 JWT 存在的問題

説了這麼多，JWT 也不是天衣無縫，由客户端維護登錄狀態帶來的一些問題在這裏依然存在，舉例如下：

續簽問題，這是被很多人詬病的問題之一，傳統的 cookie+session 的方案天然的支持續簽，但是 jwt 由於服務端不保存用户狀態，因此很難完美解決續簽問題，如果引入 redis，雖然可以解決問題，但是 jwt 也變得不倫不類了。
註銷問題，由於服務端不再保存用户信息，所以一般可以通過修改 secret 來實現註銷，服務端 secret 修改後，已經頒發的未過期的 token 就會認證失敗，進而實現註銷，不過畢竟沒有傳統的註銷方便。
密碼重置，密碼重置後，原本的 token 依然可以訪問系統，這時候也需要強制修改 secret。
基於第 2 點和第 3 點，一般建議不同用户取不同 secret。

對於上面提到的這些問題，在目前具體的項目實踐中，更多的是通過引入 Redis 來解決這些問題。

三實戰

説了這麼久，接下來我們就來看看這個東西到底要怎麼用？

3.1 環境搭建

首先我們來創建一個 Spring Boot 項目，創建時需要添加 Spring Security 依賴，創建完成後，添加 jjwt 依賴，完整的 pom.xml 文件如下：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
</dependency>

然後在項目中創建一個簡單的 User 對象實現 UserDetails 接口，如下：

public class User implements UserDetails {
    private String username;
    private String password;
    private List<GrantedAuthority> authorities;
    public String getUsername() {
        return username;
    }
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }
    @Override
    public boolean isEnabled() {
        return true;
    }
    //省略getter/setter
}

這個就是我們的用户對象，先放着備用，再創建一個 HelloController，內容如下：

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "hello jwt !";
    }
    @GetMapping("/admin")
    public String admin() {
        return "hello admin !";
    }
}

HelloController 很簡單，這裏有兩個接口，設計是 /hello 接口可以被具有 user 角色的用户訪問，而 /admin 接口則可以被具有 admin 角色的用户訪問。

3.2 JWT 配置

先準備一個 JWT 操作的工具類：

public class JwtUtils {

    public static final Integer EXPIRE_TIME = 7 * 24 * 60 * 60;
    public static final Integer REDIS_TOKEN_EXPIRE_TIME = 30 * 60;
    public static final String TOKEN_ISSUER = "javaboy";

    /**
     * 生成 JWT 字符串
     *
     * @return
     */
    public static String createJWT() throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        String jws = Jwts.builder()
                //設置頭部信息(相當於 JWT 字符串第一部分的內容)
                .header().add("type", "JWT")
                .and()
                //相當於 JWT 字符串第二部分的內容
                //簽名密鑰
                .signWith(getPrivateKey())
                //設置過期時間
                .expiration(java.util.Date.from(java.time.Instant.now().plusSeconds(EXPIRE_TIME)))
                //設置用户名
                .subject(authentication.getName())
                //設置用户權限，相當於把用户權限轉為字符串 admin,user,xxx
                .claim("authorities", authentication.getAuthorities().stream().map(a -> a.getAuthority()).collect(Collectors.joining(",")))
                //令牌簽發時間
                .issuedAt(new Date())
                .issuer(TOKEN_ISSUER)
                .compact();
        return jws;
    }

    public static PrivateKey getPrivateKey() throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
        ClassPathResource resource = new ClassPathResource("private_key.pem");
        byte[] privateKeyBytes = FileCopyUtils.copyToByteArray(resource.getInputStream());
        String key = new String(privateKeyBytes, StandardCharsets.UTF_8);
        String privateStr = key
                .replace("-----BEGIN PRIVATE KEY-----", "")
                .replaceAll(System.lineSeparator(), "")
                .replace("-----END PRIVATE KEY-----", "");
        byte[] privateKeyDecodedBytes = Base64.getDecoder().decode(privateStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyDecodedBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }

    public static RSAPublicKey getPublicKey() throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
        ClassPathResource resource = new ClassPathResource("public_key.pem");
        byte[] publicKeyBytes = FileCopyUtils.copyToByteArray(resource.getInputStream());
        String key = new String(publicKeyBytes, StandardCharsets.UTF_8);
        String publicStr = key
                .replace("-----BEGIN PUBLIC KEY-----", "")
                .replaceAll(System.lineSeparator(), "")
                .replace("-----END PUBLIC KEY-----", "");
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        byte[] publicKeyBase64Bytes = Base64.getDecoder().decode(publicStr);
        X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(publicKeyBase64Bytes);
        PublicKey rsaPublicKey = keyFactory.generatePublic(publicKeySpec);
        return (RSAPublicKey) rsaPublicKey;
    }

    public static Authentication verifyToken(String token) {
        try {
            Claims claims = Jwts.parser()
                    .verifyWith(getPublicKey()).build()
                    .parseSignedClaims(token).getPayload();
            String username = claims.getSubject();
            // user,admin,xxx
            String authorities = claims.get("authorities", String.class);
            // 解析用户權限
            List<SimpleGrantedAuthority> list = Arrays.stream(authorities.split(",")).map(s -> new SimpleGrantedAuthority(s)).collect(Collectors.toList());
            return UsernamePasswordAuthenticationToken.authenticated(username, null, list);
        } catch (Exception e) {
            //令牌校驗失敗
            return null;
        }

    }
}

接下來，在用户登錄成功的時候，生成 JWT 字符串，並存入到 Redis 中，如下：

@Bean
SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http.authorizeHttpRequests(a -> a.anyRequest().authenticated())
            .csrf(c -> c.disable())
            .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .formLogin(f -> f
                    .successHandler((req, resp, auth) -> {
                        //登錄成功，生成 JWT 字符串
                        try {
                            String token = JwtUtils.createJWT();
                            //將 JWT 字符串保存到 redis 中
                            redisTemplate.opsForValue().set(auth.getName() + ":" + token, auth.getName());
                            // 設置過期時間
                            redisTemplate.expire(auth.getName() + ":" + token, JwtUtils.REDIS_TOKEN_EXPIRE_TIME, TimeUnit.SECONDS);
                            resp.setContentType("application/json;charset=utf-8");
                            RespBean respBean = new RespBean(200, token, null);
                            resp.getWriter().write(new ObjectMapper().writeValueAsString(respBean));
                        } catch (NoSuchAlgorithmException e) {
                            throw new RuntimeException(e);
                        } catch (InvalidKeySpecException e) {
                            throw new RuntimeException(e);
                        }
                    })
                    .permitAll())
            .logout(l -> l.logoutSuccessHandler((req, resp, auth) -> {
                // 刪除 redis 中的 token
                String key = auth.getName() + ":" + req.getHeader("Authorization").replace("Bearer ", "");
                System.out.println("key = " + key);
                redisTemplate.delete(key);
                resp.getWriter().write("logout success");
            }).logoutUrl("/logout").permitAll());
    http.addFilterAfter(new JwtFilter(redisTemplate), SecurityContextHolderFilter.class);
    return http.build();
}

最後再來一個校驗的過濾器，在用法發送請求的時候，校驗 JWT 字符串，如下：

public class JwtFilter extends GenericFilterBean {
    StringRedisTemplate redisTemplate;

    public JwtFilter(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) {
        RespBean result = null;
        HttpServletRequest req = (HttpServletRequest) servletRequest;
        HttpServletResponse resp = (HttpServletResponse) servletResponse;
        resp.setContentType("application/json;charset=utf-8");
        try {
            //如果是登錄請求，則直接放行
            if (req.getRequestURI().equals("/login")) {
                filterChain.doFilter(servletRequest, servletResponse);
                return;
            }
            //獲取請求頭中的token
            String token = req.getHeader("Authorization");
            if (token == null) {
                result = new RespBean(500, "令牌為空，請求失敗", null);
                PrintWriter out = resp.getWriter();
                out.write(new ObjectMapper().writeValueAsString(result));
            } else {
                //驗證token
                token = token.replace("Bearer ", "");
                //驗證token是否有效
                //校驗通過，則返回認證後的 Auhtentication 對象，否則返回 null
                Authentication authentication = JwtUtils.verifyToken(token);
                String s = redisTemplate.opsForValue().get(authentication.getName() + ":" + token);
                if (s == null) {
                    // 令牌失效
                    result = new RespBean(501, "令牌失效，請重新登錄", null);
                    resp.getWriter().write(new ObjectMapper().writeValueAsString(result));
                } else {
                    //令牌有效，檢查令牌過期時間，如果臨近過期，則為令牌續期
                    Long expire = redisTemplate.getExpire(authentication.getName() + ":" + token);
                    if (expire != null && expire < 10 * 60) {
                        //説明令牌還有 10 分鐘過期，則重新設置新的過期時間
                        redisTemplate.expire(authentication.getName() + ":" + token, Duration.ofSeconds(JwtUtils.REDIS_TOKEN_EXPIRE_TIME));
                    }
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                    filterChain.doFilter(servletRequest, servletResponse);
                }
            }
        } catch (Exception e) {

        } finally {
            // 清除上下文
            SecurityContextHolder.clearContext();
        }

    }
}

關於這個過濾器，我説如下幾點：

首先從請求頭中提取出 Authorization 字段，這個字段對應的 value 就是用户的 token。
將提取出來的 token 字符串調用 JwtUtils.verifyToken 方法進行驗證，將驗證結果放到當前的 SecurityContext 中，然後執行過濾鏈使請求繼續執行下去。

3.3 Spring Security 配置

最後，在 Spring Security 中配置這個過濾器。

http.addFilterAfter(new JwtFilter(redisTemplate), SecurityContextHolderFilter.class);

搞定！

3.4 測試

做完這些之後，我們的環境就算完全搭建起來了，接下來啓動項目然後在 POSTMAN 中進行測試，如下：

登錄成功後返回的字符串就是經過 base64url 轉碼的 token，一共有三部分，通過一個 . 隔開，我們可以對第一個 . 之前的字符串進行解碼，即 Header，如下：

再對兩個 . 之間的字符解碼，即 payload：

可以看到，我們設置信息，由於 base64 並不是加密方案，只是一種編碼方案，因此，不建議將敏感的用户信息放到 token 中。

接下來再去訪問 /hello 接口，注意認證方式選擇 Bearer Token，Token 值為剛剛獲取到的值，如下：

可以看到，訪問成功。

四總結

這就是 JWT 結合 Spring Security 的一個簡單用法。

江南一點雨動態日志

@lenve

標簽

JAVA (556)

MySQL (192)

spring (87)

Nginx (75)

java-ee (35)

Jwt (22)

java-web (18)

前後端分離 (14)

動態

什麼是 JWT？它是如何工作的？ - 動態詳情

一無狀態登錄

1.1 什麼是有狀態

1.2 什麼是無狀態

1.3 如何實現無狀態

二 JWT

2.1 JWT 簡介

2.2 JWT 數據格式

2.3 JWT 交互流程

2.4 JWT 存在的問題

三實戰

3.1 環境搭建

3.2 JWT 配置

3.3 Spring Security 配置

3.4 測試

四總結

Add a new 評論

江南一點雨 動態日志

@lenve

標簽

JAVA (556)

MySQL (192)

spring (87)

Nginx (75)

java-ee (35)

Jwt (22)

java-web (18)

前後端分離 (14)

動態

什麼是 JWT？它是如何工作的？ - 動態 詳情

一 無狀態登錄

1.1 什麼是有狀態

1.2 什麼是無狀態

1.3 如何實現無狀態

二 JWT

2.1 JWT 簡介

2.2 JWT 數據格式

2.3 JWT 交互流程

2.4 JWT 存在的問題

三 實戰

3.1 環境搭建

3.2 JWT 配置

3.3 Spring Security 配置

3.4 測試

四 總結

Add a new 評論

江南一點雨動態日志

什麼是 JWT？它是如何工作的？ - 動態詳情

一無狀態登錄

三實戰

四總結