小紅書二面：什么是JWT？它是如何工作的？

作者：江南一點雨 2024-09-29 09:50:05

有狀態服務，即服務端需要記錄每次會話的客戶端信息，從而識別客戶端身份，根據用戶身份進行請求的處理，典型的設計如 Tomcat 中的 Session。

一無狀態登錄

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 的一個簡單用法。

責任編輯：武曉燕來源：江南一點雨