小紅書二面：什么是JWT？它是如何工作的？
作者：江南一點雨
有狀態服務，即服務端需要記錄每次會話的客戶端信息，從而識別客戶端身份，根據用戶身份進行請求的處理，典型的設計如 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 的一個簡單用法。
責任編輯：武曉燕
來源：
江南一點雨
